dpb/backend/scripts/_backup_query_param/target__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 (
        TargetCreateSchema,
        TargetOutSchema,
        TargetQueryParam,
        TargetUpdateSchema,
)
from .service import TargetService

TargetRouter = APIRouter(route_class=OperationLogRoute, prefix="/target", tags=["育种目标"])


@TargetRouter.get("/detail/{id}", summary="获取育种目标详情", response_model=ResponseSchema[TargetOutSchema])
async def get_target__detail_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:target:detail"]))],
    id: Annotated[int, Path(description="育种目标ID")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TargetService(auth, db)
    result_dict = await service.detail(id=id)
    return SuccessResponse(data=result_dict, msg="获取育种目标详情成功")


@TargetRouter.get("/list", summary="分页查询育种目标", response_model=ResponseSchema[PageResultSchema[TargetOutSchema]])
async def get_target__list_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:target:query"]))],
    page: Annotated[PaginationQueryParam, Depends()],
    search: Annotated[TargetQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TargetService(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="查询育种目标列表成功")


@TargetRouter.get("/options", summary="育种目标下拉选项")
async def get_target__options_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:target:query"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TargetService(auth, db)
    options = await service.list_options()
    return SuccessResponse(data=options, msg="获取育种目标选项成功")


@TargetRouter.post("/create", summary="创建育种目标", response_model=ResponseSchema[TargetOutSchema])
async def create_target__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:target:create"]))],
    data: Annotated[TargetCreateSchema, Body(description="创建参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TargetService(auth, db)
    result_dict = await service.create(data=data)
    return SuccessResponse(data=result_dict, msg="创建育种目标成功")


@TargetRouter.put("/update/{id}", summary="修改育种目标", response_model=ResponseSchema[TargetOutSchema])
async def update_target__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:target:update"]))],
    id: Annotated[int, Path(description="育种目标ID")],
    data: Annotated[TargetUpdateSchema, Body(description="修改参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TargetService(auth, db)
    result_dict = await service.update(id=id, data=data)
    return SuccessResponse(data=result_dict, msg="修改育种目标成功")


@TargetRouter.delete("/delete", summary="删除育种目标", response_model=ResponseSchema[None])
async def delete_target__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:target:delete"]))],
    ids: Annotated[list[int], Body(description="ID列表")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TargetService(auth, db)
    await service.delete(ids=ids)
    return SuccessResponse(msg="删除育种目标成功")


@TargetRouter.post("/export", summary="导出育种目标")
async def export_target__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:target:export"]))],
    search: Annotated[TargetQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> StreamingResponse:
    service = TargetService(auth, db)
    result_dict_list = await service.get_list(search=search)
    export_result = TargetService.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')}"},
    )


@TargetRouter.post("/import", summary="导入育种目标", response_model=ResponseSchema[str])
async def import_target__controller(
    file: Annotated[UploadFile, File(description="导入文件")],
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:target:import"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TargetService(auth, db)
    batch_import_result = await service.batch_import(file=file, update_support=True)
    return SuccessResponse(data=batch_import_result, msg="导入育种目标成功")


@TargetRouter.post("/download/template", summary="获取育种目标导入模板", dependencies=[Depends(AuthPermission(["module_bre:target:download"]))])
async def download_target__template_controller() -> StreamingResponse:
    import_template_result = TargetService.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",
        },
    )