@alfresco/aca-content 5.1.1 → 5.2.0

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

@@ -0,0 +1,153 @@
+/*!
+ * Copyright © 2005-2024 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 { getAppSelection, getCurrentVersion, NodeActionTypes } from '@alfresco/aca-shared/store';
+import { DownloadZipDialogComponent } from '@alfresco/adf-content-services';
+import { inject, Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { Actions, createEffect, ofType } 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";
+class DownloadEffects {
+    store = inject((Store));
+    actions$ = inject(Actions);
+    contentApi = inject(ContentApiService);
+    dialog = inject(MatDialog);
+    contentUrlService = inject(ContentUrlService);
+    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();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: DownloadEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: DownloadEffects });
+}
+export { DownloadEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: DownloadEffects, decorators: [{
+            type: Injectable
+        }] });
+//# 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-2024 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, getAppSelection, getCurrentVersion, NodeActionTypes, NodeInfo } from '@alfresco/aca-shared/store';\nimport { DownloadZipDialogComponent } from '@alfresco/adf-content-services';\nimport { NodeEntry, Version } from '@alfresco/js-api';\nimport { inject, Injectable } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { Actions, createEffect, ofType } 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  private store = inject(Store<AppStore>);\n  private actions$ = inject(Actions);\n  private contentApi = inject(ContentApiService);\n  private dialog = inject(MatDialog);\n  private contentUrlService = inject(ContentUrlService);\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<NodeEntry>, 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"]}

package/esm2022/lib/store/effects/favorite.effects.mjs

@@ -0,0 +1,72 @@
+/*!
+ * Copyright © 2005-2024 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, createEffect, ofType } from '@ngrx/effects';
+import { inject, Injectable } from '@angular/core';
+import { map, take } from 'rxjs/operators';
+import { getAppSelection, NodeActionTypes } from '@alfresco/aca-shared/store';
+import { Store } from '@ngrx/store';
+import { ContentManagementService } from '../../services/content-management.service';
+import * as i0 from "@angular/core";
+class FavoriteEffects {
+    store = inject((Store));
+    actions$ = inject(Actions);
+    content = inject(ContentManagementService);
+    addFavorite$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.AddFavorite), map((action) => {
+        if (action.payload && action.payload.length > 0) {
+            this.content.addFavorite(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && !selection.isEmpty) {
+                    this.content.addFavorite(selection.nodes);
+                }
+            });
+        }
+    })), { dispatch: false });
+    removeFavorite$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.RemoveFavorite), map((action) => {
+        if (action.payload && action.payload.length > 0) {
+            this.content.removeFavorite(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && !selection.isEmpty) {
+                    this.content.removeFavorite(selection.nodes);
+                }
+            });
+        }
+    })), { dispatch: false });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: FavoriteEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: FavoriteEffects });
+}
+export { FavoriteEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: FavoriteEffects, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmF2b3JpdGUuZWZmZWN0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FjYS1jb250ZW50L3NyYy9saWIvc3RvcmUvZWZmZWN0cy9mYXZvcml0ZS5lZmZlY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBRUgsT0FBTyxFQUFFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzlELE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFBRSxHQUFHLEVBQUUsSUFBSSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDM0MsT0FBTyxFQUErQixlQUFlLEVBQUUsZUFBZSxFQUF3QixNQUFNLDRCQUE0QixDQUFDO0FBQ2pJLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDcEMsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMkNBQTJDLENBQUM7O0FBRXJGLE1BQ2EsZUFBZTtJQUNsQixLQUFLLEdBQUcsTUFBTSxDQUFDLENBQUEsS0FBZSxDQUFBLENBQUMsQ0FBQztJQUNoQyxRQUFRLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQzNCLE9BQU8sR0FBRyxNQUFNLENBQUMsd0JBQXdCLENBQUMsQ0FBQztJQUVuRCxZQUFZLEdBQUcsWUFBWSxDQUN6QixHQUFHLEVBQUUsQ0FDSCxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FDaEIsTUFBTSxDQUFvQixlQUFlLENBQUMsV0FBVyxDQUFDLEVBQ3RELEdBQUcsQ0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFO1FBQ2IsSUFBSSxNQUFNLENBQUMsT0FBTyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRTtZQUMvQyxJQUFJLENBQUMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7U0FDMUM7YUFBTTtZQUNMLElBQUksQ0FBQyxLQUFLO2lCQUNQLE1BQU0sQ0FBQyxlQUFlLENBQUM7aUJBQ3ZCLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7aUJBQ2IsU0FBUyxDQUFDLENBQUMsU0FBUyxFQUFFLEVBQUU7Z0JBQ3ZCLElBQUksU0FBUyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRTtvQkFDbkMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO2lCQUMzQztZQUNILENBQUMsQ0FBQyxDQUFDO1NBQ047SUFDSCxDQUFDLENBQUMsQ0FDSCxFQUNILEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxDQUNwQixDQUFDO0lBRUYsZUFBZSxHQUFHLFlBQVksQ0FDNUIsR0FBRyxFQUFFLENBQ0gsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQ2hCLE1BQU0sQ0FBdUIsZUFBZSxDQUFDLGNBQWMsQ0FBQyxFQUM1RCxHQUFHLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRTtRQUNiLElBQUksTUFBTSxDQUFDLE9BQU8sSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUU7WUFDL0MsSUFBSSxDQUFDLE9BQU8sQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1NBQzdDO2FBQU07WUFDTCxJQUFJLENBQUMsS0FBSztpQkFDUCxNQUFNLENBQUMsZUFBZSxDQUFDO2lCQUN2QixJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO2lCQUNiLFNBQVMsQ0FBQyxDQUFDLFNBQVMsRUFBRSxFQUFFO2dCQUN2QixJQUFJLFNBQVMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLEVBQUU7b0JBQ25DLElBQUksQ0FBQyxPQUFPLENBQUMsY0FBYyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztpQkFDOUM7WUFDSCxDQUFDLENBQUMsQ0FBQztTQUNOO0lBQ0gsQ0FBQyxDQUFDLENBQ0gsRUFDSCxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsQ0FDcEIsQ0FBQzt1R0EvQ1MsZUFBZTsyR0FBZixlQUFlOztTQUFmLGVBQWU7MkZBQWYsZUFBZTtrQkFEM0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNCBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvblxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24uXG4gKiBJZiB0aGUgc29mdHdhcmUgd2FzIHB1cmNoYXNlZCB1bmRlciBhIHBhaWQgQWxmcmVzY28gbGljZW5zZSwgdGhlIHRlcm1zIG9mXG4gKiB0aGUgcGFpZCBsaWNlbnNlIGFncmVlbWVudCB3aWxsIHByZXZhaWwuIE90aGVyd2lzZSwgdGhlIHNvZnR3YXJlIGlzXG4gKiBwcm92aWRlZCB1bmRlciB0aGUgZm9sbG93aW5nIG9wZW4gc291cmNlIGxpY2Vuc2UgdGVybXM6XG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBmcmVlIHNvZnR3YXJlOiB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5XG4gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnlcbiAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yXG4gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCxcbiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mXG4gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGVcbiAqIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLlxuICpcbiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZVxuICogZnJvbSBIeWxhbmQgU29mdHdhcmUuIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi5cbiAqL1xuXG5pbXBvcnQgeyBBY3Rpb25zLCBjcmVhdGVFZmZlY3QsIG9mVHlwZSB9IGZyb20gJ0BuZ3J4L2VmZmVjdHMnO1xuaW1wb3J0IHsgaW5qZWN0LCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBtYXAsIHRha2UgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5pbXBvcnQgeyBBZGRGYXZvcml0ZUFjdGlvbiwgQXBwU3RvcmUsIGdldEFwcFNlbGVjdGlvbiwgTm9kZUFjdGlvblR5cGVzLCBSZW1vdmVGYXZvcml0ZUFjdGlvbiB9IGZyb20gJ0BhbGZyZXNjby9hY2Etc2hhcmVkL3N0b3JlJztcbmltcG9ydCB7IFN0b3JlIH0gZnJvbSAnQG5ncngvc3RvcmUnO1xuaW1wb3J0IHsgQ29udGVudE1hbmFnZW1lbnRTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvY29udGVudC1tYW5hZ2VtZW50LnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgRmF2b3JpdGVFZmZlY3RzIHtcbiAgcHJpdmF0ZSBzdG9yZSA9IGluamVjdChTdG9yZTxBcHBTdG9yZT4pO1xuICBwcml2YXRlIGFjdGlvbnMkID0gaW5qZWN0KEFjdGlvbnMpO1xuICBwcml2YXRlIGNvbnRlbnQgPSBpbmplY3QoQ29udGVudE1hbmFnZW1lbnRTZXJ2aWNlKTtcblxuICBhZGRGYXZvcml0ZSQgPSBjcmVhdGVFZmZlY3QoXG4gICAgKCkgPT5cbiAgICAgIHRoaXMuYWN0aW9ucyQucGlwZShcbiAgICAgICAgb2ZUeXBlPEFkZEZhdm9yaXRlQWN0aW9uPihOb2RlQWN0aW9uVHlwZXMuQWRkRmF2b3JpdGUpLFxuICAgICAgICBtYXAoKGFjdGlvbikgPT4ge1xuICAgICAgICAgIGlmIChhY3Rpb24ucGF5bG9hZCAmJiBhY3Rpb24ucGF5bG9hZC5sZW5ndGggPiAwKSB7XG4gICAgICAgICAgICB0aGlzLmNvbnRlbnQuYWRkRmF2b3JpdGUoYWN0aW9uLnBheWxvYWQpO1xuICAgICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICB0aGlzLnN0b3JlXG4gICAgICAgICAgICAgIC5zZWxlY3QoZ2V0QXBwU2VsZWN0aW9uKVxuICAgICAgICAgICAgICAucGlwZSh0YWtlKDEpKVxuICAgICAgICAgICAgICAuc3Vic2NyaWJlKChzZWxlY3Rpb24pID0+IHtcbiAgICAgICAgICAgICAgICBpZiAoc2VsZWN0aW9uICYmICFzZWxlY3Rpb24uaXNFbXB0eSkge1xuICAgICAgICAgICAgICAgICAgdGhpcy5jb250ZW50LmFkZEZhdm9yaXRlKHNlbGVjdGlvbi5ub2Rlcyk7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICB9KTtcbiAgICAgICAgICB9XG4gICAgICAgIH0pXG4gICAgICApLFxuICAgIHsgZGlzcGF0Y2g6IGZhbHNlIH1cbiAgKTtcblxuICByZW1vdmVGYXZvcml0ZSQgPSBjcmVhdGVFZmZlY3QoXG4gICAgKCkgPT5cbiAgICAgIHRoaXMuYWN0aW9ucyQucGlwZShcbiAgICAgICAgb2ZUeXBlPFJlbW92ZUZhdm9yaXRlQWN0aW9uPihOb2RlQWN0aW9uVHlwZXMuUmVtb3ZlRmF2b3JpdGUpLFxuICAgICAgICBtYXAoKGFjdGlvbikgPT4ge1xuICAgICAgICAgIGlmIChhY3Rpb24ucGF5bG9hZCAmJiBhY3Rpb24ucGF5bG9hZC5sZW5ndGggPiAwKSB7XG4gICAgICAgICAgICB0aGlzLmNvbnRlbnQucmVtb3ZlRmF2b3JpdGUoYWN0aW9uLnBheWxvYWQpO1xuICAgICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICB0aGlzLnN0b3JlXG4gICAgICAgICAgICAgIC5zZWxlY3QoZ2V0QXBwU2VsZWN0aW9uKVxuICAgICAgICAgICAgICAucGlwZSh0YWtlKDEpKVxuICAgICAgICAgICAgICAuc3Vic2NyaWJlKChzZWxlY3Rpb24pID0+IHtcbiAgICAgICAgICAgICAgICBpZiAoc2VsZWN0aW9uICYmICFzZWxlY3Rpb24uaXNFbXB0eSkge1xuICAgICAgICAgICAgICAgICAgdGhpcy5jb250ZW50LnJlbW92ZUZhdm9yaXRlKHNlbGVjdGlvbi5ub2Rlcyk7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICB9KTtcbiAgICAgICAgICB9XG4gICAgICAgIH0pXG4gICAgICApLFxuICAgIHsgZGlzcGF0Y2g6IGZhbHNlIH1cbiAgKTtcbn1cbiJdfQ==

package/esm2022/lib/store/effects/library.effects.mjs

@@ -0,0 +1,108 @@
+/*!
+ * Copyright © 2005-2024 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 { getAppSelection, LibraryActionTypes, NavigateLibraryAction, NavigateRouteAction } from '@alfresco/aca-shared/store';
+import { inject, Injectable } from '@angular/core';
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import { map, mergeMap, take } from 'rxjs/operators';
+import { ContentApiService } from '@alfresco/aca-shared';
+import { ContentManagementService } from '../../services/content-management.service';
+import { NotificationService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+class LibraryEffects {
+    notificationService = inject(NotificationService);
+    store = inject((Store));
+    actions$ = inject(Actions);
+    content = inject(ContentManagementService);
+    contentApi = inject(ContentApiService);
+    deleteLibrary$ = createEffect(() => this.actions$.pipe(ofType(LibraryActionTypes.Delete), map((action) => {
+        if (action.payload) {
+            this.content.deleteLibrary(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection?.library) {
+                    this.content.deleteLibrary(selection.library.entry.id);
+                }
+            });
+        }
+    })), { dispatch: false });
+    leaveLibrary$ = createEffect(() => this.actions$.pipe(ofType(LibraryActionTypes.Leave), map((action) => {
+        if (action.payload) {
+            this.content.leaveLibrary(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection?.library) {
+                    this.content.leaveLibrary(selection.library.entry.id, action.configuration?.focusedElementOnCloseSelector);
+                }
+            });
+        }
+    })), { dispatch: false });
+    createLibrary$ = createEffect(() => this.actions$.pipe(ofType(LibraryActionTypes.Create), mergeMap(() => this.content.createLibrary()), map((libraryId) => new NavigateLibraryAction(libraryId))), { dispatch: true });
+    navigateLibrary$ = createEffect(() => this.actions$.pipe(ofType(LibraryActionTypes.Navigate), map((action) => {
+        const libraryId = action.payload;
+        if (libraryId) {
+            this.contentApi
+                .getNode(libraryId, { relativePath: '/documentLibrary' })
+                .pipe(map((node) => node.entry.id))
+                .subscribe((id) => {
+                const route = action.route ? action.route : 'libraries';
+                this.store.dispatch(new NavigateRouteAction([route, id]));
+            }, () => {
+                this.notificationService.showError('APP.MESSAGES.ERRORS.MISSING_CONTENT');
+            });
+        }
+    })), { dispatch: false });
+    updateLibrary$ = createEffect(() => this.actions$.pipe(ofType(LibraryActionTypes.Update), map((action) => {
+        this.store
+            .select(getAppSelection)
+            .pipe(take(1))
+            .subscribe((selection) => {
+            if (selection?.library) {
+                const { id } = selection.library.entry;
+                const { title, description, visibility } = action.payload;
+                const siteBody = {
+                    title,
+                    description,
+                    visibility
+                };
+                this.content.updateLibrary(id, siteBody);
+            }
+        });
+    })), { dispatch: false });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: LibraryEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: LibraryEffects });
+}
+export { LibraryEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: LibraryEffects, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"library.effects.js","sourceRoot":"","sources":["../../../../../../../projects/aca-content/src/lib/store/effects/library.effects.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2024 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 {\n  AppStore,\n  CreateLibraryAction,\n  DeleteLibraryAction,\n  getAppSelection,\n  LeaveLibraryAction,\n  LibraryActionTypes,\n  NavigateLibraryAction,\n  NavigateRouteAction,\n  UpdateLibraryAction\n} from '@alfresco/aca-shared/store';\nimport { inject, Injectable } from '@angular/core';\nimport { Actions, createEffect, ofType } from '@ngrx/effects';\nimport { Store } from '@ngrx/store';\nimport { map, mergeMap, take } from 'rxjs/operators';\nimport { ContentApiService } from '@alfresco/aca-shared';\nimport { ContentManagementService } from '../../services/content-management.service';\nimport { NotificationService } from '@alfresco/adf-core';\n\n@Injectable()\nexport class LibraryEffects {\n  private notificationService = inject(NotificationService);\n  private store = inject(Store<AppStore>);\n  private actions$ = inject(Actions);\n  private content = inject(ContentManagementService);\n  private contentApi = inject(ContentApiService);\n\n  deleteLibrary$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<DeleteLibraryAction>(LibraryActionTypes.Delete),\n        map((action) => {\n          if (action.payload) {\n            this.content.deleteLibrary(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection?.library) {\n                  this.content.deleteLibrary(selection.library.entry.id);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  leaveLibrary$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<LeaveLibraryAction>(LibraryActionTypes.Leave),\n        map((action) => {\n          if (action.payload) {\n            this.content.leaveLibrary(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection?.library) {\n                  this.content.leaveLibrary(selection.library.entry.id, action.configuration?.focusedElementOnCloseSelector);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  createLibrary$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<CreateLibraryAction>(LibraryActionTypes.Create),\n        mergeMap(() => this.content.createLibrary()),\n        map((libraryId) => new NavigateLibraryAction(libraryId))\n      ),\n    { dispatch: true }\n  );\n\n  navigateLibrary$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<NavigateLibraryAction>(LibraryActionTypes.Navigate),\n        map((action) => {\n          const libraryId = action.payload;\n          if (libraryId) {\n            this.contentApi\n              .getNode(libraryId, { relativePath: '/documentLibrary' })\n              .pipe(map((node) => node.entry.id))\n              .subscribe(\n                (id) => {\n                  const route = action.route ? action.route : 'libraries';\n                  this.store.dispatch(new NavigateRouteAction([route, id]));\n                },\n                () => {\n                  this.notificationService.showError('APP.MESSAGES.ERRORS.MISSING_CONTENT');\n                }\n              );\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  updateLibrary$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<UpdateLibraryAction>(LibraryActionTypes.Update),\n        map((action) => {\n          this.store\n            .select(getAppSelection)\n            .pipe(take(1))\n            .subscribe((selection) => {\n              if (selection?.library) {\n                const { id } = selection.library.entry;\n                const { title, description, visibility } = action.payload;\n\n                const siteBody = {\n                  title,\n                  description,\n                  visibility\n                };\n\n                this.content.updateLibrary(id, siteBody);\n              }\n            });\n        })\n      ),\n    { dispatch: false }\n  );\n}\n"]}