@genialis/resolwe
Version:
Resolwe frontend libraries
228 lines (226 loc) • 32.1 kB
JavaScript
;
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 });
var Rx = require("rx");
var angular = require("angular");
var _ = require("lodash");
require("ng-file-upload");
var error_1 = require("../errors/error");
var lang_1 = require("../utils/lang");
var random = require("../utils/random");
var angularModule = angular.module('resolwe.services.api', [
'ngFileUpload',
]);
var UploadEventType;
(function (UploadEventType) {
UploadEventType["PROGRESS"] = "progress";
UploadEventType["RETRYING"] = "retrying";
UploadEventType["RESULT"] = "result";
})(UploadEventType = exports.UploadEventType || (exports.UploadEventType = {}));
/**
* Base API service class providing additional features like file
* upload support. It should be used as a mixin together with an
* actual API class.
*/
var APIServiceBase = /** @class */ (function () {
// @ngInject
APIServiceBase.$inject = ["Upload", "$q", "$http", "maxConsecutiveAutoretryAttempts"];
function APIServiceBase(Upload, $q, $http, maxConsecutiveAutoretryAttempts) {
this.CHUNK_SIZE = 1 * 1024 * 1024; // 1MB
/**
* Max consecutive autoretry attempts are configurable in provider. An autoretry attempt is not
* considered consecutive if it happens later than 2 * maxDelay (retry attempts are reset after
* that time).
*/
this.maxConsecutiveAutoretryAttempts = 5;
this.RETRY_DELAY_INCREMENT = 500;
this.MAX_RETRY_DELAY = 5000;
this._upload = Upload;
this._q = $q;
this._http = $http;
if (!_.isUndefined(maxConsecutiveAutoretryAttempts)) {
this.maxConsecutiveAutoretryAttempts = maxConsecutiveAutoretryAttempts;
}
}
APIServiceBase.prototype.isTimeToResetAutoretryAttempts = function (timeSincePreviousError) {
var maxDelay = Math.max(this.maxConsecutiveAutoretryAttempts * this.RETRY_DELAY_INCREMENT, this.MAX_RETRY_DELAY);
return timeSincePreviousError > 2 * maxDelay;
};
/**
* Performs a data upload.
*
* Each field including nested objects will be sent as a form data multipart.
* Samples:
* {pic: file, username: username}
* {files: files, otherInfo: {id: id, person: person,...}} multiple files (html5)
* {profiles: {[{pic: file1, username: username1}, {pic: file2, username: username2}]} nested array multiple files (html5)
* {file: file, info: Upload.json({id: id, name: name, ...})} send fields as json string
* {file: file, info: Upload.jsonBlob({id: id, name: name, ...})} send fields as json blob, 'application/json' content_type
* {picFile: Upload.rename(file, 'profile.jpg'), title: title} send file with picFile key and profile.jpg file name
*
* @param {any} data See angular.angularFileUpload.IFileUploadConfigFile.
*/
APIServiceBase.prototype.upload = function (data, fileUID) {
var _this = this;
if (fileUID === void 0) { fileUID = ''; }
var url = this.connection.createUriFromPath('/upload/');
var headers = {
'Session-Id': this.connection.sessionId(),
'X-File-Uid': fileUID,
'X-CSRFToken': this.connection.csrfCookie(),
};
return Rx.Observable.create(function (observer) {
observer.onNext({ type: UploadEventType.RETRYING }); // Note: First one of these is skipped below.
var rejectableResumeSizePromise = _this._q.defer();
var fileUpload = _this._upload.upload({
url: url,
method: 'POST',
headers: headers,
withCredentials: true,
resumeSize: function () {
var resumeSizePromise = _this._http.get(url, {
headers: headers,
withCredentials: true,
}).then(function (response) {
return response.data.resume_offset;
}, function (error) {
observer.onError(error); // Handled in observables
return _this._q.defer().promise; // Never resolve
});
rejectableResumeSizePromise.resolve(resumeSizePromise);
return rejectableResumeSizePromise.promise;
},
resumeChunkSize: _this.CHUNK_SIZE,
data: data,
});
fileUpload.then(function (result) {
observer.onNext({ result: result.data, type: UploadEventType.RESULT });
observer.onCompleted();
}, function (error) {
observer.onError(error);
}, function (progress) {
observer.onNext({ progress: progress, type: UploadEventType.PROGRESS });
});
return function () {
// To differentiate between connections aborted by server or client (when computer
// goes to standby/sleep), we emit a custom error. Otherwise we would have to
// filter out all `xhrStatus === 'abort'` and couldn't auto-retry after standby.
observer.onError({ xhrStatus: 'manual-abort' });
fileUpload.abort();
rejectableResumeSizePromise.reject();
};
})
.retryWhen(function (errors) {
return errors
.filter(function (error) { return error && error.xhrStatus !== 'manual-abort'; })
.timeInterval()
.scan(function (accumulated, value) {
var error = value.value;
var timeSincePrevious = value.interval;
var consecutiveErrors = accumulated.consecutiveErrors + 1;
if (_this.isTimeToResetAutoretryAttempts(timeSincePrevious))
consecutiveErrors = 1;
var retry = consecutiveErrors <= _this.maxConsecutiveAutoretryAttempts;
var delay = Math.min(consecutiveErrors * _this.RETRY_DELAY_INCREMENT, _this.MAX_RETRY_DELAY);
return { error: error, consecutiveErrors: consecutiveErrors, timeSincePrevious: timeSincePrevious, retry: retry, delay: delay };
}, { error: null, consecutiveErrors: 0, timeSincePrevious: 0, retry: false, delay: 0 })
.flatMap(function (_a) {
var retry = _a.retry, delay = _a.delay, error = _a.error;
// This event is probably computer going to standby. Wait a bit longer.
if (error && error.xhrStatus === 'abort')
delay = 10000;
if (!retry) { // Stop retrying after a while and return unwrapped error
return Rx.Observable.throw(error);
}
return Rx.Observable.just(error).delay(delay);
})
.do(function (error) {
console.info("Retrying upload after an error", error);
});
})
.skip(1) // Skip initial 'retrying' event.
.filter(function (event) {
// If a retry request fails, it would remove the progress bar until it
// succeeds again. With this filter we can keep the progress bar anyway.
return !(event.type === UploadEventType.PROGRESS && event.progress.loaded === 0 && event.progress.total === 0);
});
};
/**
* Uploads string content as a file.
*/
APIServiceBase.prototype.uploadString = function (filename, content) {
var file;
try {
file = new File([content], filename, { type: 'text/plain', lastModified: Date.now() });
}
catch (e) {
// Simple fallback for Safari 9 and IE/Edge, because they don't
// support File constructor.
file = _.assign(new Blob([content], { type: 'text/plain' }), { name: filename });
}
return this.upload({ file: file }, 'string-' + random.randomUuid());
};
return APIServiceBase;
}());
exports.APIServiceBase = APIServiceBase;
/**
* Service provider for configuring the API service. Before using the
* API service, this provider must be configured with an actual API
* class, which should derive from [[ResolweApi]].
*
* For example, if the API class is called `BaseApi`, we can configure
* the API service as follows:
* ```
* // Create a type for the service.
* export interface APIService extends APIServiceBase, BaseApi {
* }
*
* // Configure the API provider with our API instance.
* module.config((apiProvider: APIServiceProvider) => {
* apiProvider.setAPI(
* BaseApi,
* new SimpleConnection(),
* REST_URL,
* WEBSOCKET_URL
* );
*
* // Configure upload auto-retries to infinity
* apiProvider.setMaxConsecutiveAutoretryAttempts(Infinity);
* });
* ```
*/
var APIServiceProvider = /** @class */ (function () {
function APIServiceProvider() {
}
APIServiceProvider.prototype.setAPI = function (api, locals) {
this._api = api;
this._apiLocals = locals;
};
APIServiceProvider.prototype.setMaxConsecutiveAutoretryAttempts = function (retries) {
this._maxConsecutiveAutoretryAttempts = retries;
};
// @ngInject
APIServiceProvider.prototype.$get = function ($injector) {
// TODO: Use error notification service instead.
if (!this._api)
throw new error_1.GenError("API not configured.");
// Mix together the API and the APIServiceBase.
var serviceClass = lang_1.ngCompose([this._api, APIServiceBase]);
return $injector.instantiate(serviceClass, __assign({}, this._apiLocals, { maxConsecutiveAutoretryAttempts: this._maxConsecutiveAutoretryAttempts }));
};
APIServiceProvider.prototype.$get.$inject = ["$injector"];
return APIServiceProvider;
}());
exports.APIServiceProvider = APIServiceProvider;
angularModule.provider('api', APIServiceProvider);
//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["../src/core/services/api.ts"],"names":[],"mappings":"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","file":"core/services/api.js","sourcesContent":["import * as Rx from 'rx';\nimport * as angular from 'angular';\nimport * as _ from 'lodash';\nimport 'ng-file-upload';\n\nimport {GenError} from '../errors/error';\nimport {ResolweApi} from '../../api';\nimport {Connection} from '../../api/connection';\nimport {FileUploadResponse} from '../../api/types/modules';\nimport {ngCompose} from '../utils/lang';\nimport * as random from '../utils/random';\n\nconst angularModule: angular.IModule = angular.module('resolwe.services.api', [\n    'ngFileUpload',\n]);\n\nexport enum UploadEventType {\n    PROGRESS = 'progress',\n    RETRYING = 'retrying',\n    RESULT = 'result',\n}\n\nexport type UploadEvent<T> = { progress: ProgressEvent, type: UploadEventType.PROGRESS } |\n                             { type: UploadEventType.RETRYING } |\n                             { result: T, type: UploadEventType.RESULT };\n\n/**\n * Base API service class providing additional features like file\n * upload support. It should be used as a mixin together with an\n * actual API class.\n */\nexport class APIServiceBase {\n    public CHUNK_SIZE = 1 * 1024 * 1024; // 1MB\n\n    /**\n     * Max consecutive autoretry attempts are configurable in provider. An autoretry attempt is not\n     * considered consecutive if it happens later than 2 * maxDelay (retry attempts are reset after\n     * that time).\n     */\n    public maxConsecutiveAutoretryAttempts = 5;\n    public RETRY_DELAY_INCREMENT = 500;\n    public MAX_RETRY_DELAY = 5000;\n    public isTimeToResetAutoretryAttempts(timeSincePreviousError: number): boolean {\n        const maxDelay = Math.max(this.maxConsecutiveAutoretryAttempts * this.RETRY_DELAY_INCREMENT, this.MAX_RETRY_DELAY);\n        return timeSincePreviousError > 2 * maxDelay;\n    }\n\n    // Note that this connection property is not initialized anywhere as it will\n    // be initialized by the actual API which is mixed in by the provider.\n    public connection: Connection;\n\n    private _upload: angular.angularFileUpload.IUploadService;\n    private _q: angular.IQService;\n    private _http: angular.IHttpService;\n\n    // @ngInject\n    constructor(Upload: angular.angularFileUpload.IUploadService,\n                $q: angular.IQService,\n                $http: angular.IHttpService,\n                maxConsecutiveAutoretryAttempts?: number) {\n        this._upload = Upload;\n        this._q = $q;\n        this._http = $http;\n\n        if (!_.isUndefined(maxConsecutiveAutoretryAttempts)) {\n            this.maxConsecutiveAutoretryAttempts = maxConsecutiveAutoretryAttempts;\n        }\n    }\n\n    /**\n     * Performs a data upload.\n     *\n     * Each field including nested objects will be sent as a form data multipart.\n     * Samples:\n     *   {pic: file, username: username}\n     *   {files: files, otherInfo: {id: id, person: person,...}} multiple files (html5)\n     *   {profiles: {[{pic: file1, username: username1}, {pic: file2, username: username2}]} nested array multiple files (html5)\n     *   {file: file, info: Upload.json({id: id, name: name, ...})} send fields as json string\n     *   {file: file, info: Upload.jsonBlob({id: id, name: name, ...})} send fields as json blob, 'application/json' content_type\n     *   {picFile: Upload.rename(file, 'profile.jpg'), title: title} send file with picFile key and profile.jpg file name\n     *\n     * @param {any} data See angular.angularFileUpload.IFileUploadConfigFile.\n     */\n    public upload<T>(data: any, fileUID: string = ''): Rx.Observable<UploadEvent<T>> {\n        const url = this.connection.createUriFromPath('/upload/');\n        const headers: angular.IHttpRequestConfigHeaders = {\n            'Session-Id': this.connection.sessionId(),\n            'X-File-Uid': fileUID,\n            'X-CSRFToken': this.connection.csrfCookie(),\n        };\n\n        return Rx.Observable.create<UploadEvent<T>>((observer) => {\n            observer.onNext({ type: UploadEventType.RETRYING }); // Note: First one of these is skipped below.\n\n            const rejectableResumeSizePromise = this._q.defer<number>();\n            const fileUpload = this._upload.upload<T>({\n                url: url,\n                method: 'POST',\n                headers: headers,\n                withCredentials: true,\n                resumeSize: () => {\n                    const resumeSizePromise = this._http.get(url, {\n                        headers: headers,\n                        withCredentials: true,\n                    }).then((response) => {\n                        return (<any> response.data).resume_offset;\n                    }, (error) => {\n                        observer.onError(error); // Handled in observables\n                        return this._q.defer().promise; // Never resolve\n                    });\n\n                    rejectableResumeSizePromise.resolve(resumeSizePromise);\n                    return rejectableResumeSizePromise.promise;\n                },\n                resumeChunkSize: this.CHUNK_SIZE,\n                data: data,\n            });\n\n            fileUpload.then((result) => {\n                observer.onNext({ result: result.data, type: UploadEventType.RESULT });\n                observer.onCompleted();\n            }, (error) => {\n                observer.onError(error);\n            }, (progress) => {\n                observer.onNext({ progress: progress, type: UploadEventType.PROGRESS });\n            });\n\n            return () => {\n                // To differentiate between connections aborted by server or client (when computer\n                // goes to standby/sleep), we emit a custom error. Otherwise we would have to\n                // filter out all `xhrStatus === 'abort'` and couldn't auto-retry after standby.\n                observer.onError({xhrStatus: 'manual-abort'});\n                fileUpload.abort();\n                rejectableResumeSizePromise.reject();\n            };\n        })\n        .retryWhen((errors) => {\n            return errors\n                .filter((error) => error && error.xhrStatus !== 'manual-abort')\n                .timeInterval()\n                .scan((accumulated, value) => {\n                    const error = value.value;\n                    const timeSincePrevious = value.interval;\n\n                    let consecutiveErrors = accumulated.consecutiveErrors + 1;\n                    if (this.isTimeToResetAutoretryAttempts(timeSincePrevious)) consecutiveErrors = 1;\n\n                    const retry = consecutiveErrors <= this.maxConsecutiveAutoretryAttempts;\n                    const delay = Math.min(consecutiveErrors * this.RETRY_DELAY_INCREMENT, this.MAX_RETRY_DELAY);\n\n                    return { error, consecutiveErrors, timeSincePrevious, retry, delay };\n                }, { error: null, consecutiveErrors: 0, timeSincePrevious: 0, retry: false, delay: 0 })\n                .flatMap(({retry, delay, error}) => {\n                    // This event is probably computer going to standby. Wait a bit longer.\n                    if (error && error.xhrStatus === 'abort') delay = 10000;\n\n                    if (!retry) { // Stop retrying after a while and return unwrapped error\n                        return Rx.Observable.throw(error);\n                    }\n                    return Rx.Observable.just(error).delay(delay);\n                })\n                .do((error) => {\n                    console.info(\"Retrying upload after an error\", error);\n                });\n        })\n        .skip(1) // Skip initial 'retrying' event.\n        .filter((event) => {\n            // If a retry request fails, it would remove the progress bar until it\n            // succeeds again. With this filter we can keep the progress bar anyway.\n            return !(event.type === UploadEventType.PROGRESS && event.progress.loaded === 0 && event.progress.total === 0);\n        });\n    }\n\n    /**\n     * Uploads string content as a file.\n     */\n    public uploadString(filename: string, content: string): Rx.Observable<UploadEvent<FileUploadResponse>> {\n        let file: File;\n        try {\n            file = new File([content], filename, {type: 'text/plain', lastModified: Date.now()});\n        } catch (e) {\n            // Simple fallback for Safari 9 and IE/Edge, because they don't\n            // support File constructor.\n            file = <File> _.assign(new Blob([content], {type: 'text/plain'}), {name: filename});\n        }\n\n        return this.upload<FileUploadResponse>({file: file}, 'string-' + random.randomUuid());\n    }\n}\n\n/**\n * Service provider for configuring the API service. Before using the\n * API service, this provider must be configured with an actual API\n * class, which should derive from [[ResolweApi]].\n *\n * For example, if the API class is called `BaseApi`, we can configure\n * the API service as follows:\n * ```\n * // Create a type for the service.\n * export interface APIService extends APIServiceBase, BaseApi {\n * }\n *\n * // Configure the API provider with our API instance.\n * module.config((apiProvider: APIServiceProvider) => {\n *     apiProvider.setAPI(\n *         BaseApi,\n *         new SimpleConnection(),\n *         REST_URL,\n *         WEBSOCKET_URL\n *     );\n *\n *     // Configure upload auto-retries to infinity\n *     apiProvider.setMaxConsecutiveAutoretryAttempts(Infinity);\n * });\n * ```\n */\nexport class APIServiceProvider {\n    // API instance that should be used by the service.\n    private _api: typeof ResolweApi;\n    private _apiLocals: _.Dictionary<string>;\n    private _maxConsecutiveAutoretryAttempts: number;\n\n    public setAPI(api: new (...injections: any[]) => ResolweApi,\n                  locals: {connection: Connection, restUri: string, websocketUri: string, [key: string]: any }) {\n        this._api = api;\n        this._apiLocals = locals;\n    }\n\n    public setMaxConsecutiveAutoretryAttempts(retries: number) {\n        this._maxConsecutiveAutoretryAttempts = retries;\n    }\n\n    // @ngInject\n    public $get($injector: angular.auto.IInjectorService) {\n        // TODO: Use error notification service instead.\n        if (!this._api) throw new GenError(\"API not configured.\");\n\n        // Mix together the API and the APIServiceBase.\n        const serviceClass = ngCompose([this._api, APIServiceBase]);\n\n        return $injector.instantiate(serviceClass, {\n            ...this._apiLocals,\n            maxConsecutiveAutoretryAttempts: this._maxConsecutiveAutoretryAttempts,\n        });\n    }\n}\n\nangularModule.provider('api', APIServiceProvider);\n"]}