feat: initialize aivideo project

backend/app/modules/pricing/repository.py

@@ -0,0 +1,16 @@
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.models.entities import PricingRule
+
+
+class PricingRepository:
+    def __init__(self, db: Session) -> None:
+        self.db = db
+
+    def list_rules(self):
+        return self.db.query(PricingRule).order_by(PricingRule.id.desc())
+
+    def get_rule(self, rule_id: int) -> PricingRule | None:
+        return self.db.scalar(select(PricingRule).where(PricingRule.id == rule_id))
+

backend/app/modules/pricing/router.py

@@ -0,0 +1,48 @@
+from fastapi import APIRouter, Depends
+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 require_admin_permission
+from app.modules.pricing.schema import PricingRulePayload
+from app.modules.pricing.service import PricingService
+
+
+router = APIRouter(prefix="/api/v1/admin/pricing-rules", tags=["admin-pricing"])
+
+
+@router.get("")
+def list_pricing_rules(
+    _=Depends(require_admin_permission()),
+    db: Session = Depends(get_db),
+):
+    return success_response(PricingService(db).list_rules())
+
+
+@router.post("")
+def create_pricing_rule(
+    payload: PricingRulePayload,
+    _=Depends(require_admin_permission()),
+    db: Session = Depends(get_db),
+):
+    return success_response(PricingService(db).create_rule(payload))
+
+
+@router.put("/{rule_id}")
+def update_pricing_rule(
+    rule_id: int,
+    payload: PricingRulePayload,
+    _=Depends(require_admin_permission()),
+    db: Session = Depends(get_db),
+):
+    return success_response(PricingService(db).update_rule(rule_id, payload))
+
+
+@router.post("/{rule_id}/publish")
+def publish_pricing_rule(
+    rule_id: int,
+    _=Depends(require_admin_permission()),
+    db: Session = Depends(get_db),
+):
+    return success_response(PricingService(db).publish_rule(rule_id))
+

backend/app/modules/pricing/schema.py

@@ -0,0 +1,15 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class PricingRulePayload(BaseModel):
+    rule_name: str
+    video_model_id: int
+    points_per_second: int
+    minimum_points: int
+    effective_at: datetime
+    expired_at: datetime | None = None
+    version_no: int = 1
+    status: int = 1
+

backend/app/modules/pricing/service.py

@@ -0,0 +1,53 @@
+from sqlalchemy.orm import Session
+
+from app.common.errors.app_error import NotFoundAppError
+from app.models.entities import PricingRule
+from app.modules.pricing.repository import PricingRepository
+
+
+class PricingService:
+    def __init__(self, db: Session) -> None:
+        self.db = db
+        self.repository = PricingRepository(db)
+
+    def list_rules(self) -> list[dict]:
+        return [self.serialize(item) for item in self.repository.list_rules().all()]
+
+    def create_rule(self, payload) -> dict:
+        item = PricingRule(**payload.model_dump())
+        self.db.add(item)
+        self.db.commit()
+        self.db.refresh(item)
+        return self.serialize(item)
+
+    def update_rule(self, rule_id: int, payload) -> dict:
+        item = self.repository.get_rule(rule_id)
+        if not item:
+            raise NotFoundAppError("pricing rule not found", code=60004)
+        for key, value in payload.model_dump().items():
+            setattr(item, key, value)
+        self.db.commit()
+        return self.serialize(item)
+
+    def publish_rule(self, rule_id: int) -> dict:
+        item = self.repository.get_rule(rule_id)
+        if not item:
+            raise NotFoundAppError("pricing rule not found", code=60004)
+        item.status = 1
+        self.db.commit()
+        return self.serialize(item)
+
+    @staticmethod
+    def serialize(item: PricingRule) -> dict:
+        return {
+            "id": item.id,
+            "ruleName": item.rule_name,
+            "videoModelId": item.video_model_id,
+            "pointsPerSecond": item.points_per_second,
+            "minimumPoints": item.minimum_points,
+            "effectiveAt": item.effective_at.isoformat(),
+            "expiredAt": item.expired_at.isoformat() if item.expired_at else None,
+            "versionNo": item.version_no,
+            "status": item.status,
+        }
+