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

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

@@ -0,0 +1,77 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Actions, ofType, createEffect } from '@ngrx/effects';
+import { Injectable } from '@angular/core';
+import { map, 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.2", 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.2", ngImport: i0, type: FavoriteEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", 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,112 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { 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.2", 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.2", ngImport: i0, type: LibraryEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", 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 * @license\n * Alfresco Example Content Application\n *\n * Copyright (C) 2005 - 2020 Alfresco Software Limited\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail.  Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport {\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,310 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Actions, ofType, createEffect } from '@ngrx/effects';
+import { Injectable } from '@angular/core';
+import { map, 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 { ViewUtilService } from '@alfresco/adf-core';
+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-core";
+export class NodeEffects {
+    constructor(store, actions$, contentService, viewUtils) {
+        this.store = store;
+        this.actions$ = actions$;
+        this.contentService = contentService;
+        this.viewUtils = viewUtils;
+        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.viewUtils.printFileGeneric(id, mimeType);
+            }
+        }
+    }
+}
+NodeEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: NodeEffects, deps: [{ token: i1.Store }, { token: i2.Actions }, { token: i3.ContentManagementService }, { token: i4.ViewUtilService }], target: i0.ɵɵFactoryTarget.Injectable });
+NodeEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: NodeEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: NodeEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Actions }, { type: i3.ContentManagementService }, { type: i4.ViewUtilService }]; } });
+//# 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 * @license\n * Alfresco Example Content Application\n *\n * Copyright (C) 2005 - 2020 Alfresco Software Limited\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail.  Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { 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 { ViewUtilService } from '@alfresco/adf-core';\n\n@Injectable()\nexport class NodeEffects {\n  constructor(\n    private store: Store<AppStore>,\n    private actions$: Actions,\n    private contentService: ContentManagementService,\n    private viewUtils: ViewUtilService\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.viewUtils.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"]}