qiji/backend/app/api/key_visits.py

import uuid
from typing import Optional
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, or_
from app.database import get_db
from app.middleware.auth import get_current_user, require_any_role
from app.models.key_visit import KeyVisit
from app.models.customer import Customer
from app.models.user import User
from app.schemas.key_visit import KeyVisitCreate, KeyVisitUpdate, KeyVisitOut
from app.utils.edit_log import compute_diff, append_entry, init_entry
from app.utils.audit import log_audit

router = APIRouter(prefix="/key-visits", tags=["KeyVisits"])


async def _enrich(k: KeyVisit, db: AsyncSession) -> dict:
    cust = await db.execute(select(Customer.name).where(Customer.id == k.customer_id))
    mgr = await db.execute(select(User.name).where(User.id == k.manager_id))
    return {
        "id": str(k.id),
        "customer_id": str(k.customer_id),
        "customer_name": cust.scalar_one_or_none(),
        "urgency_level": k.urgency_level,
        "description": k.description,
        "progress_status": k.progress_status,
        "planned_date": k.planned_date,
        "planned_visitor": k.planned_visitor,
        "visit_target": k.visit_target,
        "manager_id": str(k.manager_id),
        "edit_log": k.edit_log or [],
        "manager_name": mgr.scalar_one_or_none(),
    }


@router.get("/")
async def list_key_visits(
    customer_id: Optional[str] = Query(None),
    customer_type: Optional[str] = Query(None),
    search: Optional[str] = Query(None),
    current_user: dict = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
):
    query = select(KeyVisit)
    if current_user["role"] == "manager":
        query = query.where(KeyVisit.manager_id == uuid.UUID(current_user["user_id"]))
    if customer_id:
        query = query.where(KeyVisit.customer_id == uuid.UUID(customer_id))
    if customer_type:
        query = query.join(Customer, KeyVisit.customer_id == Customer.id).where(Customer.customer_type == customer_type)
    if search:
        query = query.outerjoin(Customer, KeyVisit.customer_id == Customer.id).where(
            or_(KeyVisit.description.ilike(f"%{search}%"), KeyVisit.planned_visitor.ilike(f"%{search}%"), Customer.name.ilike(f"%{search}%"))
        )
    query = query.order_by(KeyVisit.planned_date.desc()).limit(200)
    result = await db.execute(query)
    return [await _enrich(k, db) for k in result.scalars().all()]


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


@router.post("/")
async def create_key_visit(
    data: KeyVisitCreate,
    current_user: dict = Depends(require_any_role),
    db: AsyncSession = Depends(get_db),
):
    k = KeyVisit(
        customer_id=data.customer_id,
        urgency_level=data.urgency_level,
        description=data.description,
        progress_status=data.progress_status,
        planned_date=data.planned_date,
        planned_visitor=data.planned_visitor,
        visit_target=data.visit_target,
        manager_id=data.manager_id if (current_user["role"] in ("director", "leader") and data.manager_id) else uuid.UUID(current_user["user_id"]),
    )
    init_entry(k, current_user["name"])
    db.add(k)
    await db.commit()
    await db.refresh(k)
    # Audit log
    cust = await db.execute(select(Customer.name).where(Customer.id == k.customer_id))
    await log_audit(db, "key_visit", k.id, f"{cust.scalar_one_or_none() or ''} ({k.urgency_level})", "create", current_user["user_id"], current_user["name"])
    await db.commit()
    return await _enrich(k, db)


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


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

    old_snapshot = {"customer_id": str(k.customer_id), "urgency_level": k.urgency_level, "description": k.description, "progress_status": k.progress_status, "planned_date": k.planned_date, "planned_visitor": k.planned_visitor, "visit_target": k.visit_target}
    update_data = data.model_dump(exclude_unset=True)
    if current_user["role"] not in ("director", "leader"):
        update_data.pop("manager_id", None)
    if "manager_id" in update_data and update_data["manager_id"]:
        update_data["manager_id"] = uuid.UUID(update_data["manager_id"])
    for key, v in update_data.items():
        setattr(k, key, v)
    new_snapshot = {"customer_id": str(k.customer_id), "urgency_level": k.urgency_level, "description": k.description, "progress_status": k.progress_status, "planned_date": k.planned_date, "planned_visitor": k.planned_visitor, "visit_target": k.visit_target}
    changes = compute_diff(old_snapshot, new_snapshot)
    if changes:
        append_entry(k, current_user["name"], changes, getattr(data, "edit_reason", None))
    await db.commit()
    await db.refresh(k)
    # Audit log
    cust = await db.execute(select(Customer.name).where(Customer.id == k.customer_id))
    await log_audit(db, "key_visit", k.id, f"{cust.scalar_one_or_none() or ''} ({k.urgency_level})", "update", current_user["user_id"], current_user["name"])
    await db.commit()
    return await _enrich(k, db)


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