python-fastapi-mm-zhcs-yj-api/routers/api/pattern/__init__.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from fastapi import APIRouter, Request, Depends, Query, HTTPException, status,WebSocket,WebSocketDisconnect
from common.security import valid_access_token,valid_websocket_token
from fastapi.responses import JSONResponse
from sqlalchemy.orm import Session
from sqlalchemy.sql import func
from common.auth_user import *
from sqlalchemy import  text
from pydantic import BaseModel
from common.BigDataCenterAPI import *
from common.db import db_event_management, db_user, db_yzy
from config import settings
from database import get_db
from typing import List
from models import *
from utils import *
from utils.spatial import *
from utils.ry_system_util import *
from common.websocketManager import *
from common import YzyApi
import json
import traceback
from common.enc import mpfun
from . import template
from . import classification

router = APIRouter()
router.include_router(template.router, prefix="/template", tags=["模板"])
router.include_router(classification.router, prefix="/classification", tags=["分类"])

@router.post("/create")
async def create_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        new_pattern = TpPatternList(
            id = new_guid(),
            pattern_name=body['pattern_name'],
            content=body['content'],
            create_dept = user_id
        )
        db.add(new_pattern)
        db.commit()
        return {"code": 200, "msg": "创建成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

@router.put("/update/{pattern_id}")
async def update_pattern(
    pattern_id :str ,
    user_id=Depends(valid_access_token),
    body=Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        query = db.query(TpPatternList)
        query = query.filter(TpPatternList.id == pattern_id)
        query = query.filter(TpPatternList.del_flag != '2')
        update_pattern = query.first()
        if not update_pattern:
            raise HTTPException(status_code=404, detail="图案不存在")

        update_pattern.pattern_name = body['pattern_name']
        update_pattern.content = body['content']
        update_pattern.create_dept = user_id
        db.commit()
        return {"code": 200, "msg": "更新成功"}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

@router.get("/info/{pattern_id}")
async def get_pattern_info(
    pattern_id: str,
    db: Session = Depends(get_db)
):
    try:
        query = db.query(TpPatternList)
        query = query.filter(TpPatternList.id == pattern_id)
        query = query.filter(TpPatternList.del_flag != '2')
        pattern = query.first()
        # pattern = db.query(TpPatternList).filter(TpPatternList.id == pattern_id).first()
        if not pattern:
            raise HTTPException(status_code=404, detail="图案不存在")
        return {"code": 200, "msg": "获取成功", "data": {"pattern_name": pattern.pattern_name, "content": pattern.content}}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
@router.get("/list")
async def get_pattern_list(
    pattern_name: 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(TpPatternList)
        query = query.filter(TpPatternList.del_flag != '2')
        if pattern_name:
            query = query.filter(TpPatternList.pattern_name.like(f'%{pattern_name}%'))
        total_items = query.count()

        # 排序

        query = query.order_by(TpPatternList.create_time.desc())
        # 执行分页查询
        patterns = query.offset((page - 1) * pageSize).limit(pageSize).all()
        return {"code": 200, "msg": "查询成功", "data": [{"id": p.id, "pattern_name": p.pattern_name, "content": p.content} for p in patterns],
                "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=f"Internal server error: {str(e)}")

@router.delete("/delete/{pattern_id}")
async def delete_pattern(
    pattern_id: str,
    db: Session = Depends(get_db)
):
    try:
        # 检查图案是否存在
        query = db.query(TpPatternList)
        query = query.filter(TpPatternList.id == pattern_id)
        query = query.filter(TpPatternList.del_flag != '2')
        pattern = query.first()
        if not pattern:
            raise HTTPException(status_code=404, detail="图案不存在")

        # 执行删除操作
        pattern.del_flag='2'
        db.commit()
        return {"code": 200, "msg": "删除成功"}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

# 预案分享
@router.post("/share")
async def share_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        event_id = body['event_id']
        pattern_id = body['pattern_id']
        pattern_name = body['pattern_name']
        userIdList = body['userIdList']
        
        nick_name = db_user.get_nick_name_by_id(db, user_id)

        for to_user_id in userIdList:
            user_info = db_user.get_user_info(db, to_user_id)
            yzy_account = mpfun.dec_data(user_info.yzy_account)
            yzy_userid = db_yzy.get_userid_by_account(db, yzy_account)

            detail_url = "{}{}{}".format(settings.YZY_WEB_ROOT, "/yjxp/#/leader/mobile_control?event_id=", event_id)

            description = f"{nick_name}分享预案“{pattern_name}”给您，请查看!"
            data = {
                "yzy_userid": yzy_userid,
                "mobile": yzy_account,
                "content": description,
                "recorded_by": user_id,
                "detail_url": detail_url,
                "foreign_key": pattern_id,
                "from_scenario": "pattern_list",
                "title": "预案分享"
            }
            YzyApi.add_to_msg_queue(db, data)
        
        return {"code": 200, "msg": "预案分享成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

@router.websocket("/{pattern_id}/ws")
async def websocket_endpoint(pattern_id:str ,websocket: WebSocket,db: Session = Depends(get_db)):

    await manager.connect(websocket,pattern_id,db)
    print(manager.active_connections.keys(),manager.active_connections[pattern_id])
    try:
        data = await websocket.receive_text()
        user_id = valid_websocket_token(data)
        user_list = [ ]
        for i in pattern_id_get_tp_pattern_ws_user_list(pattern_id, db):
            if i.ws_flag=='true':
                user_list.append(i.user_id)
        # print(user_id,user_list)
        if user_id not in user_list:
            await websocket.send_text('{"code":500,"msg":"抱歉，您无权限，请联系系统管理员"}')
            # manager.disconnect(websocket, pattern_id)
            raise HTTPException(status_code=500, detail="抱歉，您无权限，请联系系统管理员")
        await websocket.send_text('{"code":200,"msg":"连接成功"}')
        await manager.ownmessage(websocket,pattern_id,db)
        # await manager.broadcast(pattern_id, db)  # 广播消息给所有连接
        while True:
            data = await websocket.receive_text()
            # print(data)
            data = json.loads(data)
            if 'operation' in data:
                if data['operation'] == 'add':
                    if 'name' in data  and 'content'in data and 'visible' in data:
                        id = new_guid()
                        if 'id' in data:
                            id = data['id']
                        new_pattern_ws = TpPatternWSList(
                            id=id,
                            name=data['name'],
                            pattern_id=pattern_id,
                            content=data['content'],
                            visible=data['visible'],
                            create_by=user_id
                        )
                        db.add(new_pattern_ws)
                        db.commit()
                        await websocket.send_text('{"code": 200, "msg": "创建成功", "data": null}')
                        await manager.broadcast(pattern_id, db,websocket)
                    else:
                        await websocket.send_text('{"code": 404, "msg": "新增数据 name/content/visible为必填"}')
                elif data['operation'] == 'update' :
                    if 'id' in data:
                        id = data['id']
                        query = db.query(TpPatternWSList)
                        query = query.filter(TpPatternWSList.del_flag != '2')
                        query = query.filter(TpPatternWSList.id == id)
                        info = query.first()
                        if 'name' in data:
                            info.name = data['name']
                            info.update_by = user_id
                        # if 'pattern_id' in data:
                        #     info.pattern_id = data['pattern_id']
                        #     info.update_by = user_id
                        if 'content' in data:
                            info.content = data['content']
                            info.update_by = user_id
                        if 'visible' in data:
                            info.visible = data['visible']
                            info.update_by = user_id
                        db.commit()
                        await websocket.send_text('{"code": 200, "msg": "更新成功", "data": null}')
                        await manager.broadcast(pattern_id, db,websocket)
                elif data['operation'] == 'delete':
                    if 'id' in data:
                        id = data['id']
                        query = db.query(TpPatternWSList)
                        query = query.filter(TpPatternWSList.del_flag != '2')
                        query = query.filter(TpPatternWSList.id == id)
                        info = query.first()
                        info.del_flag='2'
                        info.update_by = user_id
                        db.commit()
                        await websocket.send_text('{"code": 200, "msg": "更新成功", "data": null}')
                        await manager.broadcast(pattern_id, db, websocket)
                    else:
                        await websocket.send_text('{"code": 404, "msg": "更新数据 id为必填","data":null}')
                elif data['operation'] == 'heartCheck':
                    await websocket.send_text('null')
                else:
                    await websocket.send_text('{"code":404,"msg":"operation入参add or update or delete or heartCheck"}')
            else:
                await websocket.send_text('{"code":404,"msg":"需包含operation参数"}')
         # 广播消息给所有连接
    except WebSocketDisconnect:
        manager.disconnect(websocket,pattern_id)

@router.post("/ws/bz_add")
async def create_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        new_pattern_ws = TpPatternWSList(
            id = new_guid(),
            name=body['name'],
            pattern_id=body['pattern_id'],
            content=body['content'],
            visible = body['visible'],
            create_by = user_id
        )
        db.add(new_pattern_ws)
        db.commit()
        # await manager.broadcast(body['pattern_id'], db)
        return {"code": 200, "msg": "创建成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

@router.put("/ws/bz_update")
async def update_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        id = body['id']
        query = db.query(TpPatternWSList)
        query = query.filter(TpPatternWSList.del_flag!='2')
        query = query.filter(TpPatternWSList.id == id)
        info  = query.first()
        if 'name' in body:
            info.name=body['name']
            info.update_by=user_id
        if 'pattern_id' in body:
            info.pattern_id=body['pattern_id']
            info.update_by=user_id
        if 'content' in body:
            info.content=body['content']
            info.update_by=user_id
        if 'visible' in body:
            info.visible=body['visible']
            info.update_by=user_id
        db.commit()
        # print(manager.active_connections.keys())
        # print(manager.active_connections)
        # await manager.broadcast(body['pattern_id'], db)
        return {"code": 200, "msg": "更新成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")


@router.post("/ws/create")
async def create_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        if pattern_id_get_tp_pattern_ws_group_def_info(body['pattern_id'],db):
            # return JSONResponse(
            #     status_code=500, content={"code":500,"msg":"pattern_id已存在"}
            # )
            body['pattern_id']=new_guid()
        user_id_list = body['user_id_list']
        if str(user_id) not in user_id_list and user_id not in user_id_list:
            print(str(user_id),user_id_list)
            user_id_list.append(str(user_id))
        for user in user_id_list:
            new_pattern_user_ws = TpPatternWSUserList(
                id=new_guid(),
                pattern_id=body['pattern_id'],
                pattern_name=body['pattern_name'],
                user_id=user,
                create_by=user_id
            )
            db.add(new_pattern_user_ws)
        for bz in body['bz_list']:
        # if 'name' in body and 'content'  in body and 'visible'  in body:
            new_pattern_ws = TpPatternWSList(
                id = new_guid(),
                name=bz['name'],
                pattern_id=body['pattern_id'],
                content=bz['content'],
                visible = bz['visible'],
                create_by = user_id
            )
            db.add(new_pattern_ws)
        visible = '0'
        if 'visible' in body:
            visible = body['visible']
        new_pattern_group_ws = TpPatternWSGroupList(
            group_id=body['pattern_id'],
            group_name='默认分组',
            pattern_id=body['pattern_id'],
            pattern_name=body['pattern_name'],
            visible=visible,
            create_by=user_id
        )
        db.add(new_pattern_group_ws)
        db.commit()
        return {"code": 200, "msg": "创建成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

# @router.put("/ws/rollback")
# async def rollback_pattern(
#     user_id=Depends(valid_access_token),
#     body = Depends(remove_xss_json),
#     db: Session = Depends(get_db)
# ):
#     try:
#         user_list = [i.user_id for i in pattern_id_get_tp_pattern_ws_user_list(body['pattern_id'],db)]
#         if str(user_id) not in user_list:
#             return JSONResponse(status_code=404, content={
#                                 'code': 404,
#                                 'msg': '抱歉，您无权限，请联系系统管理员'
#                             })
#         if pattern_id_get_tp_pattern_ws_count(body['pattern_id'],db)<=1:
#             return JSONResponse(status_code=404, content={
#                 'code': 404,
#                 'msg': '抱歉，已无法回滚'
#             })
#         data = user_id_and_pattern_id_get_tp_pattern_ws_info(user_id,body['pattern_id'],db)
#         data.del_flag='2'
#         data.update_by = user_id
#         db.commit()
#         return {"code": 200, "msg": "回滚成功", "data": None}
#     except Exception as e:
#         traceback.print_exc()
#         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")


@router.get("/ws/list")
async def get_pattern_list(
    pattern_name: str = Query(None, description='预案名称'),
    # page: int = Query(1, gt=0, description='页码'),
    # pageSize: int = Query(5, gt=0, description='每页条目数量'),
    user_id=Depends(valid_access_token),
    db: Session = Depends(get_db)
):
    try:
        query = db.query(TpPatternWSUserList)
        query = query.filter(TpPatternWSUserList.del_flag != '2')
        query = query.filter(TpPatternWSUserList.user_id==user_id)
        if pattern_name:
            query = query.filter(TpPatternWSUserList.pattern_name.like(f'%{pattern_name}%'))
        total_items = query.count()
        # 排序
        query = query.order_by(TpPatternWSUserList.create_time.desc())
        # 执行分页查询
        patterns = query.all() # .offset((page - 1) * pageSize).limit(pageSize)
        return {"code": 200, "msg": "查询成功", "data": [{"id": p.id,"pattern_id":p.pattern_id, "pattern_name": p.pattern_name} for p in patterns],
                # "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=f"Internal server error: {str(e)}")

@router.get("/ws/user_list")
async def get_pattern_list(
    pattern_id: str = Query(None, description='预案名称'),
    page: int = Query(1, gt=0, description='页码'),
    pageSize: int = Query(5, gt=0, description='每页条目数量'),
    user_id=Depends(valid_access_token),
    db: Session = Depends(get_db)
):
    try:
        query = db.query(TpPatternWSUserList)
        query = query.filter(TpPatternWSUserList.del_flag != '2')
        query = query.filter(TpPatternWSUserList.pattern_id==pattern_id)

        total_items = query.count()
        # 排序
        query = query.order_by(TpPatternWSUserList.create_time.desc())
        # 执行分页查询
        patterns = query.offset((page - 1) * pageSize).limit(pageSize).all()
        data = []
        for p in patterns:
            user = user_id_get_user_info(db, p.user_id)
            dept = dept_id_get_dept_info(db, user.dept_id)
            data.append({"id": p.id,"pattern_id":p.pattern_id,"ws_flag":p.ws_flag, "pattern_name": p.pattern_name,"nick_name":user.nick_name,"dept_name":dept.dept_name})
        return {"code": 200, "msg": "查询成功", "data": data,
                "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=f"Internal server error: {str(e)}")


@router.put("/ws/delete_user")
async def rollback_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        pattern_info = pattern_id_get_tp_pattern_ws_group_def_info(body['pattern_id'],db)
        if pattern_info is None:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，pattern_id不存在，请联系系统管理员'
                            })
        if pattern_info.create_by!=user_id:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，您无权限，请联系系统管理员'
                            })
        user = user_id_and_pattern_id_get_tp_pattern_ws_user_info(body['user_id'],body['pattern_id'],db)
        user.ws_flag='false'
        user.update_by = user_id
        db.commit()
        return {"code": 200, "msg": "关闭协同成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")


@router.put("/ws/delete_all_user")
async def rollback_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        pattern_info = pattern_id_get_tp_pattern_ws_group_def_info(body['pattern_id'],db)
        if pattern_info is None:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，pattern_id不存在，请联系系统管理员'
                            })
        if pattern_info.create_by!=user_id:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，您无权限，请联系系统管理员'
                            })
        users = pattern_id_get_tp_pattern_ws_user_list(body['pattern_id'],db)
        for user in users:
            user.ws_flag='false'
            user.update_by = user_id
        db.commit()
        return {"code": 200, "msg": "关闭协同成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")


@router.put("/ws/reset_user")
async def rollback_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        pattern_info = pattern_id_get_tp_pattern_ws_group_def_info(body['pattern_id'],db)
        if pattern_info is None:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，pattern_id不存在，请联系系统管理员'
                            })
        if pattern_info.create_by!=user_id:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，您无权限，请联系系统管理员'
                            })
        user = user_id_and_pattern_id_get_tp_pattern_ws_user_info(body['user_id'],body['pattern_id'],db)
        user.ws_flag='true'
        user.update_by = user_id
        db.commit()
        return {"code": 200, "msg": "开启协同成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")


@router.put("/ws/reset_all_user")
async def rollback_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        pattern_info = pattern_id_get_tp_pattern_ws_group_def_info(body['pattern_id'],db)
        if pattern_info is None:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，pattern_id不存在，请联系系统管理员'
                            })
        if pattern_info.create_by!=user_id:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，您无权限，请联系系统管理员'
                            })
        users = pattern_id_get_tp_pattern_ws_user_list(body['pattern_id'],db)
        for user in users:
            user.ws_flag='true'
            user.update_by = user_id
        db.commit()
        return {"code": 200, "msg": "开启协同成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")



@router.post("/ws/add_user")
async def rollback_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        pattern_info = pattern_id_get_tp_pattern_ws_group_def_info(body['pattern_id'],db)
        if pattern_info is None:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，pattern_id不存在，请联系系统管理员'
                            })
        if pattern_info.create_by!=user_id:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，您无权限，请联系系统管理员'
                            })
        user_id_list = body['user_id_list']
        if str(user_id) not in user_id_list and user_id not in user_id_list:
            # print(str(user_id),user_id_list)
            user_id_list.append(str(user_id))
        info = pattern_id_get_tp_pattern_ws_group_def_info(body['pattern_id'],db)
        user_id_list_1 = [i.user_id for i in pattern_id_get_tp_pattern_ws_user_list(body['pattern_id'], db)] # 已存在的用户列表
        for user in user_id_list:
            user = int(user)
            if user in user_id_list_1:
                user_info = user_id_and_pattern_id_get_tp_pattern_ws_user_info(user,body['pattern_id'],db)
                user_info.ws_flag='true'
            else:
                new_pattern_ws = TpPatternWSUserList(
                    id=new_guid(),
                    pattern_id=body['pattern_id'],
                    pattern_name=info.pattern_name,
                    user_id=user,
                    create_by=user_id
                )
                db.add(new_pattern_ws)
        db.commit()
        return {"code": 200, "msg": "增加协同用户成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

@router.post("/ws/add_group")
async def add_group_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        pattern_info = pattern_id_get_tp_pattern_ws_group_def_info(body['pattern_id'],db)
        if pattern_info is None:
            return JSONResponse(status_code=404, content={
                                'code': 404,
                                'msg': '抱歉，pattern_id不存在，请联系系统管理员'
                            })
        # if pattern_info.create_by!=user_id:
        #     return JSONResponse(status_code=404, content={
        #                         'code': 404,
        #                         'msg': '抱歉，您无权限，请联系系统管理员'
        #                     })
        info = pattern_id_get_tp_pattern_ws_group_def_info(body['pattern_id'], db)
        new_pattern_ws_group = TpPatternWSGroupList(
            group_id=new_guid(),
            group_name = body['group_name'],
            pattern_id=body['pattern_id'],
            pattern_name=info.pattern_name,
            create_by=user_id
        )
        db.add(new_pattern_ws_group)
        db.commit()
        return {"code": 200, "msg": "新增分组成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

@router.put("/ws/update_group")
async def add_group_pattern(
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        # pattern_info = pattern_id_get_tp_pattern_ws_group_def_info(body['pattern_id'],db)
        # if pattern_info is None:
        #     return JSONResponse(status_code=404, content={
        #                         'code': 404,
        #                         'msg': '抱歉，pattern_id不存在，请联系系统管理员'
        #                     })
        # if pattern_info.create_by!=user_id:
        #     return JSONResponse(status_code=404, content={
        #                         'code': 404,
        #                         'msg': '抱歉，您无权限，请联系系统管理员'
        #                     })
        query = db.query(TpPatternWSGroupList)
        query = query.filter(TpPatternWSGroupList.del_flag!='2')
        query = query.filter(TpPatternWSGroupList.group_id==body['group_id'])
        group = query.first()
        if 'group_name' in  body:
            group.group_name = body['group_name']
            group.update_by=user_id
        db.commit()
        return {"code": 200, "msg": "更新分组成功", "data": None}

    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
@router.delete("/ws/delete_group/{group_id}")
async def add_group_pattern(
    group_id:str ,
    user_id=Depends(valid_access_token),
    body = Depends(remove_xss_json),
    db: Session = Depends(get_db)
):
    try:
        query = db.query(TpPatternWSGroupList)
        query = query.filter(TpPatternWSGroupList.del_flag != '2')
        query = query.filter(TpPatternWSGroupList.group_id == group_id)
        group = query.first()
        group.del_flag = '2'
        db.commit()
        return {"code": 200, "msg": "删除分组成功", "data": None}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

@router.get("/ws/bz_list")
async def get_pattern_list(
        pattern_id: str = Query(None, description='预案名称'),
        # group_id:str = Query(None),
        # page: int = Query(1, gt=0, description='页码'),
        # pageSize: int = Query(5, gt=0, description='每页条目数量'),
        user_id=Depends(valid_access_token),
        db: Session = Depends(get_db)
):
    try:
        # data = pattern_id_get_tp_pattern_ws_list(pattern_id,db)
        group_list = pattern_id_get_tp_pattern_ws_group_list(pattern_id,db)
        message = []
        for group in group_list:
            # if group_id:
            #     if group.group_id!=group_id:
            #         continue
            query = db.query(TpPatternWSList)
            query = query.filter(TpPatternWSList.del_flag != '2')
            query = query.filter(TpPatternWSList.pattern_id == group.group_id)
            # total_items = query.count()
            # 排序
            query = query.order_by(TpPatternWSList.create_time.desc())
            # 执行分页查询
            print(group.group_id,group.visible)
            group = {
                "group_id":group.group_id,
                "group_name":group.group_name,
                "pattern_id":group.pattern_id,
                "pattern_name":group.pattern_name,
                "visible":group.visible,
                "bz_list":[],
                "create_time": group.create_time.strftime('%Y-%m-%d %H:%M:%S')
            }
            patterns = query.all()  # .offset((page - 1) * pageSize).limit(pageSize)
            for info in patterns:
                user= user_id_get_user_info(db,info.create_by)
                dept = dept_id_get_dept_info(db,user.dept_id)
                if info.visible=='1':
                    group['visible']='1'
                group['bz_list'].append({"id":info.id,
                                "name":info.name,
                                "group_id":info.pattern_id,
                                "content":info.content,
                                "visible":info.visible,
                                "user_id":info.create_by,
                                "nick_name":user.nick_name,
                                "dept_name":dept.dept_name,
                                "create_time":info.create_time.strftime('%Y-%m-%d %H:%M:%S')})
            message.append(group)
        return {"code": 200, "msg": "查询成功", "data": message,
                # "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=f"Internal server error: {str(e)}")

@router.get("/ws/group_info") #/{group_id}
async def get_pattern_list(
        group_id: str  = Query(None, description='预案名称'),
        # page: int = Query(1, gt=0, description='页码'),
        # pageSize: int = Query(5, gt=0, description='每页条目数量'),
        user_id=Depends(valid_access_token),
        db: Session = Depends(get_db)
):
    try:
        # data = pattern_id_get_tp_pattern_ws_list(pattern_id,db)
        group = group_id_get_tp_pattern_ws_group_info(group_id,db)
        # message = []
        query = db.query(TpPatternWSList)
        query = query.filter(TpPatternWSList.del_flag != '2')
        query = query.filter(TpPatternWSList.pattern_id == group.group_id)
        # total_items = query.count()
        # 排序
        query = query.order_by(TpPatternWSList.create_time.desc())
        # 执行分页查询
        group = {
            "group_id":group.group_id,
            "group_name":group.group_name,
            "pattern_id":group.pattern_id,
            "pattern_name":group.pattern_name,
            "visible":group.visible,
            "bz_list":[],
            "create_time": group.create_time.strftime('%Y-%m-%d %H:%M:%S')
        }
        patterns = query.all()  # .offset((page - 1) * pageSize).limit(pageSize)
        for info in patterns:
            user= user_id_get_user_info(db,info.create_by)
            dept = dept_id_get_dept_info(db,user.dept_id)
            if info.visible=='1':
                group['visible']='1'
            group['bz_list'].append({"id":info.id,
                            "name":info.name,
                            "group_id":info.pattern_id,
                            "content":info.content,
                            "visible":info.visible,
                            "user_id":info.create_by,
                            "nick_name":user.nick_name,
                            "dept_name":dept.dept_name,
                            "create_time":info.create_time.strftime('%Y-%m-%d %H:%M:%S')})
        # message.append(group)
        return {"code": 200, "msg": "查询成功", "data": group,
                # "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=f"Internal server error: {str(e)}")

@router.put('/ws/bz_visible')
async def update_bz_visible(
    body = Depends(remove_xss_json),
    user_id=Depends(valid_access_token),
    db: Session = Depends(get_db)
):
    try:
        zb_id_list = body['zb_id_list']
        for zb in zb_id_list:
            query = db.query(TpPatternWSList)
            query = query.filter(TpPatternWSList.del_flag!='2')
            query = query.filter(TpPatternWSList.id==zb)
            info = query.first()
            info.visible=body['visible']

        db.commit()
        if zb_id_list:
            try :
                pattern_id = info.pattern_id
                await manager.broadcast(pattern_id, db, WebSocket)
            except:
                pass
        return {"code": 200, "msg": "查询成功", "data": None
                }
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

@router.put('/ws/group_visible')
async def update_group_visible(
    # websocket:WebSocket,
    body = Depends(remove_xss_json),
    user_id=Depends(valid_access_token),
    db: Session = Depends(get_db)
):
    try:
        group_id = body['group_id']
        visible = body['visible']
        group0 = group_id_get_tp_pattern_ws_group_info(group_id,db)
        # print(visible,group0.visible)
        group0.visible=visible
        pattern_id = group_id_get_tp_pattern_ws_group_info(group_id, db).pattern_id
        group_list = pattern_id_get_tp_pattern_ws_group_list(pattern_id, db)
        if visible=='0':#1显示 0隐藏
            query = db.query(TpPatternWSList)
            query = query.filter(TpPatternWSList.del_flag!='2')
            query = query.filter(TpPatternWSList.pattern_id==group_id)
            bz_list = query.all()
            for info in bz_list:
                info.visible='0'
        elif visible=='1':

            for group in group_list:
                # print(group.group_id)
                visible = '0'
                if group.group_id==group_id:
                    # group.visible='1'
                    # db.commit()
                    # print(group.group_id,group_id, group.visible)
                    visible='1'
                group.visible=visible
                query = db.query(TpPatternWSList)
                query = query.filter(TpPatternWSList.del_flag != '2')
                query = query.filter(TpPatternWSList.pattern_id == group.group_id)
                bz_list = query.all()
                for info in bz_list:
                    # print(info.visible)
                    info.visible = visible
        db.commit()
        try :
            await manager.broadcast(pattern_id, db, WebSocket)
        except:
            pass
        return {"code": 200, "msg": "查询成功", "data": None
                }
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")