@alfresco/aca-content 5.1.1 → 5.2.0

package/esm2022/lib/services/content-management.service.mjs

@@ -0,0 +1,892 @@
+/*!
+ * 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 { AppHookService, AppSettingsService, ContentApiService, NodePermissionService } from '@alfresco/aca-shared';
+import { getAppSelection, NavigateRouteAction, NavigateToParentFolder, RefreshPreviewAction, SetSelectedNodesAction, ShowLoaderAction, SnackbarErrorAction, SnackbarInfoAction, SnackbarUserAction, SnackbarWarningAction, UndoDeleteNodesAction, UnlockWriteAction, ViewNodeVersionAction } from '@alfresco/aca-shared/store';
+import { DocumentListService, FolderDialogComponent, LibraryDialogComponent, NewVersionUploaderDataAction, NewVersionUploaderService, NodeAspectService, NodesApiService, ShareDialogComponent } from '@alfresco/adf-content-services';
+import { NotificationService, TranslationService, ConfirmDialogComponent } from '@alfresco/adf-core';
+import { inject, Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { Store } from '@ngrx/store';
+import { forkJoin, of, zip } from 'rxjs';
+import { catchError, map, mergeMap, take, tap } from 'rxjs/operators';
+import { NodeActionsService } from './node-actions.service';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-content-services";
+import * as i2 from "@ngrx/store";
+import * as i3 from "@alfresco/aca-shared";
+import * as i4 from "@angular/material/dialog";
+import * as i5 from "./node-actions.service";
+import * as i6 from "@alfresco/adf-core";
+import * as i7 from "@angular/router";
+class ContentManagementService {
+    nodesApiService;
+    store;
+    contentApi;
+    permission;
+    dialogRef;
+    nodeActionsService;
+    translation;
+    nodeAspectService;
+    appHookService;
+    newVersionUploaderService;
+    router;
+    appSettingsService;
+    documentListService;
+    notificationService = inject(NotificationService);
+    createMenuButtonSelector = 'app-toolbar-menu button[id="app.toolbar.create"]';
+    constructor(nodesApiService, store, contentApi, permission, dialogRef, nodeActionsService, translation, nodeAspectService, appHookService, newVersionUploaderService, router, appSettingsService, documentListService) {
+        this.nodesApiService = nodesApiService;
+        this.store = store;
+        this.contentApi = contentApi;
+        this.permission = permission;
+        this.dialogRef = dialogRef;
+        this.nodeActionsService = nodeActionsService;
+        this.translation = translation;
+        this.nodeAspectService = nodeAspectService;
+        this.appHookService = appHookService;
+        this.newVersionUploaderService = newVersionUploaderService;
+        this.router = router;
+        this.appSettingsService = appSettingsService;
+        this.documentListService = documentListService;
+    }
+    addFavorite(nodes) {
+        if (nodes && nodes.length > 0) {
+            this.contentApi.addFavorite(nodes).subscribe(() => {
+                const favoriteNodes = nodes.map((node) => {
+                    const newNode = JSON.parse(JSON.stringify(node));
+                    newNode.entry.isFavorite = true;
+                    return newNode;
+                });
+                this.store.dispatch(new SetSelectedNodesAction(favoriteNodes));
+            });
+        }
+    }
+    removeFavorite(nodes) {
+        if (nodes && nodes.length > 0) {
+            this.contentApi.removeFavorite(nodes).subscribe(() => {
+                const favoriteNodes = nodes.map((node) => {
+                    const newNode = JSON.parse(JSON.stringify(node));
+                    newNode.entry.isFavorite = false;
+                    return newNode;
+                });
+                this.store.dispatch(new SetSelectedNodesAction(favoriteNodes));
+            });
+        }
+    }
+    manageVersions(node, focusedElementOnCloseSelector) {
+        if (node?.entry) {
+            // shared and favorite
+            const id = node.entry.nodeId || node.entry.guid;
+            if (id) {
+                this.contentApi.getNodeInfo(id).subscribe((entry) => {
+                    this.openVersionManagerDialog(entry, focusedElementOnCloseSelector);
+                });
+            }
+            else {
+                this.openVersionManagerDialog(node.entry, focusedElementOnCloseSelector);
+            }
+        }
+    }
+    manageAspects(node, focusedElementOnCloseSelector) {
+        if (node?.entry) {
+            // shared and favorite
+            const id = node.entry.nodeId || node.entry.guid;
+            if (id) {
+                this.contentApi.getNodeInfo(id).subscribe((entry) => {
+                    this.openAspectListDialog(entry, focusedElementOnCloseSelector);
+                });
+            }
+            else {
+                this.openAspectListDialog(node.entry, focusedElementOnCloseSelector);
+            }
+        }
+    }
+    versionUpdateDialog(node, file) {
+        this.contentApi.getNodeVersions(node.id).subscribe(({ list }) => {
+            const newVersionUploaderDialogData = {
+                node,
+                file,
+                currentVersion: list.entries[0].entry,
+                title: 'VERSION.DIALOG.TITLE',
+                showComments: this.appSettingsService.uploadAllowComments,
+                allowDownload: this.appSettingsService.uploadAllowDownload
+            };
+            const dialogConfig = { width: '600px' };
+            this.newVersionUploaderService.openUploadNewVersionDialog(newVersionUploaderDialogData, dialogConfig).subscribe((data) => {
+                if (data.action === NewVersionUploaderDataAction.upload) {
+                    if (data.newVersion.value.entry.properties['cm:lockType'] === 'WRITE_LOCK') {
+                        this.store.dispatch(new UnlockWriteAction(data.newVersion.value));
+                    }
+                }
+            }, (error) => this.notificationService.showError(error));
+        });
+    }
+    shareNode(node, focusedElementOnCloseSelector) {
+        if (node?.entry) {
+            // shared and favorite
+            const id = node.entry.nodeId || node.entry.guid;
+            if (id) {
+                this.contentApi.getNodeInfo(id).subscribe((entry) => {
+                    this.openShareLinkDialog({ entry }, focusedElementOnCloseSelector);
+                });
+            }
+            else {
+                this.openShareLinkDialog(node, focusedElementOnCloseSelector);
+            }
+        }
+    }
+    openShareLinkDialog(node, focusedElementOnCloseSelector) {
+        const baseShareUrl = this.appSettingsService.baseShareUrl;
+        this.dialogRef
+            .open(ShareDialogComponent, {
+            restoreFocus: true,
+            width: '600px',
+            panelClass: 'adf-share-link-dialog',
+            data: {
+                node,
+                baseShareUrl
+            }
+        })
+            .afterClosed()
+            .subscribe(() => {
+            this.store.dispatch(new SetSelectedNodesAction([node]));
+            this.appHookService.linksUnshared.next();
+            this.focusAfterClose(focusedElementOnCloseSelector);
+        });
+    }
+    createFolder(parentNodeId) {
+        const dialogInstance = this.dialogRef.open(FolderDialogComponent, {
+            data: {
+                parentNodeId,
+                createTitle: undefined,
+                nodeType: 'cm:folder'
+            },
+            width: '400px',
+            role: 'dialog'
+        });
+        dialogInstance.componentInstance.error.subscribe((message) => {
+            this.notificationService.showError(message);
+        });
+        dialogInstance.afterClosed().subscribe((node) => {
+            if (node) {
+                this.documentListService.reload();
+            }
+            this.focusAfterClose(this.createMenuButtonSelector);
+        });
+    }
+    editFolder(folder, focusedElementOnCloseSelector) {
+        if (!folder) {
+            return;
+        }
+        const dialog = this.dialogRef.open(FolderDialogComponent, {
+            data: {
+                folder: folder.entry
+            },
+            width: '400px'
+        });
+        dialog.componentInstance.error.subscribe((message) => {
+            this.notificationService.showError(message);
+        });
+        dialog.afterClosed().subscribe((node) => {
+            if (node) {
+                this.store.dispatch(new SetSelectedNodesAction([{ entry: node }]));
+                this.nodesApiService.nodeUpdated.next(node);
+            }
+            this.focusAfterClose(focusedElementOnCloseSelector);
+        });
+    }
+    createLibrary() {
+        const dialogInstance = this.dialogRef.open(LibraryDialogComponent, {
+            width: '400px'
+        });
+        dialogInstance.componentInstance.error.subscribe((message) => {
+            this.notificationService.showError(message);
+        });
+        return dialogInstance.afterClosed().pipe(tap((node) => {
+            if (node) {
+                this.appHookService.libraryCreated.next(node);
+            }
+            this.focusAfterClose(this.createMenuButtonSelector);
+        }), map((node) => {
+            if (node?.entry?.guid) {
+                return node.entry.guid;
+            }
+            return null;
+        }));
+    }
+    deleteLibrary(id) {
+        this.contentApi.deleteSite(id).subscribe(() => {
+            this.appHookService.libraryDeleted.next(id);
+            this.notificationService.showInfo('APP.MESSAGES.INFO.LIBRARY_DELETED');
+            this.store.dispatch(new NavigateRouteAction(['/libraries']));
+        }, () => {
+            this.notificationService.showError('APP.MESSAGES.ERRORS.DELETE_LIBRARY_FAILED');
+        });
+    }
+    leaveLibrary(siteId, focusedElementOnCloseSelector) {
+        const dialogRef = this.dialogRef.open(ConfirmDialogComponent, {
+            data: {
+                title: 'APP.DIALOGS.CONFIRM_LEAVE.TITLE',
+                message: 'APP.DIALOGS.CONFIRM_LEAVE.MESSAGE',
+                yesLabel: 'APP.DIALOGS.CONFIRM_LEAVE.YES_LABEL',
+                noLabel: 'APP.DIALOGS.CONFIRM_LEAVE.NO_LABEL'
+            },
+            minWidth: '250px'
+        });
+        dialogRef.afterClosed().subscribe((result) => {
+            if (result === true) {
+                this.contentApi.leaveSite(siteId).subscribe(() => {
+                    this.appHookService.libraryLeft.next(siteId);
+                    this.notificationService.showInfo('APP.MESSAGES.INFO.LEFT_LIBRARY');
+                }, () => {
+                    this.notificationService.showError('APP.MESSAGES.ERRORS.LEAVE_LIBRARY_FAILED');
+                });
+            }
+            this.focusAfterClose(focusedElementOnCloseSelector);
+        });
+    }
+    updateLibrary(siteId, siteBody) {
+        this.contentApi.updateLibrary(siteId, siteBody).subscribe((siteEntry) => {
+            this.appHookService.libraryUpdated.next(siteEntry);
+            this.notificationService.showInfo('LIBRARY.SUCCESS.LIBRARY_UPDATED');
+        }, () => {
+            this.notificationService.showError('LIBRARY.ERRORS.LIBRARY_UPDATE_ERROR');
+        });
+    }
+    async unshareNodes(links) {
+        const promises = links.map((link) => this.contentApi.deleteSharedLink(link.entry.id).toPromise());
+        await Promise.all(promises);
+        this.appHookService.linksUnshared.next();
+    }
+    canUpdateNode(node) {
+        return this.permission.check(node, ['update']);
+    }
+    canUploadContent(folderNode) {
+        return this.permission.check(folderNode, ['create']);
+    }
+    purgeDeletedNodes(nodes) {
+        if (!nodes || nodes.length === 0) {
+            return;
+        }
+        const dialogRef = this.dialogRef.open(ConfirmDialogComponent, {
+            data: {
+                title: 'APP.DIALOGS.CONFIRM_PURGE.TITLE',
+                message: 'APP.DIALOGS.CONFIRM_PURGE.MESSAGE',
+                yesLabel: 'APP.DIALOGS.CONFIRM_PURGE.YES_LABEL',
+                noLabel: 'APP.DIALOGS.CONFIRM_PURGE.NO_LABEL'
+            },
+            minWidth: '250px'
+        });
+        dialogRef.afterClosed().subscribe((result) => {
+            if (result === true) {
+                const nodesToDelete = nodes.map((node) => {
+                    const { name } = node.entry;
+                    const id = node.entry.nodeId || node.entry.id;
+                    return {
+                        id,
+                        name
+                    };
+                });
+                this.purgeNodes(nodesToDelete);
+            }
+        });
+    }
+    restoreDeletedNodes(selection = []) {
+        if (!selection.length) {
+            return;
+        }
+        const nodesWithPath = selection.filter((node) => node.entry.path);
+        if (selection.length && !nodesWithPath.length) {
+            const failedStatus = this.processStatus([]);
+            failedStatus.fail.push(...selection);
+            this.showRestoreNotification(failedStatus);
+            this.documentListService.reload();
+            return;
+        }
+        let status;
+        forkJoin(nodesWithPath.map((node) => this.restoreNode(node)))
+            .pipe(tap((restoredNodes) => {
+            status = this.processStatus(restoredNodes);
+        }), mergeMap(() => this.contentApi.getDeletedNodes()))
+            .subscribe((nodes) => {
+            const selectedNodes = this.diff(status.fail, selection, false);
+            const remainingNodes = this.diff(selectedNodes, nodes.list.entries);
+            if (!remainingNodes.length) {
+                this.showRestoreNotification(status);
+                this.documentListService.reload();
+            }
+            else {
+                this.restoreDeletedNodes(remainingNodes);
+            }
+        });
+    }
+    copyNodes(nodes, focusedElementOnCloseSelector) {
+        zip(this.nodeActionsService.copyNodes(nodes, undefined, focusedElementOnCloseSelector), this.nodeActionsService.contentCopied).subscribe((result) => {
+            const [operationResult, newItems] = result;
+            this.showCopyMessage(operationResult, nodes, newItems);
+        }, (error) => {
+            this.showCopyMessage(error, nodes);
+        });
+    }
+    moveNodes(nodes, focusedElementOnCloseSelector) {
+        const permissionForMove = '!';
+        zip(this.nodeActionsService.moveNodes(nodes, permissionForMove, focusedElementOnCloseSelector), this.nodeActionsService.contentMoved).subscribe((result) => {
+            const [operationResult, moveResponse] = result;
+            this.showMoveMessage(nodes, operationResult, moveResponse);
+            this.documentListService.reload();
+        }, (error) => {
+            this.showMoveMessage(nodes, error);
+        });
+    }
+    getErrorMessage(errorObject) {
+        let i18nMessageString = 'APP.MESSAGES.ERRORS.GENERIC';
+        try {
+            const { error: { statusCode } } = JSON.parse(errorObject.message);
+            if (statusCode === 409) {
+                i18nMessageString = 'APP.MESSAGES.ERRORS.NODE_MOVE';
+            }
+            else if (statusCode === 403) {
+                i18nMessageString = 'APP.MESSAGES.ERRORS.PERMISSION';
+            }
+        }
+        catch (err) {
+            /* Do nothing, keep the original message */
+        }
+        return i18nMessageString;
+    }
+    getNodeInfo() {
+        return this.store.select(getAppSelection).pipe(take(1), mergeMap(({ file }) => {
+            const id = file.entry.nodeId || file.entry.guid;
+            if (!id) {
+                return of(file.entry);
+            }
+            else {
+                return this.contentApi.getNodeInfo(id);
+            }
+        }));
+    }
+    unlockNode(node) {
+        return this.contentApi.unlockNode(node.entry.id).catch(() => {
+            this.notificationService.showError('APP.MESSAGES.ERRORS.UNLOCK_NODE', null, { fileName: node.entry.name });
+        });
+    }
+    showCopyMessage(info, nodes, newItems) {
+        const numberOfCopiedItems = newItems ? newItems.length : 0;
+        const failedItems = nodes.length - numberOfCopiedItems;
+        let i18nMessageString = 'APP.MESSAGES.ERRORS.GENERIC';
+        if (typeof info === 'string') {
+            if (info.toLowerCase().indexOf('succes') !== -1) {
+                let i18MessageSuffix;
+                if (failedItems) {
+                    if (numberOfCopiedItems) {
+                        i18MessageSuffix = numberOfCopiedItems === 1 ? 'PARTIAL_SINGULAR' : 'PARTIAL_PLURAL';
+                    }
+                    else {
+                        i18MessageSuffix = failedItems === 1 ? 'FAIL_SINGULAR' : 'FAIL_PLURAL';
+                    }
+                }
+                else {
+                    i18MessageSuffix = numberOfCopiedItems === 1 ? 'SINGULAR' : 'PLURAL';
+                }
+                i18nMessageString = `APP.MESSAGES.INFO.NODE_COPY.${i18MessageSuffix}`;
+            }
+        }
+        else {
+            try {
+                const { error: { statusCode } } = JSON.parse(info.message);
+                if (statusCode === 403) {
+                    i18nMessageString = 'APP.MESSAGES.ERRORS.PERMISSION';
+                }
+            }
+            catch { }
+        }
+        const undo = numberOfCopiedItems > 0 ? this.translation.instant('APP.ACTIONS.UNDO') : '';
+        const message = this.translation.instant(i18nMessageString, {
+            success: numberOfCopiedItems,
+            failed: failedItems
+        });
+        this.notificationService
+            .openSnackMessageAction(message, undo, {
+            panelClass: 'info-snackbar'
+        })
+            .onAction()
+            .subscribe(() => this.undoCopyNodes(newItems));
+    }
+    undoCopyNodes(nodes) {
+        const batch = this.nodeActionsService
+            .flatten(nodes)
+            .filter((item) => item.entry)
+            .map((item) => this.contentApi.deleteNode(item.entry.id, { permanent: true }));
+        forkJoin(...batch).subscribe(() => {
+            this.appHookService.nodesDeleted.next(null);
+            this.documentListService.reload();
+        }, (error) => {
+            let i18nMessageString = 'APP.MESSAGES.ERRORS.GENERIC';
+            let errorJson = null;
+            try {
+                errorJson = JSON.parse(error.message);
+            }
+            catch { }
+            if (errorJson?.error?.statusCode === 403) {
+                i18nMessageString = 'APP.MESSAGES.ERRORS.PERMISSION';
+            }
+            this.notificationService.showError(i18nMessageString);
+        });
+    }
+    openVersionManagerDialog(node, focusedElementOnCloseSelector) {
+        // workaround Shared
+        if (node.isFile || node.nodeId) {
+            const newVersionUploaderDialogData = {
+                node,
+                showVersionsOnly: true,
+                title: 'VERSION.DIALOG.TITLE',
+                allowDownload: this.appSettingsService.uploadAllowDownload,
+                showComments: this.appSettingsService.uploadAllowComments,
+                showActions: this.appSettingsService.versionManagerShowActions,
+                allowViewVersions: this.appSettingsService.versionManagerAllowViewVersions,
+                allowVersionDelete: this.appSettingsService.versionManagerAllowVersionDelete
+            };
+            this.newVersionUploaderService
+                .openUploadNewVersionDialog(newVersionUploaderDialogData, { width: '630px', role: 'dialog' }, focusedElementOnCloseSelector)
+                .subscribe({
+                next: (newVersionUploaderData) => {
+                    switch (newVersionUploaderData.action) {
+                        case NewVersionUploaderDataAction.refresh:
+                            this.documentListService.reload();
+                            this.store.dispatch(new RefreshPreviewAction(newVersionUploaderData.node));
+                            break;
+                        case NewVersionUploaderDataAction.view:
+                            this.store.dispatch(new ViewNodeVersionAction(node.id, newVersionUploaderData.versionId, {
+                                location: this.router.url
+                            }));
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            });
+        }
+        else {
+            this.notificationService.showError('APP.MESSAGES.ERRORS.PERMISSION');
+        }
+    }
+    openAspectListDialog(node, focusedElementOnCloseSelector) {
+        // workaround Shared
+        if (node.isFile || node.id) {
+            this.nodeAspectService.updateNodeAspects(node.id, focusedElementOnCloseSelector);
+        }
+        else {
+            this.notificationService.showError('APP.MESSAGES.ERRORS.PERMISSION');
+        }
+    }
+    undoMoveNodes(moveResponse, selectionParentId) {
+        const movedNodes = moveResponse?.['succeeded'] ?? [];
+        const partiallyMovedNodes = moveResponse?.['partiallySucceeded'] ?? [];
+        const restoreDeletedNodesBatch = this.nodeActionsService.moveDeletedEntries.map((folderEntry) => this.contentApi.restoreNode(folderEntry.nodeId || folderEntry.id).pipe(map((node) => node.entry)));
+        zip(...restoreDeletedNodesBatch, of(null))
+            .pipe(mergeMap(() => {
+            const nodesToBeMovedBack = [...partiallyMovedNodes, ...movedNodes];
+            const revertMoveBatch = this.nodeActionsService
+                .flatten(nodesToBeMovedBack)
+                .filter((node) => node.entry || node.itemMoved?.entry)
+                .map((node) => {
+                if (node.itemMoved) {
+                    return this.nodeActionsService.moveNodeAction(node.itemMoved.entry, node.initialParentId);
+                }
+                else {
+                    return this.nodeActionsService.moveNodeAction(node.entry, selectionParentId);
+                }
+            });
+            return zip(...revertMoveBatch, of(null));
+        }))
+            .subscribe(() => {
+            this.documentListService.reload();
+        }, (error) => {
+            let message = 'APP.MESSAGES.ERRORS.GENERIC';
+            let errorJson = null;
+            try {
+                errorJson = JSON.parse(error.message);
+            }
+            catch { }
+            if (errorJson?.error?.statusCode === 403) {
+                message = 'APP.MESSAGES.ERRORS.PERMISSION';
+            }
+            this.notificationService.showError(message);
+        });
+    }
+    deleteNodes(items) {
+        const batch = [];
+        items.forEach((node) => {
+            batch.push(this.deleteNode(node));
+        });
+        forkJoin(...batch).subscribe((data) => {
+            const status = this.processStatus(data);
+            const message = this.getDeleteMessage(status);
+            if (message && status.someSucceeded) {
+                message.userAction = new SnackbarUserAction('APP.ACTIONS.UNDO', new UndoDeleteNodesAction([...status.success]));
+            }
+            this.store.dispatch(message);
+            if (status.someSucceeded) {
+                this.appHookService.nodesDeleted.next();
+                this.documentListService.reload();
+            }
+            this.store.dispatch(new ShowLoaderAction(false));
+        });
+    }
+    undoDeleteNodes(items) {
+        const batch = [];
+        items.forEach((item) => {
+            batch.push(this.undoDeleteNode(item));
+        });
+        forkJoin(...batch).subscribe((data) => {
+            const processedData = this.processStatus(data);
+            if (processedData.fail.length) {
+                const message = this.getUndoDeleteMessage(processedData);
+                this.store.dispatch(message);
+            }
+            if (processedData.someSucceeded) {
+                this.documentListService.reload();
+            }
+        });
+    }
+    undoDeleteNode(item) {
+        const { id, name } = item;
+        return this.contentApi.restoreNode(id).pipe(map(() => ({
+            id,
+            name,
+            status: 1
+        })), catchError(() => of({
+            id,
+            name,
+            status: 0
+        })));
+    }
+    getUndoDeleteMessage(status) {
+        if (status.someFailed && !status.oneFailed) {
+            return new SnackbarErrorAction('APP.MESSAGES.ERRORS.NODE_RESTORE_PLURAL', { number: status.fail.length });
+        }
+        if (status.oneFailed) {
+            return new SnackbarErrorAction('APP.MESSAGES.ERRORS.NODE_RESTORE', {
+                name: status.fail[0].name
+            });
+        }
+        return null;
+    }
+    restoreNode(node) {
+        const { entry } = node;
+        return this.contentApi.restoreNode(entry.id).pipe(map(() => ({
+            status: 1,
+            entry
+        })), catchError((error) => {
+            const { statusCode } = JSON.parse(error.message).error;
+            return of({
+                status: 0,
+                statusCode,
+                entry
+            });
+        }));
+    }
+    purgeNodes(selection = []) {
+        if (!selection.length) {
+            return;
+        }
+        const batch = selection.map((node) => this.purgeDeletedNode(node));
+        forkJoin(batch).subscribe((purgedNodes) => {
+            const status = this.processStatus(purgedNodes);
+            if (status.success.length) {
+                this.documentListService.reload();
+            }
+            this.sendPurgeMessage(status);
+        });
+    }
+    purgeDeletedNode(node) {
+        const { id, name } = node;
+        return this.contentApi.purgeDeletedNode(id).pipe(map(() => ({
+            status: 1,
+            id,
+            name
+        })), catchError(() => of({
+            status: 0,
+            id,
+            name
+        })));
+    }
+    processStatus(data = []) {
+        const status = {
+            fail: [],
+            success: [],
+            get someFailed() {
+                return !!this.fail.length;
+            },
+            get someSucceeded() {
+                return !!this.success.length;
+            },
+            get oneFailed() {
+                return this.fail.length === 1;
+            },
+            get oneSucceeded() {
+                return this.success.length === 1;
+            },
+            get allSucceeded() {
+                return this.someSucceeded && !this.someFailed;
+            },
+            get allFailed() {
+                return this.someFailed && !this.someSucceeded;
+            },
+            reset() {
+                this.fail = [];
+                this.success = [];
+            }
+        };
+        return data.reduce((acc, node) => {
+            if (node.status) {
+                acc.success.push(node);
+            }
+            else {
+                acc.fail.push(node);
+            }
+            return acc;
+        }, status);
+    }
+    sendPurgeMessage(status) {
+        if (status.oneSucceeded && status.someFailed && !status.oneFailed) {
+            this.notificationService.showWarning('APP.MESSAGES.INFO.TRASH.NODES_PURGE.PARTIAL_SINGULAR', null, {
+                name: status.success[0].name,
+                failed: status.fail.length
+            });
+            return;
+        }
+        if (status.someSucceeded && !status.oneSucceeded && status.someFailed) {
+            this.notificationService.showWarning('APP.MESSAGES.INFO.TRASH.NODES_PURGE.PARTIAL_PLURAL', null, {
+                number: status.success.length,
+                failed: status.fail.length
+            });
+            return;
+        }
+        if (status.oneSucceeded) {
+            this.notificationService.showInfo('APP.MESSAGES.INFO.TRASH.NODES_PURGE.SINGULAR', null, { name: status.success[0].name });
+            return;
+        }
+        if (status.oneFailed) {
+            this.notificationService.showError('APP.MESSAGES.ERRORS.TRASH.NODES_PURGE.SINGULAR', null, { name: status.fail[0].name });
+            return;
+        }
+        if (status.allSucceeded) {
+            this.notificationService.showInfo('APP.MESSAGES.INFO.TRASH.NODES_PURGE.PLURAL', null, { number: status.success.length });
+            return;
+        }
+        if (status.allFailed) {
+            this.notificationService.showError('APP.MESSAGES.ERRORS.TRASH.NODES_PURGE.PLURAL', null, { number: status.fail.length });
+            return;
+        }
+    }
+    showRestoreNotification(status) {
+        const message = this.getRestoreMessage(status);
+        if (message) {
+            if (status.oneSucceeded && !status.someFailed) {
+                const isSite = this.isSite(status.success[0].entry);
+                const path = status.success[0].entry.path;
+                const parent = path.elements[path.elements.length - 1];
+                const route = isSite ? ['/libraries', parent.id] : ['/personal-files', parent.id];
+                let navigate;
+                if (this.isLibraryContent(path)) {
+                    navigate = new NavigateToParentFolder(status.success[0]);
+                }
+                else {
+                    navigate = new NavigateRouteAction(route);
+                }
+                message.userAction = new SnackbarUserAction('APP.ACTIONS.VIEW', navigate);
+            }
+            this.store.dispatch(message);
+        }
+    }
+    isSite(entry) {
+        return entry.nodeType === 'st:site';
+    }
+    isLibraryContent(path) {
+        return path && path.elements.length >= 2 && path.elements[1].name === 'Sites';
+    }
+    getRestoreMessage(status) {
+        if (status.someFailed && !status.oneFailed) {
+            return new SnackbarErrorAction('APP.MESSAGES.ERRORS.TRASH.NODES_RESTORE.PARTIAL_PLURAL', {
+                number: status.fail.length
+            });
+        }
+        if (status.oneFailed && status.fail[0].statusCode) {
+            if (status.fail[0].statusCode === 409) {
+                return new SnackbarErrorAction('APP.MESSAGES.ERRORS.TRASH.NODES_RESTORE.NODE_EXISTS', {
+                    name: status.fail[0].entry.name
+                });
+            }
+            else {
+                return new SnackbarErrorAction('APP.MESSAGES.ERRORS.TRASH.NODES_RESTORE.GENERIC', {
+                    name: status.fail[0].entry.name
+                });
+            }
+        }
+        if (status.oneFailed && !status.fail[0].statusCode) {
+            return new SnackbarErrorAction('APP.MESSAGES.ERRORS.TRASH.NODES_RESTORE.LOCATION_MISSING', {
+                name: status.fail[0].entry.name
+            });
+        }
+        if (status.allSucceeded && !status.oneSucceeded) {
+            return new SnackbarInfoAction('APP.MESSAGES.INFO.TRASH.NODES_RESTORE.PLURAL');
+        }
+        if (status.allSucceeded && status.oneSucceeded) {
+            return new SnackbarInfoAction('APP.MESSAGES.INFO.TRASH.NODES_RESTORE.SINGULAR', {
+                name: status.success[0].entry.name
+            });
+        }
+        return null;
+    }
+    diff(selection, list, fromList = true) {
+        const ids = selection.map((item) => item.entry.id);
+        return list.filter((item) => {
+            if (fromList) {
+                return ids.includes(item.entry.id) ? item : null;
+            }
+            else {
+                return !ids.includes(item.entry.id) ? item : null;
+            }
+        });
+    }
+    deleteNode(node) {
+        const { name } = node.entry;
+        const id = node.entry.nodeId || node.entry.id;
+        return this.contentApi.deleteNode(id).pipe(map(() => ({
+            id,
+            name,
+            status: 1
+        })), catchError(() => of({
+            id,
+            name,
+            status: 0
+        })));
+    }
+    getDeleteMessage(status) {
+        if (status.allFailed && !status.oneFailed) {
+            return new SnackbarErrorAction('APP.MESSAGES.ERRORS.NODE_DELETION_PLURAL', { number: status.fail.length });
+        }
+        if (status.allSucceeded && !status.oneSucceeded) {
+            return new SnackbarInfoAction('APP.MESSAGES.INFO.NODE_DELETION.PLURAL', {
+                number: status.success.length
+            });
+        }
+        if (status.someFailed && status.someSucceeded && !status.oneSucceeded) {
+            return new SnackbarWarningAction('APP.MESSAGES.INFO.NODE_DELETION.PARTIAL_PLURAL', {
+                success: status.success.length,
+                failed: status.fail.length
+            });
+        }
+        if (status.someFailed && status.oneSucceeded) {
+            return new SnackbarWarningAction('APP.MESSAGES.INFO.NODE_DELETION.PARTIAL_SINGULAR', {
+                success: status.success.length,
+                failed: status.fail.length
+            });
+        }
+        if (status.oneFailed && !status.someSucceeded) {
+            return new SnackbarErrorAction('APP.MESSAGES.ERRORS.NODE_DELETION', {
+                name: status.fail[0].name
+            });
+        }
+        if (status.oneSucceeded && !status.someFailed) {
+            return new SnackbarInfoAction('APP.MESSAGES.INFO.NODE_DELETION.SINGULAR', { name: status.success[0].name });
+        }
+        return null;
+    }
+    showMoveMessage(nodes, info, moveResponse) {
+        const succeeded = moveResponse?.['succeeded'].length ?? 0;
+        const partiallySucceeded = moveResponse?.['partiallySucceeded'].length ?? 0;
+        const failures = moveResponse?.['failed'].length ?? 0;
+        let successMessage = '';
+        let partialSuccessMessage = '';
+        let failedMessage = '';
+        let errorMessage = '';
+        if (typeof info === 'string') {
+            // in case of success
+            if (info.toLowerCase().indexOf('succes') !== -1) {
+                const i18nMessageString = 'APP.MESSAGES.INFO.NODE_MOVE.';
+                let i18MessageSuffix = '';
+                if (succeeded) {
+                    i18MessageSuffix = succeeded === 1 ? 'SINGULAR' : 'PLURAL';
+                    successMessage = `${i18nMessageString}${i18MessageSuffix}`;
+                }
+                if (partiallySucceeded) {
+                    i18MessageSuffix = partiallySucceeded === 1 ? 'PARTIAL.SINGULAR' : 'PARTIAL.PLURAL';
+                    partialSuccessMessage = `${i18nMessageString}${i18MessageSuffix}`;
+                }
+                if (failures) {
+                    // if moving failed for ALL nodes, emit error
+                    if (failures === nodes.length) {
+                        const errors = this.nodeActionsService.flatten(moveResponse['failed']);
+                        errorMessage = this.getErrorMessage(errors[0]);
+                    }
+                    else {
+                        i18MessageSuffix = 'PARTIAL.FAIL';
+                        failedMessage = `${i18nMessageString}${i18MessageSuffix}`;
+                    }
+                }
+            }
+            else {
+                errorMessage = 'APP.MESSAGES.ERRORS.GENERIC';
+            }
+        }
+        else {
+            errorMessage = this.getErrorMessage(info);
+        }
+        const undo = succeeded + partiallySucceeded > 0 ? this.translation.instant('APP.ACTIONS.UNDO') : '';
+        failedMessage = errorMessage ? errorMessage : failedMessage;
+        const beforePartialSuccessMessage = successMessage && partialSuccessMessage ? ' ' : '';
+        const beforeFailedMessage = (successMessage || partialSuccessMessage) && failedMessage ? ' ' : '';
+        const initialParentId = this.nodeActionsService.getEntryParentId(nodes[0].entry);
+        const messages = this.translation.instant([successMessage, partialSuccessMessage, failedMessage], {
+            success: succeeded,
+            failed: failures,
+            partially: partiallySucceeded
+        });
+        // TODO: review in terms of i18n
+        this.notificationService
+            .openSnackMessageAction(messages[successMessage] + beforePartialSuccessMessage + messages[partialSuccessMessage] + beforeFailedMessage + messages[failedMessage], undo, {
+            panelClass: 'info-snackbar'
+        })
+            .onAction()
+            .subscribe(() => this.undoMoveNodes(moveResponse, initialParentId));
+    }
+    focusAfterClose(focusedElementSelector) {
+        if (focusedElementSelector) {
+            document.querySelector(focusedElementSelector)?.focus();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentManagementService, deps: [{ token: i1.NodesApiService }, { token: i2.Store }, { token: i3.ContentApiService }, { token: i3.NodePermissionService }, { token: i4.MatDialog }, { token: i5.NodeActionsService }, { token: i6.TranslationService }, { token: i1.NodeAspectService }, { token: i3.AppHookService }, { token: i1.NewVersionUploaderService }, { token: i7.Router }, { token: i3.AppSettingsService }, { token: i1.DocumentListService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentManagementService, providedIn: 'root' });
+}
+export { ContentManagementService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentManagementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NodesApiService }, { type: i2.Store }, { type: i3.ContentApiService }, { type: i3.NodePermissionService }, { type: i4.MatDialog }, { type: i5.NodeActionsService }, { type: i6.TranslationService }, { type: i1.NodeAspectService }, { type: i3.AppHookService }, { type: i1.NewVersionUploaderService }, { type: i7.Router }, { type: i3.AppSettingsService }, { type: i1.DocumentListService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-management.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-content/src/lib/services/content-management.service.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 { AppHookService, AppSettingsService, ContentApiService, NodePermissionService } from '@alfresco/aca-shared';\nimport {\n  AppStore,\n  DeletedNodeInfo,\n  DeleteStatus,\n  getAppSelection,\n  NavigateRouteAction,\n  NavigateToParentFolder,\n  NodeInfo,\n  RefreshPreviewAction,\n  SetSelectedNodesAction,\n  ShowLoaderAction,\n  SnackbarAction,\n  SnackbarErrorAction,\n  SnackbarInfoAction,\n  SnackbarUserAction,\n  SnackbarWarningAction,\n  UndoDeleteNodesAction,\n  UnlockWriteAction,\n  ViewNodeVersionAction\n} from '@alfresco/aca-shared/store';\nimport {\n  DocumentListService,\n  FolderDialogComponent,\n  LibraryDialogComponent,\n  NewVersionUploaderDataAction,\n  NewVersionUploaderDialogData,\n  NewVersionUploaderService,\n  NodeAspectService,\n  NodesApiService,\n  ShareDialogComponent\n} from '@alfresco/adf-content-services';\nimport { NotificationService, TranslationService, ConfirmDialogComponent } from '@alfresco/adf-core';\nimport { DeletedNodesPaging, Node, NodeEntry, PathInfo, SiteBodyCreate, SiteEntry } from '@alfresco/js-api';\nimport { inject, Injectable } from '@angular/core';\nimport { MatDialog, MatDialogConfig } from '@angular/material/dialog';\nimport { Store } from '@ngrx/store';\nimport { forkJoin, Observable, of, zip } from 'rxjs';\nimport { catchError, map, mergeMap, take, tap } from 'rxjs/operators';\nimport { NodeActionsService } from './node-actions.service';\nimport { Router } from '@angular/router';\n\ninterface RestoredNode {\n  status: number;\n  entry: Node;\n  statusCode?: number;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ContentManagementService {\n  private notificationService = inject(NotificationService);\n  private readonly createMenuButtonSelector = 'app-toolbar-menu button[id=\"app.toolbar.create\"]';\n\n  constructor(\n    private nodesApiService: NodesApiService,\n    private store: Store<AppStore>,\n    private contentApi: ContentApiService,\n    private permission: NodePermissionService,\n    private dialogRef: MatDialog,\n    private nodeActionsService: NodeActionsService,\n    private translation: TranslationService,\n    private nodeAspectService: NodeAspectService,\n    private appHookService: AppHookService,\n    private newVersionUploaderService: NewVersionUploaderService,\n    private router: Router,\n    private appSettingsService: AppSettingsService,\n    private documentListService: DocumentListService\n  ) {}\n\n  addFavorite(nodes: Array<NodeEntry>) {\n    if (nodes && nodes.length > 0) {\n      this.contentApi.addFavorite(nodes).subscribe(() => {\n        const favoriteNodes = nodes.map((node) => {\n          const newNode = JSON.parse(JSON.stringify(node));\n          newNode.entry.isFavorite = true;\n          return newNode;\n        });\n\n        this.store.dispatch(new SetSelectedNodesAction(favoriteNodes));\n      });\n    }\n  }\n\n  removeFavorite(nodes: Array<NodeEntry>) {\n    if (nodes && nodes.length > 0) {\n      this.contentApi.removeFavorite(nodes).subscribe(() => {\n        const favoriteNodes = nodes.map((node) => {\n          const newNode = JSON.parse(JSON.stringify(node));\n          newNode.entry.isFavorite = false;\n          return newNode;\n        });\n\n        this.store.dispatch(new SetSelectedNodesAction(favoriteNodes));\n      });\n    }\n  }\n\n  manageVersions(node: any, focusedElementOnCloseSelector?: string) {\n    if (node?.entry) {\n      // shared and favorite\n      const id = node.entry.nodeId || (node as any).entry.guid;\n\n      if (id) {\n        this.contentApi.getNodeInfo(id).subscribe((entry) => {\n          this.openVersionManagerDialog(entry, focusedElementOnCloseSelector);\n        });\n      } else {\n        this.openVersionManagerDialog(node.entry, focusedElementOnCloseSelector);\n      }\n    }\n  }\n\n  manageAspects(node: any, focusedElementOnCloseSelector?: string) {\n    if (node?.entry) {\n      // shared and favorite\n      const id = node.entry.nodeId || (node as any).entry.guid;\n\n      if (id) {\n        this.contentApi.getNodeInfo(id).subscribe((entry) => {\n          this.openAspectListDialog(entry, focusedElementOnCloseSelector);\n        });\n      } else {\n        this.openAspectListDialog(node.entry, focusedElementOnCloseSelector);\n      }\n    }\n  }\n\n  versionUpdateDialog(node: Node, file: File) {\n    this.contentApi.getNodeVersions(node.id).subscribe(({ list }) => {\n      const newVersionUploaderDialogData = {\n        node,\n        file,\n        currentVersion: list.entries[0].entry,\n        title: 'VERSION.DIALOG.TITLE',\n        showComments: this.appSettingsService.uploadAllowComments,\n        allowDownload: this.appSettingsService.uploadAllowDownload\n      } as NewVersionUploaderDialogData;\n      const dialogConfig: MatDialogConfig = { width: '600px' };\n\n      this.newVersionUploaderService.openUploadNewVersionDialog(newVersionUploaderDialogData, dialogConfig).subscribe(\n        (data) => {\n          if (data.action === NewVersionUploaderDataAction.upload) {\n            if (data.newVersion.value.entry.properties['cm:lockType'] === 'WRITE_LOCK') {\n              this.store.dispatch(new UnlockWriteAction(data.newVersion.value));\n            }\n          }\n        },\n        (error) => this.notificationService.showError(error)\n      );\n    });\n  }\n\n  shareNode(node: any, focusedElementOnCloseSelector?: string): void {\n    if (node?.entry) {\n      // shared and favorite\n      const id = node.entry.nodeId || (node as any).entry.guid;\n\n      if (id) {\n        this.contentApi.getNodeInfo(id).subscribe((entry) => {\n          this.openShareLinkDialog({ entry }, focusedElementOnCloseSelector);\n        });\n      } else {\n        this.openShareLinkDialog(node, focusedElementOnCloseSelector);\n      }\n    }\n  }\n\n  openShareLinkDialog(node: any, focusedElementOnCloseSelector?: string) {\n    const baseShareUrl = this.appSettingsService.baseShareUrl;\n\n    this.dialogRef\n      .open(ShareDialogComponent, {\n        restoreFocus: true,\n        width: '600px',\n        panelClass: 'adf-share-link-dialog',\n        data: {\n          node,\n          baseShareUrl\n        }\n      })\n      .afterClosed()\n      .subscribe(() => {\n        this.store.dispatch(new SetSelectedNodesAction([node]));\n        this.appHookService.linksUnshared.next();\n        this.focusAfterClose(focusedElementOnCloseSelector);\n      });\n  }\n\n  createFolder(parentNodeId: string) {\n    const dialogInstance = this.dialogRef.open(FolderDialogComponent, {\n      data: {\n        parentNodeId,\n        createTitle: undefined,\n        nodeType: 'cm:folder'\n      },\n      width: '400px',\n      role: 'dialog'\n    });\n\n    dialogInstance.componentInstance.error.subscribe((message: string) => {\n      this.notificationService.showError(message);\n    });\n\n    dialogInstance.afterClosed().subscribe((node) => {\n      if (node) {\n        this.documentListService.reload();\n      }\n      this.focusAfterClose(this.createMenuButtonSelector);\n    });\n  }\n\n  editFolder(folder: NodeEntry, focusedElementOnCloseSelector?: string) {\n    if (!folder) {\n      return;\n    }\n\n    const dialog = this.dialogRef.open(FolderDialogComponent, {\n      data: {\n        folder: folder.entry\n      },\n      width: '400px'\n    });\n\n    dialog.componentInstance.error.subscribe((message: string) => {\n      this.notificationService.showError(message);\n    });\n\n    dialog.afterClosed().subscribe((node) => {\n      if (node) {\n        this.store.dispatch(new SetSelectedNodesAction([{ entry: node }]));\n        this.nodesApiService.nodeUpdated.next(node);\n      }\n      this.focusAfterClose(focusedElementOnCloseSelector);\n    });\n  }\n\n  createLibrary(): Observable<string> {\n    const dialogInstance = this.dialogRef.open(LibraryDialogComponent, {\n      width: '400px'\n    });\n\n    dialogInstance.componentInstance.error.subscribe((message: string) => {\n      this.notificationService.showError(message);\n    });\n\n    return dialogInstance.afterClosed().pipe(\n      tap((node) => {\n        if (node) {\n          this.appHookService.libraryCreated.next(node);\n        }\n        this.focusAfterClose(this.createMenuButtonSelector);\n      }),\n      map((node: SiteEntry) => {\n        if (node?.entry?.guid) {\n          return node.entry.guid;\n        }\n        return null;\n      })\n    );\n  }\n\n  deleteLibrary(id: string): void {\n    this.contentApi.deleteSite(id).subscribe(\n      () => {\n        this.appHookService.libraryDeleted.next(id);\n        this.notificationService.showInfo('APP.MESSAGES.INFO.LIBRARY_DELETED');\n        this.store.dispatch(new NavigateRouteAction(['/libraries']));\n      },\n      () => {\n        this.notificationService.showError('APP.MESSAGES.ERRORS.DELETE_LIBRARY_FAILED');\n      }\n    );\n  }\n\n  leaveLibrary(siteId: string, focusedElementOnCloseSelector?: string): void {\n    const dialogRef = this.dialogRef.open(ConfirmDialogComponent, {\n      data: {\n        title: 'APP.DIALOGS.CONFIRM_LEAVE.TITLE',\n        message: 'APP.DIALOGS.CONFIRM_LEAVE.MESSAGE',\n        yesLabel: 'APP.DIALOGS.CONFIRM_LEAVE.YES_LABEL',\n        noLabel: 'APP.DIALOGS.CONFIRM_LEAVE.NO_LABEL'\n      },\n      minWidth: '250px'\n    });\n\n    dialogRef.afterClosed().subscribe((result) => {\n      if (result === true) {\n        this.contentApi.leaveSite(siteId).subscribe(\n          () => {\n            this.appHookService.libraryLeft.next(siteId);\n            this.notificationService.showInfo('APP.MESSAGES.INFO.LEFT_LIBRARY');\n          },\n          () => {\n            this.notificationService.showError('APP.MESSAGES.ERRORS.LEAVE_LIBRARY_FAILED');\n          }\n        );\n      }\n      this.focusAfterClose(focusedElementOnCloseSelector);\n    });\n  }\n\n  updateLibrary(siteId: string, siteBody: SiteBodyCreate) {\n    this.contentApi.updateLibrary(siteId, siteBody).subscribe(\n      (siteEntry: SiteEntry) => {\n        this.appHookService.libraryUpdated.next(siteEntry);\n        this.notificationService.showInfo('LIBRARY.SUCCESS.LIBRARY_UPDATED');\n      },\n      () => {\n        this.notificationService.showError('LIBRARY.ERRORS.LIBRARY_UPDATE_ERROR');\n      }\n    );\n  }\n\n  async unshareNodes(links: Array<NodeEntry>) {\n    const promises = links.map((link) => this.contentApi.deleteSharedLink(link.entry.id).toPromise());\n    await Promise.all(promises);\n    this.appHookService.linksUnshared.next();\n  }\n\n  canUpdateNode(node: NodeEntry | Node): boolean {\n    return this.permission.check(node, ['update']);\n  }\n\n  canUploadContent(folderNode: NodeEntry | Node): boolean {\n    return this.permission.check(folderNode, ['create']);\n  }\n\n  purgeDeletedNodes(nodes: NodeEntry[]) {\n    if (!nodes || nodes.length === 0) {\n      return;\n    }\n\n    const dialogRef = this.dialogRef.open(ConfirmDialogComponent, {\n      data: {\n        title: 'APP.DIALOGS.CONFIRM_PURGE.TITLE',\n        message: 'APP.DIALOGS.CONFIRM_PURGE.MESSAGE',\n        yesLabel: 'APP.DIALOGS.CONFIRM_PURGE.YES_LABEL',\n        noLabel: 'APP.DIALOGS.CONFIRM_PURGE.NO_LABEL'\n      },\n      minWidth: '250px'\n    });\n\n    dialogRef.afterClosed().subscribe((result) => {\n      if (result === true) {\n        const nodesToDelete: NodeInfo[] = nodes.map((node) => {\n          const { name } = node.entry;\n          const id = (node as any).entry.nodeId || node.entry.id;\n\n          return {\n            id,\n            name\n          };\n        });\n        this.purgeNodes(nodesToDelete);\n      }\n    });\n  }\n\n  restoreDeletedNodes(selection: NodeEntry[] = []) {\n    if (!selection.length) {\n      return;\n    }\n\n    const nodesWithPath = selection.filter((node) => node.entry.path);\n\n    if (selection.length && !nodesWithPath.length) {\n      const failedStatus = this.processStatus([]);\n      failedStatus.fail.push(...selection);\n      this.showRestoreNotification(failedStatus);\n      this.documentListService.reload();\n      return;\n    }\n\n    let status: DeleteStatus;\n\n    forkJoin(nodesWithPath.map((node) => this.restoreNode(node)))\n      .pipe(\n        tap((restoredNodes) => {\n          status = this.processStatus(restoredNodes);\n        }),\n        mergeMap(() => this.contentApi.getDeletedNodes())\n      )\n      .subscribe((nodes: DeletedNodesPaging) => {\n        const selectedNodes = this.diff(status.fail, selection, false);\n        const remainingNodes = this.diff(selectedNodes, nodes.list.entries);\n\n        if (!remainingNodes.length) {\n          this.showRestoreNotification(status);\n          this.documentListService.reload();\n        } else {\n          this.restoreDeletedNodes(remainingNodes);\n        }\n      });\n  }\n\n  copyNodes(nodes: Array<NodeEntry>, focusedElementOnCloseSelector?: string) {\n    zip(this.nodeActionsService.copyNodes(nodes, undefined, focusedElementOnCloseSelector), this.nodeActionsService.contentCopied).subscribe(\n      (result) => {\n        const [operationResult, newItems] = result;\n        this.showCopyMessage(operationResult, nodes, newItems);\n      },\n      (error) => {\n        this.showCopyMessage(error, nodes);\n      }\n    );\n  }\n\n  moveNodes(nodes: Array<NodeEntry>, focusedElementOnCloseSelector?: string) {\n    const permissionForMove = '!';\n\n    zip(this.nodeActionsService.moveNodes(nodes, permissionForMove, focusedElementOnCloseSelector), this.nodeActionsService.contentMoved).subscribe(\n      (result) => {\n        const [operationResult, moveResponse] = result;\n        this.showMoveMessage(nodes, operationResult, moveResponse);\n\n        this.documentListService.reload();\n      },\n      (error) => {\n        this.showMoveMessage(nodes, error);\n      }\n    );\n  }\n\n  getErrorMessage(errorObject: { message: any }): string {\n    let i18nMessageString = 'APP.MESSAGES.ERRORS.GENERIC';\n\n    try {\n      const {\n        error: { statusCode }\n      } = JSON.parse(errorObject.message);\n\n      if (statusCode === 409) {\n        i18nMessageString = 'APP.MESSAGES.ERRORS.NODE_MOVE';\n      } else if (statusCode === 403) {\n        i18nMessageString = 'APP.MESSAGES.ERRORS.PERMISSION';\n      }\n    } catch (err) {\n      /* Do nothing, keep the original message */\n    }\n\n    return i18nMessageString;\n  }\n\n  getNodeInfo(): Observable<Node> {\n    return this.store.select(getAppSelection).pipe(\n      take(1),\n      mergeMap(({ file }) => {\n        const id = (file as any).entry.nodeId || (file as any).entry.guid;\n        if (!id) {\n          return of(file.entry);\n        } else {\n          return this.contentApi.getNodeInfo(id);\n        }\n      })\n    );\n  }\n\n  unlockNode(node: NodeEntry): Promise<void | NodeEntry> {\n    return this.contentApi.unlockNode(node.entry.id).catch(() => {\n      this.notificationService.showError('APP.MESSAGES.ERRORS.UNLOCK_NODE', null, { fileName: node.entry.name });\n    });\n  }\n\n  private showCopyMessage(info: any, nodes: Array<NodeEntry>, newItems?: Array<NodeEntry>) {\n    const numberOfCopiedItems = newItems ? newItems.length : 0;\n    const failedItems = nodes.length - numberOfCopiedItems;\n\n    let i18nMessageString = 'APP.MESSAGES.ERRORS.GENERIC';\n\n    if (typeof info === 'string') {\n      if (info.toLowerCase().indexOf('succes') !== -1) {\n        let i18MessageSuffix;\n\n        if (failedItems) {\n          if (numberOfCopiedItems) {\n            i18MessageSuffix = numberOfCopiedItems === 1 ? 'PARTIAL_SINGULAR' : 'PARTIAL_PLURAL';\n          } else {\n            i18MessageSuffix = failedItems === 1 ? 'FAIL_SINGULAR' : 'FAIL_PLURAL';\n          }\n        } else {\n          i18MessageSuffix = numberOfCopiedItems === 1 ? 'SINGULAR' : 'PLURAL';\n        }\n\n        i18nMessageString = `APP.MESSAGES.INFO.NODE_COPY.${i18MessageSuffix}`;\n      }\n    } else {\n      try {\n        const {\n          error: { statusCode }\n        } = JSON.parse(info.message);\n\n        if (statusCode === 403) {\n          i18nMessageString = 'APP.MESSAGES.ERRORS.PERMISSION';\n        }\n      } catch {}\n    }\n\n    const undo = numberOfCopiedItems > 0 ? this.translation.instant('APP.ACTIONS.UNDO') : '';\n\n    const message = this.translation.instant(i18nMessageString, {\n      success: numberOfCopiedItems,\n      failed: failedItems\n    });\n\n    this.notificationService\n      .openSnackMessageAction(message, undo, {\n        panelClass: 'info-snackbar'\n      })\n      .onAction()\n      .subscribe(() => this.undoCopyNodes(newItems));\n  }\n\n  private undoCopyNodes(nodes: NodeEntry[]) {\n    const batch = this.nodeActionsService\n      .flatten(nodes)\n      .filter((item) => item.entry)\n      .map((item) => this.contentApi.deleteNode(item.entry.id, { permanent: true }));\n\n    forkJoin(...batch).subscribe(\n      () => {\n        this.appHookService.nodesDeleted.next(null);\n        this.documentListService.reload();\n      },\n      (error) => {\n        let i18nMessageString = 'APP.MESSAGES.ERRORS.GENERIC';\n\n        let errorJson = null;\n        try {\n          errorJson = JSON.parse(error.message);\n        } catch {}\n\n        if (errorJson?.error?.statusCode === 403) {\n          i18nMessageString = 'APP.MESSAGES.ERRORS.PERMISSION';\n        }\n\n        this.notificationService.showError(i18nMessageString);\n      }\n    );\n  }\n\n  private openVersionManagerDialog(node: any, focusedElementOnCloseSelector?: string) {\n    // workaround Shared\n    if (node.isFile || node.nodeId) {\n      const newVersionUploaderDialogData: NewVersionUploaderDialogData = {\n        node,\n        showVersionsOnly: true,\n        title: 'VERSION.DIALOG.TITLE',\n        allowDownload: this.appSettingsService.uploadAllowDownload,\n        showComments: this.appSettingsService.uploadAllowComments,\n        showActions: this.appSettingsService.versionManagerShowActions,\n        allowViewVersions: this.appSettingsService.versionManagerAllowViewVersions,\n        allowVersionDelete: this.appSettingsService.versionManagerAllowVersionDelete\n      };\n      this.newVersionUploaderService\n        .openUploadNewVersionDialog(newVersionUploaderDialogData, { width: '630px', role: 'dialog' }, focusedElementOnCloseSelector)\n        .subscribe({\n          next: (newVersionUploaderData) => {\n            switch (newVersionUploaderData.action) {\n              case NewVersionUploaderDataAction.refresh:\n                this.documentListService.reload();\n                this.store.dispatch(new RefreshPreviewAction(newVersionUploaderData.node));\n                break;\n              case NewVersionUploaderDataAction.view:\n                this.store.dispatch(\n                  new ViewNodeVersionAction(node.id, newVersionUploaderData.versionId, {\n                    location: this.router.url\n                  })\n                );\n                break;\n              default:\n                break;\n            }\n          }\n        });\n    } else {\n      this.notificationService.showError('APP.MESSAGES.ERRORS.PERMISSION');\n    }\n  }\n\n  private openAspectListDialog(node: any, focusedElementOnCloseSelector?: string) {\n    // workaround Shared\n    if (node.isFile || node.id) {\n      this.nodeAspectService.updateNodeAspects(node.id, focusedElementOnCloseSelector);\n    } else {\n      this.notificationService.showError('APP.MESSAGES.ERRORS.PERMISSION');\n    }\n  }\n\n  private undoMoveNodes(moveResponse, selectionParentId: string) {\n    const movedNodes = moveResponse?.['succeeded'] ?? [];\n    const partiallyMovedNodes = moveResponse?.['partiallySucceeded'] ?? [];\n\n    const restoreDeletedNodesBatch = this.nodeActionsService.moveDeletedEntries.map((folderEntry) =>\n      this.contentApi.restoreNode(folderEntry.nodeId || folderEntry.id).pipe(map((node) => node.entry))\n    );\n\n    zip(...restoreDeletedNodesBatch, of(null))\n      .pipe(\n        mergeMap(() => {\n          const nodesToBeMovedBack = [...partiallyMovedNodes, ...movedNodes];\n\n          const revertMoveBatch = this.nodeActionsService\n            .flatten(nodesToBeMovedBack)\n            .filter((node) => node.entry || node.itemMoved?.entry)\n            .map((node) => {\n              if (node.itemMoved) {\n                return this.nodeActionsService.moveNodeAction(node.itemMoved.entry, node.initialParentId);\n              } else {\n                return this.nodeActionsService.moveNodeAction(node.entry, selectionParentId);\n              }\n            });\n\n          return zip(...revertMoveBatch, of(null));\n        })\n      )\n      .subscribe(\n        () => {\n          this.documentListService.reload();\n        },\n        (error) => {\n          let message = 'APP.MESSAGES.ERRORS.GENERIC';\n\n          let errorJson = null;\n          try {\n            errorJson = JSON.parse(error.message);\n          } catch {}\n\n          if (errorJson?.error?.statusCode === 403) {\n            message = 'APP.MESSAGES.ERRORS.PERMISSION';\n          }\n\n          this.notificationService.showError(message);\n        }\n      );\n  }\n\n  deleteNodes(items: NodeEntry[]): void {\n    const batch: Observable<DeletedNodeInfo>[] = [];\n\n    items.forEach((node) => {\n      batch.push(this.deleteNode(node));\n    });\n\n    forkJoin(...batch).subscribe((data: DeletedNodeInfo[]) => {\n      const status = this.processStatus(data);\n      const message = this.getDeleteMessage(status);\n\n      if (message && status.someSucceeded) {\n        message.userAction = new SnackbarUserAction('APP.ACTIONS.UNDO', new UndoDeleteNodesAction([...status.success]));\n      }\n\n      this.store.dispatch(message);\n\n      if (status.someSucceeded) {\n        this.appHookService.nodesDeleted.next();\n        this.documentListService.reload();\n      }\n      this.store.dispatch(new ShowLoaderAction(false));\n    });\n  }\n\n  undoDeleteNodes(items: DeletedNodeInfo[]): void {\n    const batch: Observable<DeletedNodeInfo>[] = [];\n\n    items.forEach((item) => {\n      batch.push(this.undoDeleteNode(item));\n    });\n\n    forkJoin(...batch).subscribe((data) => {\n      const processedData = this.processStatus(data);\n\n      if (processedData.fail.length) {\n        const message = this.getUndoDeleteMessage(processedData);\n        this.store.dispatch(message);\n      }\n\n      if (processedData.someSucceeded) {\n        this.documentListService.reload();\n      }\n    });\n  }\n\n  private undoDeleteNode(item: DeletedNodeInfo): Observable<DeletedNodeInfo> {\n    const { id, name } = item;\n\n    return this.contentApi.restoreNode(id).pipe(\n      map(() => ({\n        id,\n        name,\n        status: 1\n      })),\n      catchError(() =>\n        of({\n          id,\n          name,\n          status: 0\n        })\n      )\n    );\n  }\n\n  private getUndoDeleteMessage(status: DeleteStatus): SnackbarAction {\n    if (status.someFailed && !status.oneFailed) {\n      return new SnackbarErrorAction('APP.MESSAGES.ERRORS.NODE_RESTORE_PLURAL', { number: status.fail.length });\n    }\n\n    if (status.oneFailed) {\n      return new SnackbarErrorAction('APP.MESSAGES.ERRORS.NODE_RESTORE', {\n        name: status.fail[0].name\n      });\n    }\n\n    return null;\n  }\n\n  private restoreNode(node: NodeEntry): Observable<RestoredNode> {\n    const { entry } = node;\n\n    return this.contentApi.restoreNode(entry.id).pipe(\n      map(() => ({\n        status: 1,\n        entry\n      })),\n      catchError((error) => {\n        const { statusCode } = JSON.parse(error.message).error;\n\n        return of({\n          status: 0,\n          statusCode,\n          entry\n        });\n      })\n    );\n  }\n\n  private purgeNodes(selection: NodeInfo[] = []) {\n    if (!selection.length) {\n      return;\n    }\n\n    const batch = selection.map((node) => this.purgeDeletedNode(node));\n\n    forkJoin(batch).subscribe((purgedNodes) => {\n      const status = this.processStatus(purgedNodes);\n\n      if (status.success.length) {\n        this.documentListService.reload();\n      }\n\n      this.sendPurgeMessage(status);\n    });\n  }\n\n  private purgeDeletedNode(node: NodeInfo): Observable<DeletedNodeInfo> {\n    const { id, name } = node;\n\n    return this.contentApi.purgeDeletedNode(id).pipe(\n      map(() => ({\n        status: 1,\n        id,\n        name\n      })),\n      catchError(() =>\n        of({\n          status: 0,\n          id,\n          name\n        })\n      )\n    );\n  }\n\n  private processStatus(data: Array<{ status: number }> = []): DeleteStatus {\n    const status = {\n      fail: [],\n      success: [],\n      get someFailed() {\n        return !!this.fail.length;\n      },\n      get someSucceeded() {\n        return !!this.success.length;\n      },\n      get oneFailed() {\n        return this.fail.length === 1;\n      },\n      get oneSucceeded() {\n        return this.success.length === 1;\n      },\n      get allSucceeded() {\n        return this.someSucceeded && !this.someFailed;\n      },\n      get allFailed() {\n        return this.someFailed && !this.someSucceeded;\n      },\n      reset() {\n        this.fail = [];\n        this.success = [];\n      }\n    };\n\n    return data.reduce((acc, node) => {\n      if (node.status) {\n        acc.success.push(node);\n      } else {\n        acc.fail.push(node);\n      }\n\n      return acc;\n    }, status);\n  }\n\n  private sendPurgeMessage(status: DeleteStatus): void {\n    if (status.oneSucceeded && status.someFailed && !status.oneFailed) {\n      this.notificationService.showWarning('APP.MESSAGES.INFO.TRASH.NODES_PURGE.PARTIAL_SINGULAR', null, {\n        name: status.success[0].name,\n        failed: status.fail.length\n      });\n      return;\n    }\n\n    if (status.someSucceeded && !status.oneSucceeded && status.someFailed) {\n      this.notificationService.showWarning('APP.MESSAGES.INFO.TRASH.NODES_PURGE.PARTIAL_PLURAL', null, {\n        number: status.success.length,\n        failed: status.fail.length\n      });\n      return;\n    }\n\n    if (status.oneSucceeded) {\n      this.notificationService.showInfo('APP.MESSAGES.INFO.TRASH.NODES_PURGE.SINGULAR', null, { name: status.success[0].name });\n      return;\n    }\n\n    if (status.oneFailed) {\n      this.notificationService.showError('APP.MESSAGES.ERRORS.TRASH.NODES_PURGE.SINGULAR', null, { name: status.fail[0].name });\n      return;\n    }\n\n    if (status.allSucceeded) {\n      this.notificationService.showInfo('APP.MESSAGES.INFO.TRASH.NODES_PURGE.PLURAL', null, { number: status.success.length });\n      return;\n    }\n\n    if (status.allFailed) {\n      this.notificationService.showError('APP.MESSAGES.ERRORS.TRASH.NODES_PURGE.PLURAL', null, { number: status.fail.length });\n      return;\n    }\n  }\n\n  private showRestoreNotification(status: DeleteStatus): void {\n    const message = this.getRestoreMessage(status);\n\n    if (message) {\n      if (status.oneSucceeded && !status.someFailed) {\n        const isSite = this.isSite(status.success[0].entry);\n        const path: PathInfo = status.success[0].entry.path;\n        const parent = path.elements[path.elements.length - 1];\n        const route = isSite ? ['/libraries', parent.id] : ['/personal-files', parent.id];\n\n        let navigate;\n\n        if (this.isLibraryContent(path)) {\n          navigate = new NavigateToParentFolder(status.success[0]);\n        } else {\n          navigate = new NavigateRouteAction(route);\n        }\n\n        message.userAction = new SnackbarUserAction('APP.ACTIONS.VIEW', navigate);\n      }\n\n      this.store.dispatch(message);\n    }\n  }\n\n  private isSite(entry: Node): boolean {\n    return entry.nodeType === 'st:site';\n  }\n\n  private isLibraryContent(path: PathInfo): boolean {\n    return path && path.elements.length >= 2 && path.elements[1].name === 'Sites';\n  }\n\n  private getRestoreMessage(status: DeleteStatus): SnackbarAction {\n    if (status.someFailed && !status.oneFailed) {\n      return new SnackbarErrorAction('APP.MESSAGES.ERRORS.TRASH.NODES_RESTORE.PARTIAL_PLURAL', {\n        number: status.fail.length\n      });\n    }\n\n    if (status.oneFailed && status.fail[0].statusCode) {\n      if (status.fail[0].statusCode === 409) {\n        return new SnackbarErrorAction('APP.MESSAGES.ERRORS.TRASH.NODES_RESTORE.NODE_EXISTS', {\n          name: status.fail[0].entry.name\n        });\n      } else {\n        return new SnackbarErrorAction('APP.MESSAGES.ERRORS.TRASH.NODES_RESTORE.GENERIC', {\n          name: status.fail[0].entry.name\n        });\n      }\n    }\n\n    if (status.oneFailed && !status.fail[0].statusCode) {\n      return new SnackbarErrorAction('APP.MESSAGES.ERRORS.TRASH.NODES_RESTORE.LOCATION_MISSING', {\n        name: status.fail[0].entry.name\n      });\n    }\n\n    if (status.allSucceeded && !status.oneSucceeded) {\n      return new SnackbarInfoAction('APP.MESSAGES.INFO.TRASH.NODES_RESTORE.PLURAL');\n    }\n\n    if (status.allSucceeded && status.oneSucceeded) {\n      return new SnackbarInfoAction('APP.MESSAGES.INFO.TRASH.NODES_RESTORE.SINGULAR', {\n        name: status.success[0].entry.name\n      });\n    }\n\n    return null;\n  }\n\n  private diff(selection: any[], list: any[], fromList = true): any {\n    const ids = selection.map((item) => item.entry.id);\n\n    return list.filter((item) => {\n      if (fromList) {\n        return ids.includes(item.entry.id) ? item : null;\n      } else {\n        return !ids.includes(item.entry.id) ? item : null;\n      }\n    });\n  }\n\n  private deleteNode(node: any): Observable<DeletedNodeInfo> {\n    const { name } = node.entry;\n    const id = node.entry.nodeId || node.entry.id;\n\n    return this.contentApi.deleteNode(id).pipe(\n      map(() => ({\n        id,\n        name,\n        status: 1\n      })),\n      catchError(() =>\n        of({\n          id,\n          name,\n          status: 0\n        })\n      )\n    );\n  }\n\n  private getDeleteMessage(status: DeleteStatus): SnackbarAction {\n    if (status.allFailed && !status.oneFailed) {\n      return new SnackbarErrorAction('APP.MESSAGES.ERRORS.NODE_DELETION_PLURAL', { number: status.fail.length });\n    }\n\n    if (status.allSucceeded && !status.oneSucceeded) {\n      return new SnackbarInfoAction('APP.MESSAGES.INFO.NODE_DELETION.PLURAL', {\n        number: status.success.length\n      });\n    }\n\n    if (status.someFailed && status.someSucceeded && !status.oneSucceeded) {\n      return new SnackbarWarningAction('APP.MESSAGES.INFO.NODE_DELETION.PARTIAL_PLURAL', {\n        success: status.success.length,\n        failed: status.fail.length\n      });\n    }\n\n    if (status.someFailed && status.oneSucceeded) {\n      return new SnackbarWarningAction('APP.MESSAGES.INFO.NODE_DELETION.PARTIAL_SINGULAR', {\n        success: status.success.length,\n        failed: status.fail.length\n      });\n    }\n\n    if (status.oneFailed && !status.someSucceeded) {\n      return new SnackbarErrorAction('APP.MESSAGES.ERRORS.NODE_DELETION', {\n        name: status.fail[0].name\n      });\n    }\n\n    if (status.oneSucceeded && !status.someFailed) {\n      return new SnackbarInfoAction('APP.MESSAGES.INFO.NODE_DELETION.SINGULAR', { name: status.success[0].name });\n    }\n\n    return null;\n  }\n\n  private showMoveMessage(nodes: Array<NodeEntry>, info: any, moveResponse?: any) {\n    const succeeded = moveResponse?.['succeeded'].length ?? 0;\n    const partiallySucceeded = moveResponse?.['partiallySucceeded'].length ?? 0;\n    const failures = moveResponse?.['failed'].length ?? 0;\n\n    let successMessage = '';\n    let partialSuccessMessage = '';\n    let failedMessage = '';\n    let errorMessage = '';\n\n    if (typeof info === 'string') {\n      // in case of success\n      if (info.toLowerCase().indexOf('succes') !== -1) {\n        const i18nMessageString = 'APP.MESSAGES.INFO.NODE_MOVE.';\n        let i18MessageSuffix = '';\n\n        if (succeeded) {\n          i18MessageSuffix = succeeded === 1 ? 'SINGULAR' : 'PLURAL';\n          successMessage = `${i18nMessageString}${i18MessageSuffix}`;\n        }\n\n        if (partiallySucceeded) {\n          i18MessageSuffix = partiallySucceeded === 1 ? 'PARTIAL.SINGULAR' : 'PARTIAL.PLURAL';\n          partialSuccessMessage = `${i18nMessageString}${i18MessageSuffix}`;\n        }\n\n        if (failures) {\n          // if moving failed for ALL nodes, emit error\n          if (failures === nodes.length) {\n            const errors = this.nodeActionsService.flatten(moveResponse['failed']);\n            errorMessage = this.getErrorMessage(errors[0]);\n          } else {\n            i18MessageSuffix = 'PARTIAL.FAIL';\n            failedMessage = `${i18nMessageString}${i18MessageSuffix}`;\n          }\n        }\n      } else {\n        errorMessage = 'APP.MESSAGES.ERRORS.GENERIC';\n      }\n    } else {\n      errorMessage = this.getErrorMessage(info);\n    }\n\n    const undo = succeeded + partiallySucceeded > 0 ? this.translation.instant('APP.ACTIONS.UNDO') : '';\n    failedMessage = errorMessage ? errorMessage : failedMessage;\n\n    const beforePartialSuccessMessage = successMessage && partialSuccessMessage ? ' ' : '';\n    const beforeFailedMessage = (successMessage || partialSuccessMessage) && failedMessage ? ' ' : '';\n\n    const initialParentId = this.nodeActionsService.getEntryParentId(nodes[0].entry);\n\n    const messages = this.translation.instant([successMessage, partialSuccessMessage, failedMessage], {\n      success: succeeded,\n      failed: failures,\n      partially: partiallySucceeded\n    });\n\n    // TODO: review in terms of i18n\n    this.notificationService\n      .openSnackMessageAction(\n        messages[successMessage] + beforePartialSuccessMessage + messages[partialSuccessMessage] + beforeFailedMessage + messages[failedMessage],\n        undo,\n        {\n          panelClass: 'info-snackbar'\n        }\n      )\n      .onAction()\n      .subscribe(() => this.undoMoveNodes(moveResponse, initialParentId));\n  }\n\n  private focusAfterClose(focusedElementSelector: string): void {\n    if (focusedElementSelector) {\n      document.querySelector<HTMLElement>(focusedElementSelector)?.focus();\n    }\n  }\n}\n"]}