@alfresco/aca-content 4.0.0-4895233349

package/esm2020/lib/services/node-actions.service.mjs

@@ -0,0 +1,600 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { Subject, of, zip, from } from 'rxjs';
+import { AlfrescoApiService, TranslationService, ThumbnailService } from '@alfresco/adf-core';
+import { DocumentListService, ContentNodeSelectorComponent, ContentNodeDialogService, NodeAction, ContentService } from '@alfresco/adf-content-services';
+import { SitePaging, NodesApi } from '@alfresco/js-api';
+import { ContentApiService } from '@alfresco/aca-shared';
+import { catchError, map, mergeMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-content-services";
+import * as i2 from "@alfresco/aca-shared";
+import * as i3 from "@angular/material/dialog";
+import * as i4 from "@alfresco/adf-core";
+export class NodeActionsService {
+    constructor(contentService, contentApi, dialog, documentListService, apiService, translation, thumbnailService) {
+        this.contentService = contentService;
+        this.contentApi = contentApi;
+        this.dialog = dialog;
+        this.documentListService = documentListService;
+        this.apiService = apiService;
+        this.translation = translation;
+        this.thumbnailService = thumbnailService;
+        this.contentCopied = new Subject();
+        this.contentMoved = new Subject();
+        this.moveDeletedEntries = [];
+        this.isSitesDestinationAvailable = false;
+    }
+    get nodesApi() {
+        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());
+        return this._nodesApi;
+    }
+    /**
+     * Copy node list
+     *
+     * @param contentEntities nodes to copy
+     * @param permission permission which is needed to apply the action
+     * @param focusedElementOnCloseSelector element's selector which should be autofocused after closing modal
+     */
+    copyNodes(contentEntities, permission, focusedElementOnCloseSelector) {
+        return this.doBatchOperation(NodeAction.COPY, contentEntities, permission, focusedElementOnCloseSelector);
+    }
+    /**
+     * Move node list
+     *
+     * @param contentEntities nodes to move
+     * @param permission permission which is needed to apply the action
+     * @param focusedElementOnCloseSelector element's selector which should be autofocused after closing modal
+     */
+    moveNodes(contentEntities, permission, focusedElementOnCloseSelector) {
+        return this.doBatchOperation(NodeAction.MOVE, contentEntities, permission, focusedElementOnCloseSelector);
+    }
+    /**
+     * General method for performing the given operation (copy|move) to multiple nodes
+     *
+     * @param action the action to perform (copy|move)
+     * @param contentEntities the contentEntities which have to have the action performed on
+     * @param permission permission which is needed to apply the action
+     * @param focusedElementOnCloseSelector element's selector which should be autofocused after closing modal
+     */
+    doBatchOperation(action, contentEntities, permission, focusedElementOnCloseSelector) {
+        const observable = new Subject();
+        if (!this.isEntryEntitiesArray(contentEntities)) {
+            observable.error(new Error(JSON.stringify({ error: { statusCode: 400 } })));
+        }
+        else if (this.checkPermission(action, contentEntities, permission)) {
+            const destinationSelection = this.getContentNodeSelection(action, contentEntities, focusedElementOnCloseSelector);
+            destinationSelection.subscribe((selections) => {
+                const contentEntry = contentEntities[0].entry;
+                // Check if there's nodeId for Shared Files
+                const contentEntryId = contentEntry.nodeId || contentEntry.id;
+                const type = contentEntry.isFolder ? 'folder' : 'content';
+                const batch = [];
+                // consider only first item in the selection
+                const selection = selections[0];
+                let action$;
+                if (action === NodeAction.MOVE && contentEntities.length === 1 && type === 'content') {
+                    action$ = this.documentListService.moveNode(contentEntryId, selection.id);
+                }
+                else {
+                    contentEntities.forEach((node) => {
+                        // batch.push(this.copyNodeAction(node.entry, selection.id));
+                        batch.push(this[`${action.toLowerCase()}NodeAction`](node.entry, selection.id));
+                    });
+                    action$ = zip(...batch);
+                }
+                action$.subscribe((newContent) => {
+                    observable.next(`OPERATION.SUCCESS.${type.toUpperCase()}.${action.toUpperCase()}`);
+                    const processedData = this.processResponse(newContent);
+                    if (action === NodeAction.COPY) {
+                        this.contentCopied.next(processedData.succeeded);
+                    }
+                    else if (action === NodeAction.MOVE) {
+                        this.contentMoved.next(processedData);
+                    }
+                }, observable.error.bind(observable));
+            });
+        }
+        else {
+            observable.error(new Error(JSON.stringify({ error: { statusCode: 403 } })));
+        }
+        return observable;
+    }
+    isEntryEntitiesArray(contentEntities) {
+        if (contentEntities && contentEntities.length) {
+            const nonEntryNode = contentEntities.find((node) => !node || !node.entry || !(node.entry.nodeId || node.entry.id));
+            return !nonEntryNode;
+        }
+        return false;
+    }
+    checkPermission(action, contentEntities, permission) {
+        const notAllowedNode = contentEntities.find((node) => !this.isActionAllowed(action, node.entry, permission));
+        return !notAllowedNode;
+    }
+    getEntryParentId(nodeEntry) {
+        let entryParentId = '';
+        if (nodeEntry.parentId) {
+            entryParentId = nodeEntry.parentId;
+        }
+        else if (nodeEntry.path && nodeEntry.path.elements && nodeEntry.path.elements.length) {
+            entryParentId = nodeEntry.path.elements[nodeEntry.path.elements.length - 1].id;
+        }
+        return entryParentId;
+    }
+    getContentNodeSelection(action, contentEntities, focusedElementOnCloseSelector) {
+        const currentParentFolderId = this.getEntryParentId(contentEntities[0].entry);
+        const customDropdown = new SitePaging({
+            list: {
+                entries: [
+                    {
+                        entry: {
+                            guid: '-my-',
+                            title: this.translation.instant('APP.BROWSE.PERSONAL.SIDENAV_LINK.LABEL')
+                        }
+                    },
+                    {
+                        entry: {
+                            guid: '-mysites-',
+                            title: this.translation.instant('APP.BROWSE.LIBRARIES.MENU.MY_LIBRARIES.SIDENAV_LINK.LABEL')
+                        }
+                    }
+                ]
+            }
+        });
+        const title = this.getTitleTranslation(action, contentEntities);
+        this.isSitesDestinationAvailable = false;
+        const data = {
+            selectionMode: 'single',
+            title,
+            currentFolderId: currentParentFolderId,
+            actionName: action,
+            dropdownHideMyFiles: true,
+            dropdownSiteList: customDropdown,
+            rowFilter: this.rowFilter.bind(this),
+            imageResolver: this.imageResolver.bind(this),
+            isSelectionValid: this.canCopyMoveInsideIt.bind(this),
+            breadcrumbTransform: this.customizeBreadcrumb.bind(this),
+            select: new Subject(),
+            excludeSiteContent: ContentNodeDialogService.nonDocumentSiteContent
+        };
+        this.dialog
+            .open(ContentNodeSelectorComponent, {
+            data,
+            panelClass: 'adf-content-node-selector-dialog',
+            width: '630px',
+            role: 'dialog'
+        })
+            .afterClosed()
+            .subscribe(() => this.focusAfterClose(focusedElementOnCloseSelector));
+        data.select.subscribe({
+            complete: this.close.bind(this)
+        });
+        return data.select;
+    }
+    getTitleTranslation(action, nodes = []) {
+        let keyPrefix = 'ITEMS';
+        let name = '';
+        if (nodes.length === 1 && nodes[0].entry.name) {
+            name = nodes[0].entry.name;
+            keyPrefix = 'ITEM';
+        }
+        const number = nodes.length;
+        return this.translation.instant(`NODE_SELECTOR.${action.toUpperCase()}_${keyPrefix}`, { name, number });
+    }
+    canCopyMoveInsideIt(entry) {
+        return this.hasEntityCreatePermission(entry) && !this.isSite(entry);
+    }
+    hasEntityCreatePermission(entry) {
+        return this.contentService.hasAllowableOperations(entry, 'create');
+    }
+    isSite(entry) {
+        return !!entry.guid || entry.nodeType === 'st:site' || entry.nodeType === 'st:sites';
+    }
+    close() {
+        this.dialog.closeAll();
+    }
+    // todo: review this approach once 5.2.3 is out
+    customizeBreadcrumb(node) {
+        if (node && node.path && node.path.elements) {
+            const elements = node.path.elements;
+            if (elements.length > 1) {
+                if (elements[1].name === 'User Homes') {
+                    elements.splice(0, 2);
+                    // make sure first item is 'Personal Files'
+                    if (elements[0]) {
+                        elements[0].name = this.translation.instant('APP.BROWSE.PERSONAL.TITLE');
+                        elements[0].id = '-my-';
+                    }
+                    else {
+                        node.name = this.translation.instant('APP.BROWSE.PERSONAL.TITLE');
+                    }
+                }
+                else if (elements[1].name === 'Sites') {
+                    this.normalizeSitePath(node);
+                }
+            }
+            else if (elements.length === 1) {
+                if (node.name === 'Sites') {
+                    node.name = this.translation.instant('APP.BROWSE.LIBRARIES.MENU.MY_LIBRARIES.TITLE');
+                    elements.splice(0, 1);
+                }
+            }
+        }
+        else if (node === null && this.isSitesDestinationAvailable) {
+            node = {
+                name: this.translation.instant('APP.BROWSE.LIBRARIES.MENU.MY_LIBRARIES.TITLE'),
+                path: { elements: [] }
+            };
+        }
+        return node;
+    }
+    // todo: review this approach once 5.2.3 is out
+    normalizeSitePath(node) {
+        const elements = node.path.elements;
+        // remove 'Company Home'
+        elements.splice(0, 1);
+        // replace first item with 'File Libraries'
+        elements[0].name = this.translation.instant('APP.BROWSE.LIBRARIES.MENU.MY_LIBRARIES.TITLE');
+        elements[0].id = '-mysites-';
+        if (this.isSiteContainer(node)) {
+            // rename 'documentLibrary' entry to the target site display name
+            // clicking on the breadcrumb entry loads the site content
+            node.name = elements[1].name;
+            // remove the site entry
+            elements.splice(1, 1);
+        }
+        else {
+            // remove 'documentLibrary' in the middle of the path
+            const docLib = elements.findIndex((el) => el.name === 'documentLibrary');
+            if (docLib > -1) {
+                elements.splice(docLib, 1);
+            }
+        }
+    }
+    isSiteContainer(node) {
+        if (node && node.aspectNames && node.aspectNames.length > 0) {
+            return node.aspectNames.indexOf('st:siteContainer') >= 0;
+        }
+        return false;
+    }
+    copyNodeAction(nodeEntry, selectionId) {
+        if (nodeEntry.isFolder) {
+            return this.copyFolderAction(nodeEntry, selectionId);
+        }
+        else {
+            // any other type is treated as 'content'
+            return this.copyContentAction(nodeEntry, selectionId);
+        }
+    }
+    copyContentAction(contentEntry, selectionId, oldName) {
+        const _oldName = oldName || contentEntry.name;
+        // Check if there's nodeId for Shared Files
+        const contentEntryId = contentEntry.nodeId || contentEntry.id;
+        // use local method until new name parameter is added on ADF copyNode
+        return this.copyNode(contentEntryId, selectionId, _oldName).pipe(catchError((err) => {
+            let errStatusCode;
+            try {
+                const { error: { statusCode } } = JSON.parse(err.message);
+                errStatusCode = statusCode;
+            }
+            catch (e) {
+                //
+            }
+            if (errStatusCode && errStatusCode === 409) {
+                return this.copyContentAction(contentEntry, selectionId, this.getNewNameFrom(_oldName, contentEntry.name));
+            }
+            else {
+                // do not throw error, to be able to show message in case of partial copy of files
+                return of(err || 'Server error');
+            }
+        }));
+    }
+    copyFolderAction(contentEntry, selectionId) {
+        // Check if there's nodeId for Shared Files
+        const contentEntryId = contentEntry.nodeId || contentEntry.id;
+        let $destinationFolder;
+        let $childrenToCopy;
+        let newDestinationFolder;
+        return this.copyNode(contentEntryId, selectionId, contentEntry.name).pipe(catchError((err) => {
+            let errStatusCode;
+            try {
+                const { error: { statusCode } } = JSON.parse(err.message);
+                errStatusCode = statusCode;
+            }
+            catch { }
+            if (errStatusCode && errStatusCode === 409) {
+                $destinationFolder = this.getChildByName(selectionId, contentEntry.name);
+                $childrenToCopy = this.getNodeChildren(contentEntryId);
+                return $destinationFolder.pipe(mergeMap((destination) => {
+                    newDestinationFolder = destination;
+                    return $childrenToCopy;
+                }), mergeMap((nodesToCopy) => {
+                    const batch = [];
+                    nodesToCopy.list.entries.forEach((node) => {
+                        if (node.entry.isFolder) {
+                            batch.push(this.copyFolderAction(node.entry, newDestinationFolder.entry.id));
+                        }
+                        else {
+                            batch.push(this.copyContentAction(node.entry, newDestinationFolder.entry.id));
+                        }
+                    });
+                    if (!batch.length) {
+                        return of({});
+                    }
+                    return zip(...batch);
+                }));
+            }
+            else {
+                // do not throw error, to be able to show message in case of partial copy of files
+                return of(err || 'Server error');
+            }
+        }));
+    }
+    moveNodeAction(nodeEntry, selectionId) {
+        this.moveDeletedEntries = [];
+        if (nodeEntry.isFolder) {
+            const initialParentId = nodeEntry.parentId;
+            return this.moveFolderAction(nodeEntry, selectionId).pipe(mergeMap((newContent) => {
+                // take no extra action, if folder is moved to the same location
+                if (initialParentId === selectionId) {
+                    return of(newContent);
+                }
+                const flattenResponse = this.flatten(newContent);
+                const processedData = this.processResponse(flattenResponse);
+                // else, check if moving this nodeEntry succeeded for ALL of its nodes
+                if (processedData.failed.length === 0) {
+                    // check if folder still exists on location
+                    return this.getChildByName(initialParentId, nodeEntry.name).pipe(mergeMap((folderOnInitialLocation) => {
+                        if (folderOnInitialLocation) {
+                            // Check if there's nodeId for Shared Files
+                            const nodeEntryId = nodeEntry.nodeId || nodeEntry.id;
+                            // delete it from location
+                            return this.contentApi.deleteNode(nodeEntryId).pipe(mergeMap(() => {
+                                this.moveDeletedEntries.push(nodeEntry);
+                                return of(newContent);
+                            }));
+                        }
+                        return of(newContent);
+                    }));
+                }
+                return of(newContent);
+            }));
+        }
+        else {
+            // any other type is treated as 'content'
+            return this.moveContentAction(nodeEntry, selectionId);
+        }
+    }
+    moveFolderAction(contentEntry, selectionId) {
+        // Check if there's nodeId for Shared Files
+        const contentEntryId = contentEntry.nodeId || contentEntry.id;
+        const initialParentId = this.getEntryParentId(contentEntry);
+        let $destinationFolder;
+        let $childrenToMove;
+        let newDestinationFolder;
+        return this.documentListService.moveNode(contentEntryId, selectionId).pipe(map((itemMoved) => ({ itemMoved, initialParentId })), catchError((err) => {
+            let errStatusCode;
+            try {
+                const { error: { statusCode } } = JSON.parse(err.message);
+                errStatusCode = statusCode;
+            }
+            catch (e) {
+                //
+            }
+            if (errStatusCode && errStatusCode === 409) {
+                $destinationFolder = this.getChildByName(selectionId, contentEntry.name);
+                $childrenToMove = this.getNodeChildren(contentEntryId);
+                return $destinationFolder.pipe(mergeMap((destination) => {
+                    newDestinationFolder = destination;
+                    return $childrenToMove;
+                }), mergeMap((childrenToMove) => {
+                    const batch = [];
+                    childrenToMove.list.entries.forEach((node) => {
+                        if (node.entry.isFolder) {
+                            batch.push(this.moveFolderAction(node.entry, newDestinationFolder.entry.id));
+                        }
+                        else {
+                            batch.push(this.moveContentAction(node.entry, newDestinationFolder.entry.id));
+                        }
+                    });
+                    if (!batch.length) {
+                        return of(batch);
+                    }
+                    return zip(...batch);
+                }));
+            }
+            else {
+                // do not throw error, to be able to show message in case of partial move of files
+                return of(err);
+            }
+        }));
+    }
+    moveContentAction(contentEntry, selectionId) {
+        // Check if there's nodeId for Shared Files
+        const contentEntryId = contentEntry.nodeId || contentEntry.id;
+        const initialParentId = this.getEntryParentId(contentEntry);
+        return this.documentListService.moveNode(contentEntryId, selectionId).pipe(map((itemMoved) => ({ itemMoved, initialParentId })), catchError((err) => 
+        // do not throw error, to be able to show message in case of partial move of files
+        of(err)));
+    }
+    getChildByName(parentId, name) {
+        const matchedNodes = new Subject();
+        this.getNodeChildren(parentId).subscribe((childrenNodes) => {
+            const result = childrenNodes.list.entries.find((node) => node.entry.name === name);
+            if (result) {
+                matchedNodes.next(result);
+            }
+            else {
+                matchedNodes.next(null);
+            }
+        }, (err) => matchedNodes.error(err));
+        return matchedNodes;
+    }
+    isActionAllowed(action, node, permission) {
+        if (action === NodeAction.COPY) {
+            return true;
+        }
+        return this.contentService.hasAllowableOperations(node, permission);
+    }
+    rowFilter(row) {
+        const node = row.node.entry;
+        this.isSitesDestinationAvailable = !!node['guid'];
+        return !node.isFile && node.nodeType !== 'app:folderlink';
+    }
+    imageResolver(row, _) {
+        const entry = row.node.entry;
+        if (!this.contentService.hasAllowableOperations(entry, 'update')) {
+            return this.thumbnailService.getMimeTypeIcon('disable/folder');
+        }
+        return null;
+    }
+    getNewNameFrom(name, baseName) {
+        const extensionMatch = name.match(/\.[^/.]+$/);
+        // remove extension in case there is one
+        const fileExtension = extensionMatch ? extensionMatch[0] : '';
+        let extensionFree = extensionMatch ? name.slice(0, extensionMatch.index) : name;
+        let prefixNumber = 1;
+        let baseExtensionFree;
+        if (baseName) {
+            const baseExtensionMatch = baseName.match(/\.[^/.]+$/);
+            // remove extension in case there is one
+            baseExtensionFree = baseExtensionMatch ? baseName.slice(0, baseExtensionMatch.index) : baseName;
+        }
+        if (!baseExtensionFree || baseExtensionFree !== extensionFree) {
+            // check if name already has integer appended on end:
+            const oldPrefix = extensionFree.match('-[0-9]+$');
+            if (oldPrefix) {
+                // if so, try to get the number at the end
+                const oldPrefixNumber = parseInt(oldPrefix[0].slice(1), 10);
+                if (oldPrefixNumber.toString() === oldPrefix[0].slice(1)) {
+                    extensionFree = extensionFree.slice(0, oldPrefix.index);
+                    prefixNumber = oldPrefixNumber + 1;
+                }
+            }
+        }
+        return extensionFree + '-' + prefixNumber + fileExtension;
+    }
+    /**
+     * Get children nodes of given parent node
+     *
+     * @param nodeId The id of the parent node
+     * @param params optional parameters
+     */
+    getNodeChildren(nodeId, params) {
+        return from(this.nodesApi.listNodeChildren(nodeId, params));
+    }
+    // Copied from ADF document-list.service, and added the name parameter
+    /**
+     * Copy a node to destination node
+     *
+     * @param nodeId The id of the node to be copied
+     * @param targetParentId The id of the folder-node where the node have to be copied to
+     * @param name The new name for the copy that would be added on the destination folder
+     */
+    copyNode(nodeId, targetParentId, name) {
+        return from(this.nodesApi.copyNode(nodeId, { targetParentId, name }));
+    }
+    flatten(nDimArray) {
+        if (!Array.isArray(nDimArray)) {
+            return nDimArray;
+        }
+        const nodeQueue = nDimArray.slice(0);
+        const resultingArray = [];
+        do {
+            nodeQueue.forEach((node) => {
+                if (Array.isArray(node)) {
+                    nodeQueue.push(...node);
+                }
+                else {
+                    resultingArray.push(node);
+                }
+                const nodeIndex = nodeQueue.indexOf(node);
+                nodeQueue.splice(nodeIndex, 1);
+            });
+        } while (nodeQueue.length);
+        return resultingArray;
+    }
+    processResponse(data) {
+        const moveStatus = {
+            succeeded: [],
+            failed: [],
+            partiallySucceeded: []
+        };
+        if (Array.isArray(data)) {
+            return data.reduce((acc, next) => {
+                if (next instanceof Error) {
+                    acc.failed.push(next);
+                }
+                else if (Array.isArray(next)) {
+                    // if content of a folder was moved
+                    const folderMoveResponseData = this.flatten(next);
+                    const foundError = folderMoveResponseData.find((node) => node instanceof Error);
+                    // data might contain also items of form: { itemMoved, initialParentId }
+                    const foundEntry = folderMoveResponseData.find((node) => (node.itemMoved && node.itemMoved.entry) || (node && node.entry));
+                    if (!foundError) {
+                        // consider success if NONE of the items from the folder move response is an error
+                        acc.succeeded.push(next);
+                    }
+                    else if (!foundEntry) {
+                        // consider failed if NONE of the items has an entry
+                        acc.failed.push(next);
+                    }
+                    else {
+                        // partially move folder
+                        acc.partiallySucceeded.push(next);
+                    }
+                }
+                else {
+                    acc.succeeded.push(next);
+                }
+                return acc;
+            }, moveStatus);
+        }
+        else {
+            if ((data.itemMoved && data.itemMoved.entry) || (data && data.entry)) {
+                moveStatus.succeeded.push(data);
+            }
+            else {
+                moveStatus.failed.push(data);
+            }
+            return moveStatus;
+        }
+    }
+    focusAfterClose(focusedElementSelector) {
+        if (focusedElementSelector) {
+            document.querySelector(focusedElementSelector)?.focus();
+        }
+    }
+}
+NodeActionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: NodeActionsService, deps: [{ token: i1.ContentService }, { token: i2.ContentApiService }, { token: i3.MatDialog }, { token: i1.DocumentListService }, { token: i4.AlfrescoApiService }, { token: i4.TranslationService }, { token: i4.ThumbnailService }], target: i0.ɵɵFactoryTarget.Injectable });
+NodeActionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: NodeActionsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: NodeActionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ContentService }, { type: i2.ContentApiService }, { type: i3.MatDialog }, { type: i1.DocumentListService }, { type: i4.AlfrescoApiService }, { type: i4.TranslationService }, { type: i4.ThumbnailService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-actions.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-content/src/lib/services/node-actions.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Injectable } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { Observable, Subject, of, zip, from } from 'rxjs';\nimport { AlfrescoApiService, DataColumn, TranslationService, ThumbnailService } from '@alfresco/adf-core';\nimport {\n  DocumentListService,\n  ContentNodeSelectorComponent,\n  ContentNodeSelectorComponentData,\n  ContentNodeDialogService,\n  ShareDataRow,\n  NodeAction,\n  ContentService\n} from '@alfresco/adf-content-services';\nimport {\n  MinimalNodeEntity,\n  MinimalNodeEntryEntity,\n  SitePaging,\n  NodeChildAssociationPaging,\n  NodeChildAssociationEntry,\n  NodesApi\n} from '@alfresco/js-api';\nimport { ContentApiService } from '@alfresco/aca-shared';\nimport { catchError, map, mergeMap } from 'rxjs/operators';\n\ntype BatchOperationType = Extract<NodeAction, NodeAction.COPY | NodeAction.MOVE>;\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class NodeActionsService {\n  contentCopied: Subject<MinimalNodeEntity[]> = new Subject<MinimalNodeEntity[]>();\n  contentMoved: Subject<any> = new Subject<any>();\n  moveDeletedEntries: any[] = [];\n  isSitesDestinationAvailable = false;\n\n  _nodesApi: NodesApi;\n  get nodesApi(): NodesApi {\n    this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());\n    return this._nodesApi;\n  }\n\n  constructor(\n    private contentService: ContentService,\n    private contentApi: ContentApiService,\n    private dialog: MatDialog,\n    private documentListService: DocumentListService,\n    private apiService: AlfrescoApiService,\n    private translation: TranslationService,\n    private thumbnailService: ThumbnailService\n  ) {}\n\n  /**\n   * Copy node list\n   *\n   * @param contentEntities nodes to copy\n   * @param permission permission which is needed to apply the action\n   * @param focusedElementOnCloseSelector element's selector which should be autofocused after closing modal\n   */\n  copyNodes(contentEntities: any[], permission?: string, focusedElementOnCloseSelector?: string): Subject<string> {\n    return this.doBatchOperation(NodeAction.COPY, contentEntities, permission, focusedElementOnCloseSelector);\n  }\n\n  /**\n   * Move node list\n   *\n   * @param contentEntities nodes to move\n   * @param permission permission which is needed to apply the action\n   * @param focusedElementOnCloseSelector element's selector which should be autofocused after closing modal\n   */\n  moveNodes(contentEntities: any[], permission?: string, focusedElementOnCloseSelector?: string): Subject<string> {\n    return this.doBatchOperation(NodeAction.MOVE, contentEntities, permission, focusedElementOnCloseSelector);\n  }\n\n  /**\n   * General method for performing the given operation (copy|move) to multiple nodes\n   *\n   * @param action the action to perform (copy|move)\n   * @param contentEntities the contentEntities which have to have the action performed on\n   * @param permission permission which is needed to apply the action\n   * @param focusedElementOnCloseSelector element's selector which should be autofocused after closing modal\n   */\n  doBatchOperation(action: BatchOperationType, contentEntities: any[], permission?: string, focusedElementOnCloseSelector?: string): Subject<string> {\n    const observable: Subject<string> = new Subject<string>();\n\n    if (!this.isEntryEntitiesArray(contentEntities)) {\n      observable.error(new Error(JSON.stringify({ error: { statusCode: 400 } })));\n    } else if (this.checkPermission(action, contentEntities, permission)) {\n      const destinationSelection = this.getContentNodeSelection(action, contentEntities, focusedElementOnCloseSelector);\n      destinationSelection.subscribe((selections: MinimalNodeEntryEntity[]) => {\n        const contentEntry = contentEntities[0].entry;\n        // Check if there's nodeId for Shared Files\n        const contentEntryId = contentEntry.nodeId || contentEntry.id;\n        const type = contentEntry.isFolder ? 'folder' : 'content';\n        const batch: any[] = [];\n\n        // consider only first item in the selection\n        const selection = selections[0];\n        let action$: Observable<any>;\n\n        if (action === NodeAction.MOVE && contentEntities.length === 1 && type === 'content') {\n          action$ = this.documentListService.moveNode(contentEntryId, selection.id);\n        } else {\n          contentEntities.forEach((node) => {\n            // batch.push(this.copyNodeAction(node.entry, selection.id));\n            batch.push(this[`${action.toLowerCase()}NodeAction`](node.entry, selection.id));\n          });\n          action$ = zip(...batch);\n        }\n\n        action$.subscribe((newContent) => {\n          observable.next(`OPERATION.SUCCESS.${type.toUpperCase()}.${action.toUpperCase()}`);\n\n          const processedData = this.processResponse(newContent);\n          if (action === NodeAction.COPY) {\n            this.contentCopied.next(processedData.succeeded);\n          } else if (action === NodeAction.MOVE) {\n            this.contentMoved.next(processedData);\n          }\n        }, observable.error.bind(observable));\n      });\n    } else {\n      observable.error(new Error(JSON.stringify({ error: { statusCode: 403 } })));\n    }\n\n    return observable;\n  }\n\n  isEntryEntitiesArray(contentEntities: any[]): boolean {\n    if (contentEntities && contentEntities.length) {\n      const nonEntryNode = contentEntities.find((node) => !node || !node.entry || !(node.entry.nodeId || node.entry.id));\n      return !nonEntryNode;\n    }\n    return false;\n  }\n\n  checkPermission(action: BatchOperationType, contentEntities: any[], permission?: string) {\n    const notAllowedNode = contentEntities.find((node) => !this.isActionAllowed(action, node.entry, permission));\n    return !notAllowedNode;\n  }\n\n  getEntryParentId(nodeEntry: MinimalNodeEntryEntity) {\n    let entryParentId = '';\n\n    if (nodeEntry.parentId) {\n      entryParentId = nodeEntry.parentId;\n    } else if (nodeEntry.path && nodeEntry.path.elements && nodeEntry.path.elements.length) {\n      entryParentId = nodeEntry.path.elements[nodeEntry.path.elements.length - 1].id;\n    }\n\n    return entryParentId;\n  }\n\n  getContentNodeSelection(\n    action: NodeAction,\n    contentEntities: MinimalNodeEntity[],\n    focusedElementOnCloseSelector?: string\n  ): Subject<MinimalNodeEntryEntity[]> {\n    const currentParentFolderId = this.getEntryParentId(contentEntities[0].entry);\n\n    const customDropdown = new SitePaging({\n      list: {\n        entries: [\n          {\n            entry: {\n              guid: '-my-',\n              title: this.translation.instant('APP.BROWSE.PERSONAL.SIDENAV_LINK.LABEL')\n            }\n          },\n          {\n            entry: {\n              guid: '-mysites-',\n              title: this.translation.instant('APP.BROWSE.LIBRARIES.MENU.MY_LIBRARIES.SIDENAV_LINK.LABEL')\n            }\n          }\n        ]\n      }\n    });\n\n    const title = this.getTitleTranslation(action, contentEntities);\n\n    this.isSitesDestinationAvailable = false;\n    const data: ContentNodeSelectorComponentData = {\n      selectionMode: 'single',\n      title,\n      currentFolderId: currentParentFolderId,\n      actionName: action,\n      dropdownHideMyFiles: true,\n      dropdownSiteList: customDropdown,\n      rowFilter: this.rowFilter.bind(this),\n      imageResolver: this.imageResolver.bind(this),\n      isSelectionValid: this.canCopyMoveInsideIt.bind(this),\n      breadcrumbTransform: this.customizeBreadcrumb.bind(this),\n      select: new Subject<MinimalNodeEntryEntity[]>(),\n      excludeSiteContent: ContentNodeDialogService.nonDocumentSiteContent\n    };\n\n    this.dialog\n      .open(ContentNodeSelectorComponent, {\n        data,\n        panelClass: 'adf-content-node-selector-dialog',\n        width: '630px',\n        role: 'dialog'\n      })\n      .afterClosed()\n      .subscribe(() => this.focusAfterClose(focusedElementOnCloseSelector));\n\n    data.select.subscribe({\n      complete: this.close.bind(this)\n    });\n\n    return data.select;\n  }\n\n  getTitleTranslation(action: string, nodes: MinimalNodeEntity[] = []): string {\n    let keyPrefix = 'ITEMS';\n    let name = '';\n\n    if (nodes.length === 1 && nodes[0].entry.name) {\n      name = nodes[0].entry.name;\n      keyPrefix = 'ITEM';\n    }\n\n    const number = nodes.length;\n    return this.translation.instant(`NODE_SELECTOR.${action.toUpperCase()}_${keyPrefix}`, { name, number });\n  }\n\n  private canCopyMoveInsideIt(entry: MinimalNodeEntryEntity): boolean {\n    return this.hasEntityCreatePermission(entry) && !this.isSite(entry);\n  }\n\n  private hasEntityCreatePermission(entry: MinimalNodeEntryEntity): boolean {\n    return this.contentService.hasAllowableOperations(entry, 'create');\n  }\n\n  private isSite(entry) {\n    return !!entry.guid || entry.nodeType === 'st:site' || entry.nodeType === 'st:sites';\n  }\n\n  close() {\n    this.dialog.closeAll();\n  }\n\n  // todo: review this approach once 5.2.3 is out\n  private customizeBreadcrumb(node: MinimalNodeEntryEntity) {\n    if (node && node.path && node.path.elements) {\n      const elements = node.path.elements;\n\n      if (elements.length > 1) {\n        if (elements[1].name === 'User Homes') {\n          elements.splice(0, 2);\n\n          // make sure first item is 'Personal Files'\n          if (elements[0]) {\n            elements[0].name = this.translation.instant('APP.BROWSE.PERSONAL.TITLE');\n            elements[0].id = '-my-';\n          } else {\n            node.name = this.translation.instant('APP.BROWSE.PERSONAL.TITLE');\n          }\n        } else if (elements[1].name === 'Sites') {\n          this.normalizeSitePath(node);\n        }\n      } else if (elements.length === 1) {\n        if (node.name === 'Sites') {\n          node.name = this.translation.instant('APP.BROWSE.LIBRARIES.MENU.MY_LIBRARIES.TITLE');\n          elements.splice(0, 1);\n        }\n      }\n    } else if (node === null && this.isSitesDestinationAvailable) {\n      node = {\n        name: this.translation.instant('APP.BROWSE.LIBRARIES.MENU.MY_LIBRARIES.TITLE'),\n        path: { elements: [] }\n      } as any;\n    }\n\n    return node;\n  }\n\n  // todo: review this approach once 5.2.3 is out\n  private normalizeSitePath(node: MinimalNodeEntryEntity) {\n    const elements = node.path.elements;\n\n    // remove 'Company Home'\n    elements.splice(0, 1);\n\n    // replace first item with 'File Libraries'\n    elements[0].name = this.translation.instant('APP.BROWSE.LIBRARIES.MENU.MY_LIBRARIES.TITLE');\n    elements[0].id = '-mysites-';\n\n    if (this.isSiteContainer(node)) {\n      // rename 'documentLibrary' entry to the target site display name\n      // clicking on the breadcrumb entry loads the site content\n      node.name = elements[1].name;\n\n      // remove the site entry\n      elements.splice(1, 1);\n    } else {\n      // remove 'documentLibrary' in the middle of the path\n      const docLib = elements.findIndex((el) => el.name === 'documentLibrary');\n      if (docLib > -1) {\n        elements.splice(docLib, 1);\n      }\n    }\n  }\n\n  isSiteContainer(node: MinimalNodeEntryEntity): boolean {\n    if (node && node.aspectNames && node.aspectNames.length > 0) {\n      return node.aspectNames.indexOf('st:siteContainer') >= 0;\n    }\n    return false;\n  }\n\n  copyNodeAction(nodeEntry: any, selectionId: string): Observable<any> {\n    if (nodeEntry.isFolder) {\n      return this.copyFolderAction(nodeEntry, selectionId);\n    } else {\n      // any other type is treated as 'content'\n      return this.copyContentAction(nodeEntry, selectionId);\n    }\n  }\n\n  copyContentAction(contentEntry: any, selectionId: string, oldName?: string): Observable<any> {\n    const _oldName = oldName || contentEntry.name;\n    // Check if there's nodeId for Shared Files\n    const contentEntryId = contentEntry.nodeId || contentEntry.id;\n\n    // use local method until new name parameter is added on ADF copyNode\n    return this.copyNode(contentEntryId, selectionId, _oldName).pipe(\n      catchError((err) => {\n        let errStatusCode;\n        try {\n          const {\n            error: { statusCode }\n          } = JSON.parse(err.message);\n          errStatusCode = statusCode;\n        } catch (e) {\n          //\n        }\n\n        if (errStatusCode && errStatusCode === 409) {\n          return this.copyContentAction(contentEntry, selectionId, this.getNewNameFrom(_oldName, contentEntry.name));\n        } else {\n          // do not throw error, to be able to show message in case of partial copy of files\n          return of(err || 'Server error');\n        }\n      })\n    );\n  }\n\n  copyFolderAction(contentEntry: any, selectionId: string): Observable<any> {\n    // Check if there's nodeId for Shared Files\n    const contentEntryId = contentEntry.nodeId || contentEntry.id;\n    let $destinationFolder: Observable<any>;\n    let $childrenToCopy: Observable<any>;\n    let newDestinationFolder;\n\n    return this.copyNode(contentEntryId, selectionId, contentEntry.name).pipe(\n      catchError((err) => {\n        let errStatusCode;\n        try {\n          const {\n            error: { statusCode }\n          } = JSON.parse(err.message);\n          errStatusCode = statusCode;\n        } catch {}\n\n        if (errStatusCode && errStatusCode === 409) {\n          $destinationFolder = this.getChildByName(selectionId, contentEntry.name);\n          $childrenToCopy = this.getNodeChildren(contentEntryId);\n\n          return $destinationFolder.pipe(\n            mergeMap((destination) => {\n              newDestinationFolder = destination;\n              return $childrenToCopy;\n            }),\n            mergeMap((nodesToCopy) => {\n              const batch = [];\n              nodesToCopy.list.entries.forEach((node) => {\n                if (node.entry.isFolder) {\n                  batch.push(this.copyFolderAction(node.entry, newDestinationFolder.entry.id));\n                } else {\n                  batch.push(this.copyContentAction(node.entry, newDestinationFolder.entry.id));\n                }\n              });\n\n              if (!batch.length) {\n                return of({});\n              }\n              return zip(...batch);\n            })\n          );\n        } else {\n          // do not throw error, to be able to show message in case of partial copy of files\n          return of(err || 'Server error');\n        }\n      })\n    );\n  }\n\n  moveNodeAction(nodeEntry, selectionId: string): Observable<any> {\n    this.moveDeletedEntries = [];\n\n    if (nodeEntry.isFolder) {\n      const initialParentId = nodeEntry.parentId;\n\n      return this.moveFolderAction(nodeEntry, selectionId).pipe(\n        mergeMap((newContent) => {\n          // take no extra action, if folder is moved to the same location\n          if (initialParentId === selectionId) {\n            return of(newContent);\n          }\n\n          const flattenResponse = this.flatten(newContent);\n          const processedData = this.processResponse(flattenResponse);\n\n          // else, check if moving this nodeEntry succeeded for ALL of its nodes\n          if (processedData.failed.length === 0) {\n            // check if folder still exists on location\n            return this.getChildByName(initialParentId, nodeEntry.name).pipe(\n              mergeMap((folderOnInitialLocation) => {\n                if (folderOnInitialLocation) {\n                  // Check if there's nodeId for Shared Files\n                  const nodeEntryId = nodeEntry.nodeId || nodeEntry.id;\n                  // delete it from location\n                  return this.contentApi.deleteNode(nodeEntryId).pipe(\n                    mergeMap(() => {\n                      this.moveDeletedEntries.push(nodeEntry);\n                      return of(newContent);\n                    })\n                  );\n                }\n                return of(newContent);\n              })\n            );\n          }\n          return of(newContent);\n        })\n      );\n    } else {\n      // any other type is treated as 'content'\n      return this.moveContentAction(nodeEntry, selectionId);\n    }\n  }\n\n  moveFolderAction(contentEntry, selectionId: string): Observable<any> {\n    // Check if there's nodeId for Shared Files\n    const contentEntryId = contentEntry.nodeId || contentEntry.id;\n    const initialParentId = this.getEntryParentId(contentEntry);\n    let $destinationFolder: Observable<any>;\n    let $childrenToMove: Observable<any>;\n    let newDestinationFolder;\n\n    return this.documentListService.moveNode(contentEntryId, selectionId).pipe(\n      map((itemMoved) => ({ itemMoved, initialParentId })),\n      catchError((err) => {\n        let errStatusCode;\n        try {\n          const {\n            error: { statusCode }\n          } = JSON.parse(err.message);\n          errStatusCode = statusCode;\n        } catch (e) {\n          //\n        }\n\n        if (errStatusCode && errStatusCode === 409) {\n          $destinationFolder = this.getChildByName(selectionId, contentEntry.name);\n          $childrenToMove = this.getNodeChildren(contentEntryId);\n\n          return $destinationFolder.pipe(\n            mergeMap((destination) => {\n              newDestinationFolder = destination;\n              return $childrenToMove;\n            }),\n            mergeMap((childrenToMove) => {\n              const batch: any[] = [];\n              childrenToMove.list.entries.forEach((node) => {\n                if (node.entry.isFolder) {\n                  batch.push(this.moveFolderAction(node.entry, newDestinationFolder.entry.id));\n                } else {\n                  batch.push(this.moveContentAction(node.entry, newDestinationFolder.entry.id));\n                }\n              });\n\n              if (!batch.length) {\n                return of(batch);\n              }\n              return zip(...batch);\n            })\n          );\n        } else {\n          // do not throw error, to be able to show message in case of partial move of files\n          return of(err);\n        }\n      })\n    );\n  }\n\n  moveContentAction(contentEntry: any, selectionId: string) {\n    // Check if there's nodeId for Shared Files\n    const contentEntryId = contentEntry.nodeId || contentEntry.id;\n    const initialParentId = this.getEntryParentId(contentEntry);\n\n    return this.documentListService.moveNode(contentEntryId, selectionId).pipe(\n      map((itemMoved) => ({ itemMoved, initialParentId })),\n      catchError((err) =>\n        // do not throw error, to be able to show message in case of partial move of files\n        of(err)\n      )\n    );\n  }\n\n  getChildByName(parentId: string, name: string): Subject<NodeChildAssociationEntry> {\n    const matchedNodes = new Subject<any>();\n\n    this.getNodeChildren(parentId).subscribe(\n      (childrenNodes: NodeChildAssociationPaging) => {\n        const result = childrenNodes.list.entries.find((node) => node.entry.name === name);\n\n        if (result) {\n          matchedNodes.next(result);\n        } else {\n          matchedNodes.next(null);\n        }\n      },\n      (err) => matchedNodes.error(err)\n    );\n    return matchedNodes;\n  }\n\n  private isActionAllowed(action: BatchOperationType, node: MinimalNodeEntryEntity, permission?: string): boolean {\n    if (action === NodeAction.COPY) {\n      return true;\n    }\n    return this.contentService.hasAllowableOperations(node, permission);\n  }\n\n  private rowFilter(row: ShareDataRow): boolean {\n    const node: MinimalNodeEntryEntity = row.node.entry;\n\n    this.isSitesDestinationAvailable = !!node['guid'];\n    return !node.isFile && node.nodeType !== 'app:folderlink';\n  }\n\n  private imageResolver(row: ShareDataRow, _: DataColumn): string | null {\n    const entry: MinimalNodeEntryEntity = row.node.entry;\n    if (!this.contentService.hasAllowableOperations(entry, 'update')) {\n      return this.thumbnailService.getMimeTypeIcon('disable/folder');\n    }\n\n    return null;\n  }\n\n  public getNewNameFrom(name: string, baseName?: string) {\n    const extensionMatch = name.match(/\\.[^/.]+$/);\n\n    // remove extension in case there is one\n    const fileExtension = extensionMatch ? extensionMatch[0] : '';\n    let extensionFree = extensionMatch ? name.slice(0, extensionMatch.index) : name;\n\n    let prefixNumber = 1;\n    let baseExtensionFree;\n\n    if (baseName) {\n      const baseExtensionMatch = baseName.match(/\\.[^/.]+$/);\n\n      // remove extension in case there is one\n      baseExtensionFree = baseExtensionMatch ? baseName.slice(0, baseExtensionMatch.index) : baseName;\n    }\n\n    if (!baseExtensionFree || baseExtensionFree !== extensionFree) {\n      // check if name already has integer appended on end:\n      const oldPrefix = extensionFree.match('-[0-9]+$');\n      if (oldPrefix) {\n        // if so, try to get the number at the end\n        const oldPrefixNumber = parseInt(oldPrefix[0].slice(1), 10);\n        if (oldPrefixNumber.toString() === oldPrefix[0].slice(1)) {\n          extensionFree = extensionFree.slice(0, oldPrefix.index);\n          prefixNumber = oldPrefixNumber + 1;\n        }\n      }\n    }\n    return extensionFree + '-' + prefixNumber + fileExtension;\n  }\n\n  /**\n   * Get children nodes of given parent node\n   *\n   * @param nodeId The id of the parent node\n   * @param params optional parameters\n   */\n  getNodeChildren(nodeId: string, params?: any): Observable<NodeChildAssociationPaging> {\n    return from(this.nodesApi.listNodeChildren(nodeId, params));\n  }\n\n  // Copied from ADF document-list.service, and added the name parameter\n  /**\n   * Copy a node to destination node\n   *\n   * @param nodeId The id of the node to be copied\n   * @param targetParentId The id of the folder-node where the node have to be copied to\n   * @param name The new name for the copy that would be added on the destination folder\n   */\n  copyNode(nodeId: string, targetParentId: string, name?: string) {\n    return from(this.nodesApi.copyNode(nodeId, { targetParentId, name }));\n  }\n\n  public flatten(nDimArray: any[]) {\n    if (!Array.isArray(nDimArray)) {\n      return nDimArray;\n    }\n\n    const nodeQueue = nDimArray.slice(0);\n    const resultingArray: any[] = [];\n\n    do {\n      nodeQueue.forEach((node) => {\n        if (Array.isArray(node)) {\n          nodeQueue.push(...node);\n        } else {\n          resultingArray.push(node);\n        }\n\n        const nodeIndex = nodeQueue.indexOf(node);\n        nodeQueue.splice(nodeIndex, 1);\n      });\n    } while (nodeQueue.length);\n\n    return resultingArray;\n  }\n\n  processResponse(data: any): any {\n    const moveStatus = {\n      succeeded: [],\n      failed: [],\n      partiallySucceeded: []\n    };\n\n    if (Array.isArray(data)) {\n      return data.reduce((acc, next) => {\n        if (next instanceof Error) {\n          acc.failed.push(next);\n        } else if (Array.isArray(next)) {\n          // if content of a folder was moved\n\n          const folderMoveResponseData = this.flatten(next);\n          const foundError = folderMoveResponseData.find((node) => node instanceof Error);\n          // data might contain also items of form: { itemMoved, initialParentId }\n          const foundEntry = folderMoveResponseData.find((node) => (node.itemMoved && node.itemMoved.entry) || (node && node.entry));\n\n          if (!foundError) {\n            // consider success if NONE of the items from the folder move response is an error\n            acc.succeeded.push(next);\n          } else if (!foundEntry) {\n            // consider failed if NONE of the items has an entry\n            acc.failed.push(next);\n          } else {\n            // partially move folder\n            acc.partiallySucceeded.push(next);\n          }\n        } else {\n          acc.succeeded.push(next);\n        }\n\n        return acc;\n      }, moveStatus);\n    } else {\n      if ((data.itemMoved && data.itemMoved.entry) || (data && data.entry)) {\n        moveStatus.succeeded.push(data);\n      } else {\n        moveStatus.failed.push(data);\n      }\n\n      return moveStatus;\n    }\n  }\n\n  private focusAfterClose(focusedElementSelector: string): void {\n    if (focusedElementSelector) {\n      document.querySelector<HTMLElement>(focusedElementSelector)?.focus();\n    }\n  }\n}\n"]}