ngx-image-uploader/esm2015/lib/image-uploader.service.js

Angular2 asynchronous image uploader with preview

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
import { Observable } from 'rxjs';
import { Injectable } from '@angular/core';
import { HttpClient, HttpRequest, HttpEventType, HttpResponse, HttpHeaders } from '@angular/common/http';
import { FileQueueObject } from './file-queue-object';
import { FileQueueStatus } from './file-queue-status';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common/http";
export class ImageUploaderService {
    /**
     * @param {?} http
     */
    constructor(http) {
        this.http = http;
    }
    /**
     * @param {?} file
     * @param {?} options
     * @param {?=} cropOptions
     * @return {?}
     */
    uploadFile(file, options, cropOptions) {
        this.setDefaults(options);
        const /** @type {?} */ form = new FormData();
        form.append(options.fieldName, file, file.name);
        if (cropOptions) {
            form.append('X', cropOptions.x.toString());
            form.append('Y', cropOptions.y.toString());
            form.append('Width', cropOptions.width.toString());
            form.append('Height', cropOptions.height.toString());
        }
        // upload file and report progress
        const /** @type {?} */ req = new HttpRequest('POST', options.uploadUrl, form, {
            reportProgress: true,
            withCredentials: options.withCredentials,
            headers: this._buildHeaders(options)
        });
        return Observable.create(obs => {
            const /** @type {?} */ queueObj = new FileQueueObject(file);
            queueObj.request = this.http.request(req).subscribe((event) => {
                if (event.type === HttpEventType.UploadProgress) {
                    this._uploadProgress(queueObj, event);
                    obs.next(queueObj);
                }
                else if (event instanceof HttpResponse) {
                    this._uploadComplete(queueObj, event);
                    obs.next(queueObj);
                    obs.complete();
                }
            }, (err) => {
                if (err.error instanceof Error) {
                    // A client-side or network error occurred. Handle it accordingly.
                    this._uploadFailed(queueObj, err);
                    obs.next(queueObj);
                    obs.complete();
                }
                else {
                    // The backend returned an unsuccessful response code.
                    this._uploadFailed(queueObj, err);
                    obs.next(queueObj);
                    obs.complete();
                }
            });
        });
    }
    /**
     * @param {?} url
     * @param {?} options
     * @return {?}
     */
    getFile(url, options) {
        return Observable.create((observer) => {
            let /** @type {?} */ headers = new HttpHeaders();
            if (options.authToken) {
                headers = headers.append('Authorization', `${options.authTokenPrefix} ${options.authToken}`);
            }
            this.http.get(url, { responseType: 'blob', headers: headers }).subscribe(res => {
                const /** @type {?} */ file = new File([res], 'filename', { type: res.type });
                observer.next(file);
                observer.complete();
            }, err => {
                observer.error(err.status);
                observer.complete();
            });
        });
    }
    /**
     * @param {?} options
     * @return {?}
     */
    _buildHeaders(options) {
        let /** @type {?} */ headers = new HttpHeaders();
        if (options.authToken) {
            headers = headers.append('Authorization', `${options.authTokenPrefix} ${options.authToken}`);
        }
        if (options.customHeaders) {
            Object.keys(options.customHeaders).forEach((key) => {
                headers = headers.append(key, options.customHeaders[key]);
            });
        }
        return headers;
    }
    /**
     * @param {?} queueObj
     * @param {?} event
     * @return {?}
     */
    _uploadProgress(queueObj, event) {
        // update the FileQueueObject with the current progress
        const /** @type {?} */ progress = Math.round(100 * event.loaded / event.total);
        queueObj.progress = progress;
        queueObj.status = FileQueueStatus.Progress;
        // this._queue.next(this._files);
    }
    /**
     * @param {?} queueObj
     * @param {?} response
     * @return {?}
     */
    _uploadComplete(queueObj, response) {
        // update the FileQueueObject as completed
        queueObj.progress = 100;
        queueObj.status = FileQueueStatus.Success;
        queueObj.response = response;
        // this._queue.next(this._files);
        // this.onCompleteItem(queueObj, response.body);
    }
    /**
     * @param {?} queueObj
     * @param {?} response
     * @return {?}
     */
    _uploadFailed(queueObj, response) {
        // update the FileQueueObject as errored
        queueObj.progress = 0;
        queueObj.status = FileQueueStatus.Error;
        queueObj.response = response;
        // this._queue.next(this._files);
    }
    /**
     * @param {?} options
     * @return {?}
     */
    setDefaults(options) {
        options.withCredentials = options.withCredentials || false;
        options.httpMethod = options.httpMethod || 'POST';
        options.authTokenPrefix = options.authTokenPrefix || 'Bearer';
        options.fieldName = options.fieldName || 'file';
    }
}
ImageUploaderService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] },
];
/** @nocollapse */
ImageUploaderService.ctorParameters = () => [
    { type: HttpClient, },
];
/** @nocollapse */ ImageUploaderService.ngInjectableDef = i0.defineInjectable({ factory: function ImageUploaderService_Factory() { return new ImageUploaderService(i0.inject(i1.HttpClient)); }, token: ImageUploaderService, providedIn: "root" });
function ImageUploaderService_tsickle_Closure_declarations() {
    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
    ImageUploaderService.decorators;
    /**
     * @nocollapse
     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
     */
    ImageUploaderService.ctorParameters;
    /** @type {?} */
    ImageUploaderService.prototype.http;
}

//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-uploader.service.js","sourceRoot":"ng://ngx-image-uploader/","sources":["lib/image-uploader.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observer, Observable } from 'rxjs';\r\nimport { Injectable } from '@angular/core';\r\nimport { HttpClient, HttpRequest, HttpEventType, HttpResponse, HttpErrorResponse, HttpHeaders } from '@angular/common/http';\r\n\r\nimport { FileQueueObject } from './file-queue-object';\r\nimport { FileQueueStatus } from './file-queue-status';\r\nimport { FileUploaderOptions, CropOptions } from './interfaces';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ImageUploaderService {\r\n\r\n  constructor(private http: HttpClient) {}\r\n\r\n  uploadFile(file: File, options: FileUploaderOptions, cropOptions?: CropOptions): Observable<FileQueueObject> {\r\n    this.setDefaults(options);\r\n\r\n    const form = new FormData();\r\n    form.append(options.fieldName, file, file.name);\r\n\r\n    if (cropOptions) {\r\n      form.append('X', cropOptions.x.toString());\r\n      form.append('Y', cropOptions.y.toString());\r\n      form.append('Width', cropOptions.width.toString());\r\n      form.append('Height', cropOptions.height.toString());\r\n    }\r\n\r\n    // upload file and report progress\r\n    const req = new HttpRequest('POST', options.uploadUrl, form, {\r\n      reportProgress: true,\r\n      withCredentials: options.withCredentials,\r\n      headers: this._buildHeaders(options)\r\n    });\r\n\r\n    return Observable.create(obs => {\r\n      const queueObj = new FileQueueObject(file);\r\n\r\n      queueObj.request = this.http.request(req).subscribe(\r\n        (event: any) => {\r\n          if (event.type === HttpEventType.UploadProgress) {\r\n            this._uploadProgress(queueObj, event);\r\n            obs.next(queueObj);\r\n          } else if (event instanceof HttpResponse) {\r\n            this._uploadComplete(queueObj, event);\r\n            obs.next(queueObj);\r\n            obs.complete();\r\n          }\r\n        },\r\n        (err: HttpErrorResponse) => {\r\n          if (err.error instanceof Error) {\r\n            // A client-side or network error occurred. Handle it accordingly.\r\n            this._uploadFailed(queueObj, err);\r\n            obs.next(queueObj);\r\n            obs.complete();\r\n          } else {\r\n            // The backend returned an unsuccessful response code.\r\n            this._uploadFailed(queueObj, err);\r\n            obs.next(queueObj);\r\n            obs.complete();\r\n          }\r\n        }\r\n      );\r\n    });\r\n  }\r\n\r\n  getFile(url: string, options: { authToken?: string, authTokenPrefix?: string }): Observable<File> {\r\n    return Observable.create((observer: Observer<File>) => {\r\n      let headers = new HttpHeaders();\r\n\r\n      if (options.authToken) {\r\n        headers = headers.append('Authorization', `${options.authTokenPrefix} ${options.authToken}`);\r\n      }\r\n\r\n      this.http.get(url, { responseType: 'blob', headers: headers}).subscribe(res => {\r\n        const file = new File([res], 'filename', { type: res.type });\r\n        observer.next(file);\r\n        observer.complete();\r\n      }, err => {\r\n        observer.error(err.status);\r\n        observer.complete();\r\n      });\r\n    });\r\n  }\r\n\r\n  private _buildHeaders(options: FileUploaderOptions): HttpHeaders {\r\n    let headers = new HttpHeaders();\r\n\r\n    if (options.authToken) {\r\n      headers = headers.append('Authorization', `${options.authTokenPrefix} ${options.authToken}`);\r\n    }\r\n\r\n    if (options.customHeaders) {\r\n      Object.keys(options.customHeaders).forEach((key) => {\r\n        headers = headers.append(key, options.customHeaders[key]);\r\n      });\r\n    }\r\n\r\n    return headers;\r\n  }\r\n\r\n  private _uploadProgress(queueObj: FileQueueObject, event: any) {\r\n    // update the FileQueueObject with the current progress\r\n    const progress = Math.round(100 * event.loaded / event.total);\r\n    queueObj.progress = progress;\r\n    queueObj.status = FileQueueStatus.Progress;\r\n    // this._queue.next(this._files);\r\n  }\r\n\r\n  private _uploadComplete(queueObj: FileQueueObject, response: HttpResponse<any>) {\r\n    // update the FileQueueObject as completed\r\n    queueObj.progress = 100;\r\n    queueObj.status = FileQueueStatus.Success;\r\n    queueObj.response = response;\r\n    // this._queue.next(this._files);\r\n    // this.onCompleteItem(queueObj, response.body);\r\n  }\r\n\r\n  private _uploadFailed(queueObj: FileQueueObject, response: HttpErrorResponse) {\r\n    // update the FileQueueObject as errored\r\n    queueObj.progress = 0;\r\n    queueObj.status = FileQueueStatus.Error;\r\n    queueObj.response = response;\r\n    // this._queue.next(this._files);\r\n  }\r\n\r\n  private setDefaults(options: FileUploaderOptions) {\r\n    options.withCredentials = options.withCredentials || false;\r\n    options.httpMethod = options.httpMethod || 'POST';\r\n    options.authTokenPrefix = options.authTokenPrefix || 'Bearer';\r\n    options.fieldName = options.fieldName || 'file';\r\n  }\r\n}\r\n"]}