@rs-pk/asset-management 1.0.0

package/esm5/lib/components/partial/asset-item/asset-item.component.js

@@ -0,0 +1,184 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { DomSanitizer } from '@angular/platform-browser';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { AssetManagementService } from '../../../asset-management.service';
+import { imagePdf } from '../../../contanst';
+import { AssetModel, FileTypeEnum } from '../../../models';
+import { AssetService } from '../../../services/asset.service';
+import { ActionTypes, select } from '../../../store';
+import { AssetDialogComponent } from '../asset-dialog/asset-dialog.component';
+var AssetItemComponent = /** @class */ (function () {
+    function AssetItemComponent(dialog, domSanitizer, svc, assetService) {
+        this.dialog = dialog;
+        this.domSanitizer = domSanitizer;
+        this.svc = svc;
+        this.assetService = assetService;
+        this.selectAsset = new EventEmitter();
+        this.base64Pdf = this.domSanitizer.bypassSecurityTrustUrl(imagePdf);
+        this.selectedAssets = [];
+        this.fileType = FileTypeEnum;
+        this.destroy$ = new Subject();
+        this.bindSubscriber();
+    }
+    /**
+     * @return {?}
+     */
+    AssetItemComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () { };
+    Object.defineProperty(AssetItemComponent.prototype, "checkSelectedAsset", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            var _this = this;
+            return (this.selectedAssets &&
+                this.selectedAssets.some((/**
+                 * @param {?} asset
+                 * @return {?}
+                 */
+                function (asset) { return asset.AssetId === _this.asset.AssetId; })));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     * @return {?}
+     */
+    AssetItemComponent.prototype.bindSubscriber = /**
+     * @private
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        function (state) { return state.selectedAssets; }))
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((/**
+         * @param {?} selectedAssets
+         * @return {?}
+         */
+        function (selectedAssets) {
+            _this.selectedAssets = selectedAssets;
+        }));
+    };
+    /**
+     * @return {?}
+     */
+    AssetItemComponent.prototype.onChange = /**
+     * @return {?}
+     */
+    function () {
+        this.selectAsset.emit(this.asset);
+    };
+    /**
+     * @return {?}
+     */
+    AssetItemComponent.prototype.editAsset = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        /** @type {?} */
+        var dialogRef = this.dialog.open(AssetDialogComponent, {
+            autoFocus: false,
+            data: {
+                assetId: this.asset.AssetId,
+                name: this.asset.OriginalFileNameWithoutExtension,
+            },
+            panelClass: 'lib-dialog--medium',
+        });
+        if (dialogRef) {
+            dialogRef.afterClosed().subscribe((/**
+             * @param {?} res
+             * @return {?}
+             */
+            function (res) {
+                if (res) {
+                    _this.svc.dispatch({
+                        type: ActionTypes.RELOAD_CURRENT_ASSETS,
+                    });
+                }
+            }));
+        }
+    };
+    /**
+     * @return {?}
+     */
+    AssetItemComponent.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        this.destroy$.next(true);
+        this.destroy$.complete();
+    };
+    AssetItemComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'lib-asset-item',
+                    template: "<div class=\"asset-wrapper\">\n  <div class=\"asset-content\">\n    <div class=\"asset-content__header\">\n      <button class=\"asset-content__header--button\" mat-raised-button>\n        <mat-checkbox\n          class=\"checkbox\"\n          [checked]=\"checkSelectedAsset\"\n          (change)=\"onChange()\"\n        ></mat-checkbox>\n      </button>\n      <button\n        class=\"asset-content__header--button edit-button\"\n        mat-raised-button\n        (click)=\"editAsset()\"\n      >\n        <mat-icon>edit</mat-icon>\n      </button>\n    </div>\n    <div class=\"asset-content__body\">\n      <ng-container [ngSwitch]=\"asset.FileType\">\n        <ng-container *ngSwitchCase=\"fileType.IMAGE\">\n          <img\n            class=\"image\"\n            [src]=\"asset.UrlThumbnail\"\n            [alt]=\"asset.OriginalFileName\"\n          />\n        </ng-container>\n        <ng-container *ngSwitchCase=\"fileType.DOCUMENT\">\n          <img [src]=\"base64Pdf\" [alt]=\"asset.OriginalFileName\" class=\"pdf\" />\n        </ng-container>\n      </ng-container>\n    </div>\n    <div class=\"asset-content__footer\">\n      <div\n        class=\"asset-content__footer--info\"\n        [ngClass]=\"{\n          'file-type__document': asset.FileType === fileType.DOCUMENT\n        }\"\n      >\n        <p\n          class=\"name\"\n          [matTooltip]=\"asset.OriginalFileNameWithoutExtension\"\n          matTooltipClass=\"width-auto\"\n        >\n          {{ asset.OriginalFileNameWithoutExtension }}\n        </p>\n        <p class=\"info\">\n          <span class=\"extension\">{{ asset.Extension }}</span>\n          <span\n            *ngIf=\"\n              asset.FileType === fileType.IMAGE && asset?.Extension !== 'svg'\n            \"\n          >\n            - {{ asset.Width }}x{{ asset.Height }}</span\n          >\n          <span *ngIf=\"asset.Size\"> - {{ asset.Size }}</span>\n        </p>\n      </div>\n      <div class=\"asset-content__footer--file-type\">\n        <span>{{ asset.FileType }}</span>\n      </div>\n    </div>\n  </div>\n</div>\n",
+                    styles: [":host::ng-deep .asset-wrapper{padding:5px}:host::ng-deep .asset-wrapper .asset-content{overflow:hidden;position:relative;border-radius:10px;border:1px solid #d8d8d8;font-size:14px;transition:.3s cubic-bezier(.25,.8,.25,1)}:host::ng-deep .asset-wrapper .asset-content:hover{box-shadow:0 14px 28px rgba(0,0,0,.25),0 10px 10px rgba(0,0,0,.22)}:host::ng-deep .asset-wrapper .asset-content__header{position:absolute;z-index:1;top:0;left:0;width:100%;display:flex;justify-content:space-between;padding:14px}:host::ng-deep .asset-wrapper .asset-content__header--button{width:30px;height:30px;min-width:30px;display:flex;align-items:center;justify-content:center;text-align:center;color:rgba(0,0,0,.65);background:rgba(255,255,255,.6)}:host::ng-deep .asset-wrapper .asset-content__header--button:hover{background:#fff}:host::ng-deep .asset-wrapper .asset-content__header--button.edit-button{transition:.3s cubic-bezier(.25,.8,.25,1);opacity:0}:host::ng-deep .asset-wrapper .asset-content__header--button .mat-icon{font-size:22px}:host::ng-deep .asset-wrapper .asset-content__header--button .mat-checkbox{display:flex;align-items:center}:host::ng-deep .asset-wrapper .asset-content__header--button .mat-checkbox .mat-checkbox-layout{margin:0}:host::ng-deep .asset-wrapper .asset-content__header--button .mat-checkbox .mat-checkbox-layout .mat-checkbox-frame{color:#767676}:host::ng-deep .asset-wrapper .asset-content__body{padding-bottom:66.66%;background:#f1f1f1;position:relative}:host::ng-deep .asset-wrapper .asset-content__body img{max-width:100%;max-height:100%;-o-object-fit:contain;object-fit:contain;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%)}:host::ng-deep .asset-wrapper .asset-content__body img.image{background-image:url(data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/2wBDAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAARCAAUABQDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD+/ivFPFOf+EjvxzjbBgdv+PeDp+OfxzSt4q18AkageASB9ntu3OM+Vn8c5rsdG0fT9d06DVdUgN1f3XmefP5ksO/ypXhj/dwvHGu2ONF+VF3bQSM0AeYUV7IPCWgjgWRA/wCvi4P85SaKAPGm5Vh7H+VeyeERjQLEDoPP/WeQ/wAzRRQB0tFFFAH/2Q==)}:host::ng-deep .asset-wrapper .asset-content__body img.pdf{width:75%;height:75%}:host::ng-deep .asset-wrapper .asset-content__footer{display:flex;align-items:center;justify-content:space-between;padding:5px 8px}:host::ng-deep .asset-wrapper .asset-content__footer--info{max-width:calc(100% - 50px)}:host::ng-deep .asset-wrapper .asset-content__footer--info p{margin:0;display:block;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}:host::ng-deep .asset-wrapper .asset-content__footer--info .info{font-size:12px;color:#979797}:host::ng-deep .asset-wrapper .asset-content__footer--info .info .extension{text-transform:uppercase}:host::ng-deep .asset-wrapper .asset-content__footer--info.file-type__document{max-width:calc(100% - 70px)}:host::ng-deep .asset-wrapper .asset-content__footer--file-type{border-radius:5px;background-color:#d8d8d8;padding:2px 6px;font-size:12px}:host::ng-deep .asset-wrapper .asset-content:hover .edit-button{opacity:1!important}"]
+                }] }
+    ];
+    /** @nocollapse */
+    AssetItemComponent.ctorParameters = function () { return [
+        { type: MatDialog },
+        { type: DomSanitizer },
+        { type: AssetManagementService },
+        { type: AssetService }
+    ]; };
+    AssetItemComponent.propDecorators = {
+        asset: [{ type: Input }],
+        selectAsset: [{ type: Output }]
+    };
+    return AssetItemComponent;
+}());
+export { AssetItemComponent };
+if (false) {
+    /** @type {?} */
+    AssetItemComponent.prototype.asset;
+    /** @type {?} */
+    AssetItemComponent.prototype.selectAsset;
+    /** @type {?} */
+    AssetItemComponent.prototype.base64Pdf;
+    /** @type {?} */
+    AssetItemComponent.prototype.selectedAssets;
+    /** @type {?} */
+    AssetItemComponent.prototype.fileType;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetItemComponent.prototype.destroy$;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetItemComponent.prototype.dialog;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetItemComponent.prototype.domSanitizer;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetItemComponent.prototype.svc;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetItemComponent.prototype.assetService;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/partial/asset-list/asset-list.component.js

@@ -0,0 +1,266 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Component, Input, ViewChild, } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { of } from 'rxjs/internal/observable/of';
+import { Subject } from 'rxjs/internal/Subject';
+import { switchMap, takeUntil } from 'rxjs/operators';
+import { AssetManagementService } from '../../../asset-management.service';
+import { AssetService } from '../../../services/asset.service';
+import { ActionTypes } from '../../../store/actions.action';
+import { select } from '../../../store/reducer';
+var AssetListComponent = /** @class */ (function () {
+    function AssetListComponent(assetService, svc) {
+        this.assetService = assetService;
+        this.svc = svc;
+        this.unsubscribe$ = new Subject();
+        this.selectedAssets = [];
+    }
+    /**
+     * @return {?}
+     */
+    AssetListComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        this.bindSubscriber();
+    };
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    AssetListComponent.prototype.ngOnChanges = /**
+     * @param {?} changes
+     * @return {?}
+     */
+    function (changes) {
+        if (changes.assets) {
+            this.paginator.pageIndex = this.assetService.pageIndex;
+            this.paginator.pageSize = this.assetService.pageSize;
+            this.paginator.length = this.assetService.fileTotal;
+        }
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    AssetListComponent.prototype.onSelectAsset = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        /** @type {?} */
+        var index = this.selectedAssets.findIndex((/**
+         * @param {?} asset
+         * @return {?}
+         */
+        function (asset) { return asset.AssetId === event.AssetId; }));
+        /** @type {?} */
+        var newSelectedAssets = index > -1
+            ? this.selectedAssets.filter((/**
+             * @param {?} asset
+             * @param {?} i
+             * @return {?}
+             */
+            function (asset, i) { return index !== i; }))
+            : tslib_1.__spread(this.selectedAssets, [event]);
+        this.svc.dispatch({
+            type: ActionTypes.SET_SELECTED_ASSETS,
+            payload: newSelectedAssets,
+        });
+    };
+    /**
+     * @private
+     * @return {?}
+     */
+    AssetListComponent.prototype.bindSubscriber = /**
+     * @private
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        function (state) { return state.deletedAssetId; }))
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} id
+         * @return {?}
+         */
+        function (id) {
+            if (_this.selectedAssets && _this.selectedAssets.length) {
+                /** @type {?} */
+                var newSelectedAssets = _this.selectedAssets.filter((/**
+                 * @param {?} asset
+                 * @return {?}
+                 */
+                function (asset) { return asset.AssetId !== id; }));
+                _this.svc.dispatch({
+                    type: ActionTypes.SET_SELECTED_ASSETS,
+                    payload: newSelectedAssets,
+                });
+            }
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        function (state) { return state.currentFolderId; }))
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} currentFolderId
+         * @return {?}
+         */
+        function (currentFolderId) {
+            _this.currentFolderId = currentFolderId;
+            _this.svc.dispatch({
+                type: ActionTypes.SET_SELECTED_ASSETS,
+                payload: [],
+            });
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        function (state) { return state.selectedAssets; }))
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} selectedAssets
+         * @return {?}
+         */
+        function (selectedAssets) {
+            _this.selectedAssets = selectedAssets;
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        function (state) { return state.reloadCurrentAssets; }))
+            .pipe(takeUntil(this.unsubscribe$), switchMap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        function (res) { return of(res); })))
+            .subscribe((/**
+         * @return {?}
+         */
+        function () {
+            _this.fetchChildrenAssets();
+        }));
+    };
+    /**
+     * @param {?=} event
+     * @return {?}
+     */
+    AssetListComponent.prototype.pageChange = /**
+     * @param {?=} event
+     * @return {?}
+     */
+    function (event) {
+        this.assetService.pageSize = event.pageSize;
+        this.assetService.pageIndex = event.pageIndex;
+        this.fetchChildrenAssets();
+    };
+    /**
+     * @private
+     * @return {?}
+     */
+    AssetListComponent.prototype.fetchChildrenAssets = /**
+     * @private
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        if (!this.currentFolderId) {
+            return;
+        }
+        this.svc.dispatch({
+            type: ActionTypes.SET_GLOBAL_LOADING,
+            payload: true,
+        });
+        this.assetService
+            .getChildrenAssets({ assetId: this.currentFolderId })
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} res
+         * @return {?}
+         */
+        function (res) {
+            _this.assetService.setAssetList(res.Data.Children, res.Meta);
+        }))
+            .add((/**
+         * @return {?}
+         */
+        function () {
+            _this.svc.dispatch({
+                type: ActionTypes.SET_GLOBAL_LOADING,
+                payload: false,
+            });
+        }));
+    };
+    /**
+     * @return {?}
+     */
+    AssetListComponent.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    };
+    AssetListComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'lib-asset-list',
+                    template: "<div class=\"asset-container\">\n  <div class=\"asset-heading\">\n    <h6 class=\"asset-heading__title\">Files</h6>\n    <lib-sort-items\n      [hidden]=\"!assets?.length\"\n      class=\"asset-heading__sort\"\n    ></lib-sort-items>\n  </div>\n  <ng-container *ngIf=\"assets && !assets.length; else assetsTemplate\">\n    <div class=\"asset-empty\">\n      <span>This asset is empty.</span>\n    </div>\n  </ng-container>\n  <ng-template #assetsTemplate>\n    <div class=\"asset-list\">\n      <lib-asset-item\n        class=\"asset-list__item\"\n        *ngFor=\"let asset of assets\"\n        [asset]=\"asset\"\n        (selectAsset)=\"onSelectAsset($event)\"\n      >\n      </lib-asset-item>\n    </div>\n  </ng-template>\n  <div [hidden]=\"!assets?.length\">\n    <mat-paginator\n      #paginator\n      [pageSizeOptions]=\"[12, 24, 60, 120]\"\n      (page)=\"pageChange($event)\"\n      [showFirstLastButtons]=\"true\"\n    >\n    </mat-paginator>\n  </div>\n</div>\n",
+                    styles: [":host::ng-deep .asset-container .asset-heading{display:flex;justify-content:space-between;align-items:center;margin-bottom:.5rem}:host::ng-deep .asset-container .asset-heading__title{margin-bottom:0;color:#979797}:host::ng-deep .asset-container .asset-list{display:flex;flex-wrap:wrap;justify-content:flex-start;align-items:stretch;margin:0 -5px}:host::ng-deep .asset-container .asset-list__item{width:25%}@media only screen and (max-width:1200px){:host::ng-deep .asset-container .asset-list__item{width:calc(100% / 3)}}@media only screen and (max-width:960px){:host::ng-deep .asset-container .asset-list__item{width:50%}}:host::ng-deep .asset-container .asset-empty{text-align:center;color:#979797;font-size:14px}"]
+                }] }
+    ];
+    /** @nocollapse */
+    AssetListComponent.ctorParameters = function () { return [
+        { type: AssetService },
+        { type: AssetManagementService }
+    ]; };
+    AssetListComponent.propDecorators = {
+        paginator: [{ type: ViewChild, args: [MatPaginator, { static: true },] }],
+        assets: [{ type: Input }]
+    };
+    return AssetListComponent;
+}());
+export { AssetListComponent };
+if (false) {
+    /** @type {?} */
+    AssetListComponent.prototype.paginator;
+    /** @type {?} */
+    AssetListComponent.prototype.assets;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetListComponent.prototype.unsubscribe$;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetListComponent.prototype.currentFolderId;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetListComponent.prototype.selectedAssets;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetListComponent.prototype.assetService;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetListComponent.prototype.svc;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-list.component.js","sourceRoot":"ng://@rs-pk/asset-management/","sources":["lib/components/partial/asset-list/asset-list.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { MatPaginator, PageEvent } from '@angular/material/paginator';\nimport { of } from 'rxjs/internal/observable/of';\nimport { Subject } from 'rxjs/internal/Subject';\nimport { switchMap, takeUntil } from 'rxjs/operators';\nimport { AssetManagementService } from '../../../asset-management.service';\nimport { AssetModel } from '../../../models';\nimport { AssetService } from '../../../services/asset.service';\nimport { ActionTypes } from '../../../store/actions.action';\nimport { select } from '../../../store/reducer';\n\n@Component({\n  selector: 'lib-asset-list',\n  templateUrl: './asset-list.component.html',\n  styleUrls: ['./asset-list.component.scss'],\n})\nexport class AssetListComponent implements OnInit, OnChanges, OnDestroy {\n  constructor(\n    private assetService: AssetService,\n    private svc: AssetManagementService\n  ) {}\n\n  @ViewChild(MatPaginator, { static: true }) paginator: MatPaginator;\n  @Input() assets: AssetModel[];\n\n  private unsubscribe$ = new Subject<void>();\n  private currentFolderId: string;\n  private selectedAssets: Array<AssetModel> = [];\n\n  ngOnInit() {\n    this.bindSubscriber();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.assets) {\n      this.paginator.pageIndex = this.assetService.pageIndex;\n      this.paginator.pageSize = this.assetService.pageSize;\n      this.paginator.length = this.assetService.fileTotal;\n    }\n  }\n\n  public onSelectAsset(event: AssetModel) {\n    const index = this.selectedAssets.findIndex(\n      (asset) => asset.AssetId === event.AssetId\n    );\n    const newSelectedAssets: AssetModel[] =\n      index > -1\n        ? this.selectedAssets.filter((asset, i) => index !== i)\n        : [...this.selectedAssets, event];\n\n    this.svc.dispatch({\n      type: ActionTypes.SET_SELECTED_ASSETS,\n      payload: newSelectedAssets,\n    });\n  }\n\n  private bindSubscriber() {\n    select((state) => state.deletedAssetId)\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((id) => {\n        if (this.selectedAssets && this.selectedAssets.length) {\n          const newSelectedAssets = this.selectedAssets.filter(\n            (asset) => asset.AssetId !== id\n          );\n          this.svc.dispatch({\n            type: ActionTypes.SET_SELECTED_ASSETS,\n            payload: newSelectedAssets,\n          });\n        }\n      });\n\n    select((state) => state.currentFolderId)\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((currentFolderId) => {\n        this.currentFolderId = currentFolderId;\n        this.svc.dispatch({\n          type: ActionTypes.SET_SELECTED_ASSETS,\n          payload: [],\n        });\n      });\n\n    select((state) => state.selectedAssets)\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((selectedAssets) => {\n        this.selectedAssets = selectedAssets;\n      });\n\n    select((state) => state.reloadCurrentAssets)\n      .pipe(\n        takeUntil(this.unsubscribe$),\n        switchMap((res) => of(res))\n      )\n      .subscribe(() => {\n        this.fetchChildrenAssets();\n      });\n  }\n\n  public pageChange(event?: PageEvent) {\n    this.assetService.pageSize = event.pageSize;\n    this.assetService.pageIndex = event.pageIndex;\n    this.fetchChildrenAssets();\n  }\n\n  private fetchChildrenAssets() {\n    if (!this.currentFolderId) {\n      return;\n    }\n    this.svc.dispatch({\n      type: ActionTypes.SET_GLOBAL_LOADING,\n      payload: true,\n    });\n\n    this.assetService\n      .getChildrenAssets({ assetId: this.currentFolderId })\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((res) => {\n        this.assetService.setAssetList(res.Data.Children, res.Meta);\n      })\n      .add(() => {\n        this.svc.dispatch({\n          type: ActionTypes.SET_GLOBAL_LOADING,\n          payload: false,\n        });\n      });\n  }\n\n  ngOnDestroy() {\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n  }\n}\n"]}

package/esm5/lib/components/partial/asset-management-dialog/asset-management-dialog.component.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Inject } from '@angular/core';
+import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';
+import { Subject } from 'rxjs/internal/Subject';
+import { takeUntil } from 'rxjs/operators';
+import { DialogConfig } from '../../../models';
+import { AssetService } from '../../../services/asset.service';
+import { select } from '../../../store';
+var AssetManagementDialogComponent = /** @class */ (function () {
+    function AssetManagementDialogComponent(data, dialogRef, assetService) {
+        this.data = data;
+        this.dialogRef = dialogRef;
+        this.assetService = assetService;
+        this.destroy$ = new Subject();
+        this.selectedAssets = [];
+    }
+    /**
+     * @return {?}
+     */
+    AssetManagementDialogComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        this.initDialogConfig(this.data);
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        function (state) { return state.selectedAssets; }))
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((/**
+         * @param {?} selectedAssets
+         * @return {?}
+         */
+        function (selectedAssets) {
+            _this.selectedAssets = selectedAssets;
+        }));
+    };
+    Object.defineProperty(AssetManagementDialogComponent.prototype, "disabled", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            var limit = this.data.limit;
+            return ((!this.selectedAssets || !this.selectedAssets.length) ||
+                (limit && this.selectedAssets.length > limit));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    AssetManagementDialogComponent.prototype.selectAssets = /**
+     * @return {?}
+     */
+    function () {
+        this.dialogRef.close(this.selectedAssets);
+    };
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    AssetManagementDialogComponent.prototype.initDialogConfig = /**
+     * @param {?} data
+     * @return {?}
+     */
+    function (data) {
+        if (!data) {
+            return;
+        }
+        this.assetService.dialogConfig = data;
+    };
+    /**
+     * @return {?}
+     */
+    AssetManagementDialogComponent.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        this.assetService.dialogConfig = new DialogConfig();
+        this.destroy$.next(true);
+        this.destroy$.complete();
+    };
+    AssetManagementDialogComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'lib-asset-management-dialog',
+                    template: "<lib-modal heading=\"Asset management\" [customHeader]=\"true\">\n  <ng-container subtitle>\n    <lib-breadcrumb></lib-breadcrumb>\n  </ng-container>\n  <ng-container headerActions>\n    <lib-search-box></lib-search-box>\n  </ng-container>\n  <ng-container content>\n    <lib-asset-wrapper [header]=\"false\"></lib-asset-wrapper>\n  </ng-container>\n  <ng-container actions>\n    <div class=\"asset-management-dialog__footer\">\n      <div class=\"selected-assets\">\n        <ng-container *ngIf=\"data?.limit\">\n          <span>Selected{{' '}}</span>\n          <span class=\"count\" [ngClass]=\"{'error': selectedAssets?.length && disabled}\">\n            {{selectedAssets?.length}}/{{data?.limit}}\n          </span>\n          <span>\n            {{data?.limit > 1 ? \"assets\": \"asset\"}}\n          </span>\n        </ng-container>\n\n      </div>\n      <div>\n        <button mat-raised-button mat-dialog-close>Cancel</button>\n        <button mat-raised-button color=\"primary\" (click)=\"selectAssets()\" [disabled]=\"disabled\">Done</button>\n      </div>\n    </div>\n  </ng-container>\n</lib-modal>",
+                    styles: [":host::ng-deep .asset-management-dialog__footer{display:flex;width:100%;align-items:center;justify-content:space-between}:host::ng-deep .asset-management-dialog__footer .selected-assets{font-size:14px;color:#979797}:host::ng-deep .asset-management-dialog__footer .selected-assets .count{color:#000}:host::ng-deep .asset-management-dialog__footer .selected-assets .error{color:#f44336}"]
+                }] }
+    ];
+    /** @nocollapse */
+    AssetManagementDialogComponent.ctorParameters = function () { return [
+        { type: DialogConfig, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] },
+        { type: MatDialogRef },
+        { type: AssetService }
+    ]; };
+    return AssetManagementDialogComponent;
+}());
+export { AssetManagementDialogComponent };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetManagementDialogComponent.prototype.destroy$;
+    /** @type {?} */
+    AssetManagementDialogComponent.prototype.selectedAssets;
+    /** @type {?} */
+    AssetManagementDialogComponent.prototype.data;
+    /** @type {?} */
+    AssetManagementDialogComponent.prototype.dialogRef;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetManagementDialogComponent.prototype.assetService;
+}
+//# sourceMappingURL=data:application/json;base64,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