@alfresco/aca-content 5.1.1 → 5.2.0

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

@@ -0,0 +1,318 @@
+/*!
+ * 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, SecurityContext } from '@angular/core';
+import { first, map, take } from 'rxjs/operators';
+import { Store } from '@ngrx/store';
+import { getAppSelection, getCurrentFolder, NavigateRouteAction, NavigateUrlAction, NodeActionTypes, SetInfoDrawerStateAction, ShowLoaderAction } from '@alfresco/aca-shared/store';
+import { ContentManagementService } from '../../services/content-management.service';
+import { RenditionService } from '@alfresco/adf-content-services';
+import { ActivatedRoute, NavigationEnd, Router } from '@angular/router';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+class NodeEffects {
+    store = inject((Store));
+    actions$ = inject(Actions);
+    router = inject(Router);
+    contentService = inject(ContentManagementService);
+    renditionViewer = inject(RenditionService);
+    activatedRoute = inject(ActivatedRoute);
+    sanitizer = inject(DomSanitizer);
+    shareNode$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.Share), map((action) => {
+        if (action.payload) {
+            this.contentService.shareNode(action.payload, action.configuration?.focusedElementOnCloseSelector);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection?.file) {
+                    this.contentService.shareNode(selection.file, action.configuration?.focusedElementOnCloseSelector);
+                }
+            });
+        }
+    })), { dispatch: false });
+    unshareNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.Unshare), map((action) => {
+        if (action?.payload?.length > 0) {
+            this.contentService.unshareNodes(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && !selection.isEmpty) {
+                    this.contentService.unshareNodes(selection.nodes);
+                }
+            });
+        }
+    })), { dispatch: false });
+    purgeDeletedNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.PurgeDeleted), map((action) => {
+        if (action?.payload?.length > 0) {
+            this.contentService.purgeDeletedNodes(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && selection.count > 0) {
+                    this.contentService.purgeDeletedNodes(selection.nodes);
+                }
+            });
+        }
+    })), { dispatch: false });
+    restoreDeletedNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.RestoreDeleted), map((action) => {
+        if (action?.payload?.length > 0) {
+            this.contentService.restoreDeletedNodes(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && selection.count > 0) {
+                    this.contentService.restoreDeletedNodes(selection.nodes);
+                }
+            });
+        }
+    })), { dispatch: false });
+    deleteNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.Delete), map((action) => {
+        this.store.dispatch(new ShowLoaderAction(true));
+        if (action?.payload?.length > 0) {
+            this.contentService.deleteNodes(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && selection.count > 0) {
+                    this.contentService.deleteNodes(selection.nodes);
+                }
+            });
+        }
+    })), { dispatch: false });
+    undoDeleteNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.UndoDelete), map((action) => {
+        if (action.payload.length > 0) {
+            this.contentService.undoDeleteNodes(action.payload);
+        }
+    })), { dispatch: false });
+    createFolder$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.CreateFolder), map((action) => {
+        if (action.payload) {
+            this.contentService.createFolder(action.payload);
+        }
+        else {
+            this.store
+                .select(getCurrentFolder)
+                .pipe(take(1))
+                .subscribe((node) => {
+                if (node?.id) {
+                    this.contentService.createFolder(node.id);
+                }
+            });
+        }
+    })), { dispatch: false });
+    editFolder$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.EditFolder), map((action) => {
+        if (action.payload) {
+            this.contentService.editFolder(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection?.folder) {
+                    this.contentService.editFolder(selection.folder, action.configuration?.focusedElementOnCloseSelector);
+                }
+            });
+        }
+    })), { dispatch: false });
+    copyNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.Copy), map((action) => {
+        if (action.payload?.length > 0) {
+            this.contentService.copyNodes(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && !selection.isEmpty) {
+                    this.contentService.copyNodes(selection.nodes, action.configuration?.focusedElementOnCloseSelector);
+                }
+            });
+        }
+    })), { dispatch: false });
+    moveNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.Move), map((action) => {
+        if (action.payload?.length > 0) {
+            this.contentService.moveNodes(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && !selection.isEmpty) {
+                    this.contentService.moveNodes(selection.nodes, action.configuration?.focusedElementOnCloseSelector);
+                }
+            });
+        }
+    })), { dispatch: false });
+    managePermissions$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.ManagePermissions), map((action) => {
+        this.router.events
+            .pipe(first((event) => event instanceof NavigationEnd))
+            .subscribe(() => this.store.dispatch(new SetInfoDrawerStateAction(true)));
+        if (action?.payload) {
+            const route = 'personal-files/details';
+            this.store.dispatch(new NavigateUrlAction([route, action.payload.entry.id, 'permissions'].join('/')));
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && !selection.isEmpty) {
+                    const route = 'personal-files/details';
+                    this.store.dispatch(new NavigateUrlAction([route, selection.last.entry.id, 'permissions'].join('/')));
+                }
+            });
+        }
+    })), { dispatch: false });
+    expandInfoDrawer$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.ExpandInfoDrawer), map((action) => {
+        this.router.events
+            .pipe(first((event) => event instanceof NavigationEnd))
+            .subscribe(() => this.store.dispatch(new SetInfoDrawerStateAction(true)));
+        this.activatedRoute.queryParams.pipe(take(1)).subscribe((params) => {
+            const location = params.location || this.router.url;
+            const sanitizedLocation = this.sanitizer.sanitize(SecurityContext.URL, location);
+            const route = 'personal-files/details';
+            if (action?.payload) {
+                this.store.dispatch(new NavigateUrlAction([route, action.payload.entry.id].join('/') + `?location=${sanitizedLocation}`));
+            }
+            else {
+                this.store
+                    .select(getAppSelection)
+                    .pipe(take(1))
+                    .subscribe((selection) => {
+                    if (selection && !selection.isEmpty) {
+                        this.store.dispatch(new NavigateUrlAction([route, selection.last.entry.id].join('/') + `?location=${sanitizedLocation}`));
+                    }
+                });
+            }
+        });
+    })), { dispatch: false });
+    manageVersions$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.ManageVersions), map((action) => {
+        if (action?.payload) {
+            this.contentService.manageVersions(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection?.file) {
+                    this.contentService.manageVersions(selection.file, action.configuration?.focusedElementOnCloseSelector);
+                }
+            });
+        }
+    })), { dispatch: false });
+    printFile$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.PrintFile), map((action) => {
+        if (action?.payload) {
+            this.printFile(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection?.file) {
+                    this.printFile(selection.file);
+                }
+            });
+        }
+    })), { dispatch: false });
+    unlockWrite$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.UnlockForWriting), map((action) => {
+        if (action?.payload) {
+            this.contentService.unlockNode(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection?.file) {
+                    this.contentService.unlockNode(selection.file);
+                }
+            });
+        }
+    })), { dispatch: false });
+    aspectList$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.ChangeAspects), map((action) => {
+        if (action?.payload) {
+            this.contentService.manageAspects(action.payload);
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && !selection.isEmpty) {
+                    this.contentService.manageAspects(selection.nodes[0], action.configuration?.focusedElementOnCloseSelector);
+                }
+            });
+        }
+    })), { dispatch: false });
+    printFile(node) {
+        if (node?.entry) {
+            // shared and favorite
+            const id = node.entry.nodeId || node.entry.guid || node.entry.id;
+            const mimeType = node.entry.content.mimeType;
+            if (id) {
+                this.renditionViewer.printFileGeneric(id, mimeType);
+            }
+        }
+    }
+    manageRules$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.ManageRules), map((action) => {
+        if (action?.payload) {
+            this.store.dispatch(new NavigateRouteAction(['nodes', action.payload.entry.id, 'rules']));
+        }
+        else {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && !selection.isEmpty) {
+                    this.store.dispatch(new NavigateRouteAction(['nodes', selection.first.entry.id, 'rules']));
+                }
+            });
+        }
+    })), { dispatch: false });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NodeEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NodeEffects });
+}
+export { NodeEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NodeEffects, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.effects.js","sourceRoot":"","sources":["../../../../../../../projects/aca-content/src/lib/store/effects/node.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 { Actions, createEffect, ofType } from '@ngrx/effects';\nimport { inject, Injectable, SecurityContext } from '@angular/core';\nimport { first, map, take } from 'rxjs/operators';\nimport { Store } from '@ngrx/store';\nimport {\n  AppStore,\n  CopyNodesAction,\n  CreateFolderAction,\n  DeleteNodesAction,\n  EditFolderAction,\n  ExpandInfoDrawerAction,\n  getAppSelection,\n  getCurrentFolder,\n  ManageAspectsAction,\n  ManagePermissionsAction,\n  ManageRulesAction,\n  ManageVersionsAction,\n  MoveNodesAction,\n  NavigateRouteAction,\n  NavigateUrlAction,\n  NodeActionTypes,\n  PrintFileAction,\n  PurgeDeletedNodesAction,\n  RestoreDeletedNodesAction,\n  SetInfoDrawerStateAction,\n  ShareNodeAction,\n  ShowLoaderAction,\n  UndoDeleteNodesAction,\n  UnlockWriteAction,\n  UnshareNodesAction\n} from '@alfresco/aca-shared/store';\nimport { ContentManagementService } from '../../services/content-management.service';\nimport { RenditionService } from '@alfresco/adf-content-services';\nimport { ActivatedRoute, NavigationEnd, Router } from '@angular/router';\nimport { DomSanitizer } from '@angular/platform-browser';\n\n@Injectable()\nexport class NodeEffects {\n  private readonly store = inject(Store<AppStore>);\n  private readonly actions$ = inject(Actions);\n  private readonly router = inject(Router);\n  private readonly contentService = inject(ContentManagementService);\n  private readonly renditionViewer = inject(RenditionService);\n  private readonly activatedRoute = inject(ActivatedRoute);\n  private readonly sanitizer = inject(DomSanitizer);\n\n  shareNode$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<ShareNodeAction>(NodeActionTypes.Share),\n        map((action) => {\n          if (action.payload) {\n            this.contentService.shareNode(action.payload, action.configuration?.focusedElementOnCloseSelector);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection?.file) {\n                  this.contentService.shareNode(selection.file, action.configuration?.focusedElementOnCloseSelector);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  unshareNodes$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<UnshareNodesAction>(NodeActionTypes.Unshare),\n        map((action) => {\n          if (action?.payload?.length > 0) {\n            this.contentService.unshareNodes(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection && !selection.isEmpty) {\n                  this.contentService.unshareNodes(selection.nodes);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  purgeDeletedNodes$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<PurgeDeletedNodesAction>(NodeActionTypes.PurgeDeleted),\n        map((action) => {\n          if (action?.payload?.length > 0) {\n            this.contentService.purgeDeletedNodes(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection && selection.count > 0) {\n                  this.contentService.purgeDeletedNodes(selection.nodes);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  restoreDeletedNodes$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<RestoreDeletedNodesAction>(NodeActionTypes.RestoreDeleted),\n        map((action) => {\n          if (action?.payload?.length > 0) {\n            this.contentService.restoreDeletedNodes(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection && selection.count > 0) {\n                  this.contentService.restoreDeletedNodes(selection.nodes);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  deleteNodes$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<DeleteNodesAction>(NodeActionTypes.Delete),\n        map((action) => {\n          this.store.dispatch(new ShowLoaderAction(true));\n          if (action?.payload?.length > 0) {\n            this.contentService.deleteNodes(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection && selection.count > 0) {\n                  this.contentService.deleteNodes(selection.nodes);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  undoDeleteNodes$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<UndoDeleteNodesAction>(NodeActionTypes.UndoDelete),\n        map((action) => {\n          if (action.payload.length > 0) {\n            this.contentService.undoDeleteNodes(action.payload);\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  createFolder$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<CreateFolderAction>(NodeActionTypes.CreateFolder),\n        map((action) => {\n          if (action.payload) {\n            this.contentService.createFolder(action.payload);\n          } else {\n            this.store\n              .select(getCurrentFolder)\n              .pipe(take(1))\n              .subscribe((node) => {\n                if (node?.id) {\n                  this.contentService.createFolder(node.id);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  editFolder$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<EditFolderAction>(NodeActionTypes.EditFolder),\n        map((action) => {\n          if (action.payload) {\n            this.contentService.editFolder(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection?.folder) {\n                  this.contentService.editFolder(selection.folder, action.configuration?.focusedElementOnCloseSelector);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  copyNodes$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<CopyNodesAction>(NodeActionTypes.Copy),\n        map((action) => {\n          if (action.payload?.length > 0) {\n            this.contentService.copyNodes(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection && !selection.isEmpty) {\n                  this.contentService.copyNodes(selection.nodes, action.configuration?.focusedElementOnCloseSelector);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  moveNodes$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<MoveNodesAction>(NodeActionTypes.Move),\n        map((action) => {\n          if (action.payload?.length > 0) {\n            this.contentService.moveNodes(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection && !selection.isEmpty) {\n                  this.contentService.moveNodes(selection.nodes, action.configuration?.focusedElementOnCloseSelector);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  managePermissions$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<ManagePermissionsAction>(NodeActionTypes.ManagePermissions),\n        map((action) => {\n          this.router.events\n            .pipe(first((event) => event instanceof NavigationEnd))\n            .subscribe(() => this.store.dispatch(new SetInfoDrawerStateAction(true)));\n          if (action?.payload) {\n            const route = 'personal-files/details';\n            this.store.dispatch(new NavigateUrlAction([route, action.payload.entry.id, 'permissions'].join('/')));\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection && !selection.isEmpty) {\n                  const route = 'personal-files/details';\n                  this.store.dispatch(new NavigateUrlAction([route, selection.last.entry.id, 'permissions'].join('/')));\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  expandInfoDrawer$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<ExpandInfoDrawerAction>(NodeActionTypes.ExpandInfoDrawer),\n        map((action) => {\n          this.router.events\n            .pipe(first((event) => event instanceof NavigationEnd))\n            .subscribe(() => this.store.dispatch(new SetInfoDrawerStateAction(true)));\n\n          this.activatedRoute.queryParams.pipe(take(1)).subscribe((params) => {\n            const location = params.location || this.router.url;\n            const sanitizedLocation = this.sanitizer.sanitize(SecurityContext.URL, location);\n            const route = 'personal-files/details';\n\n            if (action?.payload) {\n              this.store.dispatch(new NavigateUrlAction([route, action.payload.entry.id].join('/') + `?location=${sanitizedLocation}`));\n            } else {\n              this.store\n                .select(getAppSelection)\n                .pipe(take(1))\n                .subscribe((selection) => {\n                  if (selection && !selection.isEmpty) {\n                    this.store.dispatch(new NavigateUrlAction([route, selection.last.entry.id].join('/') + `?location=${sanitizedLocation}`));\n                  }\n                });\n            }\n          });\n        })\n      ),\n    { dispatch: false }\n  );\n\n  manageVersions$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<ManageVersionsAction>(NodeActionTypes.ManageVersions),\n        map((action) => {\n          if (action?.payload) {\n            this.contentService.manageVersions(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection?.file) {\n                  this.contentService.manageVersions(selection.file, action.configuration?.focusedElementOnCloseSelector);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  printFile$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<PrintFileAction>(NodeActionTypes.PrintFile),\n        map((action) => {\n          if (action?.payload) {\n            this.printFile(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection?.file) {\n                  this.printFile(selection.file);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  unlockWrite$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<UnlockWriteAction>(NodeActionTypes.UnlockForWriting),\n        map((action) => {\n          if (action?.payload) {\n            this.contentService.unlockNode(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection?.file) {\n                  this.contentService.unlockNode(selection.file);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  aspectList$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<ManageAspectsAction>(NodeActionTypes.ChangeAspects),\n        map((action) => {\n          if (action?.payload) {\n            this.contentService.manageAspects(action.payload);\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection && !selection.isEmpty) {\n                  this.contentService.manageAspects(selection.nodes[0], action.configuration?.focusedElementOnCloseSelector);\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  printFile(node: any) {\n    if (node?.entry) {\n      // shared and favorite\n      const id = node.entry.nodeId || node.entry.guid || node.entry.id;\n      const mimeType = node.entry.content.mimeType;\n\n      if (id) {\n        this.renditionViewer.printFileGeneric(id, mimeType);\n      }\n    }\n  }\n\n  manageRules$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<ManageRulesAction>(NodeActionTypes.ManageRules),\n        map((action) => {\n          if (action?.payload) {\n            this.store.dispatch(new NavigateRouteAction(['nodes', action.payload.entry.id, 'rules']));\n          } else {\n            this.store\n              .select(getAppSelection)\n              .pipe(take(1))\n              .subscribe((selection) => {\n                if (selection && !selection.isEmpty) {\n                  this.store.dispatch(new NavigateRouteAction(['nodes', selection.first.entry.id, 'rules']));\n                }\n              });\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n}\n"]}

package/esm2022/lib/store/effects/search-ai.effects.mjs

@@ -0,0 +1,54 @@
+/*!
+ * 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 { inject, Injectable } from '@angular/core';
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+import { SearchAiActionTypes } from '@alfresco/aca-shared/store';
+import { map } from 'rxjs/operators';
+import { SearchAiNavigationService } from '../../services/search-ai-navigation.service';
+import { SearchAiService } from '@alfresco/adf-content-services';
+import * as i0 from "@angular/core";
+class SearchAiEffects {
+    actions$ = inject(Actions);
+    searchNavigationService = inject(SearchAiNavigationService);
+    searchAiService = inject(SearchAiService);
+    searchByTerm$ = createEffect(() => this.actions$.pipe(ofType(SearchAiActionTypes.SearchByTermAi), map((action) => {
+        const queryParams = {
+            query: encodeURIComponent(action.payload.searchTerm),
+            agentId: action.payload.agentId
+        };
+        this.searchNavigationService.navigateToSearchAi(queryParams);
+    })), { dispatch: false });
+    toggleAISearchInput$ = createEffect(() => this.actions$.pipe(ofType(SearchAiActionTypes.ToggleAiSearchInput), map((action) => this.searchAiService.updateSearchAiInputState({
+        active: true,
+        selectedAgentId: action.agentId,
+        searchTerm: action.searchTerm
+    }))), { dispatch: false });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SearchAiEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SearchAiEffects });
+}
+export { SearchAiEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SearchAiEffects, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,52 @@
+/*!
+ * 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 } from 'rxjs/operators';
+import { SearchActionTypes, SearchOptionIds } from '@alfresco/aca-shared/store';
+import { SearchNavigationService } from '../../components/search/search-navigation.service';
+import { SearchQueryBuilderService } from '@alfresco/adf-content-services';
+import { formatSearchTerm } from '../../utils/aca-search-utils';
+import * as i0 from "@angular/core";
+class SearchEffects {
+    actions$ = inject(Actions);
+    queryBuilder = inject(SearchQueryBuilderService);
+    searchNavigationService = inject(SearchNavigationService);
+    search$ = createEffect(() => this.actions$.pipe(ofType(SearchActionTypes.Search), map(() => {
+        this.searchNavigationService.navigateToSearch();
+    })), { dispatch: false });
+    searchByTerm$ = createEffect(() => this.actions$.pipe(ofType(SearchActionTypes.SearchByTerm), map((action) => {
+        const query = formatSearchTerm(action.payload, this.queryBuilder.config['app:fields']);
+        const libItem = action.searchOptions.find((item) => item.id === SearchOptionIds.Libraries);
+        const librarySelected = !!libItem && libItem.value;
+        this.queryBuilder.navigateToSearch(query, librarySelected ? '/search-libraries' : '/search');
+    })), { dispatch: false });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SearchEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SearchEffects });
+}
+export { SearchEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SearchEffects, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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