Support API to delete dirs and files

Author: xxx7xxxx

src/api/api.py

@@ -88,9 +88,9 @@ class CreateDirectoryRequest(BaseModel):
     directoryPath: str
 
 
-class DeleteDirectoryRequest(BaseModel):
-    """Request model for deleting a directory."""
-    directoryPath: str
+class DeleteDirsFilesRequest(BaseModel):
+    """Request model for deleting directores or files."""
+    paths: List[str]
 
 
 class UploadFileRequest(BaseModel):
@@ -100,11 +100,6 @@ class UploadFileRequest(BaseModel):
     fileContent: str  # Base64-encoded content
 
 
-class DeleteFilesRequest(BaseModel):
-    """Request model for deleting files."""
-    filePaths: List[str]
-
-
 class FileMetadata(BaseModel):
     """Metadata for a file."""
     type: str

src/rest/rest.py

@@ -9,9 +9,8 @@
     UpdateNamespaceRequest,
     ListNamespaceResponse,
     CreateDirectoryRequest,
-    DeleteDirectoryRequest,
+    DeleteDirsFilesRequest,
     UploadFileRequest,
-    DeleteFilesRequest,
     ListDirectoryResponse,
 )
 from src.logger import logger
@@ -104,10 +103,9 @@ def __init__(self, file_service: FileService):
     def _setup_routes(self):
         """Setup API routes."""
         self.router.post("/directories")(self.create_directory)
-        self.router.delete("/directories")(self.delete_directory)
         self.router.get("/directories", response_model=ListDirectoryResponse)(self.list_directory)
         self.router.post("/files")(self.upload_file)
-        self.router.delete("/files")(self.delete_files)
+        self.router.post("/delete-dirs-files")(self.delete_dirs_files)
 
     async def create_directory(self, request: CreateDirectoryRequest):
         """
@@ -126,22 +124,18 @@ async def create_directory(self, request: CreateDirectoryRequest):
                 raise HTTPException(status_code=409, detail=str(e))
             raise HTTPException(status_code=400, detail=str(e))
 
-    async def delete_directory(self, request: DeleteDirectoryRequest):
+    async def delete_dirs_files(self, request: DeleteDirsFilesRequest):
         """
-        Delete a directory.
+        Delete directories or files.
 
         Returns:
             200: Succeed
             400: Bad Request
-            404: Not Found (Directory does not exist)
         """
-        try:
-            self.file_service.delete_directory(request.directoryPath)
-            return {"message": "Directory deleted successfully"}
-        except ValueError as e:
-            if "Not Found" in str(e):
-                raise HTTPException(status_code=404, detail=str(e))
-            raise HTTPException(status_code=400, detail=str(e))
+        result = self.file_service.delete_dirs_files(request.paths)
+        if result["hasFailure"] is True:
+            print(result)
+        return result
 
     async def list_directory(self, directoryPath: str):
         """
@@ -174,24 +168,6 @@ async def upload_file(self, request: UploadFileRequest):
         except ValueError as e:
             raise HTTPException(status_code=400, detail=str(e))
 
-    async def delete_files(self, request: DeleteFilesRequest):
-        """
-        Delete files.
-
-        Returns:
-            200: Succeed
-            400: Bad Request
-            404: Not Found
-        """
-        try:
-            self.file_service.delete_files(request.filePaths)
-            return {"message": "Files deleted successfully"}
-        except ValueError as e:
-            if "Not Found" in str(e):
-                raise HTTPException(status_code=404, detail=str(e))
-            raise HTTPException(status_code=400, detail=str(e))
-
-
 class SessionAPI:
     """Class to encapsulate session-related API endpoints."""
 

src/service/file.py

@@ -1,5 +1,6 @@
 import os
 import base64
+import shutil
 from datetime import datetime
 from typing import List, Dict
 
@@ -28,30 +29,6 @@ def create_directory(self, directory_path: str):
         except Exception as e:
             raise ValueError(f"Bad Request: Unable to create directory. {str(e)}")
 
-    def delete_directory(self, directory_path: str):
-        """
-        Delete a directory.
-
-        Args:
-            directory_path (str): Path of the directory to delete.
-
-        Raises:
-            ValueError: If the directory does not exist or the path is invalid.
-        """
-        if not os.path.exists(directory_path):
-            raise ValueError("Not Found: Directory does not exist.")
-        if not os.path.isdir(directory_path):
-            raise ValueError("Bad Request: Path is not a directory.")
-        try:
-            for root, dirs, files in os.walk(directory_path, topdown=False):
-                for file in files:
-                    os.remove(os.path.join(root, file))
-                for dir in dirs:
-                    os.rmdir(os.path.join(root, dir))
-            os.rmdir(directory_path)
-        except Exception as e:
-            raise ValueError(f"Bad Request: Unable to delete directory. {str(e)}")
-
     def list_directory(self, directory_path: str) -> Dict[str, List[Dict[str, str]]]:
         """
         List files and directories in a specified directory.
@@ -122,27 +99,39 @@ def upload_file(self, directory_path: str, file_name: str, file_content: str):
         except Exception as e:
             raise ValueError(f"Bad Request: Unable to upload file. {str(e)}")
 
-    def delete_files(self, file_paths: List[str]):
+    def delete_dirs_files(self, paths: List[str]) -> Dict[str, any]:
         """
-        Delete specified files.
+        Delete multiple files or directories.
 
         Args:
-            file_paths (List[str]): List of file paths to delete.
+            paths (List[str]): List of paths (files or directories) to delete.
 
-        Raises:
-            ValueError: If a file does not exist or the path is invalid.
+        Returns:
+            Dict[str, any]: A dictionary containing the deletion status for each path.
         """
-        errors = []
-        for file_path in file_paths:
-            if not os.path.exists(file_path):
-                errors.append(f"Not Found: {file_path}")
-                continue
-            if not os.path.isfile(file_path):
-                errors.append(f"Bad Request: {file_path} is not a file.")
-                continue
+        results = {
+            "hasFailure": False,
+            "paths": [],
+        }
+
+        for path in paths:
             try:
-                os.remove(file_path)
+                if not os.path.exists(path):
+                    results["paths"].append({"path": path, "status": "not found"})
+                    results["hasFailure"] = True
+                    continue
+
+                if os.path.isfile(path):
+                    os.remove(path)  # Remove file
+                    results["paths"].append({"path": path, "status": "file deleted"})
+                elif os.path.isdir(path):
+                    shutil.rmtree(path)  # Recursively delete directory
+                    results["paths"].append({"path": path, "status": "directory deleted"})
+                else:
+                    results["paths"].append({"path": path, "status": "invalid path type"})
+                    results["hasFailure"] = True
             except Exception as e:
-                errors.append(f"Unable to delete {file_path}. {str(e)}")
-        if errors:
-            raise ValueError("; ".join(errors))
+                results["paths"].append({"path": path, "status": "error", "message": str(e)})
+                results["hasFailure"] = True
+
+        return results