dingdanquanliucheng/backend/app/api/orders.py

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

from backend.app.api.deps import get_order_service, require_permissions, require_roles
from backend.app.core.error_codes import ErrorCode
from backend.app.core.exceptions import AppException
from backend.app.db import get_db_session
from backend.app.schemas.common import success_payload
from backend.app.schemas.orders import (
    ApproveOrderRequest,
    CancelOrderRequest,
    ChangeOrderStatusRequest,
    ConfirmSupplierTextRequest,
    CreateOrderRequest,
    SupplierTextRequest,
)
from backend.app.services.order_service import OrderService

router = APIRouter(prefix="/api/orders", tags=["orders"])


@router.get("")
def list_orders(
    order_no: str | None = Query(default=None),
    order_status: str | None = Query(default=None),
    customer_name: str | None = Query(default=None),
    customer_mobile: str | None = Query(default=None),
    salesman_id: int | None = Query(default=None),
    factory_id: int | None = Query(default=None),
    order_source: str | None = Query(default=None),
    start_time: str | None = Query(default=None),
    end_time: str | None = Query(default=None),
    page_no: int = Query(default=1),
    page_size: int = Query(default=20),
    order_service: OrderService = Depends(get_order_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("salesman", "manager", "admin")),
    _permission_user: dict = Depends(require_permissions("order:list")),
) -> dict:
    orders = order_service.list_orders(
        session,
        order_service.normalize_list_filters(
            {
            "order_no": order_no,
            "order_status": order_status,
            "customer_name": customer_name,
            "customer_mobile": customer_mobile,
            "salesman_id": salesman_id,
            "factory_id": factory_id,
            "order_source": order_source,
            "start_time": start_time,
            "end_time": end_time,
            },
            current_user,
        ),
    )
    start = max(page_no - 1, 0) * page_size
    page_list = orders[start : start + page_size]
    return success_payload(
        {
            "total": len(orders),
            "page_no": page_no,
            "page_size": page_size,
            "list": page_list,
        }
    )


@router.post("")
def create_order(
    payload: CreateOrderRequest,
    order_service: OrderService = Depends(get_order_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("salesman", "admin")),
    _permission_user: dict = Depends(require_permissions("order:create")),
) -> dict:
    if not payload.items:
        raise AppException(code=ErrorCode.PARAM_ERROR, message="订单明细不能为空", status_code=400)
    order = order_service.create_order(payload.model_dump(), session, current_user)
    return success_payload(order)


@router.get("/{order_id}")
def get_order(
    order_id: int,
    order_service: OrderService = Depends(get_order_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("salesman", "manager", "admin")),
    _permission_user: dict = Depends(require_permissions("order:list")),
) -> dict:
    order = order_service.get_order(order_id, session, current_user)
    if not order:
        raise AppException(code=ErrorCode.NOT_FOUND, message="订单不存在", status_code=404)
    return success_payload(order)


@router.post("/{order_id}/submit")
def submit_order(
    order_id: int,
    order_service: OrderService = Depends(get_order_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("salesman", "admin")),
    _permission_user: dict = Depends(require_permissions("order:submit")),
) -> dict:
    order = order_service.submit_order(order_id, session, current_user)
    if not order:
        raise AppException(code=ErrorCode.NOT_FOUND, message="订单不存在", status_code=404)
    return success_payload(order)


@router.post("/{order_id}/cancel")
def cancel_order(
    order_id: int,
    payload: CancelOrderRequest,
    order_service: OrderService = Depends(get_order_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("salesman", "admin")),
    _permission_user: dict = Depends(require_permissions("order:list")),
) -> dict:
    order = order_service.cancel_order(order_id, payload.model_dump(), session, current_user)
    if not order:
        raise AppException(code=ErrorCode.NOT_FOUND, message="订单不存在", status_code=404)
    return success_payload(order)


@router.post("/{order_id}/status")
def change_order_status(
    order_id: int,
    payload: ChangeOrderStatusRequest,
    order_service: OrderService = Depends(get_order_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("manager", "admin")),
    _permission_user: dict = Depends(require_permissions("logistics:task:create")),
) -> dict:
    order = order_service.change_order_status(order_id, payload.model_dump(), session, current_user)
    if not order:
        raise AppException(code=ErrorCode.NOT_FOUND, message="订单不存在", status_code=404)
    return success_payload(order)


@router.post("/{order_id}/approve")
def approve_order(
    order_id: int,
    payload: ApproveOrderRequest,
    order_service: OrderService = Depends(get_order_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("manager", "admin")),
    _permission_user: dict = Depends(require_permissions("order:approve")),
) -> dict:
    order = order_service.approve_order(order_id, payload.model_dump(), session, current_user)
    if not order:
        raise AppException(code=ErrorCode.NOT_FOUND, message="订单不存在", status_code=404)
    return success_payload(order)


@router.post("/{order_id}/cancel-approve")
def cancel_approve_order(
    order_id: int,
    payload: ApproveOrderRequest,
    order_service: OrderService = Depends(get_order_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("manager", "admin")),
    _permission_user: dict = Depends(require_permissions("order:cancel-approve")),
) -> dict:
    order = order_service.cancel_approve_order(order_id, payload.model_dump(), session, current_user)
    if not order:
        raise AppException(code=ErrorCode.NOT_FOUND, message="订单不存在", status_code=404)
    return success_payload(order)


@router.post("/{order_id}/supplier-text")
def supplier_text(
    order_id: int,
    payload: SupplierTextRequest,
    order_service: OrderService = Depends(get_order_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("manager", "admin")),
    _permission_user: dict = Depends(require_permissions("order:supplier-text")),
) -> dict:
    order = order_service.get_supplier_text(order_id, payload.model_dump(), session, current_user)
    if not order:
        raise AppException(code=ErrorCode.NOT_FOUND, message="订单不存在", status_code=404)
    return success_payload(order)


@router.post("/{order_id}/supplier-text/confirm")
def confirm_supplier_text(
    order_id: int,
    payload: ConfirmSupplierTextRequest,
    order_service: OrderService = Depends(get_order_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("manager", "admin")),
    _permission_user: dict = Depends(require_permissions("order:supplier-text")),
) -> dict:
    order = order_service.confirm_supplier_text(order_id, payload.model_dump(), session, current_user)
    if not order:
        raise AppException(code=ErrorCode.NOT_FOUND, message="订单不存在", status_code=404)
    return success_payload(order)