填报&物资

models/resource_provision_base.py

@@ -86,7 +86,7 @@ class Unit(Base):
     position = Column(String(100), comment='负责人职务')
     team_size = Column(Integer, comment='队伍人数')
     supervisor_unit = Column(String(100), comment='主管单位')
-
+    add_time = Column(DateTime, comment='插入时间')
 
     def to_dict(self):
         return {
@@ -103,6 +103,7 @@ class Unit(Base):
             "position": self.position,  # 新增字段：负责人职务
             "team_size": self.team_size,  # 新增字段：队伍人数
             "supervisor_unit": self.supervisor_unit,  # 新增字段：主管单位
+            "add_time": self.add_time
             # "is_delete": self.is_delete
         }
     class Config:

routers/api/dataFilling/__init__.py

@@ -73,7 +73,8 @@ async def get_report_structure(
         ReportManagement.creator_id == creator_id
     ).first()
     if not report:
-        raise HTTPException(status_code=404, detail="Report not found")
+        return {"code": 404, "msg": "Report not found"}
+        # raise HTTPException(status_code=404, detail="Report not found")
 
     data_table_name = report.data_table_name
 
@@ -208,7 +209,8 @@ def create_dynamic_table(table_name: str, field_names: List[str], db: Session):
 
     # 检查表是否已存在
     if inspector.has_table(table_name):
-        raise HTTPException(status_code=400, detail="Table already exists")
+        return {"code": 500, "msg": "请检查表格"}
+        # raise HTTPException(status_code=400, detail="Table already exists")
 
     table = Table(table_name, metadata,
                   Column('id', Integer, primary_key=True,comment="id"),
@@ -237,7 +239,8 @@ def create_dynamic_table(table_name: str, field_names: List[str], db: Session):
         metadata.create_all(bind=db.bind)
     except Exception as e:
         db.rollback()
-        raise HTTPException(status_code=400, detail=f"创建表失败：{str(e)}")
+        return {"code": 500, "msg": "创建表失败"}
+        # raise HTTPException(status_code=400, detail=f"创建表失败：{str(e)}")
 
 
 class ReportCreate(BaseModel):
@@ -271,7 +274,8 @@ def create_report_and_table(report: ReportCreate, db: Session = Depends(get_db),
         # 可以先不创表，但是填报人先报上？
         if str(report.issued_status) == '2' and not report.field_names:
             #这里有bug
-            raise HTTPException(status_code=403, detail='发布状态下，需要填写字段信息')
+            return {"code": 400, "msg": "发布状态下，需要填写字段信息"}
+            # raise HTTPException(status_code=403, detail='发布状态下，需要填写字段信息')
 
         if str(report.issued_status) == '2':
 
@@ -498,7 +502,8 @@ def update_table_fields(table_name: str, field_names: List[str], db: Session):
                 added_columns.add(unique_column_name)  # 记录已添加的字段名
             except Exception as e:
                 db.rollback()
-                raise HTTPException(status_code=400, detail=f"添加字段失败：{str(e)}")
+                return {"code": 500, "msg": "添加字段失败，请联系管理员排查"}
+                # raise HTTPException(status_code=400, detail=f"添加字段失败：{str(e)}")
 
 
 # class ReportCreate(BaseModel):
@@ -552,7 +557,8 @@ def drop_table_if_exists(db: Session, table_name: str):
                 del metadata.tables[table_name]
         except Exception as e:
             db.rollback()
-            raise HTTPException(status_code=400, detail=f"删除表失败：{str(e)}")
+            return {"code": 500, "msg": "联系管理员排查"}
+            # raise HTTPException(status_code=400, detail=f"删除表失败：{str(e)}")
 
 
 
@@ -573,31 +579,35 @@ async def update_report(
     report = db.query(ReportManagement).filter(ReportManagement.report_id == report_id,
                                                ReportManagement.creator_id == creator_id).first()
     if not report:
-        raise HTTPException(status_code=404, detail="Report not found")
+        return {"code": 404, "msg": "Report not found"}
+        # raise HTTPException(status_code=404, detail="Report not found")
 
     if report.issued_status in ['2', 2]:
-        raise HTTPException(status_code=400, detail="当前表单已发布，无法修改")
+        return {"code": 400, "msg": "当前表单已发布，无法修改"}
+        # raise HTTPException(status_code=400, detail="当前表单已发布，无法修改")
 
 
     if report.collection_status in ['2',2]:
-        raise HTTPException(status_code=400, detail="当前表单已收取，无法修改")
+        return {"code": 400, "msg": "当前表单已收取，无法修改"}
+        # raise HTTPException(status_code=400, detail="当前表单已收取，无法修改")
 
 
     # 这里要添加发布状态判断，如果是暂存状态则跳过，发布状态则要提供字段信息
-    # if update_data.issued_status  in ['0', 0]:
-    # 检查表是否存在
-    table_name = report.data_table_name
-    if not table_exists(db, table_name):
-        # 如果表不存在，根据 new_fields 创建表
-        if not update_data.new_fields:
-            raise HTTPException(status_code=400, detail="表不存在且未提供字段信息，无法创建表")
-        create_dynamic_table(table_name, update_data.new_fields, db)
-
-    elif table_exists(db, table_name) and update_data.new_fields:
-        # print("修改")
-        # print(table_name)
-        # print("新字段",update_data.new_fields)
-        update_table_fields(table_name, update_data.new_fields, db)
+    #
+    if update_data.issued_status in ['2', 2]:
+        # 检查表是否存在
+        table_name = report.data_table_name
+        if not table_exists(db, table_name):
+            # 如果表不存在，根据 new_fields 创建表
+            if not update_data.new_fields:
+                raise HTTPException(status_code=400, detail="表不存在且未提供字段信息，无法创建表")
+            create_dynamic_table(table_name, update_data.new_fields, db)
+
+        elif table_exists(db, table_name) and update_data.new_fields:
+            # print("修改")
+            # print(table_name)
+            # print("新字段",update_data.new_fields)
+            update_table_fields(table_name, update_data.new_fields, db)
 
         # 更新 creator_phone 和 creator_name
     if update_data.creator_phone:
@@ -678,13 +688,16 @@ async def update_report_status_and_time(
     # 查询要修改的记录
     report = db.query(ReportManagement).filter(ReportManagement.report_id == report_id).first()
     if not report:
-        raise HTTPException(status_code=404, detail="Report not found")
+        return {"code": 404, "msg": "Report not found"}
+        # raise HTTPException(status_code=404, detail="Report not found")
     # 验证请求者ID
     if str(report.creator_id) != str(creator_id):
-        raise HTTPException(status_code=403, detail="没有权限操作")
+        return {"code": 403, "msg": "没有权限操作"}
+        # raise HTTPException(status_code=403, detail="没有权限操作")
 
     if report.issued_status ==2:
-        raise HTTPException(status_code=403, detail="不可重复发布")
+        return {"code": 400, "msg": "不可重复发布"}
+        # raise HTTPException(status_code=403, detail="不可重复发布")
 
     data_table_name = report.data_table_name
 
@@ -738,18 +751,16 @@ async def update_report_status_and_time(
 
 
 class TaskQuery(BaseModel):
-    # user_id: str
     submission_status: Optional[List[int]] = None
     table_name: Optional[str] = None
+    page: int = 1  # 分页参数：当前页码，默认为1
+    pageSize: int = 10  # 分页参数：每页大小，默认为10
 
 @router.post("/my_filling")
-@router.get("/my_filling")
 async def get_user_tasks(
     db: Session = Depends(get_db),
     query: TaskQuery = Body(...),
     user_id: str = Depends(valid_access_token),
-    page: int = Query(default=1, gt=0),  # 分页参数：当前页码，默认为1
-    pageSize: int = Query(default=10, gt=0)  # 分页参数：每页大小，默认为10
 ):
     # 检查用户ID是否提供
     if not user_id:
@@ -776,8 +787,8 @@ async def get_user_tasks(
     total_count = user_tasks.count()
 
     # 分页查询
-    offset = (page - 1) * pageSize
-    tasks = user_tasks.offset(offset).limit(pageSize).all()
+    offset = (query.page - 1) * query.pageSize
+    tasks = user_tasks.offset(offset).limit(query.pageSize).all()
 
     # 构造返回结果
     result_items = []
@@ -797,9 +808,9 @@ async def get_user_tasks(
         "code": 200,
         "msg": "查询成功",
         "total": total_count,
-        "totalPages": (total_count + pageSize - 1) // pageSize,
-        "page": page,
-        "pageSize": pageSize,
+        "totalPages": (total_count + query.pageSize - 1) // query.pageSize,
+        "page": query.page,
+        "pageSize": query.pageSize,
         "data": result_items
     }
 
@@ -914,24 +925,29 @@ async def submit_data(
 ):
     # 检查用户ID和填报ID是否提供
     if not user_id or not submit_data.report_id:
-        raise HTTPException(status_code=400, detail="填报ID是必填项")
+        return {"code":400,"msg":"填报ID是必填项"}
+        # raise HTTPException(status_code=400, detail="填报ID是必填项")
 
     # 获取对应填报ID的数据表名称
     report = db.query(ReportManagement).filter(ReportManagement.report_id == submit_data.report_id).first()
     if not report:
-        raise HTTPException(status_code=404, detail="未找到对应的填报ID")
+        return {"code": 400, "msg": "未找到对应的填报ID"}
+        # raise HTTPException(status_code=404, detail="未找到对应的填报ID")
 
     data_table_name = report.data_table_name
     if not data_table_name:
-        raise HTTPException(status_code=404, detail="未找到对应的数据表名称")
+        return {"code": 400, "msg": "未找到对应的数据表名称"}
+        # raise HTTPException(status_code=404, detail="未找到对应的数据表名称")
 
     if report.issued_status not in [2,'2']:
-        raise HTTPException(status_code=404, detail="当前未发布，不可填写")
+        return {"code": 400, "msg": "当前未发布，不可填写"}
+        # raise HTTPException(status_code=404, detail="当前未发布，不可填写")
 
     is_collection = report.collection_status
 
     if is_collection == 2 or is_collection == '2':
-        raise HTTPException(status_code=404, detail="管理员已收取信息，无法填写")
+        return {"code": 400, "msg": "管理员已收取信息，无法填写"}
+        # raise HTTPException(status_code=404, detail="管理员已收取信息，无法填写")
 
     # 检查用户是否有权限填报
     submission = db.query(FormSubmission).filter(
@@ -939,13 +955,15 @@ async def submit_data(
         FormSubmission.user_id == str(user_id)  # 确保user_id是字符串类型
     ).first()
     if not submission:
-        raise HTTPException(status_code=403, detail="用户没有填报权限")
+        return {"code": 400, "msg": "用户没有填报权限"}
+        # raise HTTPException(status_code=403, detail="用户没有填报权限")
 
 
     current_time = datetime.now()
 
     if report.end_time < current_time:
-        raise HTTPException(status_code=403, detail="填写时间已过")
+        return {"code": 400, "msg": "填写时间已过"}
+        # raise HTTPException(status_code=403, detail="填写时间已过")
 
 
     # 将数据写入数据库
@@ -984,17 +1002,20 @@ async def get_submission_status(
     user_id = Depends(valid_access_token)
 ):
     # 检查用户ID和填报ID是否提供
-    if not user_id or not query.report_id:
-        raise HTTPException(status_code=400, detail="用户ID和填报ID是必填项")
+    # if not user_id or not query.report_id:
+        # return {"code": 400, "msg": "用户ID和填报ID是必填项"}
+        # raise HTTPException(status_code=400, detail="用户ID和填报ID是必填项")
 
     # 获取对应填报ID的数据表名称
     report = db.query(ReportManagement).filter(ReportManagement.report_id == query.report_id).first()
     if not report:
-        raise HTTPException(status_code=404, detail="未找到对应的填报ID")
+        return {"code": 400, "msg": "未找到对应的填报ID"}
+        # raise HTTPException(status_code=404, detail="未找到对应的填报ID")
 
     data_table_name = report.data_table_name
     if not data_table_name:
-        raise HTTPException(status_code=404, detail="未找到对应的数据表名称")
+        return {"code": 400, "msg": "未找到对应的数据表名称"}
+        # raise HTTPException(status_code=404, detail="未找到对应的数据表名称")
 
     # 获取填报情况
     submission = db.query(FormSubmission).filter(
@@ -1002,7 +1023,8 @@ async def get_submission_status(
         FormSubmission.user_id == str(user_id)  # 确保user_id是字符串类型
     ).first()
     if not submission:
-        raise HTTPException(status_code=404, detail="未找到对应的填报情况")
+        return {"code": 404, "msg": "未找到对应的填报"}
+        # raise HTTPException(status_code=404, detail="未找到对应的填报情况")
 
     start_time = report.start_time
     end_time = report.end_time
@@ -1132,7 +1154,8 @@ async def get_reports_by_creator(
 
     # 如果没有找到任何记录，抛出404异常
     if not results:
-        raise HTTPException(status_code=404, detail="没有找到与该创建人ID相关的记录")
+        return {"code": 404, "msg": "没有找到与该创建人ID相关的记录"}
+        # raise HTTPException(status_code=404, detail="没有找到与该创建人ID相关的记录")
 
     # 构造分页结果
     result = {
@@ -1161,7 +1184,8 @@ async def update_collection_status(
 ):
     # 检查 new_status 是否为允许的值之一
     if new_status not in (0, 1, 2):
-        raise HTTPException(status_code=400, detail="Invalid collection status value")
+        return {"code": 400, "msg": "Invalid collection status value"}
+        # raise HTTPException(status_code=400, detail="Invalid collection status value")
 
     # 查询 ReportManagement 表以获取对应记录
     report = db.query(ReportManagement).filter(
@@ -1172,10 +1196,12 @@ async def update_collection_status(
 
     # 如果没有找到记录，返回404
     if not report:
-        raise HTTPException(status_code=404, detail="Report not found")
+        return {"code": 404, "msg": "Report not found"}
+        # raise HTTPException(status_code=404, detail="Report not found")
 
     if report.collection_status == 2 or report.collection_status == '2':
-        raise HTTPException(status_code=404, detail="当前已收取，无需重复收取")
+        return {"code": 404, "msg": "当前已收取，无需重复收取"}
+        # raise HTTPException(status_code=404, detail="当前已收取，无需重复收取")
 
 
     current_time_str = datetime.now().strftime("%Y%m%d%H%M%S")
@@ -1214,11 +1240,13 @@ async def get_records_by_creator_and_report(
 
     # 如果没有找到记录，返回404
     if not report:
-        raise HTTPException(status_code=404, detail="Report not found")
+        return {"code": 404, "msg": "Report not found"}
+        # raise HTTPException(status_code=404, detail="Report not found")
 
     # 如果没有 data_table_name，返回404
     if not report.data_table_name:
-        raise HTTPException(status_code=404, detail="Data table name not found")
+        return {"code": 404, "msg": "Data table name not found"}
+        # raise HTTPException(status_code=404, detail="Data table name not found")
 
     # 查询工单表所有信息，并关联用户表匹配到用户名字
     query_sql = text(f"""

routers/api/resourceProvison/emergency_resources.py

@@ -10,7 +10,8 @@ import uuid
 from common.security import valid_access_token
 from pydantic import BaseModel
 
-
+from sqlalchemy import create_engine, Column, Integer, String, Boolean, MetaData, Table, \
+    inspect, exists,or_,text,insert,asc,desc
 
 router = APIRouter()
 
@@ -50,7 +51,7 @@ class WaterResourceProjectListSchema(BaseModel):
         orm_mode = True
 #插入数据
 @router.post("/projects/")
-def create_projects(project_list_data: WaterResourceProjectListSchema, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def create_projects(project_list_data: WaterResourceProjectListSchema, db: Session = Depends(get_db)):
     projects = project_list_data.projects
     if not projects:  # 确保列表不为空
         raise HTTPException(status_code=400, detail="项目列表不能为空")
@@ -173,15 +174,19 @@ class UnitListSchema(BaseModel):
         orm_mode = True
 #创建
 @router.post("/rescue_units/")
-def create_units(unit_list_data: UnitListSchema,
-    user_id=Depends(valid_access_token), db: Session = Depends(get_db)):
+def create_units(unit_list_data: UnitListSchema, db: Session = Depends(get_db)):
     units = unit_list_data.units
     if not units:  # 确保列表不为空
         raise HTTPException(status_code=400, detail="单位列表不能为空")
     try:
         new_units = []  # 创建一个空列表来存储新对象
         for unit_data in units:
-            new_unit = Unit(**unit_data.dict(exclude_none=True))
+
+            unit_data = unit_data.dict(exclude_none=True)
+            n_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            unit_data["add_time"] = n_time
+
+            new_unit = Unit(**unit_data)
             db.add(new_unit)
             new_units.append(new_unit)
         db.commit()
@@ -219,7 +224,7 @@ def get_units(page: int = Query(default=1, gt=0),
               user_id=Depends(valid_access_token)):
     # 应用过滤条件，仅查询未被删除的单位
     data_query = db.query(Unit).filter(Unit.is_delete == 0)
-
+    data_query = data_query.order_by(Unit.add_time.desc())
     # 计算总数
     total_count = data_query.count()
 
@@ -298,15 +303,19 @@ class RescuePersonnelListSchema(BaseModel):
         orm_mode = True
 #创建
 @router.post("/rescue_personnel/")
-def create_rescue_personnel(personnel_list_data: RescuePersonnelListSchema,
-    user_id=Depends(valid_access_token), db: Session = Depends(get_db)):
+def create_rescue_personnel(personnel_list_data: RescuePersonnelListSchema, db: Session = Depends(get_db)):
     personnel_list = personnel_list_data.personnel_list
     if not personnel_list:  # 确保列表不为空
         raise HTTPException(status_code=400, detail="人员列表不能为空")
     try:
         new_personnel_objects = []  # 创建一个空列表来存储新对象
         for personnel_data in personnel_list:
-            new_personnel = RescuePersonnel(**personnel_data.dict(exclude_none=True))
+            personnel_data = personnel_data.dict(exclude_none=True)
+            n_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+            personnel_data["created_time"] = n_time
+
+            new_personnel = RescuePersonnel(**personnel_data)
             db.add(new_personnel)
             new_personnel_objects.append(new_personnel)
         db.commit()
@@ -318,8 +327,7 @@ def create_rescue_personnel(personnel_list_data: RescuePersonnelListSchema,
 
 #删除
 @router.delete("/rescue_personnel/{personnel_id}/")
-def delete_rescue_personnel(personnel_id: int,
-    user_id=Depends(valid_access_token),db: Session = Depends(get_db)):
+def delete_rescue_personnel(personnel_id: int, db: Session = Depends(get_db)):
     personnel = db.query(RescuePersonnel).get(personnel_id)
     if not personnel:
         raise HTTPException(status_code=404, detail="救灾人员不存在")
@@ -330,11 +338,12 @@ def delete_rescue_personnel(personnel_id: int,
 
 # 查询列表
 @router.get("/rescue_personnel/")
-def get_rescue_personnel(page: int = Query(default=1, gt=0),
-                 pageSize: int = Query(default=10, gt=0), db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def get_rescue_personnel(
+                    page: int = Query(default=1, gt=0),
+                 pageSize: int = Query(default=10, gt=0), db: Session = Depends(get_db)):
     # 应用过滤条件，仅查询未被删除的人员
     data_query = db.query(RescuePersonnel).filter(RescuePersonnel.is_delete == 0)
-
+    data_query = data_query.order_by(RescuePersonnel.created_time.desc())
     # 计算总数
     total_count = data_query.count()
 
@@ -372,7 +381,7 @@ def get_rescue_personnel(page: int = Query(default=1, gt=0),
 
 #查询详情
 @router.get("/rescue_personnel/{personnel_id}/")
-def get_rescue_personnel_by_id(personnel_id: int, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def get_rescue_personnel_by_id(personnel_id: int, db: Session = Depends(get_db)):
     # unit = db.query(Unit).filter_by(id=unit_id, is_delete=0).first()
     personnel = db.query(RescuePersonnel).filter_by(id = personnel_id, is_delete = 0).first()
 
@@ -406,7 +415,7 @@ def get_rescue_personnel_by_id(personnel_id: int, db: Session = Depends(get_db),
 
 #修改
 @router.put("/rescue_personnel/{personnel_id}/")
-def update_rescue_personnel(personnel_id: int, update_data: RescuePersonnelSchema, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def update_rescue_personnel(personnel_id: int, update_data: RescuePersonnelSchema, db: Session = Depends(get_db)):
     personnel = db.query(RescuePersonnel).filter_by(id=personnel_id, is_delete=0).first()
     if not personnel:
         raise HTTPException(status_code=404, detail="救灾人员不存在或已被标记为删除")
@@ -432,7 +441,7 @@ def update_rescue_personnel(personnel_id: int, update_data: RescuePersonnelSchem
 class RescueStationSchema(BaseModel):
     id: int = None
     fwdx: str = None
-    data_id: str = uuid.uuid1()
+    data_id: str = None
     zj: str = None
     lng: str = None
     cd_time: str = None
@@ -463,15 +472,24 @@ class RescueStationListSchema(BaseModel):
 
 
 #救助站管理
+#创建
 @router.post("/rescue_stations/")
-def create_rescue_stations(rescue_station_list_data: RescueStationListSchema, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def create_rescue_stations(rescue_station_list_data: RescueStationListSchema, db: Session = Depends(get_db)):
     stations = rescue_station_list_data.stations
     if not stations:  # 确保列表不为空
         raise HTTPException(status_code=400, detail="救助站列表不能为空")
     try:
         new_stations = []  # 创建一个空列表来存储新对象
         for station_data in stations:
-            new_station = RescueStation(**station_data.dict(exclude_none=True))
+            station_data_dict = station_data.dict(exclude_none=True)
+            n_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            station_data_dict["cd_time"] = n_time
+            station_data_dict["add_time"] = n_time
+            station_data_dict["data_id"] = uuid.uuid1()
+            new_station = RescueStation(**station_data_dict)
+
+
+            # new_station = RescueStation(**station_data.dict(exclude_none=True))
             db.add(new_station)
             new_stations.append(new_station)
         db.commit()
@@ -485,7 +503,7 @@ def create_rescue_stations(rescue_station_list_data: RescueStationListSchema, db
 
 
 @router.delete("/rescue_stations/{station_id}/")
-def delete_rescue_station(station_id: int, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def delete_rescue_station(station_id: int, db: Session = Depends(get_db)):
     station = db.query(RescueStation).filter_by(id=station_id, is_delete=0).first()
     if not station:
         raise HTTPException(status_code=404, detail="救助站不存在")
@@ -504,10 +522,11 @@ def delete_rescue_station(station_id: int, db: Session = Depends(get_db), user_i
 
 @router.get("/rescue_stations/")
 def get_rescue_stations(page: int = Query(default=1, gt=0),
-                 pageSize: int = Query(default=10, gt=0), db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+                 pageSize: int = Query(default=10, gt=0), db: Session = Depends(get_db)):
     # 应用过滤条件，仅查询未被删除的救助站
     data_query = db.query(RescueStation).filter(RescueStation.is_delete == 0)
 
+    data_query = data_query.order_by(RescueStation.add_time.desc())
     # 计算总数
     total_count = data_query.count()
 
@@ -515,6 +534,8 @@ def get_rescue_stations(page: int = Query(default=1, gt=0),
     offset = (page - 1) * pageSize
     stations = data_query.offset(offset).limit(pageSize).all()
 
+
+
     # 构造结果
     result_items = [station.to_dict() for station in stations]
 
@@ -531,7 +552,7 @@ def get_rescue_stations(page: int = Query(default=1, gt=0),
     return result
 
 @router.get("/rescue_stations/{station_id}/")
-def get_rescue_station_by_id(station_id: int, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def get_rescue_station_by_id(station_id: int, db: Session = Depends(get_db)):
     station = db.query(RescueStation).filter_by(id=station_id, is_delete=0).first()
 
     if not station:
@@ -539,7 +560,7 @@ def get_rescue_station_by_id(station_id: int, db: Session = Depends(get_db), use
     return {"code": 200, "msg": "查询成功", "station": station.to_dict()}
 
 @router.put("/rescue_stations/{station_id}/")
-def update_rescue_station(station_id: int, update_data: RescueStationSchema, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def update_rescue_station(station_id: int, update_data: RescueStationSchema, db: Session = Depends(get_db)):
     station = db.query(RescueStation).filter_by(id=station_id, is_delete=0).first()
     if not station:
         raise HTTPException(status_code=404, detail="救助站不存在或已被标记为删除")
@@ -607,7 +628,7 @@ class DefenseProjectListSchema(BaseModel):
 
 # 创建
 @router.post("/defense_projects/")
-def create_defense_projects(defense_project_list_data: DefenseProjectListSchema, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def create_defense_projects(defense_project_list_data: DefenseProjectListSchema, db: Session = Depends(get_db)):
     projects = defense_project_list_data.projects
     if not projects:  # 确保列表不为空
         raise HTTPException(status_code=400, detail="项目列表不能为空")
@@ -626,7 +647,7 @@ def create_defense_projects(defense_project_list_data: DefenseProjectListSchema,
 
 # 删除
 @router.delete("/defense_projects/{project_id}/")
-def delete_defense_project(project_id: int, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def delete_defense_project(project_id: int, db: Session = Depends(get_db)):
     # project = db.query(DefenseProject).get(project_id)
     project = db.query(DefenseProject).filter_by(id=project_id, is_delete=0).first()
 
@@ -650,7 +671,7 @@ class DefenseProjectListQueryParams(BaseModel):
     # page_size: int = Query(10, gt=0, description='pageSize'),
 @router.get("/defense_projects/")
 def get_defense_projects(page: int = Query(default=1, gt=0),
-                 pageSize: int = Query(default=10, gt=0), db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+                 pageSize: int = Query(default=10, gt=0), db: Session = Depends(get_db)):
     # 应用过滤条件，仅查询未被删除的项目
     data_query = db.query(DefenseProject).filter(DefenseProject.is_delete == False)
 
@@ -678,7 +699,7 @@ def get_defense_projects(page: int = Query(default=1, gt=0),
 
 # 查询详情
 @router.get("/defense_projects/{project_id}/")
-def get_defense_project_by_id(project_id: int, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def get_defense_project_by_id(project_id: int, db: Session = Depends(get_db)):
     # project = db.query(DefenseProject).filter_by(id=project_id, is_delete=0).first()
     project = db.query(DefenseProject).filter_by(id=project_id, is_delete=0).first()
 
@@ -688,7 +709,7 @@ def get_defense_project_by_id(project_id: int, db: Session = Depends(get_db), us
 
 # 修改
 @router.put("/defense_projects/{project_id}/")
-def update_defense_project(project_id: int, update_data: DefenseProjectSchema, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def update_defense_project(project_id: int, update_data: DefenseProjectSchema, db: Session = Depends(get_db)):
     project = db.query(DefenseProject).filter_by(id=project_id, is_delete=False).first()
     if not project:
         raise HTTPException(status_code=404, detail="项目不存在或已被标记为删除")
@@ -736,7 +757,7 @@ class ShelterListSchema(BaseModel):
 
 # 创建
 @router.post("/shelters/")
-def create_shelters(shelter_list_data: ShelterListSchema, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def create_shelters(shelter_list_data: ShelterListSchema, db: Session = Depends(get_db)):
     shelters = shelter_list_data.shelters
     if not shelters:
         raise HTTPException(status_code=400, detail="避难场所列表不能为空")
@@ -755,7 +776,7 @@ def create_shelters(shelter_list_data: ShelterListSchema, db: Session = Depends(
 
 # 删除
 @router.delete("/shelters/{shelter_id}/")
-def delete_shelter(shelter_id: int, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def delete_shelter(shelter_id: int, db: Session = Depends(get_db)):
     shelter = db.query(Shelter).filter_by(id=shelter_id, is_delete=0).first()
     if not shelter:
         raise HTTPException(status_code=404, detail="避难场所不存在")
@@ -772,7 +793,7 @@ def delete_shelter(shelter_id: int, db: Session = Depends(get_db), user_id=Depen
 
 @router.get("/shelters/")
 def get_shelters(page: int = Query(default=1, gt=0),
-                 pageSize: int = Query(default=10, gt=0), db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+                 pageSize: int = Query(default=10, gt=0), db: Session = Depends(get_db)):
     data_query = db.query(Shelter).filter(Shelter.is_delete == False)
     total_count = data_query.count()
     offset = (page - 1) * pageSize
@@ -791,7 +812,7 @@ def get_shelters(page: int = Query(default=1, gt=0),
 
 # 查询详情
 @router.get("/shelters/{shelter_id}/")
-def get_shelter_by_id(shelter_id: int, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def get_shelter_by_id(shelter_id: int, db: Session = Depends(get_db)):
     shelter = db.query(Shelter).filter_by(id=shelter_id, is_delete=0).first()
     if not shelter:
         raise HTTPException(status_code=404, detail="避难场所不存在或已被标记为删除")
@@ -799,7 +820,7 @@ def get_shelter_by_id(shelter_id: int, db: Session = Depends(get_db), user_id=De
 
 # 修改
 @router.put("/shelters/{shelter_id}/")
-def update_shelter(shelter_id: int, update_data: ShelterSchema, db: Session = Depends(get_db), user_id=Depends(valid_access_token)):
+def update_shelter(shelter_id: int, update_data: ShelterSchema, db: Session = Depends(get_db)):
     shelter = db.query(Shelter).filter_by(id=shelter_id, is_delete=False).first()
     if not shelter:
         raise HTTPException(status_code=404, detail="避难场所不存在或已被标记为删除")
@@ -813,4 +834,6 @@ def update_shelter(shelter_id: int, update_data: ShelterSchema, db: Session = De
         return {"code": 200, "msg": "更新成功", "shelter": shelter.to_dict()}
     except Exception as e:
         db.rollback()
-        raise HTTPException(status_code=400, detail=str(e))
+        raise HTTPException(status_code=400, detail=str(e))
+
+