[AAE-11496] Move 'content-plugin' to projects folder as 'aca-content' (#2817)

* [AAE-11496] Move content-plugin to projects

* Fix unit test

projects/aca-content/src/lib/services/node-actions.service.ts

@@ -0,0 +1,706 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { Observable, Subject, of, zip, from } from 'rxjs';
+import { AlfrescoApiService, ContentService, DataColumn, TranslationService, ThumbnailService } from '@alfresco/adf-core';
+import {
+  DocumentListService,
+  ContentNodeSelectorComponent,
+  ContentNodeSelectorComponentData,
+  ContentNodeDialogService,
+  ShareDataRow,
+  NodeAction
+} from '@alfresco/adf-content-services';
+import {
+  MinimalNodeEntity,
+  MinimalNodeEntryEntity,
+  SitePaging,
+  NodeChildAssociationPaging,
+  NodeChildAssociationEntry,
+  NodesApi
+} from '@alfresco/js-api';
+import { ContentApiService } from '@alfresco/aca-shared';
+import { catchError, map, mergeMap } from 'rxjs/operators';
+
+type BatchOperationType = Extract<NodeAction, NodeAction.COPY | NodeAction.MOVE>;
+
+@Injectable({
+  providedIn: 'root'
+})
+export class NodeActionsService {
+  contentCopied: Subject<MinimalNodeEntity[]> = new Subject<MinimalNodeEntity[]>();
+  contentMoved: Subject<any> = new Subject<any>();
+  moveDeletedEntries: any[] = [];
+  isSitesDestinationAvailable = false;
+
+  _nodesApi: NodesApi;
+  get nodesApi(): NodesApi {
+    this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());
+    return this._nodesApi;
+  }
+
+  constructor(
+    private contentService: ContentService,
+    private contentApi: ContentApiService,
+    private dialog: MatDialog,
+    private documentListService: DocumentListService,
+    private apiService: AlfrescoApiService,
+    private translation: TranslationService,
+    private thumbnailService: ThumbnailService
+  ) {}
+
+  /**
+   * 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: any[], permission?: string, focusedElementOnCloseSelector?: string): Subject<string> {
+    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: any[], permission?: string, focusedElementOnCloseSelector?: string): Subject<string> {
+    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: BatchOperationType, contentEntities: any[], permission?: string, focusedElementOnCloseSelector?: string): Subject<string> {
+    const observable: Subject<string> = new Subject<string>();
+
+    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: MinimalNodeEntryEntity[]) => {
+        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: any[] = [];
+
+        // consider only first item in the selection
+        const selection = selections[0];
+        let action$: Observable<any>;
+
+        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: any[]): boolean {
+    if (contentEntities && contentEntities.length) {
+      const nonEntryNode = contentEntities.find((node) => !node || !node.entry || !(node.entry.nodeId || node.entry.id));
+      return !nonEntryNode;
+    }
+    return false;
+  }
+
+  checkPermission(action: BatchOperationType, contentEntities: any[], permission?: string) {
+    const notAllowedNode = contentEntities.find((node) => !this.isActionAllowed(action, node.entry, permission));
+    return !notAllowedNode;
+  }
+
+  getEntryParentId(nodeEntry: MinimalNodeEntryEntity) {
+    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: NodeAction,
+    contentEntities: MinimalNodeEntity[],
+    focusedElementOnCloseSelector?: string
+  ): Subject<MinimalNodeEntryEntity[]> {
+    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: ContentNodeSelectorComponentData = {
+      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<MinimalNodeEntryEntity[]>(),
+      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: string, nodes: MinimalNodeEntity[] = []): string {
+    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 });
+  }
+
+  private canCopyMoveInsideIt(entry: MinimalNodeEntryEntity): boolean {
+    return this.hasEntityCreatePermission(entry) && !this.isSite(entry);
+  }
+
+  private hasEntityCreatePermission(entry: MinimalNodeEntryEntity): boolean {
+    return this.contentService.hasAllowableOperations(entry, 'create');
+  }
+
+  private 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
+  private customizeBreadcrumb(node: MinimalNodeEntryEntity) {
+    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: [] }
+      } as any;
+    }
+
+    return node;
+  }
+
+  // todo: review this approach once 5.2.3 is out
+  private normalizeSitePath(node: MinimalNodeEntryEntity) {
+    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: MinimalNodeEntryEntity): boolean {
+    if (node && node.aspectNames && node.aspectNames.length > 0) {
+      return node.aspectNames.indexOf('st:siteContainer') >= 0;
+    }
+    return false;
+  }
+
+  copyNodeAction(nodeEntry: any, selectionId: string): Observable<any> {
+    if (nodeEntry.isFolder) {
+      return this.copyFolderAction(nodeEntry, selectionId);
+    } else {
+      // any other type is treated as 'content'
+      return this.copyContentAction(nodeEntry, selectionId);
+    }
+  }
+
+  copyContentAction(contentEntry: any, selectionId: string, oldName?: string): Observable<any> {
+    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: any, selectionId: string): Observable<any> {
+    // Check if there's nodeId for Shared Files
+    const contentEntryId = contentEntry.nodeId || contentEntry.id;
+    let $destinationFolder: Observable<any>;
+    let $childrenToCopy: Observable<any>;
+    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: string): Observable<any> {
+    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: string): Observable<any> {
+    // Check if there's nodeId for Shared Files
+    const contentEntryId = contentEntry.nodeId || contentEntry.id;
+    const initialParentId = this.getEntryParentId(contentEntry);
+    let $destinationFolder: Observable<any>;
+    let $childrenToMove: Observable<any>;
+    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: any[] = [];
+              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: any, selectionId: string) {
+    // 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: string, name: string): Subject<NodeChildAssociationEntry> {
+    const matchedNodes = new Subject<any>();
+
+    this.getNodeChildren(parentId).subscribe(
+      (childrenNodes: NodeChildAssociationPaging) => {
+        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;
+  }
+
+  private isActionAllowed(action: BatchOperationType, node: MinimalNodeEntryEntity, permission?: string): boolean {
+    if (action === NodeAction.COPY) {
+      return true;
+    }
+    return this.contentService.hasAllowableOperations(node, permission);
+  }
+
+  private rowFilter(row: ShareDataRow): boolean {
+    const node: MinimalNodeEntryEntity = row.node.entry;
+
+    this.isSitesDestinationAvailable = !!node['guid'];
+    return !node.isFile && node.nodeType !== 'app:folderlink';
+  }
+
+  private imageResolver(row: ShareDataRow, _: DataColumn): string | null {
+    const entry: MinimalNodeEntryEntity = row.node.entry;
+    if (!this.contentService.hasAllowableOperations(entry, 'update')) {
+      return this.thumbnailService.getMimeTypeIcon('disable/folder');
+    }
+
+    return null;
+  }
+
+  public getNewNameFrom(name: string, baseName?: string) {
+    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: string, params?: any): Observable<NodeChildAssociationPaging> {
+    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: string, targetParentId: string, name?: string) {
+    return from(this.nodesApi.copyNode(nodeId, { targetParentId, name }));
+  }
+
+  public flatten(nDimArray: any[]) {
+    if (!Array.isArray(nDimArray)) {
+      return nDimArray;
+    }
+
+    const nodeQueue = nDimArray.slice(0);
+    const resultingArray: any[] = [];
+
+    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: any): any {
+    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;
+    }
+  }
+
+  private focusAfterClose(focusedElementSelector: string): void {
+    if (focusedElementSelector) {
+      document.querySelector<HTMLElement>(focusedElementSelector).focus();
+    }
+  }
+}