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 fastapi.responses import JSONResponse
from sqlalchemy.orm import Session
from sqlalchemy import and_, or_
from pydantic import BaseModel
from datetime import datetime
from database import get_db
from typing import List
from models import *
from utils import *
import json
import traceback

router = APIRouter()

class File(BaseModel):
    status :str
    name : str
    url : str

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

class PlanUpdateForm(BaseModel):
    planUid : str
    planName : str = None
    planType : int = None
    publishDate: str = None
    organizingUnit : str = None
    document : str = None
    fileList : List[File] = []

class DrillCreateForm(BaseModel):
    planId : str
    drillName : str
    drillUnit : str
    year : int
    drillTime: str
    drillAddress : str
    lon : float
    lat : float
    drillProject : List[File]
    drillVideo : List[File]
    drillPicture : List[File]

class DrillUpdateForm(BaseModel):
    drillId : str
    planId : str = None
    drillName : str = None
    drillUnit : str = None
    year : int = None
    drillTime: str = None
    drillAddress : str = None
    lon : float = None
    lat : float = None
    drillProject : List[File] = []
    drillVideo : List[File] = []
    drillPicture : List[File] = []

class TrainingCreateForm(BaseModel):
    planId:str
    theme : str
    unitName : str
    trainingWay : str
    peopleNum: int
    startTime : str
    endTime : str
    Content :str
    address : str
    lon : float
    lat : float

class TrainingUpdateForm(BaseModel):
    trainingId : str
    planId:str = None
    theme : str = None
    unitName : str = None
    trainingWay : str = None
    peopleNum: int = None
    startTime : str = None
    endTime : str = None
    Content :str = None
    address : str = None
    lon : float = None
    lat : float = None



def get_file_query_fun(from_scenario,foreign_key,db: Session):
    file_query = db.query(EmergencyFile)
    file_query = file_query.filter(EmergencyFile.del_flag != '2')
    file_query = file_query.filter(EmergencyFile.from_scenario == from_scenario)
    file_query = file_query.filter(EmergencyFile.foreign_key == foreign_key)
    files = file_query.all()
    result = [{
        "uid": file.file_id,
        "status": file.status,
        "name": file.file_name_desc,
        "url":  file.file_name  #"/api/file/download/%s" %
    } for file in files]
    return result

def delete_file_fun(from_scenario,foreign_key,db: Session):
    file_query = db.query(EmergencyFile)
    file_query = file_query.filter(EmergencyFile.del_flag != '2')
    file_query = file_query.filter(EmergencyFile.from_scenario == from_scenario)
    file_query = file_query.filter(EmergencyFile.foreign_key == foreign_key)
    files = file_query.all()
    for file in files:
        file.del_flag='2'
    # db.commit()

def create_file_fun(file,from_scenario,foreign_key,db: Session):
    file_name = file.url
    file_name_desc = file.name
    status = file.status
    new_file = EmergencyFile(
        file_id=new_guid(),
        foreign_key=foreign_key,
        from_scenario=from_scenario,
        file_name=file_name,
        file_name_desc=file_name_desc,
        status=status
    )
    db.add(new_file)
    # db.commit()
    # db.refresh(new_file)


@router.get('/plan/list')
async def get_emergency_plan_list(
    planType: str = Query(None, description='预案类型'),
    # publishDate: datetime = Query(None, description='发布日期'),
    beginTime :str = Query(None, description='发布日期起始'),
    endTime :str = Query(None, description='发布日期结束'),
    # planName: str = Query(None, description='预案名称'),
    keywords : str = Query(None, description='预案名称/编制单位'),
    page: int = Query(1, gt=0, description='页码'),
    pageSize: int = Query(5, 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 beginTime:
            query = query.filter(EmergencyPlan.publish_date >= beginTime)
        if endTime:
            query = query.filter(EmergencyPlan.publish_date <= endTime)
        if keywords:
            query = query.filter(
                or_(
                    EmergencyPlan.plan_name.like(f'%{keywords}%'),
                    EmergencyPlan.organizing_unit.like(f'%{keywords}%')
                )
            )
            # query = query.filter(EmergencyPlan.plan_name.like(f'%{planName}%'))

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

        # 排序

        query = query.order_by(EmergencyPlan.create_time.desc())
        # 执行分页查询
        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,
                "organizingUnit": plan.organizing_unit,
                "document": plan.document_number,
                "publishDate": plan.publish_date.strftime('%Y-%m-%d')
            }
            for plan in emergency_plans
        ]

        # 返回结果
        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/{planId}')
async def get_emergency_plan(
    planId: str ,
    db: Session = Depends(get_db)
):
    try:
        # 构建查询
        query = db.query(EmergencyPlan)
        query = query.filter(EmergencyPlan.del_flag != '2')
        # 应用查询条件
        if planId:
            query = query.filter(EmergencyPlan.plan_number == planId)

        # 执行查询
        emergency_plan = query.first()
        if not emergency_plan:
            detail = "预案不存在"
            raise HTTPException(status_code=404, detail="预案不存在")
        # 将查询结果转换为列表形式的字典
        emergency_plan_result = {
            "planUid": emergency_plan.plan_id,
            "planId": emergency_plan.plan_number,
            "planName": emergency_plan.plan_name,
            "planType": emergency_plan.plan_type,
            "organizingUnit": emergency_plan.organizing_unit,
            "document": emergency_plan.document_number,
            "publishDate": emergency_plan.publish_date.strftime('%Y-%m-%d'),
            "fileList": get_file_query_fun(from_scenario='emergencyPlans_plan',foreign_key=emergency_plan.plan_id,db=db)
        }

        # 返回结果
        return {
            "code": 200,
            "msg": "成功获取预案详情",
            "data": emergency_plan_result
        }
    except Exception as e:
        # 处理异常
        if str(e)=='':
            e = detail
        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:
            create_file_fun(file=file, from_scenario='emergencyPlans_plan', foreign_key=new_plan.plan_id, db=db)
        db.commit()
        # 返回创建成功的响应
        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(
    form_data: PlanUpdateForm,
    db: Session = Depends(get_db)
):
    try:
        # 提取请求数据
        query = db.query(EmergencyPlan)
        query = query.filter(EmergencyPlan.plan_id == form_data.planUid)
        query = query.filter(EmergencyPlan.del_flag != '2')
        plan = query.first()

        if not plan:
            detail = "预案不存在"
            raise HTTPException(status_code=404, detail="预案不存在")

        if form_data.planName:
            plan.plan_name = form_data.planName

        if form_data.planType:
            plan.plan_type = form_data.planType

        if form_data.publishDate:
            plan.publish_date = form_data.publishDate

        if form_data.organizingUnit:
            plan.organizing_unit = form_data.organizingUnit

        if form_data.document:
            plan.document_number = form_data.document

        if len(form_data.fileList)>0:
            delete_file_fun(from_scenario='emergencyPlans_plan',foreign_key=plan.plan_id,db=db)
            for file in form_data.fileList:
                create_file_fun(file=file,from_scenario='emergencyPlans_plan',foreign_key=plan.plan_id,db=db)

        # 更新到数据库会话并提交
        db.commit()
        db.refresh(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_plans(
        planUids: list,
        db: Session = Depends(get_db)
):
    try:
        # 提取请求数据
        query = db.query(EmergencyPlan)
        query = query.filter(EmergencyPlan.del_flag != '2')
        query = query.filter(EmergencyPlan.plan_id.in_(planUids))
        plans = query.all()
        if not plans:
            detail = "预案不存在"
            raise HTTPException(status_code=404, detail="预案不存在")
        for plan in plans:
            plan.del_flag = '2'

        # 更新到数据库会话并提交
        db.commit()

        # 返回创建成功的响应
        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/{planUid}')
async def delete_emergency_plan(
        planUid: str,
        db: Session = Depends(get_db)
):
    try:
        # 提取请求数据
        query = db.query(EmergencyPlan)
        query = query.filter(EmergencyPlan.del_flag != '2')
        query = query.filter(EmergencyPlan.plan_id == planUid)
        plan = query.first()
        if not plan:
            detail = "预案不存在"
            raise HTTPException(status_code=404, detail="预案不存在")

        plan.del_flag = '2'

        # 更新到数据库会话并提交
        db.commit()
        db.refresh(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(5, 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:
            detail = "planNum不存在"
            raise HTTPException(status_code=404, detail="planNum不存在")


        # 计算总条目数
        total_items = query.count()
        query = query.order_by(EmergencyDrill.create_time.desc())
        # 执行分页查询
        emergency_drill = query.offset((page - 1) * pageSize).limit(pageSize).all()   #
        print(emergency_drill)
        # 将查询结果转换为列表形式的字典
        emergency_drill_list = []
        for drill in emergency_drill:
            emergency_drill = {
                "drillId": drill.drill_id,
                "drillName": drill.drill_name,
                "drillUnit": drill.organizing_unit,
                "year":  drill.planned_annual,
                "drillTime": drill.planned_time.strftime('%Y-%m-%d %H:%M:%S'),
                "drillAddress": drill.drill_location,
                "drillProject": get_file_query_fun(from_scenario='emergencyPlans_drill_project', foreign_key=drill.drill_id,db=db),
                "drillVideo": get_file_query_fun(from_scenario='emergencyPlans_drill_video', foreign_key=drill.drill_id,db=db),
                "drillPicture": get_file_query_fun(from_scenario='emergencyPlans_drill_pic', foreign_key=drill.drill_id,db=db)
            }
            emergency_drill_list.append(emergency_drill)

            # 返回结果
        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:
        # 处理异常
        if str(e) == '':
            e = detail
        raise HTTPException(status_code=500, detail=str(e))

@router.get('/drill/{drillId}')
async def get_emergency_drill(
    drillId: str = Query(None, description='演练编号'),
    db: Session = Depends(get_db)
):
    try:
        # 构建查询
        query = db.query(EmergencyDrill)
        query = query.filter(EmergencyDrill.del_flag != '2')
        # 应用查询条件
        if drillId:
            query = query.filter(EmergencyDrill.drill_id == drillId)
        else:
            detail = "drillId不存在"
            raise HTTPException(status_code=404, detail="drillId不存在")

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

        # 将查询结果转换为字典形式
        emergency_drill = {
            "drillId": drill.drill_id,
            "drillName": drill.drill_name,
            "drillUnit": drill.organizing_unit,
            "year": drill.planned_annual,
            "drillTime": drill.planned_time.strftime('%Y-%m-%d %H:%M:%S'),
            "drillAddress": drill.drill_location,
            "drillProject": get_file_query_fun(from_scenario='emergencyPlans_drill_project',foreign_key=drill.drill_id,db=db),
            "drillVideo": get_file_query_fun(from_scenario='emergencyPlans_drill_video', foreign_key=drill.drill_id,db=db),
            "drillPicture": get_file_query_fun(from_scenario='emergencyPlans_drill_pic', foreign_key=drill.drill_id,db=db)
        }

        # 返回结果
        return {
            "code": 200,
            "msg": "成功",
            "data": emergency_drill
        }
    except Exception as e:
        # 处理异常
        if str(e) == '':
            e = detail
        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.planId
        drill_name = form_data.drillName
        organizing_unit = form_data.drillUnit
        planned_annual = form_data.year
        planned_time = form_data.drillTime
        drill_location = form_data.drillAddress
        drill_lon = form_data.lon
        drill_lat = form_data.lat


        # 创建新的预案记录
        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:
            create_file_fun(file=file, from_scenario='emergencyPlans_drill_project', foreign_key=new_drill.drill_id, db=db)

        for file in form_data.drillVideo:
            create_file_fun(file=file, from_scenario='emergencyPlans_drill_video', foreign_key=new_drill.drill_id, db=db)

        for file in form_data.drillPicture:
            create_file_fun(file=file, from_scenario='emergencyPlans_drill_pic', foreign_key=new_drill.drill_id, db=db)

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

@router.put('/drill/update')
async def update_emergency_drill(
    form_data:DrillUpdateForm,
    db: Session = Depends(get_db)
):
    try:
        query = db.query(EmergencyDrill)
        query = query.filter(EmergencyDrill.drill_id == form_data.drillId)
        query = query.filter(EmergencyDrill.del_flag != '2')
        drill = query.first()

        # 判断预案编号是否存在，存在即更新
        if form_data.planId:
            drill.plan_number=form_data.planId
        # 判断演练名称是否存在，存在即更新
        if form_data.drillName:
            drill.drill_name=form_data.drillName
        # 判断演练单位是否存在，存在即更新
        if form_data.drillUnit:
            drill.organizing_unit=form_data.drillUnit
        # 判断演练年份是否存在，存在即更新
        if form_data.year:
            drill.planned_annual=form_data.year
        # 判断演练日期是否存在，存在即更新
        if form_data.drillTime:
            drill.planned_time=form_data.drillTime
        # 判断演练地址是否存在，存在即更新
        if form_data.drillAddress:
            drill.drill_location=form_data.drillAddress
        # 判断经度是否存在，存在即更新
        if form_data.lon:
            drill.drill_lon=form_data.lon
        # 判断纬度是否存在，存在即更新
        if form_data.lat:
            drill.drill_lat=form_data.lat
        # 判断演练方案是否存在，存在即更新
        if len(form_data.drillProject)>0:
            delete_file_fun(from_scenario='emergencyPlans_drill_project',foreign_key=drill.drill_id,db=db)
            for file in form_data.drillProject:
                create_file_fun(file=file,from_scenario='emergencyPlans_drill_project',foreign_key=drill.drill_id,db=db)
        # 判断演练视频是否存在，存在即更新
        if len(form_data.drillVideo) > 0:
            delete_file_fun(from_scenario='emergencyPlans_drill_video', foreign_key=drill.drill_id, db=db)
            for file in form_data.drillVideo:
                create_file_fun(file=file, from_scenario='emergencyPlans_drill_video', foreign_key=drill.drill_id,db=db)
        # 判断演练图片是否存在，存在即更新
        if len(form_data.drillPicture) > 0:
            delete_file_fun(from_scenario='emergencyPlans_drill_pic', foreign_key=drill.drill_id, db=db)
            for file in form_data.drillPicture:
                create_file_fun(file=file, from_scenario='emergencyPlans_drill_pic', foreign_key=drill.drill_id,db=db)
        # 提交所有更新
        db.commit()

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


@router.delete('/drill/delete')
async def delete_emergency_drill(
        drillUids: list,
        db: Session = Depends(get_db)
):
    try:
        # 提取请求数据
        query = db.query(EmergencyDrill)
        query = query.filter(EmergencyDrill.del_flag != '2')
        query = query.filter(EmergencyDrill.drill_id.in_(drillUids))
        drills = query.all()
        if not drills:
            detail = "演练不存在"
            raise HTTPException(status_code=404, detail="演练不存在")

        for drill in drills:
            drill.del_flag = '2'

        # 更新到数据库会话并提交
        db.commit()

        # 返回创建成功的响应
        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('/drill/delete/{drillUid}')
async def delete_emergency_drill(
        drillUid: str,
        db: Session = Depends(get_db)
):
    try:
        # 提取请求数据
        query = db.query(EmergencyDrill)
        query = query.filter(EmergencyDrill.del_flag != '2')
        query = query.filter(EmergencyDrill.drill_id == drillUid)
        drill = query.first()
        if not drill:
            detail = "演练不存在"
            raise HTTPException(status_code=404, detail="演练不存在")

        drill.del_flag = '2'

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

        # 返回创建成功的响应
        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('/training/list')
async def get_emergency_training_list(
    planNum: str = Query(None, description='预案编号'),
    page: int = Query(1, gt=0, description='页码'),
    pageSize: int = Query(5, 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:
            detail = "planNum不存在"
            raise HTTPException(status_code=404, detail="planNum不存在")


        # 计算总条目数
        total_items = query.count()
        query = query.order_by(EmergencyTrainingSession.start_time.desc())
        # 执行分页查询
        emergency_training = query.offset((page - 1) * pageSize).limit(pageSize).all()   #
        # print(emergency_drill)
        # 将查询结果转换为列表形式的字典
        emergency_training_list = [
            {
                "trainingId": training.training_id,
                "theme": training.training_theme,
                "unitName": training.training_unit,
                "peopleNum": 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:
        # 处理异常
        if str(e) == '':
            e = detail
        raise HTTPException(status_code=500, detail=str(e))


@router.get('/training/{trainingId}')
async def get_emergency_training(
    trainingId: str = Query(None, description='培训编号'),
    db: Session = Depends(get_db)
):
    try:
        # 构建查询
        query = db.query(EmergencyTrainingSession)
        query = query.filter(EmergencyTrainingSession.del_flag != '2')
        # 应用查询条件
        if trainingId:
            query = query.filter(EmergencyTrainingSession.training_id == trainingId)
        else:
            detail = "trainingId不存在"
            raise HTTPException(status_code=404, detail="trainingId不存在")


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

        # 将查询结果转换为列表形式的字典
        emergency_training = {
                "trainingId": training.training_id,
                "theme": training.training_theme,
                "unitName": training.training_unit,
                "peopleNum": 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
            }


            # 返回结果
        return {
            "code": 200,
            "msg": "成功",
            "data": emergency_training
        }
    except Exception as e:
        # 处理异常
        if str(e) == '':
            e = detail
        raise HTTPException(status_code=500, detail=str(e))




@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.theme,
            training_unit=form_data.unitName,
            training_method=form_data.trainingWay,
            participant_count=form_data.peopleNum,
            start_time=form_data.startTime,
            end_time=form_data.endTime,
            training_content=form_data.Content,
            training_location=form_data.address,
            training_lon=form_data.lon,
            training_lat=form_data.lat,
            plan_number = form_data.planId
        )

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

        # 返回创建成功的响应
        return {
            "code": 200,
            "msg": "培训创建成功",
            "data": None
        }
    except Exception as e:
        # 处理异常

        raise HTTPException(status_code=500, detail=str(e))


@router.put('/training/update')
async def update_emergency_training(
    form_data:TrainingUpdateForm,
    db: Session = Depends(get_db)
):
    try:
        query = db.query(EmergencyTrainingSession)
        query = query.filter(EmergencyTrainingSession.training_id == form_data.trainingId)
        query = query.filter(EmergencyTrainingSession.del_flag != '2')
        training = query.first()

        # 判断预案编号是否存在，存在即更新
        if form_data.planId:
            training.plan_number = form_data.planId
        # 判断预案编号是否存在，存在即更新
        if form_data.theme:
            training.training_theme = form_data.theme
        # 判断预案编号是否存在，存在即更新
        if form_data.unitName:
            training.training_unit = form_data.unitName
        # 判断预案编号是否存在，存在即更新
        if form_data.trainingWay:
            training.training_method = form_data.trainingWay
        # 判断预案编号是否存在，存在即更新
        if form_data.peopleNum:
            training.participant_count = form_data.peopleNum
        # 判断预案编号是否存在，存在即更新
        if form_data.startTime:
            training.start_time = form_data.startTime
        # 判断预案编号是否存在，存在即更新
        if form_data.endTime:
            training.end_time = form_data.endTime
        # 判断预案编号是否存在，存在即更新
        if form_data.Content:
            training.training_content = form_data.Content
        # 判断预案编号是否存在，存在即更新
        if form_data.address:
            training.training_location = form_data.address
        # 判断预案编号是否存在，存在即更新
        if form_data.lon:
            training.training_lon = form_data.lon
        # 判断预案编号是否存在，存在即更新
        if form_data.lat:
            training.training_lat = form_data.lat

        # 提交
        db.commit()

        # 返回创建成功的响应
        return {
            "code": 200,
            "msg": "培训更新成功",
            "data": None
        }
    except Exception as e:
        # 处理异常

        raise HTTPException(status_code=500, detail=str(e))

@router.delete('/training/delete')
async def delete_emergency_training(
        trainingUids: list,
        db: Session = Depends(get_db)
):
    try:
        # 提取请求数据
        query = db.query(EmergencyTrainingSession)
        query = query.filter(EmergencyTrainingSession.del_flag != '2')
        query = query.filter(EmergencyTrainingSession.training_id.in_(trainingUids))
        trainings = query.all()
        if not trainings:
            detail = "培训不存在"
            raise HTTPException(status_code=404, detail="培训不存在")

        for training in trainings:
            training.del_flag = '2'

        # 更新到数据库会话并提交
        db.commit()

        # 返回创建成功的响应
        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('/training/delete/{trainingUid}')
async def delete_emergency_training(
        trainingUid: str,
        db: Session = Depends(get_db)
):
    try:
        # 提取请求数据
        query = db.query(EmergencyTrainingSession)
        query = query.filter(EmergencyTrainingSession.del_flag != '2')
        query = query.filter(EmergencyTrainingSession.training_id == trainingUid)
        training = query.first()
        if not training:
            detail = "培训不存在"
            raise HTTPException(status_code=404, detail="培训不存在")

        training.del_flag = '2'

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

        # 返回创建成功的响应
        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('/response/list')
async def get_emergency_response_list(
    planNum:str,
    page: int = Query(1, gt=0, description='页码'),
    pageSize: int = Query(5, gt=0, description='每页条目数量'),
    db: Session = Depends(get_db)
):
    try:
        # 查询所有响应事件

        query = db.query(EmergencyResponse)
        query = query.filter(EmergencyResponse.del_flag!='2')
        query = query.filter(EmergencyResponse.plan_id==planNum)

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

        # 排序

        query = query.order_by(EmergencyResponse.response_start_time.desc())
        # 执行分页查询
        responses = query.offset((page - 1) * pageSize).limit(pageSize).all()



        # 将查询结果转换为列表形式的字典
        response_list = [
            {
                "responseId": response.response_id,
                "eventName": response.event_name,
                "eventType": response.event_type,
                "responseUnit": response.response_unit,
                "eventAddress": response.event_address,
                "responseLevel": response.response_level,
                "responseStartTime": response.response_start_time.strftime('%Y-%m-%d %H:%M:%S') if response.response_start_time else '',
                "responseEndTime": response.response_end_time.strftime('%Y-%m-%d %H:%M:%S') if response.response_end_time else '',
            }
            for response in responses
        ]

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