Merge branch '20029-collection-batch-file-operations' into main. Closes #20029 and...

[arvados-workbench2.git] / src / services / collection-service / collection-service.ts

diff --git a/src/services/collection-service/collection-service.ts b/src/services/collection-service/collection-service.ts
index 1a03d8da3a1f536108b3707239714ec1eea73785..74cf75956f7cec87a36abb8f0fdcaee5b7e0883e 100644 (file)
--- a/src/services/collection-service/collection-service.ts
+++ b/src/services/collection-service/collection-service.ts
@@ -10,11 +10,13 @@ import { AuthService } from "../auth-service/auth-service";
 import { extractFilesData } from "./collection-service-files-response";
 import { TrashableResourceService } from "services/common-service/trashable-resource-service";
 import { ApiActions } from "services/api/api-actions";
-import { customEncodeURI } from "common/url";
 import { Session } from "models/session";
+import { CommonService } from "services/common-service/common-service";
 
 export type UploadProgress = (fileId: number, loaded: number, total: number, currentTime: number) => void;
 
+export const emptyCollectionPdh = 'd41d8cd98f00b204e9800998ecf8427e+0';
+
 export class CollectionService extends TrashableResourceService<CollectionResource> {
     constructor(serverApi: AxiosInstance, private webdavClient: WebDAV, private authService: AuthService, actions: ApiActions) {
         super(serverApi, "collections", actions, [
@@ -52,27 +54,34 @@ export class CollectionService extends TrashableResourceService<CollectionResour
         return Promise.reject();
     }
 
-    async deleteFiles(collectionUuid: string, filePaths: string[]) {
-        const sortedUniquePaths = Array.from(new Set(filePaths))
-            .sort((a, b) => a.length - b.length)
-            .reduce((acc, currentPath) => {
-                const parentPathFound = acc.find((parentPath) => currentPath.indexOf(`${parentPath}/`) > -1);
-
-                if (!parentPathFound) {
-                    return [...acc, currentPath];
-                }
-
-                return acc;
-            }, []);
-
-        for (const path of sortedUniquePaths) {
-            if (path.indexOf(collectionUuid) === -1) {
-                await this.webdavClient.delete(`c=${collectionUuid}${path}`);
+    private combineFilePath(parts: string[]) {
+        return parts.reduce((path, part) => {
+            // Trim leading and trailing slashes
+            const trimmedPart = part.split('/').filter(Boolean).join('/');
+            if (trimmedPart.length) {
+                const separator = path.endsWith('/') ? '' : '/';
+                return `${path}${separator}${trimmedPart}`;
             } else {
-                await this.webdavClient.delete(`c=${path}`);
+                return path;
             }
-        }
-        await this.update(collectionUuid, { preserveVersion: true });
+        }, "/");
+    }
+
+    private replaceFiles(collectionUuid: string, fileMap: {}, showErrors?: boolean) {
+        const payload = {
+            collection: {
+                preserve_version: true
+            },
+            replace_files: fileMap
+        };
+
+        return CommonService.defaultResponse(
+            this.serverApi
+                .put<CollectionResource>(`/${this.resourceType}/${collectionUuid}`, payload),
+            this.actions,
+            true, // mapKeys
+            showErrors
+        );
     }
 
     async uploadFiles(collectionUuid: string, files: File[], onProgress?: UploadProgress, targetLocation: string = '') {
@@ -84,12 +93,11 @@ export class CollectionService extends TrashableResourceService<CollectionResour
         await this.update(collectionUuid, { preserveVersion: true });
     }
 
-    async moveFile(collectionUuid: string, oldPath: string, newPath: string) {
-        await this.webdavClient.move(
-            `c=${collectionUuid}${oldPath}`,
-            `c=${collectionUuid}/${customEncodeURI(newPath)}`
-        );
-        await this.update(collectionUuid, { preserveVersion: true });
+    async renameFile(collectionUuid: string, collectionPdh: string, oldPath: string, newPath: string) {
+        return this.replaceFiles(collectionUuid, {
+            [this.combineFilePath([newPath])]: `${collectionPdh}${this.combineFilePath([oldPath])}`,
+            [this.combineFilePath([oldPath])]: '',
+        });
     }
 
     extendFileURL = (file: CollectionDirectory | CollectionFile) => {
@@ -123,4 +131,66 @@ export class CollectionService extends TrashableResourceService<CollectionResour
         };
         return this.webdavClient.upload(fileURL, [file], requestConfig);
     }
+
+    deleteFiles(collectionUuid: string, files: string[], showErrors?: boolean) {
+        const optimizedFiles = files
+            .sort((a, b) => a.length - b.length)
+            .reduce((acc, currentPath) => {
+                const parentPathFound = acc.find((parentPath) => currentPath.indexOf(`${parentPath}/`) > -1);
+
+                if (!parentPathFound) {
+                    return [...acc, currentPath];
+                }
+
+                return acc;
+            }, []);
+
+        const fileMap = optimizedFiles.reduce((obj, filePath) => {
+            return {
+                ...obj,
+                [this.combineFilePath([filePath])]: ''
+            }
+        }, {})
+
+        return this.replaceFiles(collectionUuid, fileMap, showErrors);
+    }
+
+    copyFiles(sourcePdh: string, files: string[], destinationCollectionUuid: string, destinationPath: string, showErrors?: boolean) {
+        const fileMap = files.reduce((obj, sourceFile) => {
+            const sourceFileName = sourceFile.split('/').filter(Boolean).slice(-1).join("");
+            return {
+                ...obj,
+                [this.combineFilePath([destinationPath, sourceFileName])]: `${sourcePdh}${this.combineFilePath([sourceFile])}`
+            };
+        }, {});
+
+        return this.replaceFiles(destinationCollectionUuid, fileMap, showErrors);
+    }
+
+    moveFiles(sourceUuid: string, sourcePdh: string, files: string[], destinationCollectionUuid: string, destinationPath: string, showErrors?: boolean) {
+        if (sourceUuid === destinationCollectionUuid) {
+            const fileMap = files.reduce((obj, sourceFile) => {
+                const sourceFileName = sourceFile.split('/').filter(Boolean).slice(-1).join("");
+                return {
+                    ...obj,
+                    [this.combineFilePath([destinationPath, sourceFileName])]: `${sourcePdh}${this.combineFilePath([sourceFile])}`,
+                    [this.combineFilePath([sourceFile])]: '',
+                };
+            }, {});
+
+            return this.replaceFiles(sourceUuid, fileMap, showErrors)
+        } else {
+            return this.copyFiles(sourcePdh, files, destinationCollectionUuid, destinationPath, showErrors)
+                .then(() => {
+                    return this.deleteFiles(sourceUuid, files, showErrors);
+                });
+        }
+    }
+
+    createDirectory(collectionUuid: string, path: string, showErrors?: boolean) {
+        const fileMap = {[this.combineFilePath([path])]: emptyCollectionPdh};
+
+        return this.replaceFiles(collectionUuid, fileMap, showErrors);
+    }
+
 }