python-fastapi-mm-zhcs-yj-api/routers/api/eventManagement/event_xp.py

from fastapi import APIRouter, Request, Depends, HTTPException, Query
from sqlalchemy.exc import IntegrityError
from fastapi.responses import HTMLResponse, FileResponse
from fastapi.responses import JSONResponse
from database import get_db
from sqlalchemy import text, exists, and_, or_, not_, extract, func
from sqlalchemy.orm import Session
from models import *
import json
import random
from sqlalchemy import create_engine, select
from typing import Optional
from utils.StripTagsHTMLParser import *
from common.db import db_event_management, db_dept, db_user, db_area, db_emergency_plan, db_dict, db_task
from common.security import valid_access_token
import traceback
from utils import *
from datetime import datetime, timedelta
from dateutil.relativedelta import relativedelta
import os

router = APIRouter()

# 上报伤亡情况
@router.post("/creat_event_briefing")
async def creat_event_briefing(
    request: Request,  
    body = Depends(remove_xss_json), 
    db: Session = Depends(get_db),
    user_id = Depends(valid_access_token)
):
    fileList = []
    if 'fileList' in body:
        fileList = body['fileList']
        del body['fileList']

    longitude = ''
    latitude = ''
    if 'lnglat' in body:
        longitude = body['lnglat'][0]
        latitude = body['lnglat'][1]
        del body['lnglat']

    new_briefing = EventBriefing(**body, del_flag='0', recorded_by=user_id, create_time=datetime.now(), longitude=longitude, latitude=latitude)
    db.add(new_briefing)
    db.commit()
    db.refresh(new_briefing)

    if len(fileList) > 0:
        event_files = [
            EventFile(
                event_id=new_briefing.id,
                file_name=fileName["name"],  # 使用 fileName["name"] 作为文件名
                file_path=f'/data/upload/mergefile/uploads/{fileName["url"]}',
                file_size=os.path.getsize(f'/data/upload/mergefile/uploads/{fileName["url"]}'),
                storage_file_name=fileName["url"],
                foreign_key=new_briefing.event_id,
                from_scenario="event_briefing",
                update_time=datetime.now(),
                create_time=datetime.now(),
                del_flag='0'
            )
            for fileName in fileList  # body['fileList'] 现在是一个包含对象的数组，每个对象都有 'name' 和 'url' 属性
        ]
        db.add_all(event_files)
        db.commit()

    return {
        "code": 200,
        "msg": "保存事件简报成功"
    }

    
@router.get('/event_briefing/list')
async def get_event_list(
    event_id: str,
    page: int = Query(1, gt=0, description='页码'),
    page_size: int = Query(10, gt=0, description='pageSize'),
    db: Session = Depends(get_db)
):
    try:
        # 应用查询条件
        where = and_(EventBriefing.del_flag == '0', EventBriefing.event_id == event_id)
        # 计算总条目数
        q = db.query(func.count(EventBriefing.id))
        q = q.filter(where)
        total = q.scalar()
        
        # 执行分页查询
        q = db.query(EventBriefing)
        q = q.filter(where)
        rows = q.order_by(EventBriefing.id.desc()).offset((page - 1) * page_size).limit(page_size).all()
        data = [
            {
                "event_id": row.event_id,
                "address": row.address,
                "longitude": row.longitude,
                "latitude": row.latitude,
                "report_dept": row.report_dept,
                "briefing_content": row.briefing_content,
                "create_time": get_datetime_str(row.create_time),
                "files": db_event_management.get_briefing_file_list(db, row.id)
            }
            for row in rows
        ]

        # 返回结果
        return {
            "code": 200,
            "msg": "查询成功",
            "data": data,
            "total": total
        }

    except Exception as e:
        # 处理异常
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=str(e))



# 上报事件指挥人员
@router.post("/create_leader_user")
async def create_leader_user(
    request: Request,  
    body = Depends(remove_xss_json), 
    db: Session = Depends(get_db),
    user_id = Depends(valid_access_token)
):
    '''
    event_id = body['event_id']
    if 'users' not in body:

        return {
            "code": 500,
            "msg": "请上报事件指挥人员"
        }
    
    for n in body['users']:
        unit_id = n['unit_id']
        unit_name = db_dept.get_dept_name_by_id(db, unit_id)

        new_user = EventLeaderUser(
            unit_id = unit_id,
            unit_name = unit_name,
            event_id = event_id,
            user_type = n['user_type'],
            user_name = n['user_name'],
            mobile = n['mobile'],
            create_time = datetime.now(),
            recorded_by = user_id,
            del_flag = '0'
        )
        db.add(new_user)
        db.commit()
    '''

    notify_id = body['id']
    notify_info = db.query(EventEmergencyNotify).filter(EventEmergencyNotify.id == notify_id).first()
    dept_id = notify_info.dept_id
    dept_name = notify_info.dept_name
    event_id = notify_info.event_id
    
    data1 = body['data1']
    if data1 is not None and len(data1) > 0:
        db.query(EventLeaderUser).filter(and_(EventLeaderUser.user_type == '赶赴现场人员', EventLeaderUser.del_flag == '0').update({"del_flag": "1"}))
        db.commit()
        
        for n in data1:            
            new_user = EventLeaderUser(
                unit_id = dept_id,
                unit_name = dept_name,
                event_id = event_id,
                user_type = '赶赴现场人员',
                user_name = n['name'],
                mobile = n['phone'],
                create_time = datetime.now(),
                recorded_by = user_id,
                del_flag = '0'
            )
            db.add(new_user)
            db.commit()

    data2 = body['data2']
    if data2 is not None and len(data2) > 0:
        db.query(EventLeaderUser).filter(and_(EventLeaderUser.user_type == '指挥部值守人员', EventLeaderUser.del_flag == '0').update({"del_flag": "1"}))
        db.commit()
        
        for n in data2:
            new_user = EventLeaderUser(
                unit_id = dept_id,
                unit_name = dept_name,
                event_id = event_id,
                user_type = '指挥部值守人员',
                user_name = n['name'],
                mobile = n['phone'],
                create_time = datetime.now(),
                recorded_by = user_id,
                del_flag = '0'
            )
            db.add(new_user)
            db.commit()
    
    return {
        "code": 200,
        "msg": "上报事件指挥人员成功"
    }


@router.get('/emergency_notify/detail')
async def get_info_detail(
    request: Request, 
    id: str = Query(None, description='信息编号'),
    db: Session = Depends(get_db),
    user_id = Depends(valid_access_token)):
    
    try: 
        # 构建查询
        notify_info = db.query(EventEmergencyNotify).filter(EventEmergencyNotify.id == id).first()
        if notify_info is not None:
            event_id = notify_info.event_id
            plan_id = notify_info.plan_id
            sent_time = notify_info.sent_time

            plan_info = db.query(EmergencyPlan).filter(EmergencyPlan.plan_number == plan_id).first()
            plan_name = plan_info.plan_name
            
            event_info  = db.query(EventBase).filter(EventBase.event_code == event_id).first()
            event_title  = db_event_management.get_event_title(db, event_id)
            response_level = db_dict.get_dict_label(db, "response_level", event_info.response_level)

            data = {
                "id": notify_info.id,
                "title": f"{plan_name}{response_level}通知",
                "response_level": response_level,
                "sent_time": sent_time.strftime("%Y-%m-%d %H:%M"),
                "event_title": event_title,
                "content": notify_info.yzy_content            
            }

            return {
                "code": 200,
                "msg": "查询成功",
                "data": data
            }
        else:
            return {
                "code": 500,
                "msg": "查询失败"
            }

    except Exception as e:
        # 处理异常
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=str(e))
    



@router.get('/task_registration/detail')
async def get_info_detail(
    request: Request, 
    task_id: str = Query(None, description='任务编号'),
    db: Session = Depends(get_db),
    user_id = Depends(valid_access_token)):
    
    try: 
        # 构建查询
        task_info = db.query(TaskRegistration).filter(TaskRegistration.task_id == task_id).first()
        if task_info is not None:
            event_id = task_info.event_code

            event_title  = db_event_management.get_event_title(db, event_id)

            data = {
                "id": task_info.id,
                "task_id": task_info.task_id,
                "title": f"{event_title}任务",
                "event_title": event_title,
                "unit_name": task_info.unit_name,
                "executor": task_info.executor,
                "creation_time": task_info.creation_time.strftime("%Y-%m-%d %H:%M"),
                "expire_time": task_info.expire_time.strftime("%Y-%m-%d"),
                "task_description": task_info.task_description,
                "task_type": db_task.get_task_type_text(task_info.task_type),
                "processing_status": task_info.processing_status
            }

            return {
                "code": 200,
                "msg": "查询成功",
                "data": data
            }
        else:
            return {
                "code": 500,
                "msg": "查询失败"
            }

    except Exception as e:
        # 处理异常
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=str(e))
    

@router.get('/completed_trend')
async def get_completed_trend(
    request: Request, 
    db: Session = Depends(get_db),
    user_id = Depends(valid_access_token)):
    
    current_date = datetime.now()
    xAxis = []
    series = [[], [], [], []]
    for n in range(-5, 1):
        last_date = current_date + relativedelta(months=n)
        last_year = last_date.year
        last_month = last_date.month

        last_date_str = datetime.strftime(last_date, "%Y-%m")
        xAxis.append(last_date_str)

        i = 0
        for event_type in ['0', '1', '2', '3']:
            c1 = db.query(func.count(EventBase.id)).filter(and_(
                    EventBase.del_flag == '0',
                    EventBase.event_type == event_type,
                    extract('year', EventBase.event_time) == last_year,
                    extract('month', EventBase.event_time) == last_month
                )).scalar()
            if c1 is None:
                c1 = 0
            series[i].append(c1)
            i = i + 1

    data = {
        "xAxis":  xAxis,
        "series": series
    }

    return {
        "code": 200,
        "msg": "查询成功",
        "data": data
    }