This commit is contained in:
zlwu committed 2026-05-18 16:21:38 +08:00
1 parent 2a4767a014
commit f269a994f4
61 files changed
+27430 -8

No files matched your search

+6
View File
@@ -10,6 +10,9 @@ from app.api.operations import router as operations_router
from app.api.ethnic import router as ethnic_router
from app.api.sample_reception import router as sample_reception_router
from app.api.qc import router as qc_router
from app.api.research_donation import router as research_donation_router
from app.api.production import router as production_router
from app.api.pilot_service import router as pilot_service_router
__all__ = [
"public_router",
@@ -23,4 +26,7 @@ __all__ = [
"ethnic_router",
"sample_reception_router",
"qc_router",
"research_donation_router",
"production_router",
"pilot_service_router",
]
File diff suppressed because it is too large. Load diff
+914
View File
@@ -0,0 +1,914 @@
"""生产管理 API 路由(7 个子模块:耗材、试剂、SOP文档、工艺工序分类、产出物类型、耗材包、工艺库)"""
from fastapi import APIRouter, Depends, Query
from pydantic import BaseModel, ConfigDict, Field
from sqlalchemy.orm import Session
from typing import Any, Optional, List
from app.core.database import get_db
from app.core.menu_guard import require_admin_or_super_admin, require_menu_code
from app.core.response import success_response, error_response
from app.crud import consumable as consumable_svc
from app.crud import reagent as reagent_svc
from app.crud import sop_document as sop_document_svc
from app.crud import process_category as process_category_svc
from app.crud import output_type as output_type_svc
from app.crud import consumable_pack as consumable_pack_svc
from app.crud import process as process_svc
from app.models.models import SysUser
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:
return "zkxw"
sys_user = db.query(SysUser).filter(SysUser.id == user_id).first()
return (sys_user.tenant_no if sys_user else None) or "zkxw"
# ---------------------------------------------------------------------------
# 1. 耗材
# ---------------------------------------------------------------------------
class ConsumableCreateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
consumable_code: str = Field(..., alias="consumableCode")
consumable_name: str = Field(..., alias="consumableName")
spec_model: Optional[str] = Field(None, alias="specModel")
standard_usage: Optional[str] = Field(None, alias="standardUsage")
description: Optional[str] = None
order_num: Optional[int] = Field(0, alias="orderNum")
remark: Optional[str] = None
class ConsumableUpdateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
consumable_code: Optional[str] = Field(None, alias="consumableCode")
consumable_name: Optional[str] = Field(None, alias="consumableName")
spec_model: Optional[str] = Field(None, alias="specModel")
standard_usage: Optional[str] = Field(None, alias="standardUsage")
description: Optional[str] = None
order_num: Optional[int] = Field(None, alias="orderNum")
remark: Optional[str] = None
@router.get("/consumables")
async def list_consumables(
page: int = Query(1, ge=1),
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
keyword: Optional[str] = None,
user: dict = Depends(require_menu_code("production:consumable:list")),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, total = consumable_svc.list_consumables(db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no)
tp = consumable_svc.total_pages(total, pageSize)
return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})
@router.get("/consumables/all")
async def list_all_consumables(
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, _ = consumable_svc.list_consumables(db, page=1, page_size=9999, tenant_no=tenant_no)
return success_response(items)
@router.post("/consumables")
async def create_consumable(
body: ConsumableCreateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
tenant_no = _get_tenant_no(db, user)
obj = consumable_svc.create_consumable(
db,
consumable_code=body.consumable_code,
consumable_name=body.consumable_name,
spec_model=body.spec_model,
standard_usage=body.standard_usage,
description=body.description,
tenant_no=tenant_no,
order_num=body.order_num,
remark=body.remark,
user_id=user.get("user_id"),
)
return success_response(consumable_svc._row_to_dict(obj), message="创建成功")
except ValueError as e:
return error_response(400, str(e))
@router.put("/consumables/{consumable_id}")
async def update_consumable(
consumable_id: str,
body: ConsumableUpdateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
obj = consumable_svc.update_consumable(
db,
consumable_id,
consumable_code=payload.get("consumable_code"),
consumable_name=payload.get("consumable_name"),
spec_model=payload.get("spec_model"),
standard_usage=payload.get("standard_usage"),
description=payload.get("description"),
order_num=payload.get("order_num"),
remark=payload.get("remark"),
user_id=user.get("user_id"),
)
return success_response(consumable_svc._row_to_dict(obj), message="更新成功")
except ValueError as e:
return error_response(400, str(e))
@router.delete("/consumables/{consumable_id}")
async def delete_consumable(
consumable_id: str,
_user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
consumable_svc.soft_delete_consumable(db, consumable_id)
return success_response(None, message="删除成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 2. 试剂
# ---------------------------------------------------------------------------
class ReagentCreateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
reagent_code: str = Field(..., alias="reagentCode")
reagent_name: str = Field(..., alias="reagentName")
spec: Optional[str] = None
standard_usage: Optional[str] = Field(None, alias="standardUsage")
unit: Optional[str] = None
description: Optional[str] = None
order_num: Optional[int] = Field(0, alias="orderNum")
remark: Optional[str] = None
class ReagentUpdateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
reagent_code: Optional[str] = Field(None, alias="reagentCode")
reagent_name: Optional[str] = Field(None, alias="reagentName")
spec: Optional[str] = None
standard_usage: Optional[str] = Field(None, alias="standardUsage")
unit: Optional[str] = None
description: Optional[str] = None
order_num: Optional[int] = Field(None, alias="orderNum")
remark: Optional[str] = None
@router.get("/reagents")
async def list_reagents(
page: int = Query(1, ge=1),
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
keyword: Optional[str] = None,
user: dict = Depends(require_menu_code("production:reagent:list")),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, total = reagent_svc.list_reagents(db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no)
tp = reagent_svc.total_pages(total, pageSize)
return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})
@router.get("/reagents/all")
async def list_all_reagents(
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, _ = reagent_svc.list_reagents(db, page=1, page_size=9999, tenant_no=tenant_no)
return success_response(items)
@router.post("/reagents")
async def create_reagent(
body: ReagentCreateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
tenant_no = _get_tenant_no(db, user)
obj = reagent_svc.create_reagent(
db,
reagent_code=body.reagent_code,
reagent_name=body.reagent_name,
spec=body.spec,
standard_usage=body.standard_usage,
unit=body.unit,
description=body.description,
tenant_no=tenant_no,
order_num=body.order_num,
remark=body.remark,
user_id=user.get("user_id"),
)
return success_response(reagent_svc._row_to_dict(obj), message="创建成功")
except ValueError as e:
return error_response(400, str(e))
@router.put("/reagents/{reagent_id}")
async def update_reagent(
reagent_id: str,
body: ReagentUpdateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
obj = reagent_svc.update_reagent(
db,
reagent_id,
reagent_code=payload.get("reagent_code"),
reagent_name=payload.get("reagent_name"),
spec=payload.get("spec"),
standard_usage=payload.get("standard_usage"),
unit=payload.get("unit"),
description=payload.get("description"),
order_num=payload.get("order_num"),
remark=payload.get("remark"),
user_id=user.get("user_id"),
)
return success_response(reagent_svc._row_to_dict(obj), message="更新成功")
except ValueError as e:
return error_response(400, str(e))
@router.delete("/reagents/{reagent_id}")
async def delete_reagent(
reagent_id: str,
_user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
reagent_svc.soft_delete_reagent(db, reagent_id)
return success_response(None, message="删除成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 3. SOP文档
# ---------------------------------------------------------------------------
class SopDocumentCreateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
sop_code: str = Field(..., alias="sopCode")
sop_name: str = Field(..., alias="sopName")
version_no: Optional[str] = Field(None, alias="versionNo")
sop_attachments: Optional[str] = Field(None, alias="sopAttachments")
order_num: Optional[int] = Field(0, alias="orderNum")
remark: Optional[str] = None
class SopDocumentUpdateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
sop_code: Optional[str] = Field(None, alias="sopCode")
sop_name: Optional[str] = Field(None, alias="sopName")
version_no: Optional[str] = Field(None, alias="versionNo")
sop_attachments: Optional[str] = Field(None, alias="sopAttachments")
order_num: Optional[int] = Field(None, alias="orderNum")
remark: Optional[str] = None
@router.get("/sop-documents")
async def list_sop_documents(
page: int = Query(1, ge=1),
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
keyword: Optional[str] = None,
user: dict = Depends(require_menu_code("production:sop-document:list")),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, total = sop_document_svc.list_sop_documents(db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no)
tp = sop_document_svc.total_pages(total, pageSize)
return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})
@router.get("/sop-documents/all")
async def list_all_sop_documents(
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, _ = sop_document_svc.list_sop_documents(db, page=1, page_size=9999, tenant_no=tenant_no)
return success_response(items)
@router.post("/sop-documents")
async def create_sop_document(
body: SopDocumentCreateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
tenant_no = _get_tenant_no(db, user)
obj = sop_document_svc.create_sop_document(
db,
sop_code=body.sop_code,
sop_name=body.sop_name,
version_no=body.version_no,
sop_attachments=body.sop_attachments,
tenant_no=tenant_no,
order_num=body.order_num,
remark=body.remark,
user_id=user.get("user_id"),
)
return success_response(sop_document_svc._row_to_dict(obj), message="创建成功")
except ValueError as e:
return error_response(400, str(e))
@router.put("/sop-documents/{sop_id}")
async def update_sop_document(
sop_id: str,
body: SopDocumentUpdateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
obj = sop_document_svc.update_sop_document(
db,
sop_id,
sop_code=payload.get("sop_code"),
sop_name=payload.get("sop_name"),
version_no=payload.get("version_no"),
sop_attachments=payload.get("sop_attachments"),
order_num=payload.get("order_num"),
remark=payload.get("remark"),
user_id=user.get("user_id"),
)
return success_response(sop_document_svc._row_to_dict(obj), message="更新成功")
except ValueError as e:
return error_response(400, str(e))
@router.delete("/sop-documents/{sop_id}")
async def delete_sop_document(
sop_id: str,
_user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
sop_document_svc.soft_delete_sop_document(db, sop_id)
return success_response(None, message="删除成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 4. 工艺工序分类
# ---------------------------------------------------------------------------
class ProcessCategoryCreateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
category_code: str = Field(..., alias="categoryCode")
category_name: str = Field(..., alias="categoryName")
order_num: Optional[int] = Field(0, alias="orderNum")
remark: Optional[str] = None
class ProcessCategoryUpdateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
category_code: Optional[str] = Field(None, alias="categoryCode")
category_name: Optional[str] = Field(None, alias="categoryName")
order_num: Optional[int] = Field(None, alias="orderNum")
remark: Optional[str] = None
@router.get("/process-categories")
async def list_process_categories(
page: int = Query(1, ge=1),
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
keyword: Optional[str] = None,
user: dict = Depends(require_menu_code("production:process-category:list")),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, total = process_category_svc.list_process_categories(db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no)
tp = process_category_svc.total_pages(total, pageSize)
return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})
@router.get("/process-categories/all")
async def list_all_process_categories(
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, _ = process_category_svc.list_process_categories(db, page=1, page_size=9999, tenant_no=tenant_no)
return success_response(items)
@router.post("/process-categories")
async def create_process_category(
body: ProcessCategoryCreateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
tenant_no = _get_tenant_no(db, user)
obj = process_category_svc.create_process_category(
db,
category_code=body.category_code,
category_name=body.category_name,
tenant_no=tenant_no,
order_num=body.order_num,
remark=body.remark,
user_id=user.get("user_id"),
)
return success_response(process_category_svc._row_to_dict(obj), message="创建成功")
except ValueError as e:
return error_response(400, str(e))
@router.put("/process-categories/{category_id}")
async def update_process_category(
category_id: str,
body: ProcessCategoryUpdateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
obj = process_category_svc.update_process_category(
db,
category_id,
category_code=payload.get("category_code"),
category_name=payload.get("category_name"),
order_num=payload.get("order_num"),
remark=payload.get("remark"),
user_id=user.get("user_id"),
)
return success_response(process_category_svc._row_to_dict(obj), message="更新成功")
except ValueError as e:
return error_response(400, str(e))
@router.delete("/process-categories/{category_id}")
async def delete_process_category(
category_id: str,
_user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
process_category_svc.soft_delete_process_category(db, category_id)
return success_response(None, message="删除成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 5. 工艺产出物类型
# ---------------------------------------------------------------------------
class OutputTypeCreateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
type_code: str = Field(..., alias="typeCode")
type_name: str = Field(..., alias="typeName")
order_num: Optional[int] = Field(0, alias="orderNum")
remark: Optional[str] = None
class OutputTypeUpdateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
type_code: Optional[str] = Field(None, alias="typeCode")
type_name: Optional[str] = Field(None, alias="typeName")
order_num: Optional[int] = Field(None, alias="orderNum")
remark: Optional[str] = None
@router.get("/output-types")
async def list_output_types(
page: int = Query(1, ge=1),
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
keyword: Optional[str] = None,
user: dict = Depends(require_menu_code("production:output-type:list")),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, total = output_type_svc.list_output_types(db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no)
tp = output_type_svc.total_pages(total, pageSize)
return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})
@router.get("/output-types/all")
async def list_all_output_types(
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, _ = output_type_svc.list_output_types(db, page=1, page_size=9999, tenant_no=tenant_no)
return success_response(items)
@router.post("/output-types")
async def create_output_type(
body: OutputTypeCreateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
tenant_no = _get_tenant_no(db, user)
obj = output_type_svc.create_output_type(
db,
type_code=body.type_code,
type_name=body.type_name,
tenant_no=tenant_no,
order_num=body.order_num,
remark=body.remark,
user_id=user.get("user_id"),
)
return success_response(output_type_svc._row_to_dict(obj), message="创建成功")
except ValueError as e:
return error_response(400, str(e))
@router.put("/output-types/{type_id}")
async def update_output_type(
type_id: str,
body: OutputTypeUpdateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
obj = output_type_svc.update_output_type(
db,
type_id,
type_code=payload.get("type_code"),
type_name=payload.get("type_name"),
order_num=payload.get("order_num"),
remark=payload.get("remark"),
user_id=user.get("user_id"),
)
return success_response(output_type_svc._row_to_dict(obj), message="更新成功")
except ValueError as e:
return error_response(400, str(e))
@router.delete("/output-types/{type_id}")
async def delete_output_type(
type_id: str,
_user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
output_type_svc.soft_delete_output_type(db, type_id)
return success_response(None, message="删除成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 6. 耗材包(主 + 子项)
# ---------------------------------------------------------------------------
class PackItemInput(BaseModel):
model_config = ConfigDict(populate_by_name=True)
consumable_code: Optional[str] = Field(None, alias="consumableCode")
consumable_name: Optional[str] = Field(None, alias="consumableName")
spec_model: Optional[str] = Field(None, alias="specModel")
standard_usage: Optional[str] = Field(None, alias="standardUsage")
remark: Optional[str] = None
class ConsumablePackCreateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
pack_code: str = Field(..., alias="packCode")
pack_name: str = Field(..., alias="packName")
usage_scene: Optional[str] = Field(None, alias="usageScene")
pack_type: Optional[str] = Field(None, alias="packType")
status: Optional[str] = "1"
order_num: Optional[int] = Field(0, alias="orderNum")
remark: Optional[str] = None
items: List[PackItemInput] = []
class ConsumablePackUpdateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
pack_code: Optional[str] = Field(None, alias="packCode")
pack_name: Optional[str] = Field(None, alias="packName")
usage_scene: Optional[str] = Field(None, alias="usageScene")
pack_type: Optional[str] = Field(None, alias="packType")
status: Optional[str] = None
order_num: Optional[int] = Field(None, alias="orderNum")
remark: Optional[str] = None
items: Optional[List[PackItemInput]] = None
@router.get("/consumable-packs")
async def list_consumable_packs(
page: int = Query(1, ge=1),
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
keyword: Optional[str] = None,
user: dict = Depends(require_menu_code("production:consumable-pack:list")),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, total = consumable_pack_svc.list_consumable_packs(db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no)
tp = consumable_pack_svc.total_pages(total, pageSize)
return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})
@router.get("/consumable-packs/all")
async def list_all_consumable_packs(
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items = consumable_pack_svc.list_all_packs(db, tenant_no)
return success_response(items)
@router.get("/consumable-packs/{pack_id}")
async def get_consumable_pack_detail(
pack_id: str,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
detail = consumable_pack_svc.get_pack_detail(db, pack_id)
if not detail:
return error_response(404, "耗材包不存在")
return success_response(detail)
@router.post("/consumable-packs")
async def create_consumable_pack(
body: ConsumablePackCreateBody,
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.items] if body.items else None
obj = consumable_pack_svc.create_consumable_pack(
db,
pack_code=body.pack_code,
pack_name=body.pack_name,
usage_scene=body.usage_scene,
pack_type=body.pack_type,
status=int(body.status) if body.status is not None else None,
items=items_data,
tenant_no=tenant_no,
order_num=body.order_num,
remark=body.remark,
user_id=user.get("user_id"),
)
return success_response(consumable_pack_svc._row_to_dict(obj), message="创建成功")
except ValueError as e:
return error_response(400, str(e))
@router.put("/consumable-packs/{pack_id}")
async def update_consumable_pack(
pack_id: str,
body: ConsumablePackUpdateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
items_data = [it.model_dump(by_alias=False) for it in body.items] if body.items is not None else None
obj = consumable_pack_svc.update_consumable_pack(
db,
pack_id,
pack_code=payload.get("pack_code"),
pack_name=payload.get("pack_name"),
usage_scene=payload.get("usage_scene"),
pack_type=payload.get("pack_type"),
status=int(payload["status"]) if "status" in payload else None,
items=items_data,
order_num=payload.get("order_num"),
remark=payload.get("remark"),
user_id=user.get("user_id"),
)
return success_response(consumable_pack_svc._row_to_dict(obj), message="更新成功")
except ValueError as e:
return error_response(400, str(e))
@router.delete("/consumable-packs/{pack_id}")
async def delete_consumable_pack(
pack_id: str,
_user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
consumable_pack_svc.soft_delete_consumable_pack(db, pack_id)
return success_response(None, message="删除成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 7. 工艺库(主 + 3 个子表:试剂、耗材、产出物)
# ---------------------------------------------------------------------------
class ProcessReagentInput(BaseModel):
model_config = ConfigDict(populate_by_name=True)
reagent_code: Optional[str] = Field(None, alias="reagentCode")
reagent_name: Optional[str] = Field(None, alias="reagentName")
spec: Optional[str] = None
standard_usage: Optional[str] = Field(None, alias="standardUsage")
unit: Optional[str] = None
is_key_material: Optional[str] = Field("0", alias="isKeyMaterial")
class ProcessConsumableInput(BaseModel):
model_config = ConfigDict(populate_by_name=True)
consumable_code: Optional[str] = Field(None, alias="consumableCode")
consumable_name: Optional[str] = Field(None, alias="consumableName")
spec_model: Optional[str] = Field(None, alias="specModel")
standard_usage: Optional[str] = Field(None, alias="standardUsage")
is_required: Optional[str] = Field("1", alias="isRequired")
remark: Optional[str] = None
class ProcessOutputInput(BaseModel):
model_config = ConfigDict(populate_by_name=True)
output_type_id: Optional[str] = Field(None, alias="outputTypeId")
output_name: Optional[str] = Field(None, alias="outputName")
output_barcode: Optional[str] = Field(None, alias="outputBarcode")
class ProcessCreateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
process_code: str = Field(..., alias="processCode")
category_id: Optional[str] = Field(None, alias="categoryId")
process_name: str = Field(..., alias="processName")
description: Optional[str] = None
equipment_name: Optional[str] = Field(None, alias="equipmentName")
estimated_duration: Optional[str] = Field(None, alias="estimatedDuration")
sop_ids: Optional[str] = Field(None, alias="sopIds")
order_num: Optional[int] = Field(0, alias="orderNum")
remark: Optional[str] = None
reagents: List[ProcessReagentInput] = []
consumables: List[ProcessConsumableInput] = []
outputs: List[ProcessOutputInput] = []
class ProcessUpdateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
process_code: Optional[str] = Field(None, alias="processCode")
category_id: Optional[str] = Field(None, alias="categoryId")
process_name: Optional[str] = Field(None, alias="processName")
description: Optional[str] = None
equipment_name: Optional[str] = Field(None, alias="equipmentName")
estimated_duration: Optional[str] = Field(None, alias="estimatedDuration")
sop_ids: Optional[str] = Field(None, alias="sopIds")
order_num: Optional[int] = Field(None, alias="orderNum")
remark: Optional[str] = None
reagents: Optional[List[ProcessReagentInput]] = None
consumables: Optional[List[ProcessConsumableInput]] = None
outputs: Optional[List[ProcessOutputInput]] = None
@router.get("/processes")
async def list_processes(
page: int = Query(1, ge=1),
pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
keyword: Optional[str] = None,
user: dict = Depends(require_menu_code("production:process:list")),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items, total = process_svc.list_processes(db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no)
tp = process_svc.total_pages(total, pageSize)
return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})
@router.get("/processes/all")
async def list_all_processes(
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
items = process_svc.list_all_processes(db, tenant_no)
return success_response(items)
@router.get("/processes/{process_id}")
async def get_process_detail(
process_id: str,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
detail = process_svc.get_process_detail(db, process_id)
if not detail:
return error_response(404, "工艺不存在")
return success_response(detail)
@router.post("/processes")
async def create_process(
body: ProcessCreateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
tenant_no = _get_tenant_no(db, user)
reagents_data = [r.model_dump(by_alias=False) for r in body.reagents] if body.reagents else None
consumables_data = [c.model_dump(by_alias=False) for c in body.consumables] if body.consumables else None
outputs_data = [o.model_dump(by_alias=False) for o in body.outputs] if body.outputs else None
# Convert string fields to appropriate types for sub-records
for rd in (reagents_data or []):
if "is_key_material" in rd and isinstance(rd["is_key_material"], str):
rd["is_key_material"] = int(rd["is_key_material"])
for cd in (consumables_data or []):
if "is_required" in cd and isinstance(cd["is_required"], str):
cd["is_required"] = int(cd["is_required"])
obj = process_svc.create_process(
db,
process_code=body.process_code,
category_id=body.category_id,
process_name=body.process_name,
description=body.description,
equipment_name=body.equipment_name,
estimated_duration=body.estimated_duration,
sop_ids=body.sop_ids,
reagents=reagents_data,
consumables=consumables_data,
outputs=outputs_data,
tenant_no=tenant_no,
order_num=body.order_num,
remark=body.remark,
user_id=user.get("user_id"),
)
return success_response(process_svc._row_to_dict(obj), message="创建成功")
except ValueError as e:
return error_response(400, str(e))
@router.put("/processes/{process_id}")
async def update_process(
process_id: str,
body: ProcessUpdateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
reagents_data = [r.model_dump(by_alias=False) for r in body.reagents] if body.reagents is not None else None
consumables_data = [c.model_dump(by_alias=False) for c in body.consumables] if body.consumables is not None else None
outputs_data = [o.model_dump(by_alias=False) for o in body.outputs] if body.outputs is not None else None
# Convert string fields to appropriate types for sub-records
for rd in (reagents_data or []):
if "is_key_material" in rd and isinstance(rd["is_key_material"], str):
rd["is_key_material"] = int(rd["is_key_material"])
for cd in (consumables_data or []):
if "is_required" in cd and isinstance(cd["is_required"], str):
cd["is_required"] = int(cd["is_required"])
obj = process_svc.update_process(
db,
process_id,
process_code=payload.get("process_code"),
category_id=payload.get("category_id"),
process_name=payload.get("process_name"),
description=payload.get("description"),
equipment_name=payload.get("equipment_name"),
estimated_duration=payload.get("estimated_duration"),
sop_ids=payload.get("sop_ids"),
reagents=reagents_data,
consumables=consumables_data,
outputs=outputs_data,
order_num=payload.get("order_num"),
remark=payload.get("remark"),
user_id=user.get("user_id"),
)
return success_response(process_svc._row_to_dict(obj), message="更新成功")
except ValueError as e:
return error_response(400, str(e))
@router.delete("/processes/{process_id}")
async def delete_process(
process_id: str,
_user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
try:
process_svc.soft_delete_process(db, process_id)
return success_response(None, message="删除成功")
except ValueError as e:
return error_response(400, str(e))
+385
View File
@@ -0,0 +1,385 @@
"""科研捐赠管理 — 捐赠单 CRUD / 审核 / 状态变更 / 转换 API"""
from typing import Any, Dict, List, Optional
from fastapi import APIRouter, Depends, Query
from pydantic import BaseModel, ConfigDict, Field
from sqlalchemy.orm import Session
from app.core.database import get_db
from app.core.menu_guard import require_admin_or_super_admin
from app.core.response import error_response, success_response
from app.crud import research_donation as rd_svc
from app.models.models import SysUser
from app.models.research_donation import BizResearchDonation
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)
# ---------------------------------------------------------------------------
# Pydantic bodies
# ---------------------------------------------------------------------------
class DonationCreateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
donation_no: str = Field(..., alias="donationNo")
donation_status: Optional[str] = Field("dsx", alias="donationStatus")
donation_date: Optional[str] = Field(None, alias="donationDate")
source_type: Optional[str] = Field("direct", alias="sourceType")
source_protocol_id: Optional[str] = Field(None, alias="sourceProtocolId")
consent_form_urls: Optional[str] = Field(None, alias="consentFormUrls")
attachment_urls: Optional[str] = Field(None, alias="attachmentUrls")
remark: Optional[str] = None
party: Optional[dict] = None
collection: Optional[dict] = None
samples: Optional[list] = None
class DonationUpdateBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
donation_no: Optional[str] = Field(None, alias="donationNo")
donation_status: Optional[str] = Field(None, alias="donationStatus")
donation_date: Optional[str] = Field(None, alias="donationDate")
source_type: Optional[str] = Field(None, alias="sourceType")
source_protocol_id: Optional[str] = Field(None, alias="sourceProtocolId")
consent_form_urls: Optional[str] = Field(None, alias="consentFormUrls")
attachment_urls: Optional[str] = Field(None, alias="attachmentUrls")
remark: Optional[str] = None
party: Optional[dict] = None
collection: Optional[dict] = None
samples: Optional[list] = None
class BatchDeleteBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
ids: List[str] = Field(..., alias="ids", min_length=1)
class AuditSubmitBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
audit_status: str = Field(..., alias="auditStatus")
audit_remark: Optional[str] = Field(None, alias="auditRemark")
class StatusChangeBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
new_status: str = Field(..., alias="newStatus")
desc: Optional[str] = Field(None, alias="desc")
time_val: Optional[str] = Field(None, alias="timeVal")
class ConvertFromStorageBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
protocol_id: str = Field(..., alias="protocolId")
# ---------------------------------------------------------------------------
# 1. 列表
# ---------------------------------------------------------------------------
@router.get("/research-donations")
async def list_research_donations(
page: int = Query(1, ge=1),
pageSize: int = Query(20, ge=1, le=200, alias="pageSize"),
keyword: Optional[str] = Query(None, alias="keyword"),
donationStatus: Optional[str] = Query(None, alias="donationStatus"),
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
collector_user_id = _get_current_user_id(user)
result = rd_svc.list_donations(
db,
tenant_no=tenant_no,
page=page,
page_size=pageSize,
keyword=keyword,
donation_status=donationStatus,
collector_user_id=collector_user_id,
)
return success_response(result)
# ---------------------------------------------------------------------------
# 2. 详情
# ---------------------------------------------------------------------------
@router.get("/research-donations/{donation_id}")
async def get_research_donation_detail(
donation_id: str,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
result = rd_svc.get_donation_detail(db, donation_id, tenant_no)
if not result:
return error_response(404, "捐赠单不存在或无权查看")
return success_response(result)
# ---------------------------------------------------------------------------
# 3. 创建
# ---------------------------------------------------------------------------
@router.post("/research-donations")
async def create_research_donation(
body: DonationCreateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
user_id = _get_current_user_id(user)
try:
data = body.model_dump(exclude_none=False, by_alias=True)
data["collector_user_id"] = user_id
obj = rd_svc.create_donation(
db,
data=data,
tenant_no=tenant_no,
user_id=user_id,
)
return success_response(rd_svc._donation_to_dict(obj), message="创建成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 4. 更新
# ---------------------------------------------------------------------------
@router.put("/research-donations/{donation_id}")
async def update_research_donation(
donation_id: str,
body: DonationUpdateBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
user_id = _get_current_user_id(user)
try:
data = body.model_dump(exclude_none=False, by_alias=True)
obj = rd_svc.update_donation(
db,
donation_id,
data=data,
tenant_no=tenant_no,
user_id=user_id,
)
return success_response(rd_svc._donation_to_dict(obj), message="更新成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 5. 删除
# ---------------------------------------------------------------------------
@router.delete("/research-donations/{donation_id}")
async def delete_research_donation(
donation_id: str,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
user_id = _get_current_user_id(user)
try:
rd_svc.delete_donation(
db,
donation_id,
tenant_no=tenant_no,
user_id=user_id,
)
return success_response(None, message="删除成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 6. 批量删除
# ---------------------------------------------------------------------------
@router.post("/research-donations/batch-delete")
async def batch_delete_research_donations(
body: BatchDeleteBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
user_id = _get_current_user_id(user)
try:
count = rd_svc.batch_delete_donations(
db,
ids=body.ids,
tenant_no=tenant_no,
user_id=user_id,
)
return success_response({"count": count}, message=f"已成功删除 {count} 条")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 7. 审核列表
# ---------------------------------------------------------------------------
@router.get("/research-donations/audits")
async def list_research_donation_audits(
page: int = Query(1, ge=1),
pageSize: int = Query(20, ge=1, le=200, alias="pageSize"),
keyword: Optional[str] = Query(None, alias="keyword"),
auditStatus: Optional[str] = Query(None, alias="auditStatus"),
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
result = rd_svc.list_audits(
db,
tenant_no=tenant_no,
page=page,
page_size=pageSize,
keyword=keyword,
audit_status=auditStatus,
)
return success_response(result)
# ---------------------------------------------------------------------------
# 8. 提交审核
# ---------------------------------------------------------------------------
@router.post("/research-donations/{donation_id}/audit")
async def submit_donation_audit(
donation_id: str,
body: AuditSubmitBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
try:
rd_svc.submit_audit(
db,
donation_id,
audit_status=body.audit_status,
audit_remark=body.audit_remark,
user_id=user.get("user_id"),
tenant_no=tenant_no,
)
d = (
db.query(BizResearchDonation)
.filter(BizResearchDonation.id == donation_id)
.first()
)
dn = (d.donation_no if d else "") or ""
return success_response({"donationNo": dn}, message="审核已提交")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 9. 状态变更
# ---------------------------------------------------------------------------
@router.post("/research-donations/{donation_id}/status-change")
async def change_donation_status(
donation_id: str,
body: StatusChangeBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
user_id = _get_current_user_id(user)
try:
obj = rd_svc.change_status(
db,
donation_id,
new_status=body.new_status,
desc=body.desc,
time_val=body.time_val,
user_id=user_id,
tenant_no=tenant_no,
)
return success_response(rd_svc._donation_to_dict(obj), message="状态变更成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 10. 细胞存储 → 科研捐赠
# ---------------------------------------------------------------------------
@router.post("/research-donations/convert-from-storage")
async def convert_from_storage(
body: ConvertFromStorageBody,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
user_id = _get_current_user_id(user)
try:
obj = rd_svc.convert_from_storage(
db,
body.protocol_id,
tenant_no=tenant_no,
user_id=user_id,
)
return success_response(rd_svc._donation_to_dict(obj), message="转换成功")
except ValueError as e:
return error_response(400, str(e))
# ---------------------------------------------------------------------------
# 11. 科研捐赠 → 细胞存储
# ---------------------------------------------------------------------------
@router.post("/research-donations/{donation_id}/convert-to-storage")
async def convert_to_storage(
donation_id: str,
user: dict = Depends(require_admin_or_super_admin),
db: Session = Depends(get_db),
):
tenant_no = _get_tenant_no(db, user)
user_id = _get_current_user_id(user)
try:
obj = rd_svc.convert_to_storage(
db,
donation_id,
tenant_no=tenant_no,
user_id=user_id,
)
return success_response(rd_svc._donation_to_dict(obj), message="转换成功")
except ValueError as e:
return error_response(400, str(e))