python-fastapi-mm-zhcs-yj-api/routers/api/emergencyPlans/__init__.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from fastapi import APIRouter, Request, Depends,Query, HTTPException, status
from pydantic import BaseModel
from typing import List
from fastapi.responses import JSONResponse
from database import get_db
from sqlalchemy.orm import Session
from datetime import datetime
from models import *
from utils import *
import json

router = APIRouter()


class File(BaseModel):
    fileName:str
    fileNameDesc:str
    filePath : str = 'null'

class PlanCreateForm(BaseModel):
    planName : str
    planType : int
    # planTypeDesc : str
    publishDate: str
    organizingUnit : str
    document : str
    fileList : List[File] = []

class DrillCreateForm(BaseModel):
    planNumber : str
    drillName : str
    organizingUnit : str
    plannedAnnual : int
    plannedTime: str
    drillLocation : str
    drillLon : float
    drillLat : float
    drillProject : List[File] = []
    drillVideo : List[File] = []
    drillPicture : List[File] = []


@router.get('/plan/list')
async def get_emergency_plan_list(
    planType: str = Query(None, description='预案类型'),
    publishDate: datetime = Query(None, description='发布日期'),
    planName: str = Query(None, description='预案名称'),
    page: int = Query(1, gt=0, description='页码'),
    pageSize: int = Query(10, gt=0, description='每页条目数量'),
    db: Session = Depends(get_db)
):
    try:
        # 构建查询
        query = db.query(EmergencyPlan)
        query = query.filter(EmergencyPlan.del_flag != '2')
        # 应用查询条件
        if planType:
            query = query.filter(EmergencyPlan.plan_type == planType)
        if publishDate:
            query = query.filter(EmergencyPlan.publish_date == publishDate)
        if planName:
            query = query.filter(EmergencyPlan.plan_name.like(f'%{planName}%'))

        # 计算总条目数
        total_items = query.count()

        # 执行分页查询
        emergency_plans = query.offset((page - 1) * pageSize).limit(pageSize).all()

        # 将查询结果转换为列表形式的字典
        emergency_plans_list = [
            {
                "planUid": plan.plan_id,
                "planId": plan.plan_number,
                "planName": plan.plan_name,
                "planType": plan.plan_type,
                "organUnit": plan.organizing_unit,
                "document": plan.document_number,
                "publishDate": plan.publish_date.strftime('%Y-%m-%d')
            }
            for plan in emergency_plans
        ]

        # 构建分页信息
        pagination_info = {

        }

        # 返回结果
        return {
            "code": 200,
            "msg": "成功获取预案列表",
            "data": emergency_plans_list,
            "total": total_items,
            "page": page,
            "pageSize": pageSize,
            "totalPages": (total_items + pageSize - 1) // pageSize
        }
    except Exception as e:
        # 处理异常
        raise HTTPException(status_code=500, detail=str(e))

@router.get('/plan/{planNum}')
async def get_emergency_plan(
    planNum: str ,
    db: Session = Depends(get_db)
):
    try:
        # 构建查询
        query = db.query(EmergencyPlan)
        query = query.filter(EmergencyPlan.del_flag != '2')
        # 应用查询条件
        if planNum:
            query = query.filter(EmergencyPlan.plan_number == planNum)

        # 执行查询
        emergency_plan = query.first()

        file_query = db.query(EmergencyFile)
        file_query = file_query.filter(EmergencyFile.del_flag != '2')

        file_query = file_query.filter(EmergencyFile.from_scenario == 'emergencyPlans_plan')
        file_query = file_query.filter(EmergencyFile.foreign_key == emergency_plan.plan_id)
        files = file_query.all()
        # 将查询结果转换为列表形式的字典
        emergency_plans ={
                "planUid": emergency_plan.plan_id,
                "planId": emergency_plan.plan_number,
                "planName": emergency_plan.plan_name,
                "planType": emergency_plan.plan_type,
                "organUnit": emergency_plan.organizing_unit,
                "document": emergency_plan.document_number,
                "publish_date": emergency_plan.publish_date.strftime('%Y-%m-%d'),
                "fileList":[{
                    "fileName":file.file_name,
                    "fileNameDesc":file.file_name_desc,
                    "fileUrl":"/api/file/download/%s"%file.file_name
                } for file in files ]
            }

        # 返回结果
        return {
            "code": 200,
            "msg": "成功获取预案详情",
            "data": emergency_plans
        }
    except Exception as e:
        # 处理异常
        raise HTTPException(status_code=500, detail=str(e))




@router.post('/plan/create')
async def create_emergency_plan(
    form_data:PlanCreateForm,
    db: Session = Depends(get_db)
):
    try:
        # 提取请求数据
        plan_name = form_data.planName
        plan_type = form_data.planType
        # plan_type_desc = form_data.planTypeDesc
        publish_date = form_data.publishDate  # 如果没有提供发布日期，则使用当前时间
        organizing_unit = form_data.organizingUnit  # 使用用户位置作为编制单位
        document_number = form_data.document

        # 创建新的预案记录
        new_plan = EmergencyPlan(
            plan_id=new_guid(),  # 假设使用 UUID 作为预案 UID
            plan_name=plan_name,
            plan_type=plan_type,
            # plan_type_desc=plan_type_desc,
            publish_date=publish_date,
            organizing_unit=organizing_unit,
            document_number=document_number
        )

        # 添加到数据库会话并提交
        db.add(new_plan)
        db.commit()
        db.refresh(new_plan)  # 可选，如果需要刷新实例状态
        new_plan.plan_number= f'YJYA{str(new_plan.id).zfill(10)}'
        db.commit()
        for file in form_data.fileList:
            file_name = file.fileName
            file_name_desc = file.fileNameDesc
            file_path = file.filePath
            new_file = EmergencyFile(
                file_id = new_guid(),
                foreign_key = new_plan.plan_id,
                from_scenario = 'emergencyPlans_plan',
                file_name=file_name,
                file_name_desc = file_name_desc,
                file_path = file_path
            )
            db.add(new_file)
            db.commit()
            db.refresh(new_file)

        # 返回创建成功的响应
        return {
            "code": 200,
            "msg": "预案创建成功",
            "data": None
        }
    except Exception as e:
        # 处理异常
        raise HTTPException(status_code=500, detail=str(e))


# @router.put('/plan/update')
# async def update_emergency_plan(
#     plan_data: dict,
#     db: Session = Depends(get_db)
# ):
#     try:
#         # 提取请求数据
#         query = db.query(EmergencyPlan)
#         query = query.filter(EmergencyPlan.plan_id == plan_data.get('plan_id'))
#         query = query.filter(EmergencyPlan.del_flag != '2')
#         plan = query.first()
#         if not plan:
#             detail = "预案不存在"
#             raise HTTPException(status_code=404, detail="预案不存在")
#
#         plan.plan_name = plan_data.get('plan_name')
#         plan.plan_type = plan_data.get('plan_type')
#         plan.plan_type_desc = plan_data.get('plan_type_desc')
#         plan.publish_date = plan_data.get('publish_date')  # 如果没有提供发布日期，则使用当前时间
#         plan.organizing_unit = plan_data.get('organizing_unit')  # 使用用户位置作为编制单位
#         plan.document_number = plan_data.get('document_number')
#
#
#         # 更新到数据库会话并提交
#         db.commit()
#         db.refresh(new_plan)  # 可选，如果需要刷新实例状态
#
#         # 返回创建成功的响应
#         return {
#             "code": 200,
#             "msg": "预案更新成功",
#             "data": None
#         }
#     except Exception as e:
#         # 处理异常
#         if str(e)=='':
#             e = detail
#         raise HTTPException(status_code=500, detail=str(e))
#
#
# @router.delete('/plan/delete')
# async def delete_emergency_plan(
#         plan_data: dict,
#         db: Session = Depends(get_db)
# ):
#     try:
#         # 提取请求数据
#         query = db.query(EmergencyPlan)
#         query = query.filter(EmergencyPlan.plan_id == plan_data.get('plan_id'))
#         query = query.filter(EmergencyPlan.del_flag != '2')
#         plan = query.first()
#         if not plan:
#             detail = "预案不存在"
#             raise HTTPException(status_code=404, detail="预案不存在")
#
#         plan.del_flag = '2'
#
#         # 更新到数据库会话并提交
#         db.commit()
#         db.refresh(new_plan)  # 可选，如果需要刷新实例状态
#
#         # 返回创建成功的响应
#         return {
#             "code": 200,
#             "msg": "预案删除成功",
#             "data": None
#         }
#     except Exception as e:
#         # 处理异常
#         if str(e) == '':
#             e = detail
#         raise HTTPException(status_code=500, detail=str(e))


@router.get('/drill/list')
async def get_emergency_drill_list(
    planNum: str = Query(None, description='预案编号'),
    page: int = Query(1, gt=0, description='页码'),
    pageSize: int = Query(10, gt=0, description='每页条目数量'),
    db: Session = Depends(get_db)
):
    try:
        # 构建查询
        query = db.query(EmergencyDrill)
        query = query.filter(EmergencyDrill.del_flag != '2')
        # 应用查询条件
        if planNum:
            query = query.filter(EmergencyDrill.plan_number == planNum)
        else:
            return 'planNum不存在'

        # 计算总条目数
        total_items = query.count()

        # 执行分页查询
        emergency_drill = query.offset((page - 1) * pageSize).limit(pageSize).all()   #
        print(emergency_drill)
        # 将查询结果转换为列表形式的字典
        emergency_drill_list = []
        for drill in emergency_drill:
            project_query = db.query(EmergencyFile)
            project_query = project_query.filter(EmergencyFile.del_flag != '2')
            project_query = project_query.filter(EmergencyFile.from_scenario == 'emergencyPlans_plan')
            project_query = project_query.filter(EmergencyFile.foreign_key == emergency_plan.plan_id)
            projects = project_query.all()

            video_query = db.query(EmergencyFile)
            video_query = video_query.filter(EmergencyFile.del_flag != '2')
            video_query = video_query.filter(EmergencyFile.from_scenario == 'emergencyPlans_plan')
            video_query = video_query.filter(EmergencyFile.foreign_key == emergency_plan.plan_id)
            videos = video_query.all()

            picture_query = db.query(EmergencyFile)
            picture_query = picture_query.filter(EmergencyFile.del_flag != '2')
            picture_query = picture_query.filter(EmergencyFile.from_scenario == 'emergencyPlans_plan')
            picture_query = picture_query.filter(EmergencyFile.foreign_key == emergency_plan.plan_id)
            pictures = picture_query.all()

            {
                "drillId": drill.drill_id,
                "drillName": drill.drill_name,
                "drillUnit": drill.organizing_unit,
                "year": "%s年"%drill.planned_annual,
                "drillTime": drill.planned_time.strftime('%Y-%m-%d %H:%M:%S'),
                "drillAddress": drill.drill_location,
                "drillProject":[{
                    "fileName":file.file_name,
                    "fileNameDesc":file.file_name_desc,
                    "fileUrl":"/api/file/download/%s"%file.file_name
                } for file in projects ],
                "drillVideo":[{
                    "fileName":file.file_name,
                    "fileNameDesc":file.file_name_desc,
                    "fileUrl":"/api/file/download/%s"%file.file_name
                } for file in videos ],
                "drillPicture":[{
                    "fileName":file.file_name,
                    "fileNameDesc":file.file_name_desc,
                    "fileUrl":"/api/file/download/%s"%file.file_name
                } for file in pictures ]
            }




            # 返回结果
        return {
            "code": 200,
            "msg": "成功",
            "data": emergency_drill_list,
            "total": total_items,
            "page": page,
            "pageSize": pageSize,
            "totalPages": (total_items + pageSize - 1) // pageSize
        }
    except Exception as e:
        # 处理异常
        raise HTTPException(status_code=500, detail=str(e))



@router.post('/drill/create')
async def create_emergency_drill(
    form_data:DrillCreateForm,
    db: Session = Depends(get_db)
):
    try:
        # 提取请求数据
        plan_number = form_data.planNumber
        drill_name = form_data.drillName
        organizing_unit = form_data.organizingUnit
        planned_annual = form_data.plannedAnnual
        planned_time = form_data.plannedTime
        drill_location = form_data.drillLocation
        drill_lon = form_data.drillLon
        drill_lat = form_data.drillLat


        # 创建新的预案记录
        new_drill = EmergencyDrill(
            drill_id=new_guid(),  # 假设使用 UUID 作为预案 UID
            plan_number = plan_number,
            drill_name=drill_name,
            organizing_unit = organizing_unit,
            planned_annual = planned_annual,
            planned_time = planned_time,
            drill_location = drill_location,
            drill_lon = drill_lon,
            drill_lat = drill_lat
        )

        # 添加到数据库会话并提交
        db.add(new_drill)
        db.commit()
        db.refresh(new_drill)  # 可选，如果需要刷新实例状态

        for file in form_data.drillProject:
            file_name = file.fileName
            file_name_desc = file.fileNameDesc
            file_path = file.filePath
            new_file = EmergencyFile(
                file_id = new_guid(),
                foreign_key = new_drill.drill_id,
                from_scenario = 'emergencyPlans_drill_project',
                file_name=file_name,
                file_name_desc = file_name_desc,
                file_path = file_path
            )
            db.add(new_file)
            db.commit()
            db.refresh(new_file)
        for file in form_data.drillVideo:
            file_name = file.fileName
            file_name_desc = file.fileNameDesc
            file_path = file.filePath
            new_file = EmergencyFile(
                file_id = new_guid(),
                foreign_key = new_drill.drill_id,
                from_scenario = 'emergencyPlans_drill_video',
                file_name=file_name,
                file_name_desc = file_name_desc,
                file_path = file_path
            )
            db.add(new_file)
            db.commit()
            db.refresh(new_file)
        for file in form_data.drillPicture:
            file_name = file.fileName
            file_name_desc = file.fileNameDesc
            file_path = file.filePath
            new_file = EmergencyFile(
                file_id = new_guid(),
                foreign_key = new_drill.drill_id,
                from_scenario = 'emergencyPlans_drill_pic',
                file_name=file_name,
                file_name_desc = file_name_desc,
                file_path = file_path
            )
            db.add(new_file)
            db.commit()
            db.refresh(new_file)
        # 返回创建成功的响应
        return {
            "code": 200,
            "msg": "演练创建成功",
            "data": None
        }
    except Exception as e:
        # 处理异常
        raise HTTPException(status_code=500, detail=str(e))





@router.get('/training/list')
async def get_emergency_training_list(
    planNum: str = Query(None, description='预案编号'),
    page: int = Query(1, gt=0, description='页码'),
    pageSize: int = Query(10, gt=0, description='每页条目数量'),
    db: Session = Depends(get_db)
):
    try:
        # 构建查询
        query = db.query(EmergencyTrainingSession)
        query = query.filter(EmergencyTrainingSession.del_flag != '2')
        # 应用查询条件
        if planNum:
            query = query.filter(EmergencyTrainingSession.plan_number == planNum)
        else:
            return 'planNum不存在'

        # 计算总条目数
        total_items = query.count()

        # 执行分页查询
        emergency_training = query.offset((page - 1) * pageSize).limit(pageSize).all()   #
        # print(emergency_drill)
        # 将查询结果转换为列表形式的字典
        emergency_training_list = [
            {
                "textId": training.training_id,
                "theme": training.training_theme,
                "unitName": training.training_unit,
                "peopleNum": "%s人"%training.participant_count,
                "trainingWay":training.training_method,
                "startTime":training.start_time.strftime('%Y-%m-%d %H:%M:%S'),
                "endTime": training.end_time.strftime('%Y-%m-%d %H:%M:%S'),
                "address": training.training_location,
                "Content":training.training_content
            }
            for training in emergency_training
        ]


            # 返回结果
        return {
            "code": 200,
            "msg": "成功",
            "data": emergency_training_list,
            "total": total_items,
            "page": page,
            "pageSize": pageSize,
            "totalPages": (total_items + pageSize - 1) // pageSize
        }
    except Exception as e:
        # 处理异常
        raise HTTPException(status_code=500, detail=str(e))

class TrainingCreateForm(BaseModel):
    trainingTheme : str
    trainingUnit : str
    trainingMethod : str
    participantCount: int
    startTime : str
    endTime : str
    trainingContent :str
    drillLocation : str
    drillLon : float
    drillLat : float

@router.post('/training/create')
async def create_emergency_training(
    form_data:TrainingCreateForm,
    db: Session = Depends(get_db)
):
    try:
        # 创建新的预案记录
        new_training = EmergencyTrainingSession(
            training_id=new_guid(),  # 假设使用 UUID 作为预案 UID
            training_theme=form_data.trainingTheme,
            training_unit=form_data.trainingUnit,
            training_method=form_data.trainingMethod,
            participant_count=form_data.participantCount,
            start_time=form_data.startTime,
            end_time=form_data.endTime,
            training_content=form_data.trainingContent,
            drill_location=form_data.drillLocation,
            drill_lon=form_data.drillLon,
            drill_lat=form_data.drillLat
        )

        # 添加到数据库会话并提交
        db.add(new_training)
        db.commit()
        db.refresh(new_plan)  # 可选，如果需要刷新实例状态

        # 返回创建成功的响应
        return {
            "code": 200,
            "msg": "培训创建成功",
            "data": None
        }
    except Exception as e:
        # 处理异常
        raise HTTPException(status_code=500, detail=str(e))