@ibm-aspera/sdk 0.2.29 → 0.4.12

package/dist/commonjs/models/aspera-sdk.model.js

@@ -0,0 +1,349 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsperaSdk = exports.ActivityTracking = exports.AsperaSdkGlobals = void 0;
+var constants_1 = require("../constants/constants");
+var messages_1 = require("../constants/messages");
+var safari_client_1 = require("../helpers/client/safari-client");
+var client_1 = require("../helpers/client/client");
+var helpers_1 = require("../helpers/helpers");
+var ws_1 = require("../helpers/ws");
+var index_1 = require("../index");
+var AsperaSdkGlobals = /** @class */ (function () {
+    function AsperaSdkGlobals() {
+        /** The URL of the IBM Aspera HTTP server to use with the SDK */
+        this.asperaAppUrl = 'http://127.0.0.1';
+        /** The URL of the IBM Aspera Desktop HTTP server to use with the SDK */
+        this.rpcPort = 33024;
+        /** The list of RPC methods supported by the running IBM Aspera for desktop application */
+        this.rpcMethods = [];
+        /** The default URL to check for latest Aspera installers */
+        this.installerUrl = constants_1.installerUrl;
+        /** Indicate that the server has been verified as working */
+        this.asperaAppVerified = false;
+        /** Indicate if multiple session is supported */
+        this.supportMultipleUsers = false;
+        /** Map of drop zones created by querySelector */
+        this.dropZonesCreated = new Map();
+        /** Indicate that the HTTP Gateway has been verified as working */
+        this.httpGatewayVerified = false;
+        /** Connect status */
+        this.connectStatus = 'WAITING';
+    }
+    AsperaSdkGlobals.prototype.backupLaunchMethod = function (url) {
+        window.alert(messages_1.messages.loadingProtocol);
+        window.location.href = url;
+    };
+    /**
+     * Launch the IBM Aspera App via protocol url. By default, a hidden IFRAME attempts to
+     * open the app but if that fails a fallback of opening a new window happens.
+     */
+    AsperaSdkGlobals.prototype.launch = function () {
+        var _this = this;
+        try {
+            var element = document.createElement('iframe');
+            element.src = constants_1.protocol;
+            element.onerror = function (error) {
+                (0, helpers_1.errorLog)(messages_1.messages.failedToGenerateIframe, error);
+                _this.backupLaunchMethod(constants_1.protocol);
+            };
+            element.setAttribute('style', constants_1.hiddenStyleList);
+            document.body.appendChild(element);
+        }
+        catch (error) {
+            (0, helpers_1.errorLog)(messages_1.messages.failedToGenerateIframe, error);
+            this.backupLaunchMethod(constants_1.protocol);
+        }
+    };
+    Object.defineProperty(AsperaSdkGlobals.prototype, "sdkResponseData", {
+        get: function () {
+            return __assign(__assign({ verified: this.asperaAppVerified }, this.asperaSdkInfo), { httpGateway: {
+                    verified: this.httpGatewayVerified,
+                    url: this.httpGatewayUrl,
+                    info: this.httpGatewayInfo,
+                }, connect: {
+                    active: this.connectStatus === 'RUNNING',
+                    status: this.connectStatus,
+                } });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AsperaSdkGlobals;
+}());
+exports.AsperaSdkGlobals = AsperaSdkGlobals;
+var ActivityTracking = /** @class */ (function () {
+    function ActivityTracking() {
+        /** Map of callbacks that receive transfer update events */
+        this.activity_callbacks = new Map();
+        /** Map of callbacks that receive connection events */
+        this.event_callbacks = new Map();
+        /** Keep track of the last WebSocket event **/
+        this.lastWebSocketEvent = 'CLOSED';
+        /** Keep track of the last notified WebSocket event **/
+        this.lastNotifiedWebSocketEvent = undefined;
+    }
+    /**
+     * Notify all consumers when a message is received from the websocket
+     *
+     * @param message the message received from the websocket
+     */
+    ActivityTracking.prototype.handleTransferActivity = function (message) {
+        if (message.type === 'transferUpdated' || message.type === 'transferRemoved') {
+            this.activity_callbacks.forEach(function (callback) {
+                if (typeof callback === 'function') {
+                    callback(message.data);
+                }
+            });
+        }
+    };
+    /**
+     * Handle and notify if needed when a connection webSocketEvent occurs. For example, when the SDK
+     * websocket connection to IBM Aspera App is closed or reconnected.
+     *
+     * @param webSocketEvent the event type.
+     */
+    ActivityTracking.prototype.handleWebSocketEvents = function (webSocketEvent) {
+        if (this.lastWebSocketEvent === webSocketEvent) {
+            return;
+        }
+        this.lastWebSocketEvent = webSocketEvent;
+        this.notifyWebSocketEvent(webSocketEvent);
+    };
+    /**
+     * Notify all consumers when a connection webSocketEvent occurs.
+     *
+     * @param webSocketEvent the event type.
+     */
+    ActivityTracking.prototype.notifyWebSocketEvent = function (webSocketEvent) {
+        if (this.lastNotifiedWebSocketEvent === webSocketEvent) {
+            return;
+        }
+        this.lastNotifiedWebSocketEvent = webSocketEvent;
+        this.event_callbacks.forEach(function (callback) {
+            if (typeof callback === 'function') {
+                callback(webSocketEvent);
+            }
+        });
+    };
+    /** Trigger manual event for other event types. */
+    ActivityTracking.prototype.sendManualEventCallback = function (status) {
+        this.event_callbacks.forEach(function (callback) {
+            if (typeof callback === 'function') {
+                callback(status);
+            }
+        });
+    };
+    /**
+     * Notify all consumers when the client changes status. For example, when
+     * IBM Aspera App is launched or closed.
+     *
+     * @param running whether the client is running or not.
+     */
+    ActivityTracking.prototype.handleClientEvents = function (running) {
+        var webSocketEvent;
+        if (!running) {
+            webSocketEvent = 'CLOSED';
+        }
+        else {
+            webSocketEvent = this.lastWebSocketEvent;
+        }
+        this.notifyWebSocketEvent(webSocketEvent);
+    };
+    /**
+     * Notify all consumers when a Safari extension safariExtensionEvent occurs (enabled/disabled).
+     *
+     * @param safariExtensionEvent the event type.
+     */
+    ActivityTracking.prototype.handleSafariExtensionEvents = function (safariExtensionEvent) {
+        index_1.asperaSdk.SAFARI_EXTENSION_STATUS = safariExtensionEvent;
+    };
+    /**
+     * Set up the activity tracking with IBM Aspera.
+     *
+     * @returns a promise that resolves when the websocket connection is established.
+     * Currently, this promise does not reject.
+     */
+    ActivityTracking.prototype.setup = function () {
+        var _this = this;
+        if (index_1.asperaSdk.globals.sessionId) {
+            this.registerDesktopAppSession();
+        }
+        var finalCall = function () {
+            if ((0, helpers_1.isSafari)()) {
+                return safari_client_1.safariClient.monitorTransferActivity();
+            }
+            return ws_1.websocketService.init()
+                .then(function () {
+                ws_1.websocketService.registerMessage('transfer_activity', function (data) { return _this.handleTransferActivity(data); });
+                ws_1.websocketService.registerEvent(function (status) { return _this.handleWebSocketEvents(status); });
+            });
+        };
+        if (index_1.asperaSdk.globals.supportMultipleUsers) {
+            var retryCount_1 = 0;
+            var makeVerifyCall_1 = function (incrementIt) {
+                if (incrementIt) {
+                    index_1.asperaSdk.globals.rpcPort = index_1.asperaSdk.globals.rpcPort + 1;
+                }
+                if (index_1.asperaSdk.globals.rpcPort > 33029) {
+                    retryCount_1++;
+                    index_1.asperaSdk.globals.rpcPort = 33024;
+                    return new Promise(function (resolve) { return setTimeout(resolve, retryCount_1 * 1050); }).then(function () { return makeVerifyCall_1(false); });
+                }
+                return client_1.client.request('verify_session', { app_id: index_1.asperaSdk.globals.appId, session_id: index_1.asperaSdk.globals.sessionId })
+                    .then(function (data) {
+                    if (data.result) {
+                        return finalCall();
+                    }
+                    return makeVerifyCall_1(true);
+                }).catch(function () {
+                    if (retryCount_1 > 5) {
+                        index_1.asperaSdk.globals.rpcPort = 33024;
+                        return Promise.reject('Unable to find port running for session');
+                    }
+                    return makeVerifyCall_1(true);
+                });
+            };
+            return makeVerifyCall_1(false);
+        }
+        else {
+            return finalCall();
+        }
+    };
+    /**
+     * Register a callback for getting transfers back to the consumer
+     *
+     * @param callback the function to call with the array of transfers
+     *
+     * @returns the ID of the callback index
+     */
+    ActivityTracking.prototype.setCallback = function (callback) {
+        if (typeof callback !== 'function') {
+            (0, helpers_1.errorLog)(messages_1.messages.callbackIsNotFunction);
+            return;
+        }
+        var id = "callback-".concat(this.activity_callbacks.size + 1);
+        this.activity_callbacks.set(id, callback);
+        return id;
+    };
+    /**
+     * Remove the callback (deregister) from the list of callbacks
+     *
+     * @param id the string of the callback to remove
+     */
+    ActivityTracking.prototype.removeCallback = function (id) {
+        this.activity_callbacks.delete(id);
+    };
+    /**
+     * Register a callback for getting websocket events back to the consumer
+     *
+     * @param callback the function to call with the websocket event
+     *
+     * @returns the ID of the callback index
+     */
+    ActivityTracking.prototype.setWebSocketEventCallback = function (callback) {
+        if (typeof callback !== 'function') {
+            (0, helpers_1.errorLog)(messages_1.messages.callbackIsNotFunction);
+            return;
+        }
+        var id = "callback-".concat(this.event_callbacks.size + 1);
+        this.event_callbacks.set(id, callback);
+        callback(this.lastWebSocketEvent);
+        return id;
+    };
+    /**
+     * Remove the callback (deregister) from the list of callbacks
+     *
+     * @param id the string of the callback to remove
+     */
+    ActivityTracking.prototype.removeWebSocketEventCallback = function (id) {
+        this.event_callbacks.delete(id);
+    };
+    ActivityTracking.prototype.registerDesktopAppSession = function () {
+        var iframe = document.createElement('iframe');
+        iframe.style.display = 'none';
+        iframe.src = "aspera://initialize?app_id=".concat(index_1.asperaSdk.globals.appId, "&session_id=").concat(index_1.asperaSdk.globals.sessionId);
+        document.body.appendChild(iframe);
+        setTimeout(function () {
+            document.body.removeChild(iframe);
+        }, 1000);
+    };
+    return ActivityTracking;
+}());
+exports.ActivityTracking = ActivityTracking;
+var AsperaSdk = /** @class */ (function () {
+    function AsperaSdk() {
+        /** Global information about IBM Aspera */
+        this.globals = new AsperaSdkGlobals();
+        /** Activity tracking for watching transfers */
+        /** @ignore */
+        this.activityTracking = new ActivityTracking();
+        /** HTTP Gateway file store. Key is the file name. */
+        this.httpGatewaySelectedFiles = new Map();
+        /** Indicate if Safari Extension is enabled. If the extension is disabled during the lifecycle this will not update to disabled. */
+        this.SAFARI_EXTENSION_STATUS = 'DISABLED';
+        /** Store of HTTP Gateway transfers */
+        this.httpGatewayTransferStore = new Map();
+        /** HTTP Gateway in app threshold limit. This can be changed globally for the app. */
+        this.httpGatewayInBrowserDownloadThreshold = 1000000000;
+    }
+    Object.defineProperty(AsperaSdk.prototype, "isReady", {
+        /**
+         * Check if IBM Aspera is ready to be used and has been verified.
+         *
+         * @returns a boolean indicating if SDK can be used for requests
+         */
+        get: function () {
+            return this.globals.asperaAppVerified && this.globals.appId !== '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AsperaSdk.prototype, "useConnect", {
+        /** Indicate that Connect is available. */
+        get: function () {
+            return this.globals.connectStatus === 'RUNNING';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AsperaSdk.prototype, "httpGatewayIsReady", {
+        /** Indicate that HTTP Gateway is available. */
+        get: function () {
+            return !!this.globals.httpGatewayVerified;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AsperaSdk.prototype, "useHttpGateway", {
+        /** Indicates if internal calls should use Gateway */
+        get: function () {
+            return this.httpGatewayIsReady && !this.isReady && !this.useConnect;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AsperaSdk.prototype, "useOldHttpGateway", {
+        /** Indicates if old HTTP Gateway SDK should be used (v2 and lower) */
+        get: function () {
+            if (!this.useHttpGateway) {
+                return false;
+            }
+            return Number(this.globals.httpGatewayInfo.version.split('.')[0] || 3) <= 2;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AsperaSdk;
+}());
+exports.AsperaSdk = AsperaSdk;