@alfresco/aca-content 4.0.0-4895233349

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

@@ -0,0 +1,149 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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-toolbar-menu button[id="app.toolbar.create"]').focus();
+    }
+}
+NodeTemplateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", 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.3", ngImport: i0, type: NodeTemplateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", 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 * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\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 * from Hyland Software. 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-toolbar-menu button[id=\"app.toolbar.create\"]').focus();\n  }\n}\n"]}

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

@@ -0,0 +1,95 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", ngImport: i0, type: AppStoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppStoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.3", ngImport: i0, type: AppStoreModule, imports: [i1.StoreRootModule, i2.StoreRouterConnectingModule, SharedStoreModule, i3.EffectsRootModule] });
+AppStoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.3", 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.3", 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,61 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", ngImport: i0, type: AppEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", 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,55 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", ngImport: i0, type: ContextMenuEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: ContextMenuEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ContextMenuService }, { type: i2.Actions }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dG1lbnUuZWZmZWN0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FjYS1jb250ZW50L3NyYy9saWIvc3RvcmUvZWZmZWN0cy9jb250ZXh0bWVudS5lZmZlY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBRUgsT0FBTyxFQUFFLHNCQUFzQixFQUFlLE1BQU0sNEJBQTRCLENBQUM7QUFDakYsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDOUQsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRXJDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG9EQUFvRCxDQUFDOzs7O0FBR3hGLE1BQU0sT0FBTyxrQkFBa0I7SUFHN0IsWUFBb0Isa0JBQXNDLEVBQVUsUUFBaUI7UUFBakUsdUJBQWtCLEdBQWxCLGtCQUFrQixDQUFvQjtRQUFVLGFBQVEsR0FBUixRQUFRLENBQVM7UUFGN0UsZUFBVSxHQUEwQixJQUFJLENBQUM7UUFJakQsaUJBQVksR0FBRyxZQUFZLENBQ3pCLEdBQUcsRUFBRSxDQUNILElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUNoQixNQUFNLENBQWMsc0JBQXNCLENBQUMsV0FBVyxDQUFDLEVBQ3ZELEdBQUcsQ0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFO1lBQ2IsSUFBSSxJQUFJLENBQUMsVUFBVSxFQUFFO2dCQUNuQixJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssRUFBRSxDQUFDO2FBQ3pCO1lBRUQsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDO2dCQUM3QyxNQUFNLEVBQUUsTUFBTSxDQUFDLEtBQUs7Z0JBQ3BCLFdBQVcsRUFBRSxLQUFLO2dCQUNsQixhQUFhLEVBQUUsa0NBQWtDO2dCQUNqRCxVQUFVLEVBQUUsa0JBQWtCO2FBQy9CLENBQUMsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUNILEVBQ0gsRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLENBQ3BCLENBQUM7SUFwQnNGLENBQUM7OytHQUg5RSxrQkFBa0I7bUhBQWxCLGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQUQ5QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDIzIEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uXG4gKlxuICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbi5cbiAqIElmIHRoZSBzb2Z0d2FyZSB3YXMgcHVyY2hhc2VkIHVuZGVyIGEgcGFpZCBBbGZyZXNjbyBsaWNlbnNlLCB0aGUgdGVybXMgb2ZcbiAqIHRoZSBwYWlkIGxpY2Vuc2UgYWdyZWVtZW50IHdpbGwgcHJldmFpbC4gT3RoZXJ3aXNlLCB0aGUgc29mdHdhcmUgaXNcbiAqIHByb3ZpZGVkIHVuZGVyIHRoZSBmb2xsb3dpbmcgb3BlbiBzb3VyY2UgbGljZW5zZSB0ZXJtczpcbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnlcbiAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieVxuICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3JcbiAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uXG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLFxuICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2ZcbiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZVxuICogR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuXG4gKlxuICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlXG4gKiBmcm9tIEh5bGFuZCBTb2Z0d2FyZS4gSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LlxuICovXG5cbmltcG9ydCB7IENvbnRleHRNZW51QWN0aW9uVHlwZXMsIENvbnRleHRNZW51IH0gZnJvbSAnQGFsZnJlc2NvL2FjYS1zaGFyZWQvc3RvcmUnO1xuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQWN0aW9ucywgb2ZUeXBlLCBjcmVhdGVFZmZlY3QgfSBmcm9tICdAbmdyeC9lZmZlY3RzJztcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IENvbnRleHRNZW51T3ZlcmxheVJlZiB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvY29udGV4dC1tZW51L2NvbnRleHQtbWVudS1vdmVybGF5JztcbmltcG9ydCB7IENvbnRleHRNZW51U2VydmljZSB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvY29udGV4dC1tZW51L2NvbnRleHQtbWVudS5zZXJ2aWNlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIENvbnRleHRNZW51RWZmZWN0cyB7XG4gIHByaXZhdGUgb3ZlcmxheVJlZjogQ29udGV4dE1lbnVPdmVybGF5UmVmID0gbnVsbDtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGNvbnRleHRNZW51U2VydmljZTogQ29udGV4dE1lbnVTZXJ2aWNlLCBwcml2YXRlIGFjdGlvbnMkOiBBY3Rpb25zKSB7fVxuXG4gIGNvbnRleHRNZW51JCA9IGNyZWF0ZUVmZmVjdChcbiAgICAoKSA9PlxuICAgICAgdGhpcy5hY3Rpb25zJC5waXBlKFxuICAgICAgICBvZlR5cGU8Q29udGV4dE1lbnU+KENvbnRleHRNZW51QWN0aW9uVHlwZXMuQ29udGV4dE1lbnUpLFxuICAgICAgICBtYXAoKGFjdGlvbikgPT4ge1xuICAgICAgICAgIGlmICh0aGlzLm92ZXJsYXlSZWYpIHtcbiAgICAgICAgICAgIHRoaXMub3ZlcmxheVJlZi5jbG9zZSgpO1xuICAgICAgICAgIH1cblxuICAgICAgICAgIHRoaXMub3ZlcmxheVJlZiA9IHRoaXMuY29udGV4dE1lbnVTZXJ2aWNlLm9wZW4oe1xuICAgICAgICAgICAgc291cmNlOiBhY3Rpb24uZXZlbnQsXG4gICAgICAgICAgICBoYXNCYWNrZHJvcDogZmFsc2UsXG4gICAgICAgICAgICBiYWNrZHJvcENsYXNzOiAnY2RrLW92ZXJsYXktdHJhbnNwYXJlbnQtYmFja2Ryb3AnLFxuICAgICAgICAgICAgcGFuZWxDbGFzczogJ2Nkay1vdmVybGF5LXBhbmUnXG4gICAgICAgICAgfSk7XG4gICAgICAgIH0pXG4gICAgICApLFxuICAgIHsgZGlzcGF0Y2g6IGZhbHNlIH1cbiAgKTtcbn1cbiJdfQ==

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

@@ -0,0 +1,159 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { NodeActionTypes, getAppSelection, getCurrentVersion } from '@alfresco/aca-shared/store';
+import { DownloadZipDialogComponent } from '@alfresco/adf-content-services';
+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.3", 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.3", ngImport: i0, type: DownloadEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", 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 * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\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 * from Hyland Software. 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-content-services';\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"]}