@alfresco/aca-content 4.0.0-A.2-9984

package/esm2020/lib/services/node-template.service.mjs

@@ -0,0 +1,150 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { CreateFromTemplateDialogComponent } from '../dialogs/node-template/create-from-template.dialog';
+import { Subject, from, of } from 'rxjs';
+import { SearchApi } from '@alfresco/js-api';
+import { AlfrescoApiService, TranslationService } from '@alfresco/adf-core';
+import { switchMap, catchError } from 'rxjs/operators';
+import { Store } from '@ngrx/store';
+import { SnackbarErrorAction } from '@alfresco/aca-shared/store';
+import { ContentNodeSelectorComponent, NodeAction } from '@alfresco/adf-content-services';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@angular/material/dialog";
+export class NodeTemplateService {
+    constructor(store, alfrescoApiService, translation, dialog) {
+        this.store = store;
+        this.alfrescoApiService = alfrescoApiService;
+        this.translation = translation;
+        this.dialog = dialog;
+        this.currentTemplateConfig = null;
+    }
+    get searchApi() {
+        this._searchApi = this._searchApi ?? new SearchApi(this.alfrescoApiService.getInstance());
+        return this._searchApi;
+    }
+    selectTemplateDialog(config) {
+        this.currentTemplateConfig = config;
+        const select = new Subject();
+        select.subscribe({
+            complete: this.close.bind(this)
+        });
+        const data = {
+            selectionMode: 'single',
+            title: this.title(config.selectionType),
+            actionName: NodeAction.NEXT,
+            dropdownHideMyFiles: true,
+            currentFolderId: null,
+            dropdownSiteList: null,
+            breadcrumbTransform: this.transformNode.bind(this),
+            select,
+            showSearch: false,
+            showDropdownSiteList: false,
+            isSelectionValid: this.isSelectionValid.bind(this),
+            rowFilter: this.rowFilter.bind(this)
+        };
+        const query = {
+            query: {
+                query: `PATH:"//${config.primaryPathName}"`,
+                language: 'afts'
+            },
+            include: ['path', 'properties', 'allowableOperations', 'permissions']
+        };
+        from(this.searchApi.search(query))
+            .pipe(switchMap((response) => {
+            const entry = response.list.entries[0].entry;
+            this.rootNode = entry;
+            data.currentFolderId = entry.id;
+            return this.dialog
+                .open(ContentNodeSelectorComponent, {
+                data,
+                panelClass: ['adf-content-node-selector-dialog', 'aca-template-node-selector-dialog'],
+                width: '630px'
+            })
+                .afterClosed();
+        }), catchError((error) => {
+            this.store.dispatch(new SnackbarErrorAction('APP.MESSAGES.ERRORS.GENERIC'));
+            return of(error);
+        }))
+            .subscribe({ next: () => select.complete() });
+        return select;
+    }
+    createTemplateDialog(node) {
+        const dialog = this.dialog.open(CreateFromTemplateDialogComponent, {
+            data: node,
+            panelClass: 'aca-create-from-template-dialog',
+            width: '630px'
+        });
+        dialog.afterClosed().subscribe(() => NodeTemplateService.focusCreateMenuButton());
+        return dialog;
+    }
+    transformNode(node) {
+        if (node && node.path && node.path && node.path.elements instanceof Array) {
+            node.path.elements = this.getPathElements(node);
+        }
+        return node;
+    }
+    isSelectionValid(node) {
+        if (!node.path.elements.length) {
+            return false;
+        }
+        if (this.currentTemplateConfig.selectionType === 'folder') {
+            return node.isFolder;
+        }
+        return node.isFile;
+    }
+    close() {
+        this.dialog.closeAll();
+        NodeTemplateService.focusCreateMenuButton();
+    }
+    title(selectionType) {
+        if (selectionType === 'file') {
+            return this.translation.instant('NODE_SELECTOR.SELECT_FILE_TEMPLATE_TITLE');
+        }
+        return this.translation.instant('NODE_SELECTOR.SELECT_FOLDER_TEMPLATE_TITLE');
+    }
+    rowFilter(row) {
+        const node = row.node.entry;
+        return node.nodeType !== 'app:filelink' && node.nodeType !== 'app:folderlink';
+    }
+    getPathElements(node) {
+        return node.path.elements.filter((pathElement) => !this.rootNode.path.elements.some((rootPathElement) => pathElement.id === rootPathElement.id));
+    }
+    static focusCreateMenuButton() {
+        document.querySelector('app-create-menu button').focus();
+    }
+}
+NodeTemplateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: NodeTemplateService, deps: [{ token: i1.Store }, { token: i2.AlfrescoApiService }, { token: i2.TranslationService }, { token: i3.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+NodeTemplateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: NodeTemplateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: NodeTemplateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AlfrescoApiService }, { type: i2.TranslationService }, { type: i3.MatDialog }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-template.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-content/src/lib/services/node-template.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Alfresco Example Content Application\n *\n * Copyright (C) 2005 - 2020 Alfresco Software Limited\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail.  Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Injectable } from '@angular/core';\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { CreateFromTemplateDialogComponent } from '../dialogs/node-template/create-from-template.dialog';\nimport { Subject, from, of } from 'rxjs';\nimport { Node, MinimalNode, MinimalNodeEntryEntity, ResultNode, PathElement, SearchApi } from '@alfresco/js-api';\nimport { AlfrescoApiService, TranslationService } from '@alfresco/adf-core';\nimport { switchMap, catchError } from 'rxjs/operators';\nimport { Store } from '@ngrx/store';\nimport { AppStore, SnackbarErrorAction } from '@alfresco/aca-shared/store';\nimport { ContentNodeSelectorComponent, ContentNodeSelectorComponentData, ShareDataRow, NodeAction } from '@alfresco/adf-content-services';\n\nexport interface TemplateDialogConfig {\n  primaryPathName: string;\n  selectionType: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class NodeTemplateService {\n  private currentTemplateConfig: TemplateDialogConfig = null;\n  private rootNode: ResultNode;\n\n  _searchApi: SearchApi;\n  get searchApi(): SearchApi {\n    this._searchApi = this._searchApi ?? new SearchApi(this.alfrescoApiService.getInstance());\n    return this._searchApi;\n  }\n\n  constructor(\n    private store: Store<AppStore>,\n    private alfrescoApiService: AlfrescoApiService,\n    private translation: TranslationService,\n    public dialog: MatDialog\n  ) {}\n\n  selectTemplateDialog(config: TemplateDialogConfig): Subject<Node[]> {\n    this.currentTemplateConfig = config;\n\n    const select = new Subject<Node[]>();\n    select.subscribe({\n      complete: this.close.bind(this)\n    });\n\n    const data: ContentNodeSelectorComponentData = {\n      selectionMode: 'single',\n      title: this.title(config.selectionType),\n      actionName: NodeAction.NEXT,\n      dropdownHideMyFiles: true,\n      currentFolderId: null,\n      dropdownSiteList: null,\n      breadcrumbTransform: this.transformNode.bind(this),\n      select,\n      showSearch: false,\n      showDropdownSiteList: false,\n      isSelectionValid: this.isSelectionValid.bind(this),\n      rowFilter: this.rowFilter.bind(this)\n    };\n\n    const query = {\n      query: {\n        query: `PATH:\"//${config.primaryPathName}\"`,\n        language: 'afts'\n      },\n      include: ['path', 'properties', 'allowableOperations', 'permissions']\n    };\n\n    from(this.searchApi.search(query))\n      .pipe(\n        switchMap((response) => {\n          const entry = response.list.entries[0].entry;\n          this.rootNode = entry;\n          data.currentFolderId = entry.id;\n\n          return this.dialog\n            .open(ContentNodeSelectorComponent, {\n              data,\n              panelClass: ['adf-content-node-selector-dialog', 'aca-template-node-selector-dialog'],\n              width: '630px'\n            })\n            .afterClosed();\n        }),\n        catchError((error) => {\n          this.store.dispatch(new SnackbarErrorAction('APP.MESSAGES.ERRORS.GENERIC'));\n          return of(error);\n        })\n      )\n      .subscribe({ next: () => select.complete() });\n\n    return select;\n  }\n\n  createTemplateDialog(node: Node): MatDialogRef<CreateFromTemplateDialogComponent> {\n    const dialog = this.dialog.open(CreateFromTemplateDialogComponent, {\n      data: node,\n      panelClass: 'aca-create-from-template-dialog',\n      width: '630px'\n    });\n    dialog.afterClosed().subscribe(() => NodeTemplateService.focusCreateMenuButton());\n    return dialog;\n  }\n\n  private transformNode(node: MinimalNode): MinimalNode {\n    if (node && node.path && node.path && node.path.elements instanceof Array) {\n      node.path.elements = this.getPathElements(node);\n    }\n    return node;\n  }\n\n  private isSelectionValid(node: Node): boolean {\n    if (!node.path.elements.length) {\n      return false;\n    }\n\n    if (this.currentTemplateConfig.selectionType === 'folder') {\n      return node.isFolder;\n    }\n\n    return node.isFile;\n  }\n\n  private close() {\n    this.dialog.closeAll();\n    NodeTemplateService.focusCreateMenuButton();\n  }\n\n  private title(selectionType: string) {\n    if (selectionType === 'file') {\n      return this.translation.instant('NODE_SELECTOR.SELECT_FILE_TEMPLATE_TITLE');\n    }\n\n    return this.translation.instant('NODE_SELECTOR.SELECT_FOLDER_TEMPLATE_TITLE');\n  }\n\n  private rowFilter(row: ShareDataRow): boolean {\n    const node: MinimalNodeEntryEntity = row.node.entry;\n    return node.nodeType !== 'app:filelink' && node.nodeType !== 'app:folderlink';\n  }\n\n  private getPathElements(node: Node): PathElement[] {\n    return node.path.elements.filter((pathElement) => !this.rootNode.path.elements.some((rootPathElement) => pathElement.id === rootPathElement.id));\n  }\n\n  private static focusCreateMenuButton(): void {\n    document.querySelector<HTMLElement>('app-create-menu button').focus();\n  }\n}\n"]}

package/esm2020/lib/store/app-store.module.mjs

@@ -0,0 +1,96 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { NgModule } from '@angular/core';
+import { StoreModule } from '@ngrx/store';
+import { appReducer } from './reducers/app.reducer';
+import { StoreRouterConnectingModule, FullRouterStateSerializer } from '@ngrx/router-store';
+import { EffectsModule } from '@ngrx/effects';
+import { SharedStoreModule } from '@alfresco/aca-shared/store';
+import { AppEffects, NodeEffects, DownloadEffects, ViewerEffects, SearchEffects, LibraryEffects, UploadEffects, FavoriteEffects, TemplateEffects, ContextMenuEffects } from './effects';
+import { INITIAL_STATE } from './initial-state';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@ngrx/router-store";
+import * as i3 from "@ngrx/effects";
+export class AppStoreModule {
+}
+AppStoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppStoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppStoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.2", ngImport: i0, type: AppStoreModule, imports: [i1.StoreRootModule, i2.StoreRouterConnectingModule, SharedStoreModule, i3.EffectsRootModule] });
+AppStoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppStoreModule, imports: [StoreModule.forRoot({ app: appReducer }, {
+            initialState: INITIAL_STATE,
+            runtimeChecks: {
+                strictStateImmutability: false,
+                strictActionImmutability: false
+            }
+        }),
+        StoreRouterConnectingModule.forRoot({
+            serializer: FullRouterStateSerializer,
+            stateKey: 'router'
+        }),
+        SharedStoreModule,
+        EffectsModule.forRoot([
+            AppEffects,
+            NodeEffects,
+            DownloadEffects,
+            ViewerEffects,
+            SearchEffects,
+            LibraryEffects,
+            UploadEffects,
+            FavoriteEffects,
+            TemplateEffects,
+            ContextMenuEffects
+        ])] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppStoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        StoreModule.forRoot({ app: appReducer }, {
+                            initialState: INITIAL_STATE,
+                            runtimeChecks: {
+                                strictStateImmutability: false,
+                                strictActionImmutability: false
+                            }
+                        }),
+                        StoreRouterConnectingModule.forRoot({
+                            serializer: FullRouterStateSerializer,
+                            stateKey: 'router'
+                        }),
+                        SharedStoreModule,
+                        EffectsModule.forRoot([
+                            AppEffects,
+                            NodeEffects,
+                            DownloadEffects,
+                            ViewerEffects,
+                            SearchEffects,
+                            LibraryEffects,
+                            UploadEffects,
+                            FavoriteEffects,
+                            TemplateEffects,
+                            ContextMenuEffects
+                        ])
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/store/effects/app.effects.mjs

@@ -0,0 +1,62 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Actions, ofType, createEffect } from '@ngrx/effects';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { AppActionTypes } from '@alfresco/aca-shared/store';
+import { AuthenticationService } from '@alfresco/adf-core';
+import { Router } from '@angular/router';
+import { AppHookService } from '@alfresco/aca-shared';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/effects";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@angular/router";
+import * as i4 from "@alfresco/aca-shared";
+export class AppEffects {
+    constructor(actions$, auth, router, appHookService) {
+        this.actions$ = actions$;
+        this.auth = auth;
+        this.router = router;
+        this.appHookService = appHookService;
+        this.reload = createEffect(() => this.actions$.pipe(ofType(AppActionTypes.ReloadDocumentList), map((action) => {
+            this.appHookService.reload.next(action);
+        })), { dispatch: false });
+        this.resetSelection = createEffect(() => this.actions$.pipe(ofType(AppActionTypes.ResetSelection), map((action) => {
+            this.appHookService.reset.next(action);
+        })), { dispatch: false });
+        this.logout$ = createEffect(() => this.actions$.pipe(ofType(AppActionTypes.Logout), map(() => {
+            this.auth.logout().subscribe(() => this.redirectToLogin(), () => this.redirectToLogin());
+        })), { dispatch: false });
+    }
+    redirectToLogin() {
+        return this.router.navigate(['login']);
+    }
+}
+AppEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppEffects, deps: [{ token: i1.Actions }, { token: i2.AuthenticationService }, { token: i3.Router }, { token: i4.AppHookService }], target: i0.ɵɵFactoryTarget.Injectable });
+AppEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Actions }, { type: i2.AuthenticationService }, { type: i3.Router }, { type: i4.AppHookService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/store/effects/contextmenu.effects.mjs

@@ -0,0 +1,56 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { ContextMenuActionTypes } from '@alfresco/aca-shared/store';
+import { Injectable } from '@angular/core';
+import { Actions, ofType, createEffect } from '@ngrx/effects';
+import { map } from 'rxjs/operators';
+import { ContextMenuService } from '../../components/context-menu/context-menu.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../components/context-menu/context-menu.service";
+import * as i2 from "@ngrx/effects";
+export class ContextMenuEffects {
+    constructor(contextMenuService, actions$) {
+        this.contextMenuService = contextMenuService;
+        this.actions$ = actions$;
+        this.overlayRef = null;
+        this.contextMenu$ = createEffect(() => this.actions$.pipe(ofType(ContextMenuActionTypes.ContextMenu), map((action) => {
+            if (this.overlayRef) {
+                this.overlayRef.close();
+            }
+            this.overlayRef = this.contextMenuService.open({
+                source: action.event,
+                hasBackdrop: false,
+                backdropClass: 'cdk-overlay-transparent-backdrop',
+                panelClass: 'cdk-overlay-pane'
+            });
+        })), { dispatch: false });
+    }
+}
+ContextMenuEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ContextMenuEffects, deps: [{ token: i1.ContextMenuService }, { token: i2.Actions }], target: i0.ɵɵFactoryTarget.Injectable });
+ContextMenuEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ContextMenuEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ContextMenuEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ContextMenuService }, { type: i2.Actions }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/store/effects/download.effects.mjs

@@ -0,0 +1,160 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { NodeActionTypes, getAppSelection, getCurrentVersion } from '@alfresco/aca-shared/store';
+import { DownloadZipDialogComponent } from '@alfresco/adf-core';
+import { Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { Actions, ofType, createEffect } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import { map, take } from 'rxjs/operators';
+import { ContentApiService } from '@alfresco/aca-shared';
+import { ContentUrlService } from '../../services/content-url.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@ngrx/effects";
+import * as i3 from "@alfresco/aca-shared";
+import * as i4 from "@angular/material/dialog";
+import * as i5 from "../../services/content-url.service";
+export class DownloadEffects {
+    constructor(store, actions$, contentApi, dialog, contentUrlService) {
+        this.store = store;
+        this.actions$ = actions$;
+        this.contentApi = contentApi;
+        this.dialog = dialog;
+        this.contentUrlService = contentUrlService;
+        this.downloadNode$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.Download), map((action) => {
+            if (action.payload?.length > 0) {
+                this.downloadNodes(action.payload);
+            }
+            else {
+                this.store
+                    .select(getAppSelection)
+                    .pipe(take(1))
+                    .subscribe((selection) => {
+                    if (selection && !selection.isEmpty) {
+                        this.store
+                            .select(getCurrentVersion)
+                            .pipe(take(1))
+                            .subscribe((version) => {
+                            if (version) {
+                                this.downloadFileVersion(selection.nodes[0].entry, version.entry);
+                            }
+                            else {
+                                this.downloadNodes(selection.nodes, action.configuration?.focusedElementOnCloseSelector);
+                            }
+                        });
+                    }
+                });
+            }
+        })), { dispatch: false });
+    }
+    downloadNodes(toDownload, focusedElementSelector) {
+        const nodes = toDownload.map((node) => {
+            const { id, nodeId, name, isFile, isFolder } = node.entry;
+            return {
+                id: this.isSharedLinkPreview ? id : nodeId || id,
+                name,
+                isFile,
+                isFolder
+            };
+        });
+        if (!nodes || nodes.length === 0) {
+            return;
+        }
+        if (nodes.length === 1) {
+            this.downloadNode(nodes[0], focusedElementSelector);
+        }
+        else {
+            this.downloadZip(nodes, focusedElementSelector);
+        }
+    }
+    downloadNode(node, focusedElementSelector) {
+        if (node) {
+            if (node.isFolder) {
+                this.downloadZip([node], focusedElementSelector);
+            }
+            else {
+                this.downloadFile(node);
+            }
+        }
+    }
+    downloadFile(node) {
+        if (node && !this.isSharedLinkPreview) {
+            this.contentUrlService.getNodeContentUrl(node.id, true).subscribe((contentUrl) => {
+                this.download(contentUrl, node.name);
+            });
+        }
+        if (node && this.isSharedLinkPreview) {
+            this.download(this.contentApi.getSharedLinkContent(node.id, false), node.name);
+        }
+    }
+    downloadFileVersion(node, version) {
+        if (node && version) {
+            this.contentUrlService.getVersionContentUrl(node.id, version.id, true).subscribe((contentUrl) => {
+                this.download(contentUrl, node.name);
+            });
+        }
+    }
+    downloadZip(nodes, focusedElementSelector) {
+        if (nodes && nodes.length > 0) {
+            const nodeIds = nodes.map((node) => node.id);
+            this.dialog
+                .open(DownloadZipDialogComponent, {
+                width: '600px',
+                disableClose: true,
+                data: {
+                    nodeIds
+                }
+            })
+                .afterClosed()
+                .subscribe(() => this.focusAfterClose(focusedElementSelector));
+        }
+    }
+    download(url, fileName) {
+        if (url && fileName) {
+            const link = document.createElement('a');
+            link.style.display = 'none';
+            link.download = fileName;
+            link.href = url;
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        }
+    }
+    get isSharedLinkPreview() {
+        return location.href.includes('/preview/s/');
+    }
+    focusAfterClose(focusedElementSelector) {
+        if (focusedElementSelector) {
+            document.querySelector(focusedElementSelector).focus();
+        }
+    }
+}
+DownloadEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: DownloadEffects, deps: [{ token: i1.Store }, { token: i2.Actions }, { token: i3.ContentApiService }, { token: i4.MatDialog }, { token: i5.ContentUrlService }], target: i0.ɵɵFactoryTarget.Injectable });
+DownloadEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: DownloadEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: DownloadEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Actions }, { type: i3.ContentApiService }, { type: i4.MatDialog }, { type: i5.ContentUrlService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"download.effects.js","sourceRoot":"","sources":["../../../../../../../projects/aca-content/src/lib/store/effects/download.effects.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Alfresco Example Content Application\n *\n * Copyright (C) 2005 - 2020 Alfresco Software Limited\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail.  Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { AppStore, DownloadNodesAction, NodeActionTypes, NodeInfo, getAppSelection, getCurrentVersion } from '@alfresco/aca-shared/store';\nimport { DownloadZipDialogComponent } from '@alfresco/adf-core';\nimport { MinimalNodeEntity, Version } from '@alfresco/js-api';\nimport { Injectable } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { Actions, ofType, createEffect } from '@ngrx/effects';\nimport { Store } from '@ngrx/store';\nimport { map, take } from 'rxjs/operators';\nimport { ContentApiService } from '@alfresco/aca-shared';\nimport { ContentUrlService } from '../../services/content-url.service';\n\n@Injectable()\nexport class DownloadEffects {\n  constructor(\n    private store: Store<AppStore>,\n    private actions$: Actions,\n    private contentApi: ContentApiService,\n    private dialog: MatDialog,\n    private contentUrlService: ContentUrlService\n  ) {}\n\n  downloadNode$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<DownloadNodesAction>(NodeActionTypes.Download),\n        map((action) => {\n          if (action.payload?.length > 0) {\n            this.downloadNodes(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection && !selection.isEmpty) {\n                  this.store\n                    .select(getCurrentVersion)\n                    .pipe(take(1))\n                    .subscribe((version) => {\n                      if (version) {\n                        this.downloadFileVersion(selection.nodes[0].entry, version.entry);\n                      } else {\n                        this.downloadNodes(selection.nodes, action.configuration?.focusedElementOnCloseSelector);\n                      }\n                    });\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  private downloadNodes(toDownload: Array<MinimalNodeEntity>, focusedElementSelector?: string) {\n    const nodes = toDownload.map((node) => {\n      const { id, nodeId, name, isFile, isFolder } = node.entry as any;\n\n      return {\n        id: this.isSharedLinkPreview ? id : nodeId || id,\n        name,\n        isFile,\n        isFolder\n      };\n    });\n\n    if (!nodes || nodes.length === 0) {\n      return;\n    }\n\n    if (nodes.length === 1) {\n      this.downloadNode(nodes[0], focusedElementSelector);\n    } else {\n      this.downloadZip(nodes, focusedElementSelector);\n    }\n  }\n\n  private downloadNode(node: NodeInfo, focusedElementSelector?: string) {\n    if (node) {\n      if (node.isFolder) {\n        this.downloadZip([node], focusedElementSelector);\n      } else {\n        this.downloadFile(node);\n      }\n    }\n  }\n\n  private downloadFile(node: NodeInfo) {\n    if (node && !this.isSharedLinkPreview) {\n      this.contentUrlService.getNodeContentUrl(node.id, true).subscribe((contentUrl) => {\n        this.download(contentUrl, node.name);\n      });\n    }\n\n    if (node && this.isSharedLinkPreview) {\n      this.download(this.contentApi.getSharedLinkContent(node.id, false), node.name);\n    }\n  }\n\n  private downloadFileVersion(node: NodeInfo, version: Version) {\n    if (node && version) {\n      this.contentUrlService.getVersionContentUrl(node.id, version.id, true).subscribe((contentUrl) => {\n        this.download(contentUrl, node.name);\n      });\n    }\n  }\n\n  private downloadZip(nodes: Array<NodeInfo>, focusedElementSelector?: string) {\n    if (nodes && nodes.length > 0) {\n      const nodeIds = nodes.map((node) => node.id);\n\n      this.dialog\n        .open(DownloadZipDialogComponent, {\n          width: '600px',\n          disableClose: true,\n          data: {\n            nodeIds\n          }\n        })\n        .afterClosed()\n        .subscribe(() => this.focusAfterClose(focusedElementSelector));\n    }\n  }\n\n  private download(url: string, fileName: string) {\n    if (url && fileName) {\n      const link = document.createElement('a');\n\n      link.style.display = 'none';\n      link.download = fileName;\n      link.href = url;\n\n      document.body.appendChild(link);\n      link.click();\n      document.body.removeChild(link);\n    }\n  }\n\n  private get isSharedLinkPreview() {\n    return location.href.includes('/preview/s/');\n  }\n\n  private focusAfterClose(focusedElementSelector: string): void {\n    if (focusedElementSelector) {\n      document.querySelector<HTMLElement>(focusedElementSelector).focus();\n    }\n  }\n}\n"]}