zkxw/backend/app/api/storage_release_review.py

from typing import Optional

from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session

from app.core.database import get_db
from app.core.menu_guard import (
    require_admin_or_super_admin,
    require_any_menu_code,
    user_has_menu_perm,
)
from app.core.response import error_response, success_response
from app.crud import storage_release_review as srr_svc
from app.models.models import SysUser
from app.schemas.storage_release_review import (
    BatchReviewBody,
    BatchStoreBody,
    ReviewSubmitBody,
)

router = APIRouter(prefix="/web/admin", tags=["入库放行审核"])


def _get_tenant_no(db: Session, user: dict) -> str:
    user_id = user.get("user_id")
    if not user_id:
        raise PermissionError("用户身份信息缺失，无法确定租户")
    sys_user = db.query(SysUser).filter(SysUser.id == user_id).first()
    if not sys_user or not sys_user.tenant_no:
        raise PermissionError("用户租户信息缺失")
    return sys_user.tenant_no


def _get_current_user_id(user: dict) -> str:
    user_id = user.get("user_id")
    if not user_id:
        raise PermissionError("用户身份信息缺失")
    return str(user_id)


STORAGE_RELEASE_READ_MENU_CODES = (
    "biz:storageReleaseReview:list",
    "production:storageReleaseReview:list",
    "quality:storageReleaseReview:list",
)
STORAGE_RELEASE_WRITE_MENU_CODES = (
    "production:storageReleaseReview:list",
    "quality:storageReleaseReview:list",
)


def _ensure_review_side_write(db: Session, user: dict, review_side: str) -> str:
    side = srr_svc.normalize_review_side(review_side)
    if side not in ("production", "qc"):
        raise ValueError("审核侧无效")
    menu = srr_svc.review_side_required_menu(side)
    if not menu or not user_has_menu_perm(db, user, menu):
        raise PermissionError("无权提交该侧审核")
    return side


def _ensure_storage_write(db: Session, user: dict) -> None:
    if not any(user_has_menu_perm(db, user, code) for code in STORAGE_RELEASE_WRITE_MENU_CODES):
        raise PermissionError("无权执行入库操作")


@router.get("/storage-release-reviews")
async def list_storage_release_reviews(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    receptionSource: Optional[str] = None,
    reviewConclusion: Optional[str] = None,
    storageStatus: Optional[str] = None,
    reviewPhase: Optional[str] = None,
    qcWorkOrderCompleted: Optional[bool] = Query(None),
    readyForReviewOnly: Optional[bool] = Query(None),
    reviewSide: Optional[str] = None,
    prodReviewConclusion: Optional[str] = None,
    qcReviewConclusion: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code(*STORAGE_RELEASE_READ_MENU_CODES)),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        result = srr_svc.list_reviews(
            db,
            tenant_no=tenant_no,
            page=page,
            page_size=pageSize,
            reception_source=receptionSource,
            review_conclusion=reviewConclusion,
            storage_status=storageStatus,
            keyword=keyword,
            review_phase=reviewPhase,
            qc_work_order_completed=qcWorkOrderCompleted,
            ready_for_review_only=readyForReviewOnly,
            review_side=reviewSide,
            prod_review_conclusion=prodReviewConclusion,
            qc_review_conclusion=qcReviewConclusion,
            user_info=user,
        )
        return success_response(result)
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/storage-release-reviews/{review_id}")
async def get_storage_release_review_detail(
    review_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code(*STORAGE_RELEASE_READ_MENU_CODES)),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        detail = srr_svc.get_review_detail(db, review_id, tenant_no)
        if not detail:
            return error_response(404, "审核记录不存在")
        return success_response(detail)
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/storage-release-reviews/{review_id}/review")
async def submit_single_review(
    review_id: str,
    body: ReviewSubmitBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_admin_or_super_admin),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        side = _ensure_review_side_write(db, user, body.reviewSide)
        rev = srr_svc.submit_review(
            db,
            review_id,
            review_side=side,
            review_conclusion=body.reviewConclusion,
            review_remark=body.reviewRemark,
            review_attachments=body.reviewAttachments,
            tenant_no=tenant_no,
            user_id=user_id,
        )
        db.commit()
        return success_response(srr_svc._row_to_dict(rev))
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/storage-release-reviews/batch-review")
async def batch_review(
    body: BatchReviewBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_admin_or_super_admin),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        side = _ensure_review_side_write(db, user, body.reviewSide)
        result = srr_svc.batch_submit_review(
            db,
            body.ids,
            review_side=side,
            review_conclusion=body.reviewConclusion,
            review_remark=body.reviewRemark,
            review_attachments=body.reviewAttachments,
            tenant_no=tenant_no,
            user_id=user_id,
        )
        db.commit()
        return success_response(result)
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/storage-release-reviews/{review_id}/store")
async def store_single_sample(
    review_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_admin_or_super_admin),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        _ensure_storage_write(db, user)
        rev = srr_svc.store_sample(
            db,
            review_id,
            tenant_no=tenant_no,
            user_id=user_id,
        )
        db.commit()
        return success_response(srr_svc._row_to_dict(rev))
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/storage-release-reviews/batch-store")
async def batch_store_samples(
    body: BatchStoreBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_admin_or_super_admin),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        _ensure_storage_write(db, user)
        result = srr_svc.batch_store_samples(
            db,
            body.ids,
            tenant_no=tenant_no,
            user_id=user_id,
        )
        db.commit()
        return success_response(result)
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))