dpb/backend/app/api/v1/module_bre/clone/controller.py

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 (
    CloneCreateSchema,
    CloneOutSchema,
    CloneQueryParam,
    CloneUpdateSchema,
)
from .service import CloneService

CloneRouter = APIRouter(route_class=OperationLogRoute, prefix="/clone", tags=["无性系管理"])


@CloneRouter.get("/detail/{id}", summary="获取无性系详情", response_model=ResponseSchema[CloneOutSchema])
async def get_clone__detail_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:clone:detail"]))],
    id: Annotated[int, Path(description="无性系ID")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = CloneService(auth, db)
    result_dict = await service.detail(id=id)
    return SuccessResponse(data=result_dict, msg="获取无性系详情成功")


@CloneRouter.get("/list", summary="分页查询无性系", response_model=ResponseSchema[PageResultSchema[CloneOutSchema]])
async def get_clone__list_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:clone:query"]))],
    page: Annotated[PaginationQueryParam, Depends()],
    search: Annotated[CloneQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = CloneService(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="查询无性系列表成功")


@CloneRouter.get("/options", summary="无性系下拉选项")
async def get_clone__options_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:clone:query"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = CloneService(auth, db)
    options = await service.list_options()
    return SuccessResponse(data=options, msg="获取无性系选项成功")


@CloneRouter.post("/create", summary="创建无性系", response_model=ResponseSchema[CloneOutSchema])
async def create_clone__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:clone:create"]))],
    data: Annotated[CloneCreateSchema, Body(description="创建参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = CloneService(auth, db)
    result_dict = await service.create(data=data)
    return SuccessResponse(data=result_dict, msg="创建无性系成功")


@CloneRouter.put("/update/{id}", summary="修改无性系", response_model=ResponseSchema[CloneOutSchema])
async def update_clone__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:clone:update"]))],
    id: Annotated[int, Path(description="无性系ID")],
    data: Annotated[CloneUpdateSchema, Body(description="修改参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = CloneService(auth, db)
    result_dict = await service.update(id=id, data=data)
    return SuccessResponse(data=result_dict, msg="修改无性系成功")


@CloneRouter.delete("/delete", summary="删除无性系", response_model=ResponseSchema[None])
async def delete_clone__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:clone:delete"]))],
    ids: Annotated[list[int], Body(description="ID列表")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = CloneService(auth, db)
    await service.delete(ids=ids)
    return SuccessResponse(msg="删除无性系成功")


@CloneRouter.post("/export", summary="导出无性系")
async def export_clone__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:clone:export"]))],
    search: Annotated[CloneQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> StreamingResponse:
    service = CloneService(auth, db)
    result_dict_list = await service.get_list(search=search)
    export_result = CloneService.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')}"},
    )


@CloneRouter.post("/import", summary="导入无性系", response_model=ResponseSchema[ImportResultSchema])
async def import_clone__controller(
    file: Annotated[UploadFile, File(description="导入文件")],
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:clone:import"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = CloneService(auth, db)
    batch_import_result = await service.batch_import(file=file, update_support=True)
    return SuccessResponse(data=batch_import_result, msg="导入无性系成功")


@CloneRouter.post("/download/template", summary="获取无性系导入模板", dependencies=[Depends(AuthPermission(["module_bre:clone:download"]))])
async def download_clone__template_controller() -> StreamingResponse:
    import_template_result = CloneService.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",
        },
    )