init: 初始化 dpb 桃育种系统代码库

前后端 + 后端 FastAPI 全量源码、部署脚本与文档。
This commit is contained in:
34047007@qq.com
2026-08-06 00:17:49 +08:00
commit b95053c52c
1469 changed files with 322298 additions and 0 deletions
@@ -0,0 +1,134 @@
import urllib.parse
from typing import Annotated
from fastapi import APIRouter, Body, Depends, File, Path, Query, UploadFile
from fastapi.responses import JSONResponse, StreamingResponse
from sqlalchemy.ext.asyncio import AsyncSession
from app.common.response import ResponseSchema, StreamResponse, SuccessResponse
from app.core.base_schema import AuthSchema, PageResultSchema, PaginationQueryParam, ImportResultSchema
from app.core.dependencies import AuthPermission, db_getter
from app.core.router_class import OperationLogRoute
from app.utils.common_util import bytes2file_response
from .schema import (
RootstockCreateSchema,
RootstockOutSchema,
RootstockQueryParam,
RootstockUpdateSchema,
)
from .service import RootstockService
RootstockRouter = APIRouter(route_class=OperationLogRoute, prefix="/rootstock", tags=["砧木管理"])
@RootstockRouter.get("/detail/{id}", summary="获取砧木详情", response_model=ResponseSchema[RootstockOutSchema])
async def get_rootstock__detail_controller(
auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:detail"]))],
id: Annotated[int, Path(description="砧木ID")],
db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
service = RootstockService(auth, db)
result_dict = await service.detail(id=id)
return SuccessResponse(data=result_dict, msg="获取砧木详情成功")
@RootstockRouter.get("/list", summary="分页查询砧木", response_model=ResponseSchema[PageResultSchema[RootstockOutSchema]])
async def get_rootstock__list_controller(
auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:query"]))],
page: Annotated[PaginationQueryParam, Depends()],
search: Annotated[RootstockQueryParam, Query()],
db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
service = RootstockService(auth, db)
result_dict = await service.page(
page_no=page.page_no,
page_size=page.page_size,
search=search,
order_by=page.order_by,
)
return SuccessResponse(data=result_dict, msg="查询砧木列表成功")
@RootstockRouter.get("/options", summary="砧木下拉选项")
async def get_rootstock__options_controller(
auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:query"]))],
db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
service = RootstockService(auth, db)
options = await service.list_options()
return SuccessResponse(data=options, msg="获取砧木选项成功")
@RootstockRouter.post("/create", summary="创建砧木", response_model=ResponseSchema[RootstockOutSchema])
async def create_rootstock__controller(
auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:create"]))],
data: Annotated[RootstockCreateSchema, Body(description="创建参数")],
db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
service = RootstockService(auth, db)
result_dict = await service.create(data=data)
return SuccessResponse(data=result_dict, msg="创建砧木成功")
@RootstockRouter.put("/update/{id}", summary="修改砧木", response_model=ResponseSchema[RootstockOutSchema])
async def update_rootstock__controller(
auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:update"]))],
id: Annotated[int, Path(description="砧木ID")],
data: Annotated[RootstockUpdateSchema, Body(description="修改参数")],
db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
service = RootstockService(auth, db)
result_dict = await service.update(id=id, data=data)
return SuccessResponse(data=result_dict, msg="修改砧木成功")
@RootstockRouter.delete("/delete", summary="删除砧木", response_model=ResponseSchema[None])
async def delete_rootstock__controller(
auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:delete"]))],
ids: Annotated[list[int], Body(description="ID列表")],
db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
service = RootstockService(auth, db)
await service.delete(ids=ids)
return SuccessResponse(msg="删除砧木成功")
@RootstockRouter.post("/export", summary="导出砧木")
async def export_rootstock__controller(
auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:export"]))],
search: Annotated[RootstockQueryParam, Query()],
db: Annotated[AsyncSession, Depends(db_getter)],
) -> StreamingResponse:
service = RootstockService(auth, db)
result_dict_list = await service.get_list(search=search)
export_result = RootstockService.batch_export(obj_list=[item.model_dump() for item in result_dict_list])
return StreamResponse(
data=bytes2file_response(export_result),
media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
headers={"Content-Disposition": f"attachment; filename={urllib.parse.quote('砧木管理.xlsx')}"},
)
@RootstockRouter.post("/import", summary="导入砧木", response_model=ResponseSchema[ImportResultSchema])
async def import_rootstock__controller(
file: Annotated[UploadFile, File(description="导入文件")],
auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:import"]))],
db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
service = RootstockService(auth, db)
batch_import_result = await service.batch_import(file=file, update_support=True)
return SuccessResponse(data=batch_import_result, msg="导入砧木成功")
@RootstockRouter.post("/download/template", summary="获取砧木导入模板", dependencies=[Depends(AuthPermission(["module_bre:rootstock:download"]))])
async def download_rootstock__template_controller() -> StreamingResponse:
import_template_result = RootstockService.import_template_download()
return StreamResponse(
data=bytes2file_response(import_template_result),
media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
headers={
"Content-Disposition": f"attachment; filename={urllib.parse.quote('砧木管理导入模板.xlsx')}",
"Access-Control-Expose-Headers": "Content-Disposition",
},
)
@@ -0,0 +1,18 @@
from typing import Any
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.base_crud import CRUDBase
from app.core.base_schema import AuthSchema
from .model import RootstockModel
class BreedingRootstockCRUD(CRUDBase[RootstockModel, Any, Any]):
"""砧木 CRUD —— 直接复用 CRUDBase(已自动注入数据权限过滤)。"""
def __init__(self, auth: AuthSchema, db: AsyncSession) -> None:
super().__init__(RootstockModel, auth, db)
rootstock_crud = BreedingRootstockCRUD
@@ -0,0 +1,27 @@
"""砧木 数据模型"""
from sqlalchemy import Index, String
from sqlalchemy.orm import Mapped, mapped_column
from app.core.base_model import MappedBase, ModelMixin, UserMixin
class RootstockModel(ModelMixin, UserMixin, MappedBase):
"""砧木字典(规格 §3.17)。"""
__tablename__ = "bre_rootstock"
rootstock_code: Mapped[str | None] = mapped_column(String(32), nullable=True, comment="砧木编号", default=None)
rootstock_name: Mapped[str] = mapped_column(String(128), nullable=False, comment="砧木名称")
dwarf_class: Mapped[str | None] = mapped_column(String(32), nullable=True, comment="矮化类(矮化/半矮化/乔化/柱状)", default=None)
compatibility: Mapped[str | None] = mapped_column(String(16), nullable=True, comment="砧穗亲和性(强/中/弱)", default=None)
remark: Mapped[str | None] = mapped_column(String(512), nullable=True, comment="备注", default=None)
# 无 status 列:覆盖基类默认 ix_<表>_status_deleted 索引,
# 仅保留 (created_time, is_deleted) 复合索引用于数据权限过滤。
__table_args__ = (
Index("ix_bre_rootstock_created_deleted", "created_time", "is_deleted"),
)
@@ -0,0 +1,47 @@
"""砧木管理 —— Pydantic 校验/序列化模型。"""
from datetime import datetime
from pydantic import BaseModel, ConfigDict, Field
from app.core.base_schema import CommonSchema
class RootstockBaseSchema(BaseModel):
model_config = ConfigDict(from_attributes=True)
rootstock_code: str | None = Field(default=None, description="砧木编号")
rootstock_name: str = Field(..., description="砧木名称")
dwarf_class: str | None = Field(default=None, description="矮化类(矮化/半矮化/乔化/柱状)")
compatibility: str | None = Field(default=None, description="砧穗亲和性(强/中/弱)")
remark: str | None = Field(default=None, description="备注")
class RootstockCreateSchema(RootstockBaseSchema):
pass
class RootstockUpdateSchema(RootstockBaseSchema):
rootstock_name: str | None = Field(default=None, description="砧木名称")
rootstock_code: str | None = Field(default=None, description="砧木编号")
dwarf_class: str | None = Field(default=None, description="矮化类(矮化/半矮化/乔化/柱状)")
compatibility: str | None = Field(default=None, description="砧穗亲和性(强/中/弱)")
remark: str | None = Field(default=None, description="备注")
class RootstockOutSchema(RootstockBaseSchema):
id: int
uuid: str
rootstock_code: str | None = None
rootstock_name: str | None = None
dwarf_class: str | None = None
compatibility: str | None = None
remark: str | None = None
created_time: datetime | None = None
updated_time: datetime | None = None
created_by: CommonSchema | None = None
updated_by: CommonSchema | None = None
class RootstockQueryParam(BaseModel):
rootstock_code: str | None = Field(default=None, description="砧木编号", json_schema_extra={"q": "like"})
rootstock_name: str | None = Field(default=None, description="砧木名称", json_schema_extra={"q": "like"})
@@ -0,0 +1,175 @@
from typing import Any
from fastapi import UploadFile
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.base_schema import AuthSchema, PageResultSchema, ImportResultSchema
from app.core.exceptions import CustomException
from app.core.logger import logger
from app.utils.common_util import search_to_dict
from app.utils.excel_util import ExcelUtil
from .crud import BreedingRootstockCRUD
from .schema import (
RootstockCreateSchema,
RootstockOutSchema,
RootstockQueryParam,
RootstockUpdateSchema,
)
def _is_blank(v: Any) -> bool:
return v is None or (isinstance(v, str) and v.strip() == "")
def _none_if_blank(v: Any) -> Any:
if _is_blank(v):
return None
return str(v).strip() if isinstance(v, str) else v
class RootstockService:
"""砧木管理 模块服务层"""
def __init__(self, auth: AuthSchema, db: AsyncSession) -> None:
self.auth = auth
self.db = db
async def detail(self, id: int) -> RootstockOutSchema:
obj = await BreedingRootstockCRUD(self.auth, self.db).get(id=id)
if not obj:
raise CustomException(msg="该砧木不存在")
return RootstockOutSchema.model_validate(obj)
async def get_list(
self,
search: RootstockQueryParam | None = None,
order_by: list[dict[str, str]] | None = None,
) -> list[RootstockOutSchema]:
obj_list = await BreedingRootstockCRUD(self.auth, self.db).get_list(
search=search_to_dict(search), order_by=order_by
)
return [RootstockOutSchema.model_validate(obj) for obj in obj_list]
async def page(
self,
page_no: int,
page_size: int,
search: RootstockQueryParam | None = None,
order_by: list[dict[str, str]] | None = None,
) -> PageResultSchema[RootstockOutSchema]:
offset = (page_no - 1) * page_size
return await BreedingRootstockCRUD(self.auth, self.db).page(
offset=offset,
limit=page_size,
order_by=order_by or [{"id": "asc"}],
search=search_to_dict(search, {}),
out_schema=RootstockOutSchema,
)
async def create(self, data: RootstockCreateSchema) -> RootstockOutSchema:
if _is_blank(data.rootstock_name):
raise CustomException(msg="砧木名称不能为空")
obj = await BreedingRootstockCRUD(self.auth, self.db).create(data=data)
return RootstockOutSchema.model_validate(obj)
async def update(self, id: int, data: RootstockUpdateSchema) -> RootstockOutSchema:
obj = await BreedingRootstockCRUD(self.auth, self.db).get(id=id)
if not obj:
raise CustomException(msg="更新失败,该砧木不存在")
obj = await BreedingRootstockCRUD(self.auth, self.db).update(id=id, data=data)
return RootstockOutSchema.model_validate(obj)
async def delete(self, ids: list[int]) -> None:
if not ids:
raise CustomException(msg="删除失败,删除对象不能为空")
objs = await BreedingRootstockCRUD(self.auth, self.db).get_list(search={"id": ("in", ids)})
obj_map = {o.id: o for o in objs}
for id_ in ids:
if id_ not in obj_map:
raise CustomException(msg="删除失败,该砧木不存在")
await BreedingRootstockCRUD(self.auth, self.db).delete(ids=ids)
async def list_options(self) -> list[dict[str, Any]]:
"""供前端下拉选择使用:返回 [{value, label}]。"""
obj_list = await BreedingRootstockCRUD(self.auth, self.db).get_list(order_by=[{"id": "asc"}])
return [{"value": o.id, "label": o.rootstock_name} for o in obj_list]
@staticmethod
def batch_export(obj_list: list[dict[str, Any]]) -> bytes:
mapping_dict = {
"rootstock_code": "砧木编号",
"rootstock_name": "砧木名称",
"dwarf_class": "矮化类",
"compatibility": "砧穗亲和性",
"remark": "备注",
"created_time": "创建时间",
"created_by": "创建者",
}
data = [dict(item) for item in obj_list]
for item in data:
creator = item.get("created_by")
item["created_by"] = creator.get("name", "未知") if isinstance(creator, dict) else "未知"
return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict)
async def batch_import(self, file: UploadFile, update_support: bool = False) -> ImportResultSchema:
header_dict = {
"砧木编号": "rootstock_code",
"砧木名称": "rootstock_name",
"矮化类": "dwarf_class",
"砧穗亲和性": "compatibility",
"备注": "remark",
}
try:
contents = await file.read()
rows = ExcelUtil.read_excel_to_dicts(contents)
await file.close()
if not rows:
raise CustomException(msg="导入文件为空")
missing_headers = [h for h in header_dict if h not in rows[0]]
if missing_headers:
raise CustomException(msg=f"导入文件缺少必要的列: {', '.join(missing_headers)}")
error_msgs: list[str] = []
success_count = 0
crud = BreedingRootstockCRUD(self.auth, self.db)
for i, row in enumerate(rows, start=1):
try:
fields = {
"rootstock_code": _none_if_blank(row.get("rootstock_code")),
"rootstock_name": _none_if_blank(row.get("rootstock_name")),
"dwarf_class": _none_if_blank(row.get("dwarf_class")),
"compatibility": _none_if_blank(row.get("compatibility")),
"remark": _none_if_blank(row.get("remark")),
}
create_data = RootstockCreateSchema(**fields)
await crud.create(data=create_data)
success_count += 1
except Exception as e:
error_msgs.append(f"{i}行: {e!s}")
continue
return ImportResultSchema(
valid_count=success_count,
invalid_count=len(error_msgs),
message_list=error_msgs,
)
except Exception as e:
logger.error(f"批量导入砧木管理失败: {e!s}")
raise CustomException(msg=f"导入失败: {e!s}")
@staticmethod
def import_template_download() -> bytes:
header_list = [
"砧木编号",
"砧木名称",
"矮化类",
"砧穗亲和性",
"备注",
]
return ExcelUtil.get_excel_template(
header_list=header_list,
selector_header_list=["矮化类", "砧穗亲和性"],
option_list=[
{"矮化类": ["矮化", "半矮化", "乔化", "柱状", "其他"]},
{"砧穗亲和性": ["", "", ""]},
],
)