优化下载接口

routers/api/emergencyPlans/__init__.py

@@ -2,20 +2,19 @@
 # -*- 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 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
 
 router = APIRouter()
 
-
 class File(BaseModel):
     status :str
     name : str
@@ -67,10 +66,37 @@ class DrillUpdateForm(BaseModel):
     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()
@@ -78,20 +104,19 @@ def get_file_query_fun(from_scenario,foreign_key,db: Session):
         "uid": file.file_id,
         "status": file.status,
         "name": file.file_name_desc,
-        "url": "/api/file/download/%s" % file.file_name
+        "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()
+    # db.commit()
 
 def create_file_fun(file,from_scenario,foreign_key,db: Session):
     file_name = file.url
@@ -106,8 +131,8 @@ def create_file_fun(file,from_scenario,foreign_key,db: Session):
         status=status
     )
     db.add(new_file)
-    db.commit()
-    db.refresh(new_file)
+    # db.commit()
+    # db.refresh(new_file)
 
 
 @router.get('/plan/list')
@@ -147,6 +172,9 @@ async def get_emergency_plan_list(
         # 计算总条目数
         total_items = query.count()
 
+        # 排序
+
+        query = query.order_by(EmergencyPlan.create_time.desc())
         # 执行分页查询
         emergency_plans = query.offset((page - 1) * pageSize).limit(pageSize).all()
 
@@ -209,7 +237,7 @@ async def get_emergency_plan(
             "planType": emergency_plan.plan_type,
             "organizingUnit": emergency_plan.organizing_unit,
             "document": emergency_plan.document_number,
-            "publish_date": emergency_plan.publish_date.strftime('%Y-%m-%d'),
+            "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)
         }
 
@@ -260,8 +288,8 @@ async def create_emergency_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=plan.plan_id, db=db)
-
+            create_file_fun(file=file, from_scenario='emergencyPlans_plan', foreign_key=new_plan.plan_id, db=db)
+        db.commit()
         # 返回创建成功的响应
         return {
             "code": 200,
@@ -284,33 +312,34 @@ async def update_emergency_plan(
         query = query.filter(EmergencyPlan.plan_id == form_data.planId)
         query = query.filter(EmergencyPlan.del_flag != '2')
         plan = query.first()
+
         if not plan:
             detail = "预案不存在"
             raise HTTPException(status_code=404, detail="预案不存在")
 
-        if planName:
+        if form_data.planName:
             plan.plan_name = form_data.planName
 
-        if planType:
+        if form_data.planType:
             plan.plan_type = form_data.planType
 
-        if publishDate:
+        if form_data.publishDate:
             plan.publish_date = form_data.publishDate
 
-        if organizingUnit:
+        if form_data.organizingUnit:
             plan.organizing_unit = form_data.organizingUnit
 
-        if document:
+        if form_data.document:
             plan.document_number = form_data.document
 
-        if len(fileList)>0:
+        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(new_plan)  # 可选，如果需要刷新实例状态
+        db.refresh(plan)  # 可选，如果需要刷新实例状态
 
         # 返回创建成功的响应
         return {
@@ -324,6 +353,37 @@ async def update_emergency_plan(
             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(
@@ -360,6 +420,8 @@ async def delete_emergency_plan(
 
 
 
+
+
 @router.get('/drill/list')
 async def get_emergency_drill_list(
     planNum: str = Query(None, description='预案编号'),
@@ -499,50 +561,15 @@ async def create_emergency_drill(
         db.refresh(new_drill)  # 可选，如果需要刷新实例状态
 
         for file in form_data.drillProject:
-            file_name = file.url
-            file_name_desc = file.name
-            status = file.status
-            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,
-                status = status
-            )
-            db.add(new_file)
-            db.commit()
-            db.refresh(new_file)
+            create_file_fun(file=file, from_scenario='emergencyPlans_drill_project', foreign_key=new_drill.drill_id, db=db)
+
         for file in form_data.drillVideo:
-            file_name = file.url
-            file_name_desc = file.name
-            status = file.status
-            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,
-                status=status
-            )
-            db.add(new_file)
-            db.commit()
-            db.refresh(new_file)
+            create_file_fun(file=file, from_scenario='emergencyPlans_drill_video', foreign_key=new_drill.drill_id, db=db)
+
         for file in form_data.drillPicture:
-            file_name = file.url
-            file_name_desc = file.name
-            status = file.status
-            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,
-                status = status
-            )
-            db.add(new_file)
-            db.commit()
-            db.refresh(new_file)
+            create_file_fun(file=file, from_scenario='emergencyPlans_drill_pic', foreign_key=new_drill.drill_id, db=db)
+
+        db.commit()
         # 返回创建成功的响应
         return {
             "code": 200,
@@ -553,6 +580,102 @@ async def create_emergency_drill(
         # 处理异常
         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.plan_id,db=db)
+            for file in form_data.fileList:
+                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.plan_id, db=db)
+            for file in form_data.fileList:
+                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.plan_id, db=db)
+            for file in form_data.fileList:
+                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(
@@ -694,18 +817,8 @@ async def get_emergency_training(
             e = detail
         raise HTTPException(status_code=500, detail=str(e))
 
-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
+
+
 
 @router.post('/training/create')
 async def create_emergency_training(
@@ -745,6 +858,99 @@ async def create_emergency_training(
 
         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: str,
+        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,

routers/api/upload_file/__init__.py

@@ -152,7 +152,7 @@ async def mergefile(identifier: str = Query(''),
 
 
 @router.get("/download/{filename}")
-async def download_file(filename: str):
+async def download_file(filename: str,filenameDesc: str = None):
     """
     根据提供的文件名下载文件。
     :param filename: 要下载的文件的名称。
@@ -165,9 +165,11 @@ async def download_file(filename: str):
         if not os.path.isfile(file_path):
             raise HTTPException(status_code=404, detail="文件未找到")
 
+        if not filenameDesc:
+            filenameDesc = filename
         # 设置文件头部和内容类型
         headers = {
-            'Content-Disposition': f'attachment; filename={filename}'
+            'Content-Disposition': f'attachment; filename={filenameDesc}'
         }
 
         # 使用FileResponse返回文件流