sensifai-sdk-ngx/esm5/lib/sensifai-sdk-ngx.service.js

This Angular client provides a wrapper around Sensifai Image and Video recognition API.

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
 */
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common/http";
var SensifaiSdkNgxService = /** @class */ (function () {
    function SensifaiSdkNgxService(httpClient) {
        this.httpClient = httpClient;
        this.MainHost = 'https://api.sensifai.com/api/';
    }
    /**
     * Retrieve Result By Task ID
     * @param TaskID: Your Process Task ID
     * @param onSuccess: Success CallBack Function
     * @param onError: Error CallBack Function
     */
    /**
     * Retrieve Result By Task ID
     * @param {?} TaskID
     * @param {?} onSuccess
     * @param {?} onError
     * @return {?}
     */
    SensifaiSdkNgxService.prototype.getResultByTaskID = /**
     * Retrieve Result By Task ID
     * @param {?} TaskID
     * @param {?} onSuccess
     * @param {?} onError
     * @return {?}
     */
    function (TaskID, onSuccess, onError) {
        /** @type {?} */
        var payload = {
            'query': 'query( $taskId: String! ){apiResult( taskId: $taskId){ ...on ImageResult{isDone errors imageResults{nsfwResult{type probability value}logoResult{description}landmarkResult{description}taggingResult{label probability}faceResult{detectedBoxesPercentage probability detectedFace label}}} ... on VideoResult{fps duration isDone framesCount errors videoResults{startSecond endSecond startFrame endFrame thumbnailPath taggingResult{label probability}actionResult{label probability}celebrityResult{name frequency} sportResult{label probability}nsfwResult{probability type value}}}}}',
            'variables': { 'taskId': TaskID }
        };
        this.httpClient.post(this.MainHost, payload).subscribe(function (res) {
            onSuccess(res);
        }, function (err) {
            onError(err);
        });
    };
    /**
     * Start Process By URL
     * @param fileUrls: List Of URL's
     * @param ApplicationToken: Application Token
     * @param onSuccess: Success CallBack Function
     * @param onError: Error CallBack Function
     */
    /**
     * Start Process By URL
     * @param {?} fileUrls
     * @param {?} ApplicationToken
     * @param {?} onSuccess
     * @param {?} onError
     * @return {?}
     */
    SensifaiSdkNgxService.prototype.uploadByUrls = /**
     * Start Process By URL
     * @param {?} fileUrls
     * @param {?} ApplicationToken
     * @param {?} onSuccess
     * @param {?} onError
     * @return {?}
     */
    function (fileUrls, ApplicationToken, onSuccess, onError) {
        /** @type {?} */
        var payload = {
            'query': 'mutation( $token: String!, $urls: [String!]! ){uploadByUrl( token: $token, urls: $urls){result error succeed{file taskId} cannotUpload}}',
            'variables': {
                'urls': fileUrls,
                'token': ApplicationToken
            }
        };
        this.httpClient.post(this.MainHost, payload).subscribe(function (res) {
            onSuccess(res);
        }, function (err) {
            onError(err);
        });
    };
    /**
     * Start Process By Files
     * @param fileInputValue: List Of Files
     * @param ApplicationToken: Application Token
     * @param onSuccess: Success CallBack Function
     * @param onError: Error CallBack Function
     */
    /**
     * Start Process By Files
     * @param {?} fileInputValue
     * @param {?} ApplicationToken
     * @param {?} onSuccess
     * @param {?} onError
     * @return {?}
     */
    SensifaiSdkNgxService.prototype.uploadByFiles = /**
     * Start Process By Files
     * @param {?} fileInputValue
     * @param {?} ApplicationToken
     * @param {?} onSuccess
     * @param {?} onError
     * @return {?}
     */
    function (fileInputValue, ApplicationToken, onSuccess, onError) {
        /** @type {?} */
        var filesLength = fileInputValue.target.files.length;
        /** @type {?} */
        var formData = new FormData();
        /**
         * Create Base Object Query Variable *
         * @type {?}
         */
        var filesMap = {};
        /** @type {?} */
        var nullFiles = Array(filesLength).fill(null);
        /** @type {?} */
        var payload = {
            'operationName': null,
            'query': 'mutation( $token: String!, $files: [Upload!]! ){uploadByFile(token: $token, files: $files){result error succeed{file taskId} cannotUpload}}',
            'variables': {
                'files': nullFiles,
                'token': ApplicationToken
            }
        };
        /** Map Object Generator Loop **/
        for (var i = 0, len = filesLength; i < len; i++) {
            /** @type {?} */
            var tempObj = {};
            tempObj[i] = ['variables.files.' + i.toString()];
            Object.assign(filesMap, tempObj);
        }
        /** Append Operation and Map to FormData Query **/
        formData.append('operations', JSON.stringify(payload));
        formData.append('map', JSON.stringify(filesMap));
        /** Append Files To FormData  **/
        for (var file = 0, len = filesLength; file < len; file++) {
            formData.append(file.toString(), fileInputValue.target.files[file]);
        }
        this.httpClient.post(this.MainHost, formData).subscribe(function (res) {
            onSuccess(res);
        }, function (err) {
            onError(err);
        });
    };
    SensifaiSdkNgxService.decorators = [
        { type: Injectable, args: [{
                    providedIn: 'root'
                },] }
    ];
    /** @nocollapse */
    SensifaiSdkNgxService.ctorParameters = function () { return [
        { type: HttpClient }
    ]; };
    /** @nocollapse */ SensifaiSdkNgxService.ngInjectableDef = i0.defineInjectable({ factory: function SensifaiSdkNgxService_Factory() { return new SensifaiSdkNgxService(i0.inject(i1.HttpClient)); }, token: SensifaiSdkNgxService, providedIn: "root" });
    return SensifaiSdkNgxService;
}());
export { SensifaiSdkNgxService };
if (false) {
    /** @type {?} */
    SensifaiSdkNgxService.prototype.MainHost;
    /** @type {?} */
    SensifaiSdkNgxService.prototype.httpClient;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sensifai-sdk-ngx.service.js","sourceRoot":"ng://sensifai-sdk-ngx/","sources":["lib/sensifai-sdk-ngx.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SensifaiSdkNgxService {\n\n  private MainHost = 'https://api.sensifai.com/api/';\n\n  constructor( private httpClient: HttpClient ) {}\n\n  /**\n   * Retrieve Result By Task ID\n   * @param TaskID: Your Process Task ID\n   * @param onSuccess: Success CallBack Function\n   * @param onError: Error CallBack Function\n   */\n  getResultByTaskID( TaskID: string, onSuccess, onError ) {\n    const payload = {\n      'query': 'query( $taskId: String! ){apiResult( taskId: $taskId){ ...on ImageResult{isDone errors imageResults{nsfwResult{type probability value}logoResult{description}landmarkResult{description}taggingResult{label probability}faceResult{detectedBoxesPercentage probability detectedFace label}}} ... on VideoResult{fps duration isDone framesCount errors videoResults{startSecond endSecond startFrame endFrame thumbnailPath taggingResult{label probability}actionResult{label probability}celebrityResult{name frequency} sportResult{label probability}nsfwResult{probability type value}}}}}',\n      'variables': {'taskId': TaskID }\n    };\n    this.httpClient.post( this.MainHost, payload ).subscribe( function (res) {\n      onSuccess( res );\n    }, function (err) {\n      onError( err );\n    });\n  }\n\n  /**\n   * Start Process By URL\n   * @param fileUrls: List Of URL's\n   * @param ApplicationToken: Application Token\n   * @param onSuccess: Success CallBack Function\n   * @param onError: Error CallBack Function\n   */\n  uploadByUrls( fileUrls: Array<string>, ApplicationToken: string, onSuccess, onError ) {\n    const payload = {\n      'query': 'mutation( $token: String!, $urls: [String!]! ){uploadByUrl( token: $token, urls: $urls){result error succeed{file taskId} cannotUpload}}',\n      'variables': {\n        'urls': fileUrls,\n        'token': ApplicationToken\n      }\n    };\n\n    this.httpClient.post( this.MainHost, payload ).subscribe( function (res) {\n      onSuccess( res );\n    }, function (err) {\n      onError( err );\n    });\n  }\n\n  /**\n   * Start Process By Files\n   * @param fileInputValue: List Of Files\n   * @param ApplicationToken: Application Token\n   * @param onSuccess: Success CallBack Function\n   * @param onError: Error CallBack Function\n   */\n  uploadByFiles( fileInputValue, ApplicationToken: string, onSuccess, onError ) {\n    const filesLength = fileInputValue.target.files.length;\n    const formData = new FormData();\n\n    /** Create Base Object Query Variable **/\n    const filesMap = {};\n    const nullFiles = Array( filesLength ).fill(null);\n    const payload = {\n      'operationName': null,\n      'query'        : 'mutation( $token: String!, $files: [Upload!]! ){uploadByFile(token: $token, files: $files){result error succeed{file taskId} cannotUpload}}',\n      'variables'    : {\n        'files': nullFiles,\n        'token': ApplicationToken\n      }\n    };\n\n    /** Map Object Generator Loop **/\n    for ( let i = 0, len = filesLength; i < len; i++) {\n      const tempObj = {};\n      tempObj[i]  = ['variables.files.' + i.toString()];\n      Object.assign( filesMap, tempObj);\n    }\n\n    /** Append Operation and Map to FormData Query **/\n    formData.append( 'operations', JSON.stringify( payload) );\n    formData.append( 'map', JSON.stringify( filesMap ) );\n\n    /** Append Files To FormData  **/\n    for ( let file = 0, len = filesLength; file < len; file++) {\n      formData.append( file.toString() , fileInputValue.target.files[file] );\n    }\n\n    this.httpClient.post( this.MainHost, formData ).subscribe( function (res) {\n      onSuccess( res );\n    }, function (err) {\n      onError( err );\n    });\n  }\n}\n"]}