feat: Implement product moderation workflow with new product statuses, moderator ID tracking, and dedicated API endpoints

Author: codewithme-py

app/core/audit_log/service.py

@@ -17,11 +17,13 @@ async def log_event(
         target_id: UUID,
         action: str,
         changes: dict[str, Any],
+        extra_data: dict[str, Any] | None = None,
     ) -> None:
         context = get_contextvars()
         request_id = context.get('request_id')
         remote_ip = context.get('remote_ip')
-
+        if extra_data:
+            changes.update(extra_data)
         log = AuditLog(
             actor_id=actor_id,
             target_type=target_type,
@@ -63,6 +65,7 @@ async def log_object_change(
         action: str,
         old_obj: BaseModel | None,
         new_obj: BaseModel | None,
+        extra_data: dict[str, Any] | None = None,
     ) -> None:
         diff = self.get_diff(old_obj, new_obj)
         if diff:
@@ -73,6 +76,7 @@ async def log_object_change(
                 target_id=target_id,
                 action=action,
                 changes=diff,
+                extra_data=extra_data,
             )
 
 

app/services/inventory/deps.py

@@ -0,0 +1,22 @@
+from typing import Annotated
+
+from fastapi import Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database import get_session
+from app.services.inventory.service import InventoryAdminService, InventoryService
+
+
+async def get_inventory_service() -> InventoryService:
+    return InventoryService()
+
+
+async def get_inventory_admin_service() -> InventoryAdminService:
+    return InventoryAdminService()
+
+
+InventoryServiceDep = Annotated[InventoryService, Depends(get_inventory_service)]
+InventoryAdminServiceDep = Annotated[
+    InventoryAdminService, Depends(get_inventory_admin_service)
+]
+SessionDep = Annotated[AsyncSession, Depends(get_session)]

app/services/inventory/models.py

@@ -20,6 +20,9 @@ class ProductStatus(StrEnum):
     DRAFT = 'DRAFT'
     ACTIVE = 'ACTIVE'
     ARCHIVED = 'ARCHIVED'
+    PENDING_MODERATION = 'PENDING_MODERATION'
+    MODERATION_IN_PROGRESS = 'MODERATION_IN_PROGRESS'
+    REJECTED = 'REJECTED'
 
 
 class Product(Base):
@@ -46,6 +49,9 @@ class Product(Base):
     status: Mapped[ProductStatus] = mapped_column(
         SQLEnum(ProductStatus), nullable=False, default=ProductStatus.DRAFT
     )
+    moderator_id: Mapped[UUID | None] = mapped_column(
+        ForeignKey('users.id'), nullable=True, index=True
+    )
     if TYPE_CHECKING:
         from app.services.media.models import ProductImage
     images: Mapped[list['ProductImage']] = relationship(

app/services/inventory/routes.py

@@ -1,7 +1,7 @@
 from typing import Annotated
 from uuid import UUID
 
-from fastapi import APIRouter, Depends, Header, Request, status
+from fastapi import APIRouter, Depends, Header, Query, Request, status
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.database import get_session
@@ -15,11 +15,16 @@
     ReservationCreate,
     ReservationResponse,
 )
-from app.services.inventory.service import InventoryService
+from app.services.inventory.service import InventoryAdminService, InventoryService
 from app.services.user.models import User
 from app.shared.decorators import idempotent
 from app.shared.deps import get_current_user
 
+from .deps import (
+    get_inventory_admin_service,
+    get_inventory_service,
+)
+
 router_v1 = APIRouter(prefix='/inventory', tags=['Inventory'])
 
 SELLER_DEPENDENCY = Depends(
@@ -48,10 +53,11 @@
 @router_v1.get('/', response_model=list[ProductRead])
 async def get_active_products(
     session: Annotated[AsyncSession, Depends(get_session)],
+    service: Annotated[InventoryService, Depends(get_inventory_service)],
     skip: int = 0,
     limit: int = 50,
 ) -> list[ProductRead]:
-    products = await InventoryService.get_products(
+    products = await service.get_products(
         status=ProductStatus.ACTIVE,
         skip=skip,
         limit=limit,
@@ -65,8 +71,9 @@ async def create_product(
     product_data: ProductCreate,
     session: Annotated[AsyncSession, Depends(get_session)],
     current_user: Annotated[User, SELLER_DEPENDENCY],
+    service: Annotated[InventoryService, Depends(get_inventory_service)],
 ) -> ProductRead:
-    product = await InventoryService.create_product(
+    product = await service.create_product(
         current_user=current_user,
         session=session,
         product_data=product_data,
@@ -80,8 +87,9 @@ async def activate_product(
     product_id: UUID,
     session: Annotated[AsyncSession, Depends(get_session)],
     current_user: Annotated[User, ADMIN_DEPENDENCY],
+    service: Annotated[InventoryAdminService, Depends(get_inventory_admin_service)],
 ) -> ProductRead:
-    product = await InventoryService.change_status(
+    product = await service.change_status(
         session=session,
         product_id=product_id,
         status=ProductStatus.ACTIVE,
@@ -96,8 +104,9 @@ async def update_product(
     product_data: ProductUpdate,
     session: Annotated[AsyncSession, Depends(get_session)],
     current_user: Annotated[User, ADMIN_AND_SELLER_DEPENDENCY],
+    service: Annotated[InventoryService, Depends(get_inventory_service)],
 ) -> ProductRead:
-    product = await InventoryService.update_product(
+    product = await service.update_product(
         session=session,
         product_id=product_id,
         product_data=product_data,
@@ -111,8 +120,9 @@ async def delete_product(
     product_id: UUID,
     session: Annotated[AsyncSession, Depends(get_session)],
     current_user: Annotated[User, ADMIN_DEPENDENCY],
+    service: Annotated[InventoryService, Depends(get_inventory_service)],
 ) -> None:
-    await InventoryService.delete_product(
+    await service.delete_product(
         session=session,
         product_id=product_id,
         current_user=current_user,
@@ -123,8 +133,9 @@ async def delete_product(
 async def get_product(
     product_id: UUID,
     session: Annotated[AsyncSession, Depends(get_session)],
+    service: Annotated[InventoryService, Depends(get_inventory_service)],
 ) -> ProductRead:
-    product = await InventoryService.get_product(
+    product = await service.get_product(
         session=session,
         product_id=product_id,
     )
@@ -136,6 +147,7 @@ async def get_product(
 async def reservation_data(
     request: Request,
     reservation_data: ReservationCreate,
+    service: Annotated[InventoryService, Depends(get_inventory_service)],
     x_idempotency_key: str = Header(...),
     session: AsyncSession = Depends(get_session),
     current_user: User = Depends(get_current_user),
@@ -145,10 +157,72 @@ async def reservation_data(
         user_id=str(current_user.id),
         item_id=str(reservation_data.product_id),
     )
-    result = await InventoryService.reserve_items(
+    result = await service.reserve_items(
         session=session,
         user_id=current_user.id,
         idempotency_key=x_idempotency_key,
         reservation_data=reservation_data,
     )
     return ReservationResponse.model_validate(result)
+
+
+@router_v1.post('/{product_id}/submit', response_model=ProductRead)
+async def submit_for_moderation(
+    product_id: UUID,
+    session: Annotated[AsyncSession, Depends(get_session)],
+    current_user: Annotated[User, SELLER_DEPENDENCY],
+    service: Annotated[InventoryService, Depends(get_inventory_service)],
+) -> ProductRead:
+    product = await service.submit_for_moderation(
+        session=session,
+        product_id=product_id,
+        current_user=current_user,
+    )
+    return ProductRead.model_validate(product)
+
+
+@router_v1.post('/{product_id}/approve', response_model=ProductRead)
+async def approve_product(
+    product_id: UUID,
+    session: Annotated[AsyncSession, Depends(get_session)],
+    current_user: Annotated[User, ADMIN_DEPENDENCY],
+    service: Annotated[InventoryAdminService, Depends(get_inventory_admin_service)],
+) -> ProductRead:
+    product = await service.approve_product(
+        session=session,
+        product_id=product_id,
+        moderator_user=current_user,
+    )
+    return ProductRead.model_validate(product)
+
+
+@router_v1.post('/{product_id}/reject', response_model=ProductRead)
+async def reject_product(
+    product_id: UUID,
+    session: Annotated[AsyncSession, Depends(get_session)],
+    current_user: Annotated[User, ADMIN_DEPENDENCY],
+    service: Annotated[InventoryAdminService, Depends(get_inventory_admin_service)],
+    reason: str = Query(...),
+) -> ProductRead:
+    product = await service.reject_product(
+        session=session,
+        product_id=product_id,
+        moderator_user=current_user,
+        reason=reason,
+    )
+    return ProductRead.model_validate(product)
+
+
+@router_v1.post('/{product_id}/claim', response_model=ProductRead)
+async def claim_for_moderation(
+    product_id: UUID,
+    session: Annotated[AsyncSession, Depends(get_session)],
+    current_user: Annotated[User, ADMIN_DEPENDENCY],
+    service: Annotated[InventoryAdminService, Depends(get_inventory_admin_service)],
+) -> ProductRead:
+    product = await service.claim_for_moderation(
+        session=session,
+        product_id=product_id,
+        moderator_user=current_user,
+    )
+    return ProductRead.model_validate(product)