From 4b676886b0f7525da1f83101ec31a52f0eff56e2 Mon Sep 17 00:00:00 2001 From: zlwu <704541015@qq.com> Date: Wed, 20 May 2026 00:22:21 +0800 Subject: [PATCH] feat: append 21 API routes for work orders, production tasks, and cell products to production router --- backend/app/api/production.py | 416 ++++++++++++++++++++++++++++++++++ 1 file changed, 416 insertions(+) diff --git a/backend/app/api/production.py b/backend/app/api/production.py index 939416e8a..d4cb0e0c4 100644 --- a/backend/app/api/production.py +++ b/backend/app/api/production.py @@ -29,6 +29,22 @@ from app.schemas.process_route import ( StepDataCollectionUpdateBody, ) from app.models.models import SysUser +from app.crud import production_work_order as production_work_order_svc +from app.crud import production_task as production_task_svc +from app.crud import cell_product as cell_product_svc +from app.schemas.production_work_order import ProductionWorkOrderListQuery, ProductionWorkOrderComplete +from app.schemas.production_task import ( + ProductionTaskCreate, + ProductionTaskUpdate, + ProductionTaskStatusUpdate, + TaskStepAdd, + TaskStepUpdate, + TaskStepMaterialItem, + TaskStepDataCollectionItem, + TaskInputItem, + TaskOutputItem, +) +from app.schemas.cell_product import CellProductCreate, CellProductUpdate router = APIRouter(prefix="/web/admin", tags=["生产管理"]) @@ -1210,3 +1226,403 @@ async def update_step_data_collections( return success_response(None, message="更新成功") except ValueError as e: return error_response(400, str(e)) + + +# --------------------------------------------------------------------------- +# 9. 入库生产工单 +# --------------------------------------------------------------------------- + + +@router.get("/production-work-orders") +async def list_production_work_orders( + page: int = Query(1, ge=1), + pageSize: int = Query(10, ge=1, le=100, alias="pageSize"), + workOrderNo: Optional[str] = None, + workOrderStatus: Optional[str] = None, + protocolNo: Optional[str] = None, + sampleCode: Optional[str] = None, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + tenant_no = _get_tenant_no(db, user) + query = ProductionWorkOrderListQuery( + page=page, page_size=pageSize, + work_order_no=workOrderNo, work_order_status=workOrderStatus, + protocol_no=protocolNo, sample_code=sampleCode, + ) + result = production_work_order_svc.list_production_work_orders( + db, tenant_no=tenant_no, query=query, page=page, page_size=pageSize, + ) + items = result.get("items", []) + total = result.get("total", 0) + tp = production_task_svc.total_pages(total, pageSize) + return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}) + + +@router.get("/production-work-orders/{wo_id}") +async def get_production_work_order( + wo_id: str, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + tenant_no = _get_tenant_no(db, user) + wo = production_work_order_svc.get_production_work_order(db, wo_id, tenant_no) + if not wo: + return error_response(404, "工单不存在") + return success_response(production_work_order_svc._wo_to_dict(wo)) + + +@router.put("/production-work-orders/{wo_id}/complete") +async def complete_production_work_order( + wo_id: str, + body: ProductionWorkOrderComplete, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + wo = production_work_order_svc.complete_production_work_order( + db, wo_id, tenant_no, user.get("user_id"), body, + ) + return success_response(production_work_order_svc._wo_to_dict(wo), message="操作成功") + except ValueError as e: + return error_response(400, str(e)) + + +# --------------------------------------------------------------------------- +# 10. 生产任务 +# --------------------------------------------------------------------------- + + +@router.post("/production-tasks") +async def create_production_task( + body: ProductionTaskCreate, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + data = body.model_dump(by_alias=False) + task = production_task_svc.create_production_task( + db, tenant_no=tenant_no, user_id=user.get("user_id"), + create_dept_id="", data=data, + ) + db.commit() + return success_response(production_task_svc._task_to_dict(task), message="创建成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.get("/production-tasks") +async def list_production_tasks( + page: int = Query(1, ge=1), + pageSize: int = Query(10, ge=1, le=100, alias="pageSize"), + workOrderId: Optional[str] = None, + taskNo: Optional[str] = None, + taskStatus: Optional[str] = None, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + tenant_no = _get_tenant_no(db, user) + items, total = production_task_svc.list_production_tasks( + db, tenant_no=tenant_no, page=page, page_size=pageSize, + work_order_id=workOrderId, task_no=taskNo, task_status=taskStatus, + ) + tp = production_task_svc.total_pages(total, pageSize) + return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}) + + +@router.get("/production-tasks/{task_id}") +async def get_production_task_detail( + task_id: str, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + tenant_no = _get_tenant_no(db, user) + detail = production_task_svc.get_production_task_detail(db, task_id, tenant_no) + if not detail: + return error_response(404, "任务不存在") + return success_response(detail) + + +@router.put("/production-tasks/{task_id}") +async def update_production_task( + task_id: str, + body: ProductionTaskUpdate, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + data = body.model_dump(exclude_unset=True, by_alias=False) + task = production_task_svc.update_production_task( + db, task_id, tenant_no, user.get("user_id"), data, + ) + return success_response(production_task_svc._task_to_dict(task), message="更新成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.put("/production-tasks/{task_id}/status") +async def update_production_task_status( + task_id: str, + body: ProductionTaskStatusUpdate, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + task = production_task_svc.update_task_status( + db, task_id, tenant_no, user.get("user_id"), body.task_status, + ) + return success_response(production_task_svc._task_to_dict(task), message="操作成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.post("/production-tasks/{task_id}/steps") +async def add_production_task_step( + task_id: str, + body: TaskStepAdd, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + data = body.model_dump(by_alias=False) + step_data = production_task_svc.add_task_step( + db, task_id, tenant_no, user.get("user_id"), data, + ) + return success_response(step_data, message="添加成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.put("/production-tasks/{task_id}/steps/{step_id}") +async def update_production_task_step( + task_id: str, + step_id: str, + body: TaskStepUpdate, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + data = body.model_dump(exclude_unset=True, by_alias=False) + step = production_task_svc.update_task_step( + db, step_id, tenant_no, user.get("user_id"), data, + ) + return success_response(production_task_svc._step_to_dict(step), message="更新成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.delete("/production-tasks/{task_id}/steps/{step_id}") +async def delete_production_task_step( + task_id: str, + step_id: str, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + production_task_svc.delete_task_step(db, step_id, tenant_no, user.get("user_id")) + return success_response(None, message="删除成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.put("/production-tasks/{task_id}/steps/{step_id}/reagents") +async def replace_task_step_reagents( + task_id: str, + step_id: str, + body: List[TaskStepMaterialItem], + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + items_data = [] + for it in body: + d = it.model_dump(by_alias=False) + items_data.append({ + "reagent_code": d.get("material_code"), + "reagent_name": d.get("material_name"), + "spec": d.get("spec"), + "standard_usage": d.get("standard_usage"), + "actual_usage": d.get("actual_usage"), + "unit": d.get("unit"), + "is_key_material": d.get("is_key_material", "0"), + "remark": d.get("remark"), + }) + production_task_svc.replace_step_reagents(db, step_id, tenant_no, user.get("user_id"), items_data) + return success_response(None, message="更新成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.put("/production-tasks/{task_id}/steps/{step_id}/consumables") +async def replace_task_step_consumables( + task_id: str, + step_id: str, + body: List[TaskStepMaterialItem], + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + items_data = [] + for it in body: + d = it.model_dump(by_alias=False) + items_data.append({ + "consumable_code": d.get("material_code"), + "consumable_name": d.get("material_name"), + "spec_model": d.get("spec_model"), + "standard_usage": d.get("standard_usage"), + "actual_usage": d.get("actual_usage"), + "unit": d.get("unit"), + "is_required": d.get("is_required", "1"), + "remark": d.get("remark"), + }) + production_task_svc.replace_step_consumables(db, step_id, tenant_no, user.get("user_id"), items_data) + return success_response(None, message="更新成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.put("/production-tasks/{task_id}/steps/{step_id}/data-collection") +async def replace_task_step_data_collections( + task_id: str, + step_id: str, + body: List[TaskStepDataCollectionItem], + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + items_data = [it.model_dump(by_alias=False) for it in body] + production_task_svc.replace_step_data_collections(db, step_id, tenant_no, user.get("user_id"), items_data) + return success_response(None, message="更新成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.post("/production-tasks/{task_id}/inputs") +async def set_production_task_inputs( + task_id: str, + body: List[TaskInputItem], + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + items_data = [it.model_dump(by_alias=False) for it in body] + production_task_svc.set_task_inputs(db, task_id, tenant_no, user.get("user_id"), items_data) + return success_response(None, message="设置成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.post("/production-tasks/{task_id}/outputs") +async def set_production_task_outputs( + task_id: str, + body: List[TaskOutputItem], + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + items_data = [it.model_dump(by_alias=False) for it in body] + production_task_svc.set_task_outputs(db, task_id, tenant_no, user.get("user_id"), items_data) + return success_response(None, message="设置成功") + except ValueError as e: + return error_response(400, str(e)) + + +# --------------------------------------------------------------------------- +# 11. 细胞产品库 +# --------------------------------------------------------------------------- + + +@router.get("/cell-products") +async def list_cell_products( + page: int = Query(1, ge=1), + pageSize: int = Query(10, ge=1, le=100, alias="pageSize"), + productCode: Optional[str] = None, + productName: Optional[str] = None, + productTypeId: Optional[str] = None, + productStatus: Optional[str] = None, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + tenant_no = _get_tenant_no(db, user) + result = cell_product_svc.list_cell_products( + db, tenant_no=tenant_no, page=page, page_size=pageSize, + product_code=productCode, product_name=productName, + product_type_id=productTypeId, product_status=productStatus, + ) + items = result.get("items", []) + total = result.get("total", 0) + tp = cell_product_svc.total_pages(total, pageSize) + return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp}) + + +@router.get("/cell-products/{product_id}") +async def get_cell_product_detail( + product_id: str, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + tenant_no = _get_tenant_no(db, user) + obj = cell_product_svc.get_cell_product(db, product_id, tenant_no) + if not obj: + return error_response(404, "细胞产品不存在") + return success_response(cell_product_svc._row_to_dict(obj)) + + +@router.post("/cell-products") +async def create_cell_product( + body: CellProductCreate, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + obj = cell_product_svc.create_cell_product( + db, tenant_no=tenant_no, user_id=user.get("user_id"), + create_dept_id="", data=body, + ) + return success_response(cell_product_svc._row_to_dict(obj), message="创建成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.put("/cell-products/{product_id}") +async def update_cell_product( + product_id: str, + body: CellProductUpdate, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + obj = cell_product_svc.update_cell_product( + db, product_id, tenant_no, user.get("user_id"), data=body, + ) + return success_response(cell_product_svc._row_to_dict(obj), message="更新成功") + except ValueError as e: + return error_response(400, str(e)) + + +@router.delete("/cell-products/{product_id}") +async def delete_cell_product( + product_id: str, + user: dict = Depends(require_admin_or_super_admin), + db: Session = Depends(get_db), +): + try: + tenant_no = _get_tenant_no(db, user) + cell_product_svc.delete_cell_product(db, product_id, tenant_no, user.get("user_id")) + return success_response(None, message="删除成功") + except ValueError as e: + return error_response(400, str(e))