dpb/backend/app/api/v1/module_bre/site/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 (
    BreedingPlotCreateSchema,
    BreedingPlotOutSchema,
    BreedingPlotQueryParam,
    BreedingPlotUpdateSchema,
    BreedingSiteCreateSchema,
    BreedingSiteOutSchema,
    BreedingSiteQueryParam,
    BreedingSiteUpdateSchema,
)
from .service import BreedingPlotService, BreedingSiteService

# ── 基地（site） ───────────────────────────────────────────────────────

SiteRouter = APIRouter(route_class=OperationLogRoute, prefix="/site", tags=["基地管理"])


@SiteRouter.get("/detail/{id}", summary="获取基地详情", response_model=ResponseSchema[BreedingSiteOutSchema])
async def get_site_detail_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:site:detail"]))],
    id: Annotated[int, Path(description="基地ID")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingSiteService(auth, db)
    result_dict = await service.detail(id=id)
    return SuccessResponse(data=result_dict, msg="获取基地详情成功")


@SiteRouter.get("/list", summary="分页查询基地", response_model=ResponseSchema[PageResultSchema[BreedingSiteOutSchema]])
async def get_site_list_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:site:query"]))],
    page: Annotated[PaginationQueryParam, Depends()],
    search: Annotated[BreedingSiteQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingSiteService(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="查询基地列表成功")


@SiteRouter.get("/options", summary="基地下拉选项")
async def get_site_options_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:site:query"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingSiteService(auth, db)
    options = await service.list_options()
    return SuccessResponse(data=options, msg="获取基地选项成功")


@SiteRouter.post("/create", summary="创建基地", response_model=ResponseSchema[BreedingSiteOutSchema])
async def create_site_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:site:create"]))],
    data: Annotated[BreedingSiteCreateSchema, Body(description="创建参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingSiteService(auth, db)
    result_dict = await service.create(data=data)
    return SuccessResponse(data=result_dict, msg="创建基地成功")


@SiteRouter.put("/update/{id}", summary="修改基地", response_model=ResponseSchema[BreedingSiteOutSchema])
async def update_site_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:site:update"]))],
    id: Annotated[int, Path(description="基地ID")],
    data: Annotated[BreedingSiteUpdateSchema, Body(description="修改参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingSiteService(auth, db)
    result_dict = await service.update(id=id, data=data)
    return SuccessResponse(data=result_dict, msg="修改基地成功")


@SiteRouter.delete("/delete", summary="删除基地", response_model=ResponseSchema[None])
async def delete_site_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:site:delete"]))],
    ids: Annotated[list[int], Body(description="ID列表")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingSiteService(auth, db)
    await service.delete(ids=ids)
    return SuccessResponse(msg="删除基地成功")


@SiteRouter.post("/export", summary="导出基地")
async def export_site_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:site:export"]))],
    search: Annotated[BreedingSiteQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> StreamingResponse:
    service = BreedingSiteService(auth, db)
    result_dict_list = await service.get_list(search=search)
    export_result = BreedingSiteService.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')}"},
    )


@SiteRouter.post("/import", summary="导入基地", response_model=ResponseSchema[ImportResultSchema])
async def import_site_controller(
    file: Annotated[UploadFile, File(description="导入文件")],
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:site:import"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingSiteService(auth, db)
    batch_import_result = await service.batch_import(file=file, update_support=True)
    return SuccessResponse(data=batch_import_result, msg="导入基地成功")


@SiteRouter.post("/download/template", summary="获取基地导入模板", dependencies=[Depends(AuthPermission(["module_bre:site:download"]))])
async def download_site_template_controller() -> StreamingResponse:
    import_template_result = BreedingSiteService.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",
        },
    )


# ── 试验地（plot） ──────────────────────────────────────────────────────

PlotRouter = APIRouter(route_class=OperationLogRoute, prefix="/plot", tags=["试验地管理"])


@PlotRouter.get("/detail/{id}", summary="获取试验地详情", response_model=ResponseSchema[BreedingPlotOutSchema])
async def get_plot_detail_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:plot:detail"]))],
    id: Annotated[int, Path(description="试验地ID")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingPlotService(auth, db)
    result_dict = await service.detail(id=id)
    return SuccessResponse(data=result_dict, msg="获取试验地详情成功")


@PlotRouter.get("/list", summary="分页查询试验地", response_model=ResponseSchema[PageResultSchema[BreedingPlotOutSchema]])
async def get_plot_list_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:plot:query"]))],
    page: Annotated[PaginationQueryParam, Depends()],
    search: Annotated[BreedingPlotQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingPlotService(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="查询试验地列表成功")


@PlotRouter.post("/create", summary="创建试验地", response_model=ResponseSchema[BreedingPlotOutSchema])
async def create_plot_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:plot:create"]))],
    data: Annotated[BreedingPlotCreateSchema, Body(description="创建参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingPlotService(auth, db)
    result_dict = await service.create(data=data)
    return SuccessResponse(data=result_dict, msg="创建试验地成功")


@PlotRouter.put("/update/{id}", summary="修改试验地", response_model=ResponseSchema[BreedingPlotOutSchema])
async def update_plot_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:plot:update"]))],
    id: Annotated[int, Path(description="试验地ID")],
    data: Annotated[BreedingPlotUpdateSchema, Body(description="修改参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingPlotService(auth, db)
    result_dict = await service.update(id=id, data=data)
    return SuccessResponse(data=result_dict, msg="修改试验地成功")


@PlotRouter.delete("/delete", summary="删除试验地", response_model=ResponseSchema[None])
async def delete_plot_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:plot:delete"]))],
    ids: Annotated[list[int], Body(description="ID列表")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingPlotService(auth, db)
    await service.delete(ids=ids)
    return SuccessResponse(msg="删除试验地成功")


@PlotRouter.post("/export", summary="导出试验地")
async def export_plot_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:plot:export"]))],
    search: Annotated[BreedingPlotQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> StreamingResponse:
    service = BreedingPlotService(auth, db)
    result_dict_list = await service.get_list(search=search)
    export_result = BreedingPlotService.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')}"},
    )


@PlotRouter.post("/import", summary="导入试验地", response_model=ResponseSchema[ImportResultSchema])
async def import_plot_controller(
    file: Annotated[UploadFile, File(description="导入文件")],
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:plot:import"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingPlotService(auth, db)
    batch_import_result = await service.batch_import(file=file, update_support=True)
    return SuccessResponse(data=batch_import_result, msg="导入试验地成功")


@PlotRouter.post("/download/template", summary="获取试验地导入模板", dependencies=[Depends(AuthPermission(["module_bre:plot:download"]))])
async def download_plot_template_controller() -> StreamResponse:
    import_template_result = BreedingPlotService.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",
        },
    )


@PlotRouter.get("/options", summary="试验地下拉选项")
async def get_plot_options_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:plot:query"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = BreedingPlotService(auth, db)
    options = await service.list_options()
    return SuccessResponse(data=options, msg="获取试验地选项成功")