initial commit after split

src/govoplan_files/backend/storage/archives.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import mimetypes
+import zipfile
+from io import BytesIO
+from pathlib import Path
+from typing import Iterable
+
+from sqlalchemy.orm import Session
+
+from govoplan_files.backend.db.models import FileAsset
+from govoplan_files.backend.storage.common import FileConflictResolution, FileStorageError, UploadedStoredFile
+from govoplan_files.backend.storage.backends import get_storage_backend
+from govoplan_files.backend.storage.files import create_file_asset, current_version_and_blob
+from govoplan_files.backend.storage.paths import filename_from_path, normalize_folder, normalize_logical_path
+
+
+_ZIP_READ_CHUNK_SIZE = 1024 * 1024
+
+
+def _read_zip_member(
+    archive: zipfile.ZipFile,
+    info: zipfile.ZipInfo,
+    *,
+    max_file_bytes: int,
+    max_total_bytes: int,
+    current_total: int,
+) -> tuple[bytes, int]:
+    parts: list[bytes] = []
+    actual_size = 0
+    with archive.open(info) as source:
+        while True:
+            read_size = min(_ZIP_READ_CHUNK_SIZE, max_file_bytes + 1 - actual_size)
+            chunk = source.read(read_size)
+            if not chunk:
+                break
+            actual_size += len(chunk)
+            if actual_size > max_file_bytes:
+                raise FileStorageError(f"ZIP member {info.filename!r} exceeds per-file limit")
+            if current_total + actual_size > max_total_bytes:
+                raise FileStorageError("ZIP is too large after extraction")
+            parts.append(chunk)
+    return b"".join(parts), current_total + actual_size
+
+
+def create_zip_file(session: Session, assets: Iterable[FileAsset], output_path: str | Path) -> None:
+    backend = get_storage_backend()
+    with zipfile.ZipFile(output_path, mode="w", compression=zipfile.ZIP_DEFLATED) as archive:
+        for asset in assets:
+            _version, blob = current_version_and_blob(session, asset)
+            info = zipfile.ZipInfo(asset.display_path)
+            info.compress_type = zipfile.ZIP_DEFLATED
+            with archive.open(info, "w") as member:
+                for chunk in backend.iter_bytes(blob.storage_key):
+                    if chunk:
+                        member.write(chunk)
+
+
+def extract_zip_upload(
+    session: Session,
+    *,
+    tenant_id: str,
+    owner_type: str,
+    owner_id: str,
+    user_id: str,
+    zip_data: bytes,
+    folder: str | None,
+    campaign_id: str | None,
+    conflict_strategy: str = "reject",
+    conflict_resolutions: Iterable[FileConflictResolution] | None = None,
+    is_admin: bool = False,
+    max_files: int = 1000,
+    max_file_bytes: int = 50 * 1024 * 1024,
+    max_total_bytes: int = 250 * 1024 * 1024,
+) -> list[UploadedStoredFile]:
+    uploaded: list[UploadedStoredFile] = []
+    total = 0
+    base_folder = normalize_folder(folder)
+    try:
+        with zipfile.ZipFile(BytesIO(zip_data)) as archive:
+            infos = [info for info in archive.infolist() if not info.is_dir()]
+            if len(infos) > max_files:
+                raise FileStorageError(f"ZIP contains too many files (limit {max_files})")
+            for info in infos:
+                if info.flag_bits & 0x1:
+                    raise FileStorageError("Encrypted ZIP uploads are not supported")
+                if info.file_size < 0:
+                    raise FileStorageError("Invalid ZIP member")
+                if info.file_size > max_file_bytes:
+                    raise FileStorageError(f"ZIP member {info.filename!r} exceeds per-file limit")
+                if total + info.file_size > max_total_bytes:
+                    raise FileStorageError("ZIP is too large after extraction")
+                inner_path = normalize_logical_path(info.filename)
+                target_path = f"{base_folder}/{inner_path}" if base_folder else inner_path
+                data, total = _read_zip_member(
+                    archive,
+                    info,
+                    max_file_bytes=max_file_bytes,
+                    max_total_bytes=max_total_bytes,
+                    current_total=total,
+                )
+                uploaded.append(
+                    create_file_asset(
+                        session,
+                        tenant_id=tenant_id,
+                        owner_type=owner_type,
+                        owner_id=owner_id,
+                        user_id=user_id,
+                        filename=filename_from_path(inner_path),
+                        data=data,
+                        display_path=target_path,
+                        content_type=mimetypes.guess_type(inner_path)[0] or "application/octet-stream",
+                        campaign_id=campaign_id,
+                        conflict_strategy=conflict_strategy,
+                        conflict_resolutions=conflict_resolutions,
+                        is_admin=is_admin,
+                    )
+                )
+    except zipfile.BadZipFile as exc:
+        raise FileStorageError("Invalid ZIP upload") from exc
+    return uploaded