feat: contextmenu copy folders toegevoegd

2026-03-14 10:34:31 +01:00
parent 8908b1dce9
commit 4e1288fe47
16 changed files with 440 additions and 60 deletions
@@ -1,5 +1,6 @@
 from __future__ import annotations

+import os
 from pathlib import Path

 import uuid
@@ -8,7 +9,7 @@ from backend.app.api.errors import AppError
 from backend.app.api.schemas import TaskCreateResponse
 from backend.app.db.history_repository import HistoryRepository
 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


@@ -20,63 +21,42 @@ class CopyTaskService:
        self._history_repository = history_repository

    def create_copy_task(self, source: str, destination: str) -> TaskCreateResponse:
-        try:
-            resolved_source = self._path_guard.resolve_existing_path(source)
-            _, _, lexical_source, _ = self._path_guard.resolve_lexical_path(source)
-            if lexical_source.is_symlink():
-                raise AppError(
-                    code="type_conflict",
-                    message="Source must be a regular file",
-                    status_code=409,
-                    details={"path": source},
-                )
-            if not resolved_source.absolute.is_file():
-                raise AppError(
-                    code="type_conflict",
-                    message="Source must be a file",
-                    status_code=409,
-                    details={"path": source},
-                )
-
-            resolved_destination = self._path_guard.resolve_path(destination)
-            destination_parent = resolved_destination.absolute.parent
-            parent_relative = self._path_guard.entry_relative_path(
-                resolved_destination.alias,
-                destination_parent,
-                display_style=resolved_destination.display_style,
+        if not source or not destination:
+            raise AppError(
+                code="invalid_request",
+                message="Source and destination are required",
+                status_code=400,
            )
-            self._map_directory_validation(parent_relative)
-
-            if resolved_destination.absolute.exists():
-                raise AppError(
-                    code="already_exists",
-                    message="Target path already exists",
-                    status_code=409,
-                    details={"path": resolved_destination.relative},
-                )
-
-            total_bytes = int(resolved_source.absolute.stat().st_size)
+        try:
+            item = self._build_copy_item(source=source, destination=destination)
            task_id = str(uuid.uuid4())
            task = self._repository.create_task(
                operation="copy",
-                source=resolved_source.relative,
-                destination=resolved_destination.relative,
+                source=item["source_relative"],
+                destination=item["destination_relative"],
                task_id=task_id,
            )
            self._record_history(
                entry_id=task_id,
                operation="copy",
                status="queued",
-                source=resolved_source.relative,
-                destination=resolved_destination.relative,
+                source=item["source_relative"],
+                destination=item["destination_relative"],
            )

-            self._runner.enqueue_copy_file(
-                task_id=task["id"],
-                source=str(resolved_source.absolute),
-                destination=str(resolved_destination.absolute),
-                total_bytes=total_bytes,
-            )
+            if item["kind"] == "directory":
+                self._runner.enqueue_copy_directory(
+                    task_id=task["id"],
+                    source=item["source_absolute"],
+                    destination=item["destination_absolute"],
+                )
+            else:
+                self._runner.enqueue_copy_file(
+                    task_id=task["id"],
+                    source=item["source_absolute"],
+                    destination=item["destination_absolute"],
+                    total_bytes=item["total_bytes"],
+                )

            return TaskCreateResponse(task_id=task["id"], status=task["status"])
        except AppError as exc:
@@ -91,6 +71,133 @@ class CopyTaskService:
            )
            raise

+    def create_batch_copy_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 copy 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] = []
+        for source in sources:
+            destination = self._join_destination_base(destination_base, self._path_guard.resolve_existing_path(source).absolute.name)
+            item = self._build_copy_item(
+                source=source,
+                destination=destination,
+                resolved_destination=resolved_destination_base,
+                destination_base=destination_base,
+            )
+            items.append(item)
+
+        task_id = str(uuid.uuid4())
+        task = self._repository.create_task(
+            operation="copy",
+            source=f"{len(items)} items",
+            destination=resolved_destination_base.relative,
+            task_id=task_id,
+        )
+        self._record_history(
+            entry_id=task_id,
+            operation="copy",
+            status="queued",
+            source=f"{len(items)} items",
+            destination=resolved_destination_base.relative,
+        )
+        self._runner.enqueue_copy_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_copy_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)
+        if lexical_source.is_symlink():
+            raise AppError(
+                code="type_conflict",
+                message="Source must not be a symlink",
+                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:
+            raise AppError(
+                code="type_conflict",
+                message="Unsupported source path type",
+                status_code=409,
+                details={"path": source},
+            )
+
+        if source_is_directory:
+            self._validate_directory_tree(resolved_source)
+
+        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,
+            display_style=resolved_destination.display_style,
+        )
+        self._map_directory_validation(parent_relative)
+
+        if destination_absolute.exists():
+            raise AppError(
+                code="already_exists",
+                message="Target path already exists",
+                status_code=409,
+                details={"path": destination_relative},
+            )
+
+        if source_is_directory and 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_relative},
+            )
+
+        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",
+            "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:
            self._path_guard.resolve_directory_path(relative_path)
@@ -104,6 +211,31 @@ class CopyTaskService:
                )
            raise

+    def _validate_directory_tree(self, resolved_source: ResolvedPath) -> None:
+        for root, dirnames, filenames in os.walk(resolved_source.absolute, followlinks=False):
+            root_path = Path(root)
+            for name in [*dirnames, *filenames]:
+                entry = root_path / name
+                if entry.is_symlink():
+                    raise AppError(
+                        code="type_conflict",
+                        message="Source directory must not contain symlinks",
+                        status_code=409,
+                        details={"path": resolved_source.relative},
+                    )
+
+    @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:
+            destination.relative_to(source)
+            return True
+        except ValueError:
+            return False
+
    def _record_history(self, **kwargs) -> None:
        if self._history_repository:
            self._history_repository.create_entry(**kwargs)