dpb/backend/scripts/_backup_query_param/trait__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 (
        TraitCreateSchema,
        TraitOutSchema,
        TraitQueryParam,
        TraitUpdateSchema,
)
from .service import TraitService

TraitRouter = APIRouter(route_class=OperationLogRoute, prefix="/trait", tags=["性状字典"])


@TraitRouter.get("/detail/{id}", summary="获取性状字典详情", response_model=ResponseSchema[TraitOutSchema])
async def get_trait__detail_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:trait:detail"]))],
    id: Annotated[int, Path(description="性状字典ID")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TraitService(auth, db)
    result_dict = await service.detail(id=id)
    return SuccessResponse(data=result_dict, msg="获取性状字典详情成功")


@TraitRouter.get("/list", summary="分页查询性状字典", response_model=ResponseSchema[PageResultSchema[TraitOutSchema]])
async def get_trait__list_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:trait:query"]))],
    page: Annotated[PaginationQueryParam, Depends()],
    search: Annotated[TraitQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TraitService(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="查询性状字典列表成功")


@TraitRouter.get("/options", summary="性状字典下拉选项")
async def get_trait__options_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:trait:query"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TraitService(auth, db)
    options = await service.list_options()
    return SuccessResponse(data=options, msg="获取性状字典选项成功")


@TraitRouter.post("/create", summary="创建性状字典", response_model=ResponseSchema[TraitOutSchema])
async def create_trait__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:trait:create"]))],
    data: Annotated[TraitCreateSchema, Body(description="创建参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TraitService(auth, db)
    result_dict = await service.create(data=data)
    return SuccessResponse(data=result_dict, msg="创建性状字典成功")


@TraitRouter.put("/update/{id}", summary="修改性状字典", response_model=ResponseSchema[TraitOutSchema])
async def update_trait__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:trait:update"]))],
    id: Annotated[int, Path(description="性状字典ID")],
    data: Annotated[TraitUpdateSchema, Body(description="修改参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TraitService(auth, db)
    result_dict = await service.update(id=id, data=data)
    return SuccessResponse(data=result_dict, msg="修改性状字典成功")


@TraitRouter.delete("/delete", summary="删除性状字典", response_model=ResponseSchema[None])
async def delete_trait__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:trait:delete"]))],
    ids: Annotated[list[int], Body(description="ID列表")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TraitService(auth, db)
    await service.delete(ids=ids)
    return SuccessResponse(msg="删除性状字典成功")


@TraitRouter.post("/export", summary="导出性状字典")
async def export_trait__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:trait:export"]))],
    search: Annotated[TraitQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> StreamingResponse:
    service = TraitService(auth, db)
    result_dict_list = await service.get_list(search=search)
    export_result = TraitService.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')}"},
    )


@TraitRouter.post("/import", summary="导入性状字典", response_model=ResponseSchema[str])
async def import_trait__controller(
    file: Annotated[UploadFile, File(description="导入文件")],
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:trait:import"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = TraitService(auth, db)
    batch_import_result = await service.batch_import(file=file, update_support=True)
    return SuccessResponse(data=batch_import_result, msg="导入性状字典成功")


@TraitRouter.post("/download/template", summary="获取性状字典导入模板", dependencies=[Depends(AuthPermission(["module_bre:trait:download"]))])
async def download_trait__template_controller() -> StreamingResponse:
    import_template_result = TraitService.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",
        },
    )