@alfresco/aca-content 4.0.0-4895233349

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

@@ -0,0 +1,76 @@
+/*!
+ * 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, take } from 'rxjs/operators';
+import { NodeActionTypes, getAppSelection } from '@alfresco/aca-shared/store';
+import { Store } from '@ngrx/store';
+import { ContentManagementService } from '../../services/content-management.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@ngrx/effects";
+import * as i3 from "../../services/content-management.service";
+export class FavoriteEffects {
+    constructor(store, actions$, content) {
+        this.store = store;
+        this.actions$ = actions$;
+        this.content = content;
+        this.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 });
+        this.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 });
+    }
+}
+FavoriteEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: FavoriteEffects, deps: [{ token: i1.Store }, { token: i2.Actions }, { token: i3.ContentManagementService }], target: i0.ɵɵFactoryTarget.Injectable });
+FavoriteEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: FavoriteEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: FavoriteEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Actions }, { type: i3.ContentManagementService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,111 @@
+/*!
+ * 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 { LibraryActionTypes, NavigateLibraryAction, NavigateRouteAction, SnackbarErrorAction, getAppSelection } from '@alfresco/aca-shared/store';
+import { Injectable } from '@angular/core';
+import { Actions, ofType, createEffect } 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 * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@ngrx/effects";
+import * as i3 from "../../services/content-management.service";
+import * as i4 from "@alfresco/aca-shared";
+export class LibraryEffects {
+    constructor(store, actions$, content, contentApi) {
+        this.store = store;
+        this.actions$ = actions$;
+        this.content = content;
+        this.contentApi = contentApi;
+        this.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 && selection.library) {
+                        this.content.deleteLibrary(selection.library.entry.id);
+                    }
+                });
+            }
+        })), { dispatch: false });
+        this.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 && selection.library) {
+                        this.content.leaveLibrary(selection.library.entry.id, action.configuration?.focusedElementOnCloseSelector);
+                    }
+                });
+            }
+        })), { dispatch: false });
+        this.createLibrary$ = createEffect(() => this.actions$.pipe(ofType(LibraryActionTypes.Create), mergeMap(() => this.content.createLibrary()), map((libraryId) => new NavigateLibraryAction(libraryId))), { dispatch: true });
+        this.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.store.dispatch(new SnackbarErrorAction('APP.MESSAGES.ERRORS.MISSING_CONTENT'));
+                });
+            }
+        })), { dispatch: false });
+        this.updateLibrary$ = createEffect(() => this.actions$.pipe(ofType(LibraryActionTypes.Update), map((action) => {
+            this.store
+                .select(getAppSelection)
+                .pipe(take(1))
+                .subscribe((selection) => {
+                if (selection && 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 });
+    }
+}
+LibraryEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: LibraryEffects, deps: [{ token: i1.Store }, { token: i2.Actions }, { token: i3.ContentManagementService }, { token: i4.ContentApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+LibraryEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: LibraryEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: LibraryEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Actions }, { type: i3.ContentManagementService }, { type: i4.ContentApiService }]; } });
+//# 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-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 {\n  AppStore,\n  CreateLibraryAction,\n  DeleteLibraryAction,\n  LeaveLibraryAction,\n  LibraryActionTypes,\n  NavigateLibraryAction,\n  NavigateRouteAction,\n  SnackbarErrorAction,\n  UpdateLibraryAction,\n  getAppSelection\n} from '@alfresco/aca-shared/store';\nimport { Injectable } from '@angular/core';\nimport { Actions, ofType, createEffect } 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';\n\n@Injectable()\nexport class LibraryEffects {\n  constructor(\n    private store: Store<AppStore>,\n    private actions$: Actions,\n    private content: ContentManagementService,\n    private contentApi: ContentApiService\n  ) {}\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 && 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 && 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.store.dispatch(new SnackbarErrorAction('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 && 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"]}

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

@@ -0,0 +1,309 @@
+/*!
+ * 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, take } from 'rxjs/operators';
+import { Store } from '@ngrx/store';
+import { NodeActionTypes, getCurrentFolder, getAppSelection, NavigateRouteAction, ShowLoaderAction } from '@alfresco/aca-shared/store';
+import { ContentManagementService } from '../../services/content-management.service';
+import { RenditionService } from '@alfresco/adf-content-services';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@ngrx/effects";
+import * as i3 from "../../services/content-management.service";
+import * as i4 from "@alfresco/adf-content-services";
+export class NodeEffects {
+    constructor(store, actions$, contentService, renditionViewer) {
+        this.store = store;
+        this.actions$ = actions$;
+        this.contentService = contentService;
+        this.renditionViewer = renditionViewer;
+        this.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 && selection.file) {
+                        this.contentService.shareNode(selection.file, action.configuration?.focusedElementOnCloseSelector);
+                    }
+                });
+            }
+        })), { dispatch: false });
+        this.unshareNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.Unshare), map((action) => {
+            if (action && action.payload && 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 });
+        this.purgeDeletedNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.PurgeDeleted), map((action) => {
+            if (action && action.payload && 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 });
+        this.restoreDeletedNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.RestoreDeleted), map((action) => {
+            if (action && action.payload && 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 });
+        this.deleteNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.Delete), map((action) => {
+            this.store.dispatch(new ShowLoaderAction(true));
+            if (action && action.payload && 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 });
+        this.undoDeleteNodes$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.UndoDelete), map((action) => {
+            if (action.payload.length > 0) {
+                this.contentService.undoDeleteNodes(action.payload);
+            }
+        })), { dispatch: false });
+        this.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 && node.id) {
+                        this.contentService.createFolder(node.id);
+                    }
+                });
+            }
+        })), { dispatch: false });
+        this.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 && selection.folder) {
+                        this.contentService.editFolder(selection.folder, action.configuration?.focusedElementOnCloseSelector);
+                    }
+                });
+            }
+        })), { dispatch: false });
+        this.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 });
+        this.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 });
+        this.managePermissions$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.ManagePermissions), map((action) => {
+            if (action?.payload) {
+                const route = 'personal-files/details';
+                this.store.dispatch(new NavigateRouteAction([route, action.payload.entry.id, 'permissions']));
+            }
+            else {
+                this.store
+                    .select(getAppSelection)
+                    .pipe(take(1))
+                    .subscribe((selection) => {
+                    if (selection && !selection.isEmpty) {
+                        const route = 'personal-files/details';
+                        this.store.dispatch(new NavigateRouteAction([route, selection.first.entry.id, 'permissions']));
+                    }
+                });
+            }
+        })), { dispatch: false });
+        this.expandInfoDrawer$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.ExpandInfoDrawer), map((action) => {
+            if (action?.payload) {
+                const route = 'personal-files/details';
+                this.store.dispatch(new NavigateRouteAction([route, action.payload.entry.id]));
+            }
+            else {
+                this.store
+                    .select(getAppSelection)
+                    .pipe(take(1))
+                    .subscribe((selection) => {
+                    if (selection && !selection.isEmpty) {
+                        const route = 'personal-files/details';
+                        this.store.dispatch(new NavigateRouteAction([route, selection.first.entry.id]));
+                    }
+                });
+            }
+        })), { dispatch: false });
+        this.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 && selection.file) {
+                        this.contentService.manageVersions(selection.file, action.configuration?.focusedElementOnCloseSelector);
+                    }
+                });
+            }
+        })), { dispatch: false });
+        this.printFile$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.PrintFile), map((action) => {
+            if (action && action.payload) {
+                this.printFile(action.payload);
+            }
+            else {
+                this.store
+                    .select(getAppSelection)
+                    .pipe(take(1))
+                    .subscribe((selection) => {
+                    if (selection && selection.file) {
+                        this.printFile(selection.file);
+                    }
+                });
+            }
+        })), { dispatch: false });
+        this.unlockWrite$ = createEffect(() => this.actions$.pipe(ofType(NodeActionTypes.UnlockForWriting), map((action) => {
+            if (action && action.payload) {
+                this.contentService.unlockNode(action.payload);
+            }
+            else {
+                this.store
+                    .select(getAppSelection)
+                    .pipe(take(1))
+                    .subscribe((selection) => {
+                    if (selection && selection.file) {
+                        this.contentService.unlockNode(selection.file);
+                    }
+                });
+            }
+        })), { dispatch: false });
+        this.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 });
+        this.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 });
+    }
+    printFile(node) {
+        if (node && 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);
+            }
+        }
+    }
+}
+NodeEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: NodeEffects, deps: [{ token: i1.Store }, { token: i2.Actions }, { token: i3.ContentManagementService }, { token: i4.RenditionService }], target: i0.ɵɵFactoryTarget.Injectable });
+NodeEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: NodeEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: NodeEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Actions }, { type: i3.ContentManagementService }, { type: i4.RenditionService }]; } });
+//# 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-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 { Actions, ofType, createEffect } from '@ngrx/effects';\nimport { Injectable } from '@angular/core';\nimport { map, take } from 'rxjs/operators';\nimport { Store } from '@ngrx/store';\nimport {\n  AppStore,\n  NodeActionTypes,\n  PurgeDeletedNodesAction,\n  DeleteNodesAction,\n  UndoDeleteNodesAction,\n  CreateFolderAction,\n  EditFolderAction,\n  RestoreDeletedNodesAction,\n  ShareNodeAction,\n  ManageVersionsAction,\n  UnlockWriteAction,\n  UnshareNodesAction,\n  CopyNodesAction,\n  MoveNodesAction,\n  ManagePermissionsAction,\n  PrintFileAction,\n  getCurrentFolder,\n  getAppSelection,\n  ManageAspectsAction,\n  NavigateRouteAction,\n  ExpandInfoDrawerAction,\n  ManageRulesAction,\n  ShowLoaderAction\n} from '@alfresco/aca-shared/store';\nimport { ContentManagementService } from '../../services/content-management.service';\nimport { RenditionService } from '@alfresco/adf-content-services';\n\n@Injectable()\nexport class NodeEffects {\n  constructor(\n    private store: Store<AppStore>,\n    private actions$: Actions,\n    private contentService: ContentManagementService,\n    private renditionViewer: RenditionService\n  ) {}\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 && 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 && action.payload && 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 && action.payload && 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 && action.payload && 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 && action.payload && 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 && 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 && 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          if (action?.payload) {\n            const route = 'personal-files/details';\n            this.store.dispatch(new NavigateRouteAction([route, action.payload.entry.id, 'permissions']));\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 NavigateRouteAction([route, selection.first.entry.id, 'permissions']));\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          if (action?.payload) {\n            const route = 'personal-files/details';\n            this.store.dispatch(new NavigateRouteAction([route, action.payload.entry.id]));\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 NavigateRouteAction([route, selection.first.entry.id]));\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 && 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 && 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 && 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 && 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 && 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 && 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"]}