vue-fastapi-admin/vue-fastapi-backend/module_admin/controller/datastd_controller.py

from datetime import datetime
from fastapi import APIRouter, Depends, Request
from sqlalchemy.ext.asyncio import AsyncSession
from config.enums import BusinessType
from config.get_db import get_db
from module_admin.entity.vo.user_vo import CurrentUserModel
from module_admin.annotation.log_annotation import Log
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
from module_admin.entity.vo.datastd_vo import DataStdCodeModel,DataStdCodeItemModel, DataStdCodePageQueryModel, DataStdCodeItemPageQueryModel, DeleteDataStdModel
from module_admin.service.datastd_service import DataStdService
from module_admin.service.login_service import LoginService
from utils.log_util import logger
from utils.page_util import PageResponseModel
from utils.response_util import ResponseUtil
import uuid

datastdController = APIRouter(prefix='/datastd', dependencies=[Depends(LoginService.get_current_user)])


#标准代码相关API
@datastdController.get(
    '/stdcode/code/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
)
async def get_std_code_list(
    request: Request,
    code_page_query: DataStdCodePageQueryModel = Depends(DataStdCodePageQueryModel.as_query),
    query_db: AsyncSession = Depends(get_db),
):
    code_page_query_result = await DataStdService.get_std_code_list_services(query_db, code_page_query, is_page=True)
    logger.info('获取列配置列表成功')
    return ResponseUtil.success(model_content=code_page_query_result)
@datastdController.get('/stdcode/codeItem/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeItem:list'))]
)
async def get_std_code_item_list(
    request: Request,
    codeItem_page_query: DataStdCodeItemPageQueryModel = Depends(DataStdCodeItemPageQueryModel.as_query),
    query_db: AsyncSession = Depends(get_db),
):
    codeItem_page_query_result = await DataStdService.get_std_code_item_list_services(query_db, codeItem_page_query, is_page=True)
    logger.info('获取代码项列表成功')
    return ResponseUtil.success(model_content=codeItem_page_query_result)
@datastdController.get(
    '/stdcode/codeItem/{id}', response_model=DataStdCodeItemModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeItem:list'))]
)
async def query_detail_codeItem(request: Request, id: str, query_db: AsyncSession = Depends(get_db)):
    config_detail_result = await DataStdService.code_item_detail_services(query_db, id)
    logger.info(f'获取config_id为{id}的信息成功')

    return ResponseUtil.success(data=config_detail_result)
@datastdController.get(
    '/stdcode/code/{id}', response_model=DataStdCodeModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
)
async def query_detail_code(request: Request, id: str, query_db: AsyncSession = Depends(get_db)):
    config_detail_result = await DataStdService.code_detail_services(query_db, id)
    logger.info(f'获取config_id为{id}的信息成功')

    return ResponseUtil.success(data=config_detail_result)
@datastdController.post('/stdcode/code', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:add'))])
@Log(title='代码管理', business_type=BusinessType.INSERT)
async def add_std_code(
    request: Request,
    add_std_code: DataStdCodeModel,
    query_db: AsyncSession = Depends(get_db),
    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    
    add_std_code.create_by = current_user.user.user_name
    add_std_code.create_time = datetime.now()
    add_std_code.update_by = current_user.user.user_name
    add_std_code.update_time = datetime.now()
    add_std_code_result = await DataStdService.add_std_code_services(request, query_db, add_std_code)
    logger.info(add_std_code_result.message)
    return ResponseUtil.success(msg=add_std_code_result.message)


@datastdController.put('/stdcode/code', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:edit'))])
@Log(title='代码管理', business_type=BusinessType.UPDATE)
async def edit_std_code(
    request: Request,
    edit_std_code: DataStdCodeModel,
    query_db: AsyncSession = Depends(get_db),
    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    edit_std_code.update_by = current_user.user.user_name
    edit_std_code.update_time = datetime.now()
    edit_std_code_result = await DataStdService.edit_std_code_services(request, query_db, edit_std_code)
    logger.info(edit_std_code_result.message)
    return ResponseUtil.success(msg=edit_std_code_result.message)


@datastdController.delete('/stdcode/code/{ids}', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:remove'))])
@Log(title='代码管理', business_type=BusinessType.DELETE)
async def delete_std_code(
    request: Request,
    ids: str,
    query_db: AsyncSession = Depends(get_db),
):
    delete_std_code = DeleteDataStdModel(ids =ids)
    delete_std_code_result = await DataStdService.delete_std_code_services(request, query_db, delete_std_code)
    logger.info(delete_std_code_result.message)
    return ResponseUtil.success(msg=delete_std_code_result.message)


@datastdController.post('/stdcode/codeItem', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeItem:add'))])
@Log(title='代码项管理', business_type=BusinessType.INSERT)
async def add_std_code_item(
    request: Request,
    add_std_code_item: DataStdCodeItemModel,
    query_db: AsyncSession = Depends(get_db),
    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    add_std_code_item.create_by = current_user.user.user_name
    add_std_code_item.create_time = datetime.now()
    add_std_code_item.update_by = current_user.user.user_name
    add_std_code_item.update_time = datetime.now()
    add_std_code_item_result = await DataStdService.add_std_code_item_services(request, query_db, add_std_code_item)
    logger.info(add_std_code_item_result.message)
    return ResponseUtil.success(msg=add_std_code_item_result.message)


@datastdController.put('/stdcode/codeItem', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeItem:edit'))])
@Log(title='代码项管理', business_type=BusinessType.UPDATE)
async def edit_std_code_item(
    request: Request,
    edit_std_code_item: DataStdCodeItemModel,
    query_db: AsyncSession = Depends(get_db),
    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    edit_std_code_item.update_by = current_user.user.user_name
    edit_std_code_item.update_time = datetime.now()
    edit_std_code_item_result = await DataStdService.edit_std_code_item_services(request, query_db, edit_std_code_item)
    logger.info(edit_std_code_item_result.message)
    return ResponseUtil.success(msg=edit_std_code_item_result.message)


@datastdController.delete('/stdcode/codeItem/{ids}', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeItem:remove'))])
@Log(title='代码项管理', business_type=BusinessType.DELETE)
async def delete_std_code_item(
    request: Request,
    ids: str,
    query_db: AsyncSession = Depends(get_db),
):
    delete_std_code_item = DeleteDataStdModel(ids=ids)
    delete_std_code_item_result = await DataStdService.delete_std_code_item_services(request, query_db, delete_std_code_item)
    logger.info(delete_std_code_item_result.message)
    return ResponseUtil.success(msg=delete_std_code_item_result.message)


@datastdController.get('/stdcode/codeItem/{id}', response_model=DataStdCodeItemModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeItem:query'))])
async def query_std_code_item_detail(
    request: Request,
    id: int,
    query_db: AsyncSession = Depends(get_db),
):
    codeItem_detail_result = await DataStdService.get_std_code_item_by_id_services(query_db, id)
    logger.info(f'获取id为{id}的代码项信息成功')
    return ResponseUtil.success(data=codeItem_detail_result)