Multiple folder move added

2026-03-11 16:27:21 +01:00
parent 3e4761f5a7
commit 6e7b3cffae
14 changed files with 428 additions and 43 deletions
@@ -5,7 +5,7 @@ from pathlib import Path
 from backend.app.api.errors import AppError
 from backend.app.api.schemas import TaskCreateResponse
 from backend.app.db.task_repository import TaskRepository
-from backend.app.security.path_guard import PathGuard
+from backend.app.security.path_guard import PathGuard, ResolvedPath
 from backend.app.tasks_runner import TaskRunner


@@ -15,7 +15,108 @@ class MoveTaskService:
        self._repository = repository
        self._runner = runner

-    def create_move_task(self, source: str, destination: str) -> TaskCreateResponse:
+    def create_move_task(self, source: str | None, destination: str | None) -> TaskCreateResponse:
+        if not source or not destination:
+            raise AppError(
+                code="invalid_request",
+                message="Source and destination are required",
+                status_code=400,
+            )
+
+        item = self._build_move_item(source=source, destination=destination)
+
+        task = self._repository.create_task(
+            operation="move",
+            source=item["source_relative"],
+            destination=item["destination_relative"],
+        )
+
+        if item["kind"] == "directory":
+            self._runner.enqueue_move_directory(
+                task_id=task["id"],
+                source=item["source_absolute"],
+                destination=item["destination_absolute"],
+            )
+        else:
+            self._runner.enqueue_move_file(
+                task_id=task["id"],
+                source=item["source_absolute"],
+                destination=item["destination_absolute"],
+                total_bytes=item["total_bytes"],
+                same_root=item["same_root"],
+            )
+
+        return TaskCreateResponse(task_id=task["id"], status=task["status"])
+
+    def create_batch_move_task(self, sources: list[str] | None, destination_base: str | None) -> TaskCreateResponse:
+        if not sources or len(sources) < 2:
+            raise AppError(
+                code="invalid_request",
+                message="Batch move requires at least 2 sources",
+                status_code=400,
+            )
+        if not destination_base:
+            raise AppError(
+                code="invalid_request",
+                message="Destination base is required",
+                status_code=400,
+            )
+
+        resolved_destination_base = self._path_guard.resolve_directory_path(destination_base)
+        items: list[dict] = []
+        resolved_sources = [self._path_guard.resolve_existing_path(source) for source in sources]
+        source_aliases = {resolved_source.alias for resolved_source in resolved_sources}
+        if len(source_aliases) != 1:
+            raise AppError(
+                code="invalid_request",
+                message="Batch move requires all selected items to be in the same root",
+                status_code=400,
+            )
+
+        root_alias = next(iter(source_aliases))
+        if root_alias != resolved_destination_base.alias:
+            raise AppError(
+                code="invalid_request",
+                message="Cross-root batch directory move is not supported in v1",
+                status_code=400,
+                details={"destination_base": destination_base},
+            )
+
+        for source, source_resolved in zip(sources, resolved_sources):
+            destination = self._join_destination_base(destination_base, source_resolved.absolute.name)
+            item = self._build_move_item(
+                source=source,
+                destination=destination,
+                resolved_destination=resolved_destination_base,
+                destination_base=destination_base,
+            )
+            items.append(item)
+
+        task = self._repository.create_task(
+            operation="move",
+            source=f"{len(items)} items",
+            destination=resolved_destination_base.relative,
+        )
+        self._runner.enqueue_move_batch(
+            task_id=task["id"],
+            items=[
+                {
+                    "source": item["source_absolute"],
+                    "destination": item["destination_absolute"],
+                    "kind": item["kind"],
+                }
+                for item in items
+            ],
+        )
+        return TaskCreateResponse(task_id=task["id"], status=task["status"])
+
+    def _build_move_item(
+        self,
+        source: str,
+        destination: str,
+        resolved_destination: ResolvedPath | None = None,
+        destination_base: str | None = None,
+    ) -> dict:
        resolved_source = self._path_guard.resolve_existing_path(source)
        _, _, lexical_source, _ = self._path_guard.resolve_lexical_path(source)

@@ -26,6 +127,7 @@ class MoveTaskService:
                status_code=409,
                details={"path": source},
            )
+
        source_is_file = resolved_source.absolute.is_file()
        source_is_directory = resolved_source.absolute.is_dir()
        if not source_is_file and not source_is_directory:
@@ -36,8 +138,18 @@ class MoveTaskService:
                details={"path": source},
            )

-        resolved_destination = self._path_guard.resolve_path(destination)
-        destination_parent = resolved_destination.absolute.parent
+        resolved_destination = resolved_destination or self._path_guard.resolve_path(destination)
+        destination_absolute = (
+            resolved_destination.absolute / resolved_source.absolute.name
+            if destination_base is not None
+            else resolved_destination.absolute
+        )
+        destination_relative = self._path_guard.entry_relative_path(
+            resolved_destination.alias,
+            destination_absolute,
+            display_style=resolved_destination.display_style,
+        )
+        destination_parent = destination_absolute.parent
        parent_relative = self._path_guard.entry_relative_path(
            resolved_destination.alias,
            destination_parent,
@@ -45,20 +157,20 @@ class MoveTaskService:
        )
        self._map_directory_validation(parent_relative)

-        if source_is_directory and resolved_destination.absolute == resolved_source.absolute:
+        if destination_absolute == resolved_source.absolute:
            raise AppError(
                code="invalid_request",
                message="Destination must differ from source",
                status_code=400,
-                details={"path": source, "destination": destination},
+                details={"path": source, "destination": destination_relative},
            )

-        if resolved_destination.absolute.exists():
+        if destination_absolute.exists():
            raise AppError(
                code="already_exists",
                message="Target path already exists",
                status_code=409,
-                details={"path": resolved_destination.relative},
+                details={"path": destination_relative},
            )

        same_root = resolved_source.alias == resolved_destination.alias
@@ -69,44 +181,25 @@ class MoveTaskService:
                    code="invalid_request",
                    message="Cross-root directory move is not supported in v1",
                    status_code=400,
-                    details={"path": source, "destination": destination},
+                    details={"path": source, "destination": destination_relative},
                )
-            if self._is_nested_destination(resolved_source.absolute, resolved_destination.absolute):
+            if self._is_nested_destination(resolved_source.absolute, destination_absolute):
                raise AppError(
                    code="invalid_request",
                    message="Destination cannot be inside source",
                    status_code=400,
-                    details={"path": source, "destination": destination},
+                    details={"path": source, "destination": destination_relative},
                )

-            task = self._repository.create_task(
-                operation="move",
-                source=resolved_source.relative,
-                destination=resolved_destination.relative,
-            )
-            self._runner.enqueue_move_directory(
-                task_id=task["id"],
-                source=str(resolved_source.absolute),
-                destination=str(resolved_destination.absolute),
-            )
-            return TaskCreateResponse(task_id=task["id"], status=task["status"])
-
-        total_bytes = int(resolved_source.absolute.stat().st_size)
-        task = self._repository.create_task(
-            operation="move",
-            source=resolved_source.relative,
-            destination=resolved_destination.relative,
-        )
-
-        self._runner.enqueue_move_file(
-            task_id=task["id"],
-            source=str(resolved_source.absolute),
-            destination=str(resolved_destination.absolute),
-            total_bytes=total_bytes,
-            same_root=same_root,
-        )
-
-        return TaskCreateResponse(task_id=task["id"], status=task["status"])
+        return {
+            "source_relative": resolved_source.relative,
+            "destination_relative": destination_relative,
+            "source_absolute": str(resolved_source.absolute),
+            "destination_absolute": str(destination_absolute),
+            "kind": "directory" if source_is_directory else "file",
+            "same_root": same_root,
+            "total_bytes": int(resolved_source.absolute.stat().st_size) if source_is_file else None,
+        }

    def _map_directory_validation(self, relative_path: str) -> None:
        try:
@@ -121,6 +214,10 @@ class MoveTaskService:
                )
            raise

+    @staticmethod
+    def _join_destination_base(destination_base: str, name: str) -> str:
+        return f"{destination_base.rstrip('/')}/{name}" if destination_base.rstrip("/") else f"/{name}"
+
    @staticmethod
    def _is_nested_destination(source: Path, destination: Path) -> bool:
        try: