add rename functionaltity in backend and frontend content manager

Author: DenisaCG

jupyter_drives/manager.py

@@ -309,14 +309,36 @@ async def save_file(self, drive_name, path, content):
             }
         return response
 
-    async def rename_file(self, drive_name, path, **kwargs):
+    async def rename_file(self, drive_name, path, new_path):
         """Rename a file.
         
         Args:
             drive_name: name of drive where file is located
             path: path of file
         """
-        print('Rename file function called.')
+        data = {}
+        try: 
+            # eliminate leading and trailing backslashes
+            path = path.strip('/')
+            
+            await obs.rename_async(self._content_managers[drive_name], path, new_path)
+            metadata = await obs.head_async(self._content_managers[drive_name], new_path)
+
+            data = {
+                "path": new_path,
+                "last_modified": metadata["last_modified"].isoformat(),
+                "size": metadata["size"]
+            }
+        except Exception as e:
+            raise tornado.web.HTTPError(
+            status_code= httpx.codes.BAD_REQUEST,
+            reason=f"The following error occured when renaming the object: {e}",
+            )
+        
+        response = {
+                "data": data
+            }
+        return response
 
     async def delete_file(self, drive_name, path):
         """Delete an object.

src/contents.ts

@@ -9,8 +9,10 @@ import {
   getContents,
   mountDrive,
   createObject,
+  checkObject,
   deleteObjects,
-  countObjectNameAppearances
+  countObjectNameAppearances,
+  renameObjects
 } from './requests';
 
 let data: Contents.IModel = {
@@ -441,25 +443,51 @@ export class Drive implements Contents.IDrive {
     newLocalPath: string,
     options: Contents.ICreateOptions = {}
   ): Promise<Contents.IModel> {
-    /*const settings = this.serverSettings;
-    const url = this._getUrl(oldLocalPath);
-    const init = {
-      method: 'PATCH',
-      body: JSON.stringify({ path: newLocalPath })
-    };
-    const response = await ServerConnection.makeRequest(url, init, settings);
-    if (response.status !== 200) {
-      const err = await ServerConnection.ResponseError.create(response);
-      throw err;
+    // extract current drive name
+    const currentDrive = this._drivesList.filter(
+      x =>
+        x.name ===
+        (oldLocalPath.indexOf('/') !== -1
+          ? oldLocalPath.substring(0, oldLocalPath.indexOf('/'))
+          : oldLocalPath)
+    )[0];
+
+    // eliminate drive name from path
+    const relativePath =
+      oldLocalPath.indexOf('/') !== -1
+        ? oldLocalPath.substring(oldLocalPath.indexOf('/') + 1)
+        : '';
+    const newRelativePath =
+      newLocalPath.indexOf('/') !== -1
+        ? newLocalPath.substring(newLocalPath.indexOf('/') + 1)
+        : '';
+
+    // extract new file name
+    let newFileName = PathExt.basename(newLocalPath);
+
+    try {
+      // check if object with chosen name already exists
+      await checkObject(currentDrive.name, {
+        path: newLocalPath
+      });
+      newFileName = await this.incrementName(newLocalPath, this._name);
+    } catch (error) {
+      // HEAD request failed for this file name, continue, as name doesn't already exist.
+    } finally {
+      data = await renameObjects(currentDrive.name, {
+        path: relativePath,
+        newPath: newRelativePath,
+        newFileName: newFileName,
+        registeredFileTypes: this._registeredFileTypes
+      });
     }
-    const data = await response.json();*/
 
+    Contents.validateContentsModel(data);
     this._fileChanged.emit({
       type: 'rename',
       oldValue: { path: oldLocalPath },
-      newValue: { path: newLocalPath }
+      newValue: data
     });
-    Contents.validateContentsModel(data);
     return data;
   }
 

src/requests.ts

@@ -264,6 +264,77 @@ export async function deleteObjects(
   return Private.deleteSingleObject(driveName, options.path);
 }
 
+/**
+ * Rename an object.
+ *
+ * @param driveName
+ * @param options.path The path of object.
+ *
+ * @returns A promise which resolves with the contents model.
+ */
+export async function renameObjects(
+  driveName: string,
+  options: {
+    path: string;
+    newPath: string;
+    newFileName: string;
+    registeredFileTypes: IRegisteredFileTypes;
+  }
+) {
+  const formattedNewPath =
+    options.newPath.substring(0, options.newPath.lastIndexOf('/') + 1) +
+    options.newFileName;
+
+  const [fileType, fileMimeType, fileFormat] = getFileType(
+    PathExt.extname(PathExt.basename(options.newFileName)),
+    options.registeredFileTypes
+  );
+
+  // get list of contents with given prefix (path)
+  const response = await requestAPI<any>(
+    'drives/' + driveName + '/' + options.path,
+    'GET'
+  );
+
+  // renaming contents of a directory
+  if (response.data.length !== undefined && response.data.length !== 0) {
+    await Promise.all(
+      response.data.map(async (c: any) => {
+        const remainingFilePath = c.path.substring(options.path.length);
+        Private.renameSingleObject(
+          driveName,
+          PathExt.join(options.path, remainingFilePath),
+          PathExt.join(formattedNewPath, remainingFilePath)
+        );
+      })
+    );
+  }
+  // always rename the object (file or main directory)
+  try {
+    const renamedObject = await Private.renameSingleObject(
+      driveName,
+      options.path,
+      formattedNewPath
+    );
+    data = {
+      name: options.newFileName,
+      path: PathExt.join(driveName, formattedNewPath),
+      last_modified: renamedObject.data.last_modified,
+      created: '',
+      content: PathExt.extname(options.newFileName) !== '' ? null : [], // TODO: add dir check
+      format: fileFormat as Contents.FileFormat,
+      mimetype: fileMimeType,
+      size: renamedObject.data.size,
+      writable: true,
+      type: fileType
+    };
+  } catch (error) {
+    // renaming failed if directory didn't exist and was only part of a path
+  }
+
+  return data;
+}
+
 /**
  * Check existance of an object.
  *
@@ -335,4 +406,25 @@ namespace Private {
   ) {
     await requestAPI<any>('drives/' + driveName + '/' + objectPath, 'DELETE');
   }
+
+  /**
+   * Helping function for renaming files inside
+   * a directory, in the case of deleting the directory.
+   *
+   * @param driveName
+   * @param objectPath complete path of object to delete
+   */
+  export async function renameSingleObject(
+    driveName: string,
+    objectPath: string,
+    newObjectPath: string
+  ) {
+    return await requestAPI<any>(
+      'drives/' + driveName + '/' + objectPath,
+      'PATCH',
+      {
+        new_path: newObjectPath
+      }
+    );
+  }
 }