@rs-pk/asset-management 1.0.0

package/esm5/lib/services/node-tree.service.js

@@ -0,0 +1,278 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+import { AssetManagementService } from '../asset-management.service';
+import { DynamicFlatNode } from '../models';
+import { ActionTypes } from '../store';
+import { AssetService } from './asset.service';
+var NodeTreeService = /** @class */ (function () {
+    function NodeTreeService(assetService, svc) {
+        this.assetService = assetService;
+        this.svc = svc;
+        this.storedData$ = new BehaviorSubject([]);
+        this.loading$ = new BehaviorSubject(false);
+        this.initialData$ = new BehaviorSubject([]);
+    }
+    Object.defineProperty(NodeTreeService.prototype, "data", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.storedData$.getValue();
+        },
+        set: /**
+         * @param {?} values
+         * @return {?}
+         */
+        function (values) {
+            this.storedData$.next(values);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     * @param {?} id
+     * @return {?}
+     */
+    NodeTreeService.prototype.fetchChildrenFolder = /**
+     * @private
+     * @param {?} id
+     * @return {?}
+     */
+    function (id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result, err_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.assetService.getChildrenFolders({ assetId: id, isFilter: false }).toPromise()];
+                    case 1:
+                        result = _a.sent();
+                        if (result) {
+                            return [2 /*return*/, result.Data];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        err_1 = _a.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /** Initial data from database */
+    /**
+     * Initial data from database
+     * @param {?} __0
+     * @return {?}
+     */
+    NodeTreeService.prototype.initialData = /**
+     * Initial data from database
+     * @param {?} __0
+     * @return {?}
+     */
+    function (_a) {
+        var dispatchRootId = _a.dispatchRootId;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result, initData;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (dispatchRootId) {
+                            this.loading$.next(true);
+                        }
+                        return [4 /*yield*/, this.assetService.getChildrenFolders({ isFilter: false }).toPromise()];
+                    case 1:
+                        result = _b.sent();
+                        if (!result) {
+                            return [2 /*return*/];
+                        }
+                        if (dispatchRootId) {
+                            this.svc.dispatch({
+                                type: ActionTypes.SET_CURRENT_FOLDER_ID,
+                                payload: result.Data.AssetId,
+                            });
+                            this.svc.dispatch({
+                                type: ActionTypes.SET_CURRENT_FOLDER_HIERARCHY,
+                                payload: [],
+                            });
+                        }
+                        this.rootFolder = result.Data;
+                        initData = result.Data.Children.map((/**
+                         * @param {?} folder
+                         * @return {?}
+                         */
+                        function (folder) { return new DynamicFlatNode(folder, 0, _this.isExpandable(folder)); }));
+                        this.initialData$.next(initData);
+                        if (dispatchRootId) {
+                            this.loading$.next(false);
+                        }
+                        return [2 /*return*/, this.initialData$.getValue()];
+                }
+            });
+        });
+    };
+    /**
+     * @param {?} node
+     * @return {?}
+     */
+    NodeTreeService.prototype.getChildren = /**
+     * @param {?} node
+     * @return {?}
+     */
+    function (node) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.fetchChildrenFolder(node.AssetId)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * @param {?} node
+     * @return {?}
+     */
+    NodeTreeService.prototype.isExpandable = /**
+     * @param {?} node
+     * @return {?}
+     */
+    function (node) {
+        return node.HaveChildren;
+    };
+    /** Add asset to stored data */
+    /**
+     * Add asset to stored data
+     * @param {?} asset
+     * @param {?=} parentId
+     * @return {?}
+     */
+    NodeTreeService.prototype.addNode = /**
+     * Add asset to stored data
+     * @param {?} asset
+     * @param {?=} parentId
+     * @return {?}
+     */
+    function (asset, parentId) {
+        /** @type {?} */
+        var data = tslib_1.__spread(this.data);
+        /** @type {?} */
+        var index = data.findIndex((/**
+         * @param {?} node
+         * @return {?}
+         */
+        function (node) { return node.AssetId === asset.AssetId; }));
+        if (index < 0) {
+            data = tslib_1.__spread(data, [tslib_1.__assign({}, asset, { ParentId: parentId ? parentId : null })]);
+        }
+        this.data = data;
+    };
+    /**
+     * @param {?} id
+     * @return {?}
+     */
+    NodeTreeService.prototype.updateBreadcrumb = /**
+     * @param {?} id
+     * @return {?}
+     */
+    function (id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var folder, hierarchy;
+            return tslib_1.__generator(this, function (_a) {
+                folder = this.data.find((/**
+                 * @param {?} n
+                 * @return {?}
+                 */
+                function (n) { return n.AssetId === id; }));
+                if (folder) {
+                    hierarchy = this.getFolderHierarchy(folder);
+                    this.svc.dispatch({
+                        type: ActionTypes.SET_CURRENT_FOLDER_HIERARCHY,
+                        payload: hierarchy,
+                    });
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * @private
+     * @param {?} node
+     * @return {?}
+     */
+    NodeTreeService.prototype.getAssetParent = /**
+     * @private
+     * @param {?} node
+     * @return {?}
+     */
+    function (node) {
+        return this.data.find((/**
+         * @param {?} n
+         * @return {?}
+         */
+        function (n) { return n.AssetId === node.ParentId; }));
+    };
+    /**
+     * @private
+     * @param {?} node
+     * @return {?}
+     */
+    NodeTreeService.prototype.getFolderHierarchy = /**
+     * @private
+     * @param {?} node
+     * @return {?}
+     */
+    function (node) {
+        if (!node) {
+            return [];
+        }
+        /** @type {?} */
+        var parentHierarchy = [];
+        /** @type {?} */
+        var parent = this.getAssetParent(node);
+        while (parent) {
+            parentHierarchy = tslib_1.__spread([parent], parentHierarchy);
+            parent = this.getAssetParent(parent);
+        }
+        return tslib_1.__spread(parentHierarchy, [node]);
+    };
+    NodeTreeService.decorators = [
+        { type: Injectable }
+    ];
+    /** @nocollapse */
+    NodeTreeService.ctorParameters = function () { return [
+        { type: AssetService },
+        { type: AssetManagementService }
+    ]; };
+    return NodeTreeService;
+}());
+export { NodeTreeService };
+if (false) {
+    /** @type {?} */
+    NodeTreeService.prototype.storedData$;
+    /** @type {?} */
+    NodeTreeService.prototype.loading$;
+    /** @type {?} */
+    NodeTreeService.prototype.initialData$;
+    /** @type {?} */
+    NodeTreeService.prototype.rootFolder;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeTreeService.prototype.assetService;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeTreeService.prototype.svc;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-tree.service.js","sourceRoot":"ng://@rs-pk/asset-management/","sources":["lib/services/node-tree.service.ts"],"names":[],"mappings":";;;;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAc,eAAe,EAA8C,MAAM,WAAW,CAAC;AACpG,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C;IAEE,yBAAoB,YAA0B,EAAU,GAA2B;QAA/D,iBAAY,GAAZ,YAAY,CAAc;QAAU,QAAG,GAAH,GAAG,CAAwB;QAE5E,gBAAW,GAAG,IAAI,eAAe,CAAe,EAAE,CAAC,CAAC;QACpD,aAAQ,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QAC/C,iBAAY,GAAuC,IAAI,eAAe,CAAC,EAAE,CAAC,CAAC;IAJK,CAAC;IAOxF,sBAAI,iCAAI;;;;QAAR;YACE,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;QACrC,CAAC;;;;;QACD,UAAS,MAAoB;YAC3B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChC,CAAC;;;OAHA;;;;;;IAKa,6CAAmB;;;;;IAAjC,UAAkC,EAAU;;;;;;;wBAEzB,qBAAM,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,SAAS,EAAE,EAAA;;wBAAjG,MAAM,GAAG,SAAwF;wBACvG,IAAI,MAAM,EAAE;4BACV,sBAAO,MAAM,CAAC,IAAI,EAAC;yBACpB;;;;;4BAEH,sBAAO;;;;KACR;IAED,iCAAiC;;;;;;IACpB,qCAAW;;;;;IAAxB,UACE,EAA6C;YAA3C,kCAAc;;;;;;;wBAEhB,IAAI,cAAc,EAAE;4BAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;yBAAE;wBAClC,qBAAM,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,SAAS,EAAE,EAAA;;wBAApF,MAAM,GAAG,SAA2E;wBAC1F,IAAI,CAAC,MAAM,EAAE;4BAAE,sBAAO;yBAAE;wBACxB,IAAI,cAAc,EAAE;4BAClB,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC;gCAChB,IAAI,EAAE,WAAW,CAAC,qBAAqB;gCACvC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO;6BAC7B,CAAC,CAAC;4BACH,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC;gCAChB,IAAI,EAAE,WAAW,CAAC,4BAA4B;gCAC9C,OAAO,EAAE,EAAE;6BACZ,CAAC,CAAC;yBACJ;wBACD,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC;wBACxB,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG;;;;wBACvC,UAAC,MAAM,IAAK,OAAA,IAAI,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,KAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EAAzD,CAAyD,EACtE;wBACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;wBAEjC,IAAI,cAAc,EAAE;4BAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;yBAAE;wBAClD,sBAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,EAAC;;;;KACrC;;;;;IAEY,qCAAW;;;;IAAxB,UAAyB,IAAqB;;;;4BACrC,qBAAM,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAA;4BAAnD,sBAAO,SAA4C,EAAC;;;;KACrD;;;;;IAEM,sCAAY;;;;IAAnB,UAAoB,IAAqB;QACvC,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,+BAA+B;;;;;;;IACxB,iCAAO;;;;;;IAAd,UAAe,KAAiB,EAAE,QAAiB;;YAC7C,IAAI,oBAAO,IAAI,CAAC,IAAI,CAAC;;YACnB,KAAK,GAAG,IAAI,CAAC,SAAS;;;;QAAC,UAAC,IAAI,IAAK,OAAA,IAAI,CAAC,OAAO,KAAK,KAAK,CAAC,OAAO,EAA9B,CAA8B,EAAC;QACtE,IAAI,KAAK,GAAG,CAAC,EAAE;YACb,IAAI,oBAAO,IAAI,wBAAO,KAAK,IAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,KAAG,CAAC;SACtE;QACD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;;;;;IAEY,0CAAgB;;;;IAA7B,UAA8B,EAAU;;;;gBAChC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI;;;;gBAAC,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,OAAO,KAAK,EAAE,EAAhB,CAAgB,EAAC;gBACtD,IAAI,MAAM,EAAE;oBACJ,SAAS,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC;oBACjD,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC;wBAChB,IAAI,EAAE,WAAW,CAAC,4BAA4B;wBAC9C,OAAO,EAAE,SAAS;qBACnB,CAAC,CAAC;iBACJ;;;;KACF;;;;;;IAEO,wCAAc;;;;;IAAtB,UAAuB,IAAgB;QACrC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI;;;;QAAC,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,OAAO,KAAK,IAAI,CAAC,QAAQ,EAA3B,CAA2B,EAAC,CAAC;IAC5D,CAAC;;;;;;IAEO,4CAAkB;;;;;IAA1B,UAA2B,IAAqB;QAC9C,IAAI,CAAC,IAAI,EAAE;YACT,OAAO,EAAE,CAAC;SACX;;YACG,eAAe,GAA2B,EAAE;;YAC5C,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;QACtC,OAAO,MAAM,EAAE;YACb,eAAe,qBAAI,MAAM,GAAK,eAAe,CAAC,CAAC;YAC/C,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;SACtC;QACD,wBAAW,eAAe,GAAE,IAAI,GAAE;IACpC,CAAC;;gBAjGF,UAAU;;;;gBAFF,YAAY;gBAHZ,sBAAsB;;IAuG/B,sBAAC;CAAA,AAlGD,IAkGC;SAjGY,eAAe;;;IAG1B,sCAA2D;;IAC3D,mCAAsD;;IACtD,uCAAkF;;IAClF,qCAA8B;;;;;IALlB,uCAAkC;;;;;IAAE,8BAAmC","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';\nimport { AssetManagementService } from '../asset-management.service';\nimport { AssetModel, DynamicFlatNode, FolderTreeModel, IInitialFolderTreeOptions } from '../models';\nimport { ActionTypes } from '../store';\nimport { AssetService } from './asset.service';\n\n@Injectable()\nexport class NodeTreeService {\n  constructor(private assetService: AssetService, private svc: AssetManagementService) { }\n\n  public storedData$ = new BehaviorSubject<AssetModel[]>([]);\n  public loading$ = new BehaviorSubject<boolean>(false);\n  public initialData$: BehaviorSubject<DynamicFlatNode[]> = new BehaviorSubject([]);\n  public rootFolder: AssetModel;\n\n  get data(): AssetModel[] {\n    return this.storedData$.getValue();\n  }\n  set data(values: AssetModel[]) {\n    this.storedData$.next(values);\n  }\n\n  private async fetchChildrenFolder(id: string): Promise<FolderTreeModel> {\n    try {\n      const result = await this.assetService.getChildrenFolders({ assetId: id, isFilter: false }).toPromise();\n      if (result) {\n        return result.Data;\n      }\n    } catch (err) { }\n    return;\n  }\n\n  /** Initial data from database */\n  public async initialData(\n    { dispatchRootId }: IInitialFolderTreeOptions\n  ): Promise<DynamicFlatNode[]> {\n    if (dispatchRootId) { this.loading$.next(true); }\n    const result = await this.assetService.getChildrenFolders({ isFilter: false }).toPromise();\n    if (!result) { return; }\n    if (dispatchRootId) {\n      this.svc.dispatch({\n        type: ActionTypes.SET_CURRENT_FOLDER_ID,\n        payload: result.Data.AssetId,\n      });\n      this.svc.dispatch({\n        type: ActionTypes.SET_CURRENT_FOLDER_HIERARCHY,\n        payload: [],\n      });\n    }\n    this.rootFolder = result.Data;\n    const initData = result.Data.Children.map(\n      (folder) => new DynamicFlatNode(folder, 0, this.isExpandable(folder))\n    );\n    this.initialData$.next(initData);\n\n    if (dispatchRootId) { this.loading$.next(false); }\n    return this.initialData$.getValue();\n  }\n\n  public async getChildren(node: FolderTreeModel): Promise<FolderTreeModel> {\n    return await this.fetchChildrenFolder(node.AssetId);\n  }\n\n  public isExpandable(node: FolderTreeModel): boolean {\n    return node.HaveChildren;\n  }\n\n  /** Add asset to stored data */\n  public addNode(asset: AssetModel, parentId?: string): void {\n    let data = [...this.data];\n    const index = data.findIndex((node) => node.AssetId === asset.AssetId);\n    if (index < 0) {\n      data = [...data, { ...asset, ParentId: parentId ? parentId : null }];\n    }\n    this.data = data;\n  }\n\n  public async updateBreadcrumb(id: string) {\n    const folder = this.data.find((n) => n.AssetId === id);\n    if (folder) {\n      const hierarchy = this.getFolderHierarchy(folder);\n      this.svc.dispatch({\n        type: ActionTypes.SET_CURRENT_FOLDER_HIERARCHY,\n        payload: hierarchy,\n      });\n    }\n  }\n\n  private getAssetParent(node: AssetModel): AssetModel {\n    return this.data.find((n) => n.AssetId === node.ParentId);\n  }\n\n  private getFolderHierarchy(node: FolderTreeModel): Array<FolderTreeModel> {\n    if (!node) {\n      return [];\n    }\n    let parentHierarchy: Array<FolderTreeModel> = [];\n    let parent = this.getAssetParent(node);\n    while (parent) {\n      parentHierarchy = [parent, ...parentHierarchy];\n      parent = this.getAssetParent(parent);\n    }\n    return [...parentHierarchy, node];\n  }\n}\n"]}

package/esm5/lib/services/upload-assets.service.js

@@ -0,0 +1,260 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { BehaviorSubject } from 'rxjs';
+import { BaseHttpClient } from './base.service';
+import { AM_CONFIG } from './env-config.service';
+var UploadAssetsService = /** @class */ (function () {
+    function UploadAssetsService(_env, dialog, _api) {
+        this._env = _env;
+        this.dialog = dialog;
+        this._api = _api;
+        this.files = [];
+        this.namesMap = {};
+        this.errorsMap = {};
+        this.supportedSize = 10 * 1024 * 1024; // 10MB
+        // 10MB
+        this.documentExtension = ['.pdf'];
+        this.imageExtension = [
+            '.png',
+            '.gif',
+            '.jpeg',
+            '.jpg',
+            '.svg',
+            '.svg+xml',
+        ];
+        this.supportedTypes = tslib_1.__spread(this.imageExtension, this.documentExtension);
+        this.messageErrors = {
+            size: "File size should be upto",
+            ext: "Only supported file extension:",
+        };
+        this.errorObs$ = new BehaviorSubject(true);
+        this.baseUrl = this._env.asset2Url;
+    }
+    /**
+     * @return {?}
+     */
+    UploadAssetsService.prototype.getErrorObs = /**
+     * @return {?}
+     */
+    function () {
+        return this.errorObs$.asObservable();
+    };
+    /**
+     * @param {?} error
+     * @return {?}
+     */
+    UploadAssetsService.prototype.setErrorObs = /**
+     * @param {?} error
+     * @return {?}
+     */
+    function (error) {
+        this.errorObs$.next(error);
+    };
+    Object.defineProperty(UploadAssetsService.prototype, "getFiles", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.files;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(UploadAssetsService.prototype, "setFiles", {
+        set: /**
+         * @param {?} files
+         * @return {?}
+         */
+        function (files) {
+            this.files = files;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(UploadAssetsService.prototype, "nameFiles", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.namesMap;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(UploadAssetsService.prototype, "newName", {
+        set: /**
+         * @param {?} newName
+         * @return {?}
+         */
+        function (newName) {
+            this.namesMap = tslib_1.__assign({}, this.namesMap, newName);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(UploadAssetsService.prototype, "errorFiles", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return !this.files.length || Object.keys(this.errorsMap).length > 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(UploadAssetsService.prototype, "errors", {
+        set: /**
+         * @param {?} newError
+         * @return {?}
+         */
+        function (newError) {
+            this.errorsMap = tslib_1.__assign({}, this.errorsMap, newError);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(UploadAssetsService.prototype, "fileErrors", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.errorsMap;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(UploadAssetsService.prototype, "errorLength", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return Object.keys(this.errorsMap).length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @param {?} fileName
+     * @param {?} index
+     * @return {?}
+     */
+    UploadAssetsService.prototype.deleteFile = /**
+     * @param {?} fileName
+     * @param {?} index
+     * @return {?}
+     */
+    function (fileName, index) {
+        this.files = this.files.filter((/**
+         * @param {?} _file
+         * @param {?} i
+         * @return {?}
+         */
+        function (_file, i) { return i !== index; }));
+        delete this.namesMap[fileName];
+        delete this.errorsMap[fileName];
+    };
+    /**
+     * @param {?} parentAssetId
+     * @return {?}
+     */
+    UploadAssetsService.prototype.uploadMultipleAssests = /**
+     * @param {?} parentAssetId
+     * @return {?}
+     */
+    function (parentAssetId) {
+        var e_1, _a;
+        var _b = this, files = _b.files, namesMap = _b.namesMap;
+        /** @type {?} */
+        var formData = new FormData();
+        formData.append('parentAssetId', parentAssetId);
+        formData.append('companyId', '732DA8D2-04EC-4BE0-A168-63EE0DCF50D8');
+        try {
+            for (var files_1 = tslib_1.__values(files), files_1_1 = files_1.next(); !files_1_1.done; files_1_1 = files_1.next()) {
+                var file = files_1_1.value;
+                /** @type {?} */
+                var ext = "." + file.type.split('/')[1];
+                /** @type {?} */
+                var originName = file.name;
+                /** @type {?} */
+                var fileName = namesMap[originName]
+                    ? "" + namesMap[originName] + ext
+                    : originName;
+                formData.append('files', file, fileName);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (files_1_1 && !files_1_1.done && (_a = files_1.return)) _a.call(files_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return this._api.post(this.baseUrl + "/File/Upload", formData);
+    };
+    UploadAssetsService.decorators = [
+        { type: Injectable }
+    ];
+    /** @nocollapse */
+    UploadAssetsService.ctorParameters = function () { return [
+        { type: undefined, decorators: [{ type: Inject, args: [AM_CONFIG,] }] },
+        { type: MatDialog },
+        { type: BaseHttpClient }
+    ]; };
+    return UploadAssetsService;
+}());
+export { UploadAssetsService };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    UploadAssetsService.prototype.files;
+    /**
+     * @type {?}
+     * @private
+     */
+    UploadAssetsService.prototype.namesMap;
+    /**
+     * @type {?}
+     * @private
+     */
+    UploadAssetsService.prototype.errorsMap;
+    /** @type {?} */
+    UploadAssetsService.prototype.supportedSize;
+    /** @type {?} */
+    UploadAssetsService.prototype.documentExtension;
+    /** @type {?} */
+    UploadAssetsService.prototype.imageExtension;
+    /** @type {?} */
+    UploadAssetsService.prototype.supportedTypes;
+    /** @type {?} */
+    UploadAssetsService.prototype.messageErrors;
+    /**
+     * @type {?}
+     * @private
+     */
+    UploadAssetsService.prototype.errorObs$;
+    /**
+     * @type {?}
+     * @private
+     */
+    UploadAssetsService.prototype.baseUrl;
+    /**
+     * @type {?}
+     * @private
+     */
+    UploadAssetsService.prototype._env;
+    /** @type {?} */
+    UploadAssetsService.prototype.dialog;
+    /**
+     * @type {?}
+     * @private
+     */
+    UploadAssetsService.prototype._api;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-assets.service.js","sourceRoot":"ng://@rs-pk/asset-management/","sources":["lib/services/upload-assets.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { BaseHttpClient } from './base.service';\nimport { AM_CONFIG } from './env-config.service';\n\n@Injectable()\nexport class UploadAssetsService {\n  private files: File[] = [];\n  private namesMap: { [key: string]: string } = {};\n  private errorsMap: { [key: string]: boolean } = {};\n  public readonly supportedSize = 10 * 1024 * 1024; // 10MB\n  public readonly documentExtension = ['.pdf'];\n  public readonly imageExtension = [\n    '.png',\n    '.gif',\n    '.jpeg',\n    '.jpg',\n    '.svg',\n    '.svg+xml',\n  ];\n  public supportedTypes = [...this.imageExtension, ...this.documentExtension];\n  public readonly messageErrors = {\n    size: `File size should be upto`,\n    ext: `Only supported file extension:`,\n  };\n\n  private errorObs$: BehaviorSubject<any> = new BehaviorSubject(true);\n  private baseUrl: string;\n\n  constructor(\n    @Inject(AM_CONFIG) private _env,\n    public dialog: MatDialog,\n    private _api: BaseHttpClient\n  ) {\n    this.baseUrl = this._env.asset2Url;\n  }\n\n  getErrorObs(): Observable<any> {\n    return this.errorObs$.asObservable();\n  }\n\n  setErrorObs(error: boolean) {\n    this.errorObs$.next(error);\n  }\n\n  get getFiles(): File[] {\n    return this.files;\n  }\n\n  set setFiles(files: File[]) {\n    this.files = files;\n  }\n\n  get nameFiles(): { [key: string]: string } {\n    return this.namesMap;\n  }\n\n  set newName(newName: { [key: string]: string }) {\n    this.namesMap = { ...this.namesMap, ...newName };\n  }\n\n  get errorFiles(): boolean {\n    return !this.files.length || Object.keys(this.errorsMap).length > 0;\n  }\n\n  set errors(newError: { [key: string]: boolean }) {\n    this.errorsMap = { ...this.errorsMap, ...newError };\n  }\n\n  get fileErrors() {\n    return this.errorsMap;\n  }\n\n  get errorLength() {\n    return Object.keys(this.errorsMap).length;\n  }\n\n  public deleteFile(fileName: string, index: number) {\n    this.files = this.files.filter((_file, i) => i !== index);\n    delete this.namesMap[fileName];\n    delete this.errorsMap[fileName];\n  }\n\n  uploadMultipleAssests(parentAssetId: string) {\n    const { files, namesMap } = this;\n    const formData = new FormData();\n    formData.append('parentAssetId', parentAssetId);\n    formData.append('companyId', '732DA8D2-04EC-4BE0-A168-63EE0DCF50D8');\n\n    for (const file of files) {\n      const ext = `.${file.type.split('/')[1]}`;\n      const originName = file.name;\n      const fileName = namesMap[originName]\n        ? `${namesMap[originName]}${ext}`\n        : originName;\n\n      formData.append('files', file, fileName);\n    }\n\n    return this._api.post<any>(`${this.baseUrl}/File/Upload`, formData);\n  }\n}\n"]}