@rs-pk/asset-management 1.0.0

package/esm2015/lib/components/partial/folder-item/folder-item.component.js

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Input } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { AssetModel } from '../../../models';
+import { ActionTypes } from '../../../store/actions.action';
+import { EditFolderDialogComponent } from '../edit-folder-dialog/edit-folder-dialog.component';
+import { DeleteDialogComponent } from '../delete-dialog/delete-dialog.component';
+import { AssetManagementService } from '../../../asset-management.service';
+export class FolderItemComponent {
+    /**
+     * @param {?} dialog
+     * @param {?} svc
+     */
+    constructor(dialog, svc) {
+        this.dialog = dialog;
+        this.svc = svc;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() { }
+    /**
+     * @return {?}
+     */
+    openFolder() {
+        this.svc.dispatch({
+            type: ActionTypes.SET_CURRENT_FOLDER_ID,
+            payload: this.folder.AssetId,
+        });
+    }
+    /**
+     * @return {?}
+     */
+    renameFolder() {
+        /** @type {?} */
+        const dialogRef = this.dialog.open(EditFolderDialogComponent, {
+            data: {
+                assetId: this.folder.AssetId,
+                name: this.folder.OriginalFileName,
+            },
+            panelClass: 'lib-dialog--small',
+        });
+        dialogRef.afterClosed().subscribe((/**
+         * @param {?} res
+         * @return {?}
+         */
+        res => {
+            if (res) {
+                this.svc.dispatch({
+                    type: ActionTypes.RELOAD_CURRENT_FOLDER,
+                });
+            }
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    deleteFolder() {
+        /** @type {?} */
+        const dialogRef = this.dialog.open(DeleteDialogComponent, {
+            data: {
+                type: 'folder',
+                ids: [this.folder.AssetId],
+                name: this.folder.OriginalFileName,
+            },
+            panelClass: 'lib-dialog--small',
+            autoFocus: false,
+        });
+        dialogRef.afterClosed().subscribe((/**
+         * @param {?} res
+         * @return {?}
+         */
+        res => {
+            if (res) {
+                this.svc.dispatch({
+                    type: ActionTypes.RELOAD_CURRENT_FOLDER,
+                });
+            }
+        }));
+    }
+}
+FolderItemComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-folder-item',
+                template: "<div class=\"folder\" (dblclick)=\"openFolder()\">\n  <mat-icon class=\"folder__icon\">folder</mat-icon>\n  <span class=\"folder__name\" [matTooltip]=\"folder.OriginalFileName\">\n    {{ folder.OriginalFileName }}\n  </span>\n  <mat-icon class=\"folder__action\" [matMenuTriggerFor]=\"menu\"\n    >more_vert</mat-icon\n  >\n</div>\n<mat-menu #menu=\"matMenu\">\n  <button mat-menu-item (click)=\"renameFolder()\">\n    <mat-icon>edit_outline</mat-icon> <span>Rename</span>\n  </button>\n  <button mat-menu-item (click)=\"deleteFolder()\">\n    <mat-icon color=\"warn\">delete_outline</mat-icon> <span>Delete</span>\n  </button>\n</mat-menu>\n",
+                styles: [":host::ng-deep .folder{width:180px;height:50px;display:flex;position:relative;align-items:center;padding:5px 20px 5px 10px;border-radius:10px;cursor:pointer;transition:.3s}:host::ng-deep .folder:hover{background-color:#f1f1f1}:host::ng-deep .folder:hover .folder__action{display:block}:host::ng-deep .folder__icon{display:flex;align-items:center;color:#6fc0ff;font-size:38px;margin-right:20px}:host::ng-deep .folder__name{font-size:14px;display:block;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}:host::ng-deep .folder__action{display:none;right:0;position:absolute;color:#979797;transition:.3s}:host::ng-deep .folder__action:hover{color:#000}"]
+            }] }
+];
+/** @nocollapse */
+FolderItemComponent.ctorParameters = () => [
+    { type: MatDialog },
+    { type: AssetManagementService }
+];
+FolderItemComponent.propDecorators = {
+    folder: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    FolderItemComponent.prototype.folder;
+    /**
+     * @type {?}
+     * @private
+     */
+    FolderItemComponent.prototype.dialog;
+    /**
+     * @type {?}
+     * @private
+     */
+    FolderItemComponent.prototype.svc;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/partial/folder-list/folder-list.component.js

@@ -0,0 +1,69 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Input } from '@angular/core';
+import { Subject } from 'rxjs/internal/Subject';
+import { takeUntil } from 'rxjs/operators';
+import { select } from '../../../store';
+export class FolderListComponent {
+    constructor() {
+        this.loading = false;
+        this.unsubscribe$ = new Subject();
+        this.bindSubscriber();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() { }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    bindSubscriber() {
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        state => state.globalLoading))
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} globalLoading
+         * @return {?}
+         */
+        globalLoading => {
+            this.loading = globalLoading;
+        }));
+    }
+}
+FolderListComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-folder-list',
+                template: "<div class=\"folder-container\">\n  <h6>Folders</h6>\n  <div class=\"folder-list custom-scrollbar\">\n    <lib-folder-item\n      *ngFor=\"let folder of folders\"\n      [folder]=\"folder\"\n    ></lib-folder-item>\n  </div>\n  <div class=\"folder-empty\" *ngIf=\"folders && !folders.length\">\n    <span>This folder is empty.</span>\n  </div>\n</div>\n",
+                styles: [":host::ng-deep .folder-container h6{color:#979797}:host::ng-deep .folder-container .folder-list{display:flex;flex-wrap:nowrap;overflow:auto;padding-bottom:10px}:host::ng-deep .folder-container .folder-empty{text-align:center;color:#979797;font-size:14px}"]
+            }] }
+];
+/** @nocollapse */
+FolderListComponent.ctorParameters = () => [];
+FolderListComponent.propDecorators = {
+    folders: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    FolderListComponent.prototype.folders;
+    /** @type {?} */
+    FolderListComponent.prototype.loading;
+    /**
+     * @type {?}
+     * @private
+     */
+    FolderListComponent.prototype.unsubscribe$;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/partial/node-details/node-details.component.js

@@ -0,0 +1,402 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { ChangeDetectorRef, Component } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { of } from 'rxjs';
+import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+import { combineLatest } from 'rxjs/internal/observable/combineLatest';
+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 { NodeTreeService } from '../../../services/node-tree.service';
+import { ActionTypes, select } from '../../../store';
+import { AddFolderDialogComponent } from '../add-folder-dialog/add-folder-dialog.component';
+import { DeleteDialogComponent } from '../delete-dialog/delete-dialog.component';
+import { UploadDialogComponent } from '../upload-dialog/upload-dialog.component';
+export class NodeDetailsComponent {
+    /**
+     * @param {?} dialog
+     * @param {?} assetService
+     * @param {?} nodeTreeService
+     * @param {?} svc
+     * @param {?} changeDetectorRef
+     */
+    constructor(dialog, assetService, nodeTreeService, svc, changeDetectorRef) {
+        this.dialog = dialog;
+        this.assetService = assetService;
+        this.nodeTreeService = nodeTreeService;
+        this.svc = svc;
+        this.changeDetectorRef = changeDetectorRef;
+        this.unsubscribe$ = new Subject();
+        this.selectedAssets = [];
+        this.loading$ = new BehaviorSubject(false);
+        this.bindSubscriber();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this.assetService
+            .getFolderList()
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} folders
+         * @return {?}
+         */
+        (folders) => {
+            this.currentFolder = folders;
+            this.changeDetectorRef.detectChanges();
+        }));
+        this.assetService
+            .getAssetList()
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} assets
+         * @return {?}
+         */
+        (assets) => {
+            this.assets = assets;
+            this.changeDetectorRef.detectChanges();
+        }));
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    bindSubscriber() {
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.globalLoading))
+            .pipe(takeUntil(this.unsubscribe$), switchMap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => of(res))))
+            .subscribe((/**
+         * @param {?} globalLoading
+         * @return {?}
+         */
+        (globalLoading) => {
+            this.loading$.next(globalLoading);
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.selectedAssets))
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} selectedAssets
+         * @return {?}
+         */
+        (selectedAssets) => {
+            if (selectedAssets) {
+                this.selectedAssets = selectedAssets;
+            }
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.currentFolderId))
+            .pipe(takeUntil(this.unsubscribe$), switchMap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => of(res))))
+            .subscribe((/**
+         * @param {?} currentFolderId
+         * @return {?}
+         */
+        (currentFolderId) => {
+            if (currentFolderId) {
+                this.assetService.pageIndex = 0;
+                this.fetchNodeDetails(currentFolderId);
+            }
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.reloadCurrentFolder))
+            .pipe(takeUntil(this.unsubscribe$), switchMap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => of(res))))
+            .subscribe((/**
+         * @return {?}
+         */
+        () => {
+            if (!this.currentFolder) {
+                return;
+            }
+            this.fetchFolder(this.currentFolder.AssetId);
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.reloadCurrentNode))
+            .pipe(takeUntil(this.unsubscribe$), switchMap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => of(res))))
+            .subscribe((/**
+         * @return {?}
+         */
+        () => {
+            if (!this.currentFolder) {
+                return;
+            }
+            this.assetService.pageIndex = 0;
+            this.fetchNodeDetails(this.currentFolder.AssetId);
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    openUploadDialog() {
+        /** @type {?} */
+        const dialogRef = this.dialog.open(UploadDialogComponent, {
+            data: {
+                currentAssetId: this.currentFolder.AssetId,
+                fileType: this.assetService.dialogConfig.allowedType,
+            },
+            panelClass: 'lib-dialog--medium',
+        });
+        dialogRef.afterClosed().subscribe((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            if (res) {
+                this.svc.dispatch({
+                    type: ActionTypes.RELOAD_CURRENT_ASSETS,
+                });
+                this.svc.dispatch({
+                    type: ActionTypes.RELOAD_CURRENT_FOLDER,
+                });
+            }
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    addFolder() {
+        /** @type {?} */
+        const dialogRef = this.dialog.open(AddFolderDialogComponent, {
+            data: {
+                currentAssetId: this.currentFolder.AssetId,
+            },
+            panelClass: 'lib-dialog--small',
+        });
+        dialogRef.afterClosed().subscribe((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            if (res) {
+                this.svc.dispatch({
+                    type: ActionTypes.RELOAD_CURRENT_FOLDER,
+                });
+            }
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    deleteAssets() {
+        /** @type {?} */
+        const ids = this.selectedAssets.map((/**
+         * @param {?} asset
+         * @return {?}
+         */
+        (asset) => asset.AssetId));
+        /** @type {?} */
+        const dialogRef = this.dialog.open(DeleteDialogComponent, {
+            data: {
+                type: 'files',
+                ids,
+            },
+            panelClass: 'lib-dialog--small',
+            autoFocus: false,
+        });
+        dialogRef.afterClosed().subscribe((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            if (res) {
+                this.svc.dispatch({
+                    type: ActionTypes.RELOAD_CURRENT_ASSETS,
+                });
+                this.svc.dispatch({
+                    type: ActionTypes.RELOAD_CURRENT_FOLDER,
+                });
+                this.svc.dispatch({
+                    type: ActionTypes.SET_SELECTED_ASSETS,
+                    payload: [],
+                });
+            }
+        }));
+    }
+    /**
+     * @private
+     * @param {?} id
+     * @return {?}
+     */
+    fetchFolder(id) {
+        this.svc.dispatch({
+            type: ActionTypes.SET_GLOBAL_LOADING,
+            payload: true,
+        });
+        this.assetService
+            .getChildrenFolders({ assetId: id })
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            this.assetService.setFolderList(res.Data, res.Meta.Total);
+            if (res.Data && res.Data.Children) {
+                res.Data.Children.forEach((/**
+                 * @param {?} node
+                 * @return {?}
+                 */
+                (node) => this.nodeTreeService.addNode(node, this.currentFolder.AssetId)));
+            }
+        }))
+            .add((/**
+         * @return {?}
+         */
+        () => {
+            this.svc.dispatch({
+                type: ActionTypes.SET_GLOBAL_LOADING,
+                payload: false,
+            });
+        }));
+    }
+    /**
+     * @private
+     * @param {?} id
+     * @return {?}
+     */
+    fetchNodeDetails(id) {
+        this.svc.dispatch({
+            type: ActionTypes.SET_GLOBAL_LOADING,
+            payload: true,
+        });
+        combineLatest([
+            this.assetService.getChildrenFolders({ assetId: id }),
+            this.assetService.getChildrenAssets({
+                assetId: id,
+            }),
+        ])
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} __0
+         * @return {?}
+         */
+        ([folders, assets]) => {
+            this.assetService.setFolderList(folders.Data, folders.Meta.Total);
+            this.assetService.setAssetList(assets.Data.Children, assets.Meta);
+            if (folders.Data && folders.Data.Children) {
+                folders.Data.Children.forEach((/**
+                 * @param {?} node
+                 * @return {?}
+                 */
+                (node) => this.nodeTreeService.addNode(node, this.currentFolder.AssetId)));
+            }
+        }))
+            .add((/**
+         * @return {?}
+         */
+        () => {
+            this.svc.dispatch({
+                type: ActionTypes.SET_GLOBAL_LOADING,
+                payload: false,
+            });
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    get noResults() {
+        return (this.assetService.keyword &&
+            !this.currentFolder.Children.length &&
+            !this.assets.length);
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.svc.dispatch({
+            type: ActionTypes.SET_CURRENT_FOLDER_ID,
+            payload: null,
+        });
+        this.svc.dispatch({
+            type: ActionTypes.SET_SELECTED_ASSETS,
+            payload: [],
+        });
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+}
+NodeDetailsComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-node-details',
+                template: "<div class=\"node-details custom-scrollbar\">\n  <div class=\"node-header\">\n    <mat-progress-bar [style.visibility]=\"(loading$ | async) ? 'visible' : 'hidden'\" mode=\"indeterminate\">\n    </mat-progress-bar>\n    <div class=\"node-header-content\">\n      <div class=\"node-header-content__left\">\n        <H5 class=\"node-header-content__left--title\">\n          <ng-container *ngIf=\"assetService?.keyword\">\n            Search results for <span>{{ assetService?.keyword }}</span> in\n          </ng-container>\n          {{ currentFolder?.OriginalFileName }}\n        </H5>\n        <p *ngIf=\"!noResults\" class=\"node-header-content__left--subtitle\">\n          {{ assetService?.folderTotal }}\n          {{ assetService?.folderTotal > 1 ? 'folders' : 'folder' }},\n          {{ assetService?.fileTotal }}\n          {{ assetService?.fileTotal > 1 ? 'files': 'file' }}\n        </p>\n      </div>\n      <div class=\"node-header-content__right\">\n        <div class=\"button-wrapper\">\n          <button mat-raised-button [disabled]=\"!selectedAssets?.length\" (click)=\"deleteAssets()\" color=\"warn\">\n            <span>{{selectedAssets?.length > 1 ? 'Delete assets' : 'Delete asset'}}</span>\n            <span *ngIf=\"selectedAssets?.length\" class=\"count\">({{ selectedAssets.length }})</span>\n          </button>\n          <button mat-raised-button color=\"primary\" (click)=\"openUploadDialog()\" [disabled]=\"!currentFolder?.AssetId\">\n            Upload asset\n          </button>\n          <button mat-raised-button color=\"primary\" (click)=\"addFolder()\" [disabled]=\"!currentFolder?.AssetId\">\n            Add folder\n          </button>\n        </div>\n      </div>\n    </div>\n  </div>\n  <div class=\"node-body\">\n    <lib-search-not-found *ngIf=\"noResults; else contentAsset\"></lib-search-not-found>\n    <ng-template #contentAsset>\n      <lib-folder-list class=\"node-body__section\" [folders]=\"currentFolder?.Children\"></lib-folder-list>\n      <lib-asset-list [assets]=\"assets\"></lib-asset-list>\n    </ng-template>\n  </div>\n</div>",
+                styles: [":host::ng-deep .node-details{max-height:100%;overflow-y:auto}:host::ng-deep .node-details .node-header{position:-webkit-sticky;position:sticky;top:0;background-color:#fff;z-index:20}:host::ng-deep .node-details .node-header-content{padding:10px 20px;display:flex;justify-content:space-between;flex-wrap:wrap;gap:10px}:host::ng-deep .node-details .node-header-content__left--title{margin-bottom:5px}:host::ng-deep .node-details .node-header-content__left--title span{color:#fb3458}:host::ng-deep .node-details .node-header-content__left--subtitle{margin:0;color:#979797;font-size:14px}:host::ng-deep .node-details .node-header-content__right{flex:1}:host::ng-deep .node-details .node-header-content__right .button-wrapper{display:flex;gap:15px;justify-content:flex-end}:host::ng-deep .node-details .node-header-content__right .button-wrapper .count{margin-left:3px}:host::ng-deep .node-details .node-body{padding:0 20px}:host::ng-deep .node-details .node-body__section{display:block;margin-bottom:15px}"]
+            }] }
+];
+/** @nocollapse */
+NodeDetailsComponent.ctorParameters = () => [
+    { type: MatDialog },
+    { type: AssetService },
+    { type: NodeTreeService },
+    { type: AssetManagementService },
+    { type: ChangeDetectorRef }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeDetailsComponent.prototype.unsubscribe$;
+    /** @type {?} */
+    NodeDetailsComponent.prototype.selectedAssets;
+    /** @type {?} */
+    NodeDetailsComponent.prototype.loading$;
+    /** @type {?} */
+    NodeDetailsComponent.prototype.currentFolder;
+    /** @type {?} */
+    NodeDetailsComponent.prototype.assets;
+    /** @type {?} */
+    NodeDetailsComponent.prototype.dialog;
+    /** @type {?} */
+    NodeDetailsComponent.prototype.assetService;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeDetailsComponent.prototype.nodeTreeService;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeDetailsComponent.prototype.svc;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeDetailsComponent.prototype.changeDetectorRef;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-details.component.js","sourceRoot":"ng://@rs-pk/asset-management/","sources":["lib/components/partial/node-details/node-details.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, OnDestroy, OnInit } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { of } from 'rxjs';\nimport { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';\nimport { combineLatest } from 'rxjs/internal/observable/combineLatest';\nimport { Subject } from 'rxjs/internal/Subject';\nimport { switchMap, takeUntil } from 'rxjs/operators';\nimport { AssetManagementService } from '../../../asset-management.service';\nimport { AssetModel, FolderTreeModel } from '../../../models';\nimport { AssetService } from '../../../services/asset.service';\nimport { NodeTreeService } from '../../../services/node-tree.service';\nimport { ActionTypes, select } from '../../../store';\nimport { AddFolderDialogComponent } from '../add-folder-dialog/add-folder-dialog.component';\nimport { DeleteDialogComponent } from '../delete-dialog/delete-dialog.component';\nimport { UploadDialogComponent } from '../upload-dialog/upload-dialog.component';\n\n@Component({\n  selector: 'lib-node-details',\n  templateUrl: './node-details.component.html',\n  styleUrls: ['./node-details.component.scss'],\n})\nexport class NodeDetailsComponent implements OnInit, OnDestroy {\n  constructor(\n    public dialog: MatDialog,\n    public assetService: AssetService,\n    private nodeTreeService: NodeTreeService,\n    private svc: AssetManagementService,\n    private changeDetectorRef: ChangeDetectorRef\n  ) {\n    this.bindSubscriber();\n  }\n\n  private unsubscribe$ = new Subject<void>();\n\n  public selectedAssets: Array<AssetModel> = [];\n  public loading$: BehaviorSubject<boolean> = new BehaviorSubject(false);\n  public currentFolder: FolderTreeModel;\n  public assets: AssetModel[];\n\n  ngOnInit() {\n    this.assetService\n      .getFolderList()\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((folders) => {\n        this.currentFolder = folders;\n        this.changeDetectorRef.detectChanges();\n      });\n    this.assetService\n      .getAssetList()\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((assets) => {\n        this.assets = assets;\n        this.changeDetectorRef.detectChanges();\n      });\n  }\n\n  private bindSubscriber() {\n    select((state) => state.globalLoading)\n      .pipe(\n        takeUntil(this.unsubscribe$),\n        switchMap((res) => of(res))\n      )\n      .subscribe((globalLoading) => {\n        this.loading$.next(globalLoading);\n      });\n\n    select((state) => state.selectedAssets)\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((selectedAssets) => {\n        if (selectedAssets) {\n          this.selectedAssets = selectedAssets;\n        }\n      });\n\n    select((state) => state.currentFolderId)\n      .pipe(\n        takeUntil(this.unsubscribe$),\n        switchMap((res) => of(res))\n      )\n      .subscribe((currentFolderId) => {\n        if (currentFolderId) {\n          this.assetService.pageIndex = 0;\n          this.fetchNodeDetails(currentFolderId);\n        }\n      });\n\n    select((state) => state.reloadCurrentFolder)\n      .pipe(\n        takeUntil(this.unsubscribe$),\n        switchMap((res) => of(res))\n      )\n      .subscribe(() => {\n        if (!this.currentFolder) {\n          return;\n        }\n        this.fetchFolder(this.currentFolder.AssetId);\n      });\n\n    select((state) => state.reloadCurrentNode)\n      .pipe(\n        takeUntil(this.unsubscribe$),\n        switchMap((res) => of(res))\n      )\n      .subscribe(() => {\n        if (!this.currentFolder) {\n          return;\n        }\n        this.assetService.pageIndex = 0;\n        this.fetchNodeDetails(this.currentFolder.AssetId);\n      });\n  }\n\n  public openUploadDialog() {\n    const dialogRef = this.dialog.open(UploadDialogComponent, {\n      data: {\n        currentAssetId: this.currentFolder.AssetId,\n        fileType: this.assetService.dialogConfig.allowedType,\n      },\n      panelClass: 'lib-dialog--medium',\n    });\n\n    dialogRef.afterClosed().subscribe((res) => {\n      if (res) {\n        this.svc.dispatch({\n          type: ActionTypes.RELOAD_CURRENT_ASSETS,\n        });\n        this.svc.dispatch({\n          type: ActionTypes.RELOAD_CURRENT_FOLDER,\n        });\n      }\n    });\n  }\n\n  addFolder() {\n    const dialogRef = this.dialog.open(AddFolderDialogComponent, {\n      data: {\n        currentAssetId: this.currentFolder.AssetId,\n      },\n      panelClass: 'lib-dialog--small',\n    });\n\n    dialogRef.afterClosed().subscribe((res) => {\n      if (res) {\n        this.svc.dispatch({\n          type: ActionTypes.RELOAD_CURRENT_FOLDER,\n        });\n      }\n    });\n  }\n\n  deleteAssets() {\n    const ids = this.selectedAssets.map((asset) => asset.AssetId);\n    const dialogRef = this.dialog.open(DeleteDialogComponent, {\n      data: {\n        type: 'files',\n        ids,\n      },\n      panelClass: 'lib-dialog--small',\n      autoFocus: false,\n    });\n\n    dialogRef.afterClosed().subscribe((res) => {\n      if (res) {\n        this.svc.dispatch({\n          type: ActionTypes.RELOAD_CURRENT_ASSETS,\n        });\n        this.svc.dispatch({\n          type: ActionTypes.RELOAD_CURRENT_FOLDER,\n        });\n        this.svc.dispatch({\n          type: ActionTypes.SET_SELECTED_ASSETS,\n          payload: [],\n        });\n      }\n    });\n  }\n\n  private fetchFolder(id: string) {\n    this.svc.dispatch({\n      type: ActionTypes.SET_GLOBAL_LOADING,\n      payload: true,\n    });\n\n    this.assetService\n      .getChildrenFolders({ assetId: id })\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((res) => {\n        this.assetService.setFolderList(res.Data, res.Meta.Total);\n        if (res.Data && res.Data.Children) {\n          res.Data.Children.forEach((node) =>\n            this.nodeTreeService.addNode(node, this.currentFolder.AssetId)\n          );\n        }\n      })\n      .add(() => {\n        this.svc.dispatch({\n          type: ActionTypes.SET_GLOBAL_LOADING,\n          payload: false,\n        });\n      });\n  }\n\n  private fetchNodeDetails(id: string) {\n    this.svc.dispatch({\n      type: ActionTypes.SET_GLOBAL_LOADING,\n      payload: true,\n    });\n    combineLatest([\n      this.assetService.getChildrenFolders({ assetId: id }),\n      this.assetService.getChildrenAssets({\n        assetId: id,\n      }),\n    ])\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe(([folders, assets]) => {\n        this.assetService.setFolderList(folders.Data, folders.Meta.Total);\n        this.assetService.setAssetList(assets.Data.Children, assets.Meta);\n        if (folders.Data && folders.Data.Children) {\n          folders.Data.Children.forEach((node) =>\n            this.nodeTreeService.addNode(node, this.currentFolder.AssetId)\n          );\n        }\n      })\n      .add(() => {\n        this.svc.dispatch({\n          type: ActionTypes.SET_GLOBAL_LOADING,\n          payload: false,\n        });\n      });\n  }\n\n  get noResults() {\n    return (\n      this.assetService.keyword &&\n      !this.currentFolder.Children.length &&\n      !this.assets.length\n    );\n  }\n\n  ngOnDestroy() {\n    this.svc.dispatch({\n      type: ActionTypes.SET_CURRENT_FOLDER_ID,\n      payload: null,\n    });\n    this.svc.dispatch({\n      type: ActionTypes.SET_SELECTED_ASSETS,\n      payload: [],\n    });\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n  }\n}\n"]}