#!/usr/bin/env python3 # -*- coding: utf-8 -*- from fastapi import APIRouter, Request, Depends,Query, HTTPException, status from common.security import valid_access_token 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 from . import event, response, unit, doc, contact router = APIRouter() router.include_router(event.router, prefix="/event", tags=["事件相关"]) router.include_router(response.router, prefix="/response", tags=["响应相关"]) router.include_router(unit.router, prefix="/unit", tags=["单位职责相关"]) router.include_router(doc.router, prefix="/doc", tags=["结构化文档相关"]) router.include_router(contact.router, prefix="/contact", tags=["预案人员配置相关"]) class File(BaseModel): status :str name : str url : str class PlanCreateForm(BaseModel): planName : str planType : int # planTypeDesc : str publishDate: str organizingUnit : str document : str event_type: str fileList : List[File] class PlanUpdateForm(BaseModel): planUid : str planName : str = None planType : int = None publishDate: str = None organizingUnit : str = None document : str = None event_type: 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), user_id = Depends(valid_access_token) ): 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'), "event_type": plan.event_type } 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), user_id = Depends(valid_access_token) ): 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), "event_type": emergency_plan.event_type } # 返回结果 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), body = Depends(remove_xss_json), user_id = Depends(valid_access_token) ): 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 event_type = form_data.event_type # 创建新的预案记录 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, event_type=event_type, create_by = user_id ) # 添加到数据库会话并提交 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), body = Depends(remove_xss_json), user_id = Depends(valid_access_token) ): 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 form_data.event_type: plan.event_type = form_data.event_type 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) if user_id: plan.create_by = user_id # 更新到数据库会话并提交 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), body = Depends(remove_xss_json), user_id = Depends(valid_access_token) ): 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' plan.create_by=user_id # 更新到数据库会话并提交 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), body = Depends(remove_xss_json), user_id = Depends(valid_access_token) ): 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' plan.create_by = user_id # 更新到数据库会话并提交 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), user_id = Depends(valid_access_token) ): 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), body = Depends(remove_xss_json), user_id = Depends(valid_access_token) ): 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), body = Depends(remove_xss_json), user_id = Depends(valid_access_token) ): 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, create_by = user_id ) # 添加到数据库会话并提交 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), body = Depends(remove_xss_json), user_id = Depends(valid_access_token) ): 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) if user_id: drill.create_by = user_id # 提交所有更新 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), body = Depends(remove_xss_json), user_id = Depends(valid_access_token) ): 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' drill.create_by=user_id # 更新到数据库会话并提交 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), user_id = Depends(valid_access_token) ): 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' drill.create_by = user_id # 更新到数据库会话并提交 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), user_id = Depends(valid_access_token) ): 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), user_id = Depends(valid_access_token) ): 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), user_id = Depends(valid_access_token) ): 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), user_id = Depends(valid_access_token) ): 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 if user_id: training.create_by = user_id # 提交 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), user_id = Depends(valid_access_token) ): 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' training.create_by = user_id # 更新到数据库会话并提交 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), user_id = Depends(valid_access_token) ): 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' training.create_by = user_id # 更新到数据库会话并提交 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))