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 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 *
import json
import traceback

router = APIRouter()

@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 :int ,
    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: int,
    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: int,
    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.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)
        new_pattern_group_ws = TpPatternWSGroupList(
            group_id=body['pattern_id'],
            group_name='默认分组',
            pattern_id=body['pattern_id'],
            pattern_name=body['pattern_name'],
            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['gruop_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.get("/ws/bz_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:
        # 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:
            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,
                "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)
                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.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()
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")