qiji/backend/app/api/mini_business.py

import uuid
from typing import Optional
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from app.database import get_db
from app.middleware.auth import get_current_user, require_any_role
from app.models.mini_business import MiniBusiness
from app.models.customer import Customer
from app.models.user import User
from app.schemas.mini_business import MiniBusinessCreate, MiniBusinessUpdate, MiniBusinessOut
from app.utils.edit_log import compute_diff, append_entry, init_entry
from app.utils.audit import log_audit

router = APIRouter(prefix="/mini-business", tags=["MiniBusiness"])


async def _enrich(m: MiniBusiness, db: AsyncSession) -> dict:
    cust = await db.execute(select(Customer.name).where(Customer.id == m.customer_id))
    mgr = await db.execute(select(User.name).where(User.id == m.manager_id))
    return {
        "id": str(m.id),
        "customer_id": str(m.customer_id),
        "customer_name": cust.scalar_one_or_none(),
        "product_type": m.product_type,
        "amount": m.amount,
        "follow_up_detail": m.follow_up_detail,
        "status": m.status,
        "manager_id": str(m.manager_id),
        "manager_name": mgr.scalar_one_or_none(),
        "edit_log": m.edit_log or [],
        "expected_revenue_date": m.expected_revenue_date,
    }


@router.get("/")
async def list_mini_business(
    customer_id: Optional[str] = Query(None),
    current_user: dict = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
):
    query = select(MiniBusiness)
    if current_user["role"] == "manager":
        query = query.where(MiniBusiness.manager_id == uuid.UUID(current_user["user_id"]))
    if customer_id:
        query = query.where(MiniBusiness.customer_id == uuid.UUID(customer_id))
    query = query.order_by(MiniBusiness.expected_revenue_date.desc()).limit(200)
    result = await db.execute(query)
    return [await _enrich(m, db) for m in result.scalars().all()]


@router.post("/")
async def create_mini_business(
    data: MiniBusinessCreate,
    current_user: dict = Depends(require_any_role),
    db: AsyncSession = Depends(get_db),
):
    m = MiniBusiness(
        customer_id=data.customer_id,
        product_type=data.product_type,
        amount=data.amount,
        follow_up_detail=data.follow_up_detail,
        status=data.status,
        manager_id=uuid.UUID(current_user["user_id"]),
        expected_revenue_date=data.expected_revenue_date,
    )
    init_entry(m, current_user["name"])
    db.add(m)
    await db.commit()
    await db.refresh(m)
    # Audit log
    cust = await db.execute(select(Customer.name).where(Customer.id == m.customer_id))
    await log_audit(db, "mini_business", m.id, f"{cust.scalar_one_or_none() or ''} ({m.product_type})", "create", current_user["user_id"], current_user["name"])
    await db.commit()
    return await _enrich(m, db)


@router.get("/{item_id}")
async def get_mini_business(item_id: str, db: AsyncSession = Depends(get_db), current_user: dict = Depends(get_current_user)):
    result = await db.execute(select(MiniBusiness).where(MiniBusiness.id == item_id))
    m = result.scalar_one_or_none()
    if not m:
        raise HTTPException(status_code=404, detail="Not found")
    if current_user["role"] == "manager" and str(m.manager_id) != current_user["user_id"]:
        raise HTTPException(status_code=403, detail="Access denied")
    return await _enrich(m, db)


@router.put("/{item_id}")
async def update_mini_business(
    item_id: str, data: MiniBusinessUpdate,
    current_user: dict = Depends(require_any_role),
    db: AsyncSession = Depends(get_db),
):
    result = await db.execute(select(MiniBusiness).where(MiniBusiness.id == item_id))
    m = result.scalar_one_or_none()
    if not m:
        raise HTTPException(status_code=404, detail="Not found")
    if current_user["role"] == "manager" and str(m.manager_id) != current_user["user_id"]:
        raise HTTPException(status_code=403, detail="Access denied")

    old_snapshot = {"customer_id": str(m.customer_id), "product_type": m.product_type, "amount": m.amount, "follow_up_detail": m.follow_up_detail, "status": m.status, "expected_revenue_date": m.expected_revenue_date}
    update_data = data.model_dump(exclude_unset=True)
    for k, v in update_data.items():
        setattr(m, k, v)
    new_snapshot = {"customer_id": str(m.customer_id), "product_type": m.product_type, "amount": m.amount, "follow_up_detail": m.follow_up_detail, "status": m.status, "expected_revenue_date": m.expected_revenue_date}
    changes = compute_diff(old_snapshot, new_snapshot)
    if changes:
        append_entry(m, current_user["name"], changes, getattr(data, "edit_reason", None))
    await db.commit()
    await db.refresh(m)
    # Audit log
    cust = await db.execute(select(Customer.name).where(Customer.id == m.customer_id))
    await log_audit(db, "mini_business", m.id, f"{cust.scalar_one_or_none() or ''} ({m.product_type})", "update", current_user["user_id"], current_user["name"])
    await db.commit()
    return await _enrich(m, db)


@router.delete("/{item_id}")
async def delete_mini_business(
    item_id: str,
    current_user: dict = Depends(require_any_role),
    db: AsyncSession = Depends(get_db),
):
    result = await db.execute(select(MiniBusiness).where(MiniBusiness.id == item_id))
    m = result.scalar_one_or_none()
    if not m:
        raise HTTPException(status_code=404, detail="Not found")
    if current_user["role"] == "manager" and str(m.manager_id) != current_user["user_id"]:
        raise HTTPException(status_code=403, detail="Access denied")
    cust = await db.execute(select(Customer.name).where(Customer.id == m.customer_id))
    entity_name = f"{cust.scalar_one_or_none() or ''} ({m.product_type})"
    await db.delete(m)
    await db.commit()
    # Audit log
    await log_audit(db, "mini_business", uuid.UUID(item_id), entity_name, "delete", current_user["user_id"], current_user["name"])
    await db.commit()
    return {"detail": "deleted"}