Refactoring of services.py; tests

server/app/storage/folders.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from sqlalchemy import or_
+from sqlalchemy.orm import Session
+
+from app.db.models import FileAsset, FileFolder
+from app.storage.access import ensure_owner_access
+from app.storage.common import FileStorageError, utcnow
+from app.storage.files import _asset_query_for_owner
+from app.storage.paths import normalize_folder
+
+
+def _owner_filter(query, owner_type: str, owner_id: str):
+    if owner_type == "user":
+        return query.filter(FileFolder.owner_user_id == owner_id)
+    if owner_type == "group":
+        return query.filter(FileFolder.owner_group_id == owner_id)
+    raise FileStorageError("Unsupported owner type")
+
+
+def create_folder(
+    session: Session,
+    *,
+    tenant_id: str,
+    owner_type: str,
+    owner_id: str,
+    user_id: str,
+    path: str,
+    is_admin: bool = False,
+) -> FileFolder:
+    owner_type = owner_type.lower().strip()
+    ensure_owner_access(session, tenant_id=tenant_id, owner_type=owner_type, owner_id=owner_id, user_id=user_id, is_admin=is_admin)
+    normalized = normalize_folder(path)
+    if not normalized:
+        raise FileStorageError("Folder path is required")
+    query = session.query(FileFolder).filter(FileFolder.tenant_id == tenant_id, FileFolder.owner_type == owner_type, FileFolder.path == normalized)
+    query = _owner_filter(query, owner_type, owner_id)
+    active_existing = query.filter(FileFolder.deleted_at.is_(None)).first()
+    if active_existing is not None:
+        raise FileStorageError(f"Folder already exists: {normalized}")
+    deleted_existing = query.filter(FileFolder.deleted_at.is_not(None)).first()
+    if deleted_existing is not None:
+        deleted_existing.deleted_at = None
+        session.add(deleted_existing)
+        session.flush()
+        return deleted_existing
+    folder = FileFolder(
+        tenant_id=tenant_id,
+        owner_type=owner_type,
+        owner_user_id=owner_id if owner_type == "user" else None,
+        owner_group_id=owner_id if owner_type == "group" else None,
+        path=normalized,
+        created_by_user_id=user_id,
+        metadata_={},
+    )
+    session.add(folder)
+    session.flush()
+    return folder
+
+
+def list_folders_for_user(
+    session: Session,
+    *,
+    tenant_id: str,
+    user_id: str,
+    owner_type: str,
+    owner_id: str,
+    include_deleted: bool = False,
+    is_admin: bool = False,
+) -> list[FileFolder]:
+    owner_type = owner_type.lower().strip()
+    ensure_owner_access(session, tenant_id=tenant_id, owner_type=owner_type, owner_id=owner_id, user_id=user_id, is_admin=is_admin)
+    query = session.query(FileFolder).filter(FileFolder.tenant_id == tenant_id, FileFolder.owner_type == owner_type)
+    query = _owner_filter(query, owner_type, owner_id)
+    if not include_deleted:
+        query = query.filter(FileFolder.deleted_at.is_(None))
+    return query.order_by(FileFolder.path.asc()).all()
+
+
+def soft_delete_folder(
+    session: Session,
+    *,
+    tenant_id: str,
+    owner_type: str,
+    owner_id: str,
+    user_id: str,
+    path: str,
+    recursive: bool = True,
+    is_admin: bool = False,
+) -> tuple[int, int]:
+    owner_type = owner_type.lower().strip()
+    ensure_owner_access(session, tenant_id=tenant_id, owner_type=owner_type, owner_id=owner_id, user_id=user_id, is_admin=is_admin)
+    normalized = normalize_folder(path)
+    if not normalized:
+        raise FileStorageError("Folder path is required")
+    prefix = f"{normalized}/"
+    now = utcnow()
+
+    folder_query = session.query(FileFolder).filter(FileFolder.tenant_id == tenant_id, FileFolder.owner_type == owner_type, FileFolder.deleted_at.is_(None))
+    folder_query = _owner_filter(folder_query, owner_type, owner_id)
+    if recursive:
+        folder_query = folder_query.filter(or_(FileFolder.path == normalized, FileFolder.path.like(f"{prefix}%")))
+    else:
+        child_exists = folder_query.filter(FileFolder.path.like(f"{prefix}%")).first() is not None
+        file_exists = _asset_query_for_owner(session, tenant_id=tenant_id, owner_type=owner_type, owner_id=owner_id).filter(FileAsset.display_path.like(f"{prefix}%")).first() is not None
+        if child_exists or file_exists:
+            raise FileStorageError("Folder is not empty")
+        folder_query = folder_query.filter(FileFolder.path == normalized)
+
+    folders = folder_query.all()
+    for folder in folders:
+        folder.deleted_at = now
+        session.add(folder)
+
+    file_query = _asset_query_for_owner(session, tenant_id=tenant_id, owner_type=owner_type, owner_id=owner_id).filter(FileAsset.deleted_at.is_(None), FileAsset.display_path.like(f"{prefix}%"))
+    assets = file_query.all() if recursive else []
+    for asset in assets:
+        asset.deleted_at = now
+        session.add(asset)
+
+    return len(folders), len(assets)
+
+
+def _active_folder_exists(session: Session, *, tenant_id: str, owner_type: str, owner_id: str, path: str, exclude_paths: set[str] | None = None) -> bool:
+    normalized = normalize_folder(path)
+    if not normalized:
+        return False
+    query = session.query(FileFolder).filter(
+        FileFolder.tenant_id == tenant_id,
+        FileFolder.owner_type == owner_type,
+        FileFolder.deleted_at.is_(None),
+        FileFolder.path == normalized,
+    )
+    query = _owner_filter(query, owner_type, owner_id)
+    if exclude_paths:
+        query = query.filter(FileFolder.path.notin_(exclude_paths))
+    return query.first() is not None
+
+
+def _folder_query_for_owner(session: Session, *, tenant_id: str, owner_type: str, owner_id: str):
+    query = session.query(FileFolder).filter(FileFolder.tenant_id == tenant_id, FileFolder.owner_type == owner_type)
+    return _owner_filter(query, owner_type, owner_id)
+
+
+def _ensure_target_folder_hierarchy(
+    session: Session,
+    *,
+    tenant_id: str,
+    owner_type: str,
+    owner_id: str,
+    user_id: str,
+    path: str,
+) -> None:
+    parts = normalize_folder(path).split("/") if normalize_folder(path) else []
+    for index in range(1, len(parts) + 1):
+        partial = "/".join(parts[:index])
+        query = _folder_query_for_owner(session, tenant_id=tenant_id, owner_type=owner_type, owner_id=owner_id).filter(FileFolder.path == partial)
+        existing = query.one_or_none()
+        if existing:
+            if existing.deleted_at is not None:
+                existing.deleted_at = None
+                session.add(existing)
+            continue
+        folder = FileFolder(
+            tenant_id=tenant_id,
+            owner_type=owner_type,
+            owner_user_id=owner_id if owner_type == "user" else None,
+            owner_group_id=owner_id if owner_type == "group" else None,
+            path=partial,
+            created_by_user_id=user_id,
+            metadata_={},
+        )
+        session.add(folder)