dpb/backend/scripts/_backup_query_param/pedigree__controller.py.bak

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
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 (
        PedigreeCreateSchema,
        PedigreeOutSchema,
        PedigreeQueryParam,
        PedigreeUpdateSchema,
)
from .service import PedigreeService

PedigreeRouter = APIRouter(route_class=OperationLogRoute, prefix="/pedigree", tags=["系谱管理"])


@PedigreeRouter.get("/detail/{id}", summary="获取系谱管理详情", response_model=ResponseSchema[PedigreeOutSchema])
async def get_pedigree__detail_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:pedigree:detail"]))],
    id: Annotated[int, Path(description="系谱管理ID")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = PedigreeService(auth, db)
    result_dict = await service.detail(id=id)
    return SuccessResponse(data=result_dict, msg="获取系谱管理详情成功")


@PedigreeRouter.get("/list", summary="分页查询系谱管理", response_model=ResponseSchema[PageResultSchema[PedigreeOutSchema]])
async def get_pedigree__list_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:pedigree:query"]))],
    page: Annotated[PaginationQueryParam, Depends()],
    search: Annotated[PedigreeQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = PedigreeService(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="查询系谱管理列表成功")


@PedigreeRouter.get("/options", summary="系谱管理下拉选项")
async def get_pedigree__options_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:pedigree:query"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = PedigreeService(auth, db)
    options = await service.list_options()
    return SuccessResponse(data=options, msg="获取系谱管理选项成功")


@PedigreeRouter.post("/create", summary="创建系谱管理", response_model=ResponseSchema[PedigreeOutSchema])
async def create_pedigree__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:pedigree:create"]))],
    data: Annotated[PedigreeCreateSchema, Body(description="创建参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = PedigreeService(auth, db)
    result_dict = await service.create(data=data)
    return SuccessResponse(data=result_dict, msg="创建系谱管理成功")


@PedigreeRouter.put("/update/{id}", summary="修改系谱管理", response_model=ResponseSchema[PedigreeOutSchema])
async def update_pedigree__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:pedigree:update"]))],
    id: Annotated[int, Path(description="系谱管理ID")],
    data: Annotated[PedigreeUpdateSchema, Body(description="修改参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = PedigreeService(auth, db)
    result_dict = await service.update(id=id, data=data)
    return SuccessResponse(data=result_dict, msg="修改系谱管理成功")


@PedigreeRouter.delete("/delete", summary="删除系谱管理", response_model=ResponseSchema[None])
async def delete_pedigree__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:pedigree:delete"]))],
    ids: Annotated[list[int], Body(description="ID列表")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = PedigreeService(auth, db)
    await service.delete(ids=ids)
    return SuccessResponse(msg="删除系谱管理成功")


@PedigreeRouter.post("/export", summary="导出系谱管理")
async def export_pedigree__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:pedigree:export"]))],
    search: Annotated[PedigreeQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> StreamingResponse:
    service = PedigreeService(auth, db)
    result_dict_list = await service.get_list(search=search)
    export_result = PedigreeService.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')}"},
    )


@PedigreeRouter.post("/import", summary="导入系谱管理", response_model=ResponseSchema[str])
async def import_pedigree__controller(
    file: Annotated[UploadFile, File(description="导入文件")],
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:pedigree:import"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = PedigreeService(auth, db)
    batch_import_result = await service.batch_import(file=file, update_support=True)
    return SuccessResponse(data=batch_import_result, msg="导入系谱管理成功")


@PedigreeRouter.post("/download/template", summary="获取系谱管理导入模板", dependencies=[Depends(AuthPermission(["module_bre:pedigree:download"]))])
async def download_pedigree__template_controller() -> StreamingResponse:
    import_template_result = PedigreeService.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",
        },
    )