feat: initialize aivideo project

backend/app/modules/assets/repository.py

@@ -0,0 +1,26 @@
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.models.entities import MediaAsset
+
+
+class AssetsRepository:
+    def __init__(self, db: Session) -> None:
+        self.db = db
+
+    def list_assets(self, user_id: int):
+        return (
+            self.db.query(MediaAsset)
+            .filter(MediaAsset.user_id == user_id, MediaAsset.status == "active")
+            .order_by(MediaAsset.id.desc())
+        )
+
+    def get_asset(self, user_id: int, asset_id: int) -> MediaAsset | None:
+        return self.db.scalar(
+            select(MediaAsset).where(
+                MediaAsset.id == asset_id,
+                MediaAsset.user_id == user_id,
+                MediaAsset.status == "active",
+            )
+        )
+

backend/app/modules/assets/router.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter, Depends, File, Form, UploadFile
+from sqlalchemy.orm import Session
+
+from app.common.db.session import get_db
+from app.common.responses.api_response import success_response
+from app.common.security.deps import get_current_user
+from app.models.entities import User
+from app.modules.assets.service import AssetsService
+
+
+router = APIRouter(prefix="/api/v1/assets", tags=["assets"])
+
+
+@router.post("/upload-token")
+def create_upload_token(mediaType: str = "image", db: Session = Depends(get_db)):
+    return success_response(AssetsService(db).create_upload_token(mediaType))
+
+
+@router.post("")
+def upload_asset(
+    file: UploadFile = File(...),
+    mediaType: str = Form("image"),
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    return success_response(AssetsService(db).save_asset(current_user.id, file, mediaType))
+
+
+@router.get("")
+def list_assets(
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    return success_response(AssetsService(db).list_assets(current_user.id))
+
+
+@router.delete("/{asset_id}")
+def delete_asset(
+    asset_id: int,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    return success_response(AssetsService(db).delete_asset(current_user.id, asset_id))
+

backend/app/modules/assets/schema.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class UploadTokenRequest(BaseModel):
+    media_type: str = "image"
+

backend/app/modules/assets/service.py

@@ -0,0 +1,72 @@
+from datetime import datetime
+from pathlib import Path
+
+from fastapi import UploadFile
+from sqlalchemy.orm import Session
+
+from app.common.errors.app_error import NotFoundAppError
+from app.common.utils.id_gen import new_order_no
+from app.core.storage import storage_service
+from app.models.entities import MediaAsset
+from app.modules.assets.repository import AssetsRepository
+
+
+class AssetsService:
+    def __init__(self, db: Session) -> None:
+        self.db = db
+        self.repository = AssetsRepository(db)
+
+    def create_upload_token(self, media_type: str) -> dict:
+        return {
+            "uploadToken": new_order_no("upload"),
+            "mediaType": media_type,
+            "uploadMode": "multipart",
+        }
+
+    def save_asset(self, user_id: int, file: UploadFile, media_type: str) -> dict:
+        stored = storage_service.save_upload(file, folder=f"uploads/{media_type}")
+        asset = MediaAsset(
+            asset_no=new_order_no("asset"),
+            user_id=user_id,
+            media_type=media_type,
+            source_type="upload",
+            original_filename=file.filename or "upload.bin",
+            mime_type=file.content_type or "application/octet-stream",
+            file_ext=Path(file.filename or "").suffix,
+            file_size=stored["file_size"],
+            storage_provider="local",
+            storage_bucket="local",
+            storage_key=stored["storage_key"],
+            public_url=stored["public_url"],
+            sha256=stored["sha256"],
+            status="active",
+        )
+        self.db.add(asset)
+        self.db.commit()
+        self.db.refresh(asset)
+        return self.serialize(asset)
+
+    def list_assets(self, user_id: int) -> list[dict]:
+        return [self.serialize(item) for item in self.repository.list_assets(user_id).all()]
+
+    def delete_asset(self, user_id: int, asset_id: int) -> dict:
+        asset = self.repository.get_asset(user_id, asset_id)
+        if not asset:
+            raise NotFoundAppError("asset not found", code=40003)
+        asset.status = "deleted"
+        asset.deleted_at = datetime.utcnow()
+        self.db.commit()
+        return {"assetId": asset_id, "deleted": True}
+
+    @staticmethod
+    def serialize(asset: MediaAsset) -> dict:
+        return {
+            "id": asset.id,
+            "assetNo": asset.asset_no,
+            "mediaType": asset.media_type,
+            "originalFilename": asset.original_filename,
+            "fileSize": asset.file_size,
+            "publicUrl": asset.public_url,
+            "createdAt": asset.created_at.isoformat(),
+        }
+