#!/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 *
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)}")

def user_id_and_pattern_id_get_tp_pattern_ws_info(user_id:str,pattern_id:str,db: Session):
    query = db.query(TpPatternWSList)
    query = query.filter(TpPatternWSList.del_flag != '2')
    query = query.filter(TpPatternWSList.pattern_id == pattern_id)
    query = query.filter(TpPatternWSList.create_by == user_id)
    query.order_by(TpPatternWSList.create_time.desc())
    return query.first()

def pattern_id_get_tp_pattern_ws_users(pattern_id:str,db: Session):
    query = db.query(TpPatternWSList)
    query = query.filter(TpPatternWSList.del_flag != '2')
    query = query.filter(TpPatternWSList.pattern_id == pattern_id)
    query = query.group_by(TpPatternWSList.create_by)
    return query.all()

def pattern_id_get_tp_pattern_ws_list(pattern_id:str,db: Session):
    query = db.query(TpPatternWSList)
    query = query.filter(TpPatternWSList.del_flag != '2')
    query = query.filter(TpPatternWSList.pattern_id == pattern_id)
    # query = query.group_by(TpPatternWSList.create_id)
    return query.all()

def pattern_id_get_tp_pattern_ws_count(pattern_id:str,db: Session):
    query = db.query(TpPatternWSList)
    query = query.filter(TpPatternWSList.del_flag != '2')
    query = query.filter(TpPatternWSList.pattern_id == pattern_id)
    return query.count()

def pattern_id_get_tp_pattern_ws_max_time(pattern_id:str,db: Session):
    query = db.query(TpPatternWSList.update_time)
    query = query.filter(TpPatternWSList.del_flag != '2')
    query = query.filter(TpPatternWSList.pattern_id == pattern_id)
    query.order_by(TpPatternWSUserList.update_time.desc())
    return query.first()

def pattern_id_get_tp_pattern_ws_user_list(pattern_id:str,db: Session):
    query = db.query(TpPatternWSUserList)
    query = query.filter(TpPatternWSUserList.del_flag != '2')
    query = query.filter(TpPatternWSUserList.pattern_id == pattern_id)
    query.order_by(TpPatternWSUserList.create_time.desc())
    return query.all()

def pattern_id_get_tp_pattern_ws_group_def_info(pattern_id:str,db: Session):
    query = db.query(TpPatternWSGroupList)
    query = query.filter(TpPatternWSGroupList.del_flag != '2')
    query = query.filter(TpPatternWSGroupList.pattern_id == pattern_id)
    query.order_by(TpPatternWSGroupList.create_time.desc())
    return query.first()

def user_id_get_tp_pattern_ws_user_list(user_id:str,db: Session):
    query = db.query(TpPatternWSUserList)
    query = query.filter(TpPatternWSUserList.del_flag != '2')
    query = query.filter(TpPatternWSUserList.user_id == user_id)
    query.order_by(TpPatternWSUserList.create_time.desc())
    return query.all()

def user_id_and_pattern_id_get_tp_pattern_ws_user_info(user_id:str,pattern_id:str,db: Session):
    query = db.query(TpPatternWSUserList)
    query = query.filter(TpPatternWSUserList.del_flag != '2')
    query = query.filter(TpPatternWSUserList.user_id == user_id)
    query = query.filter(TpPatternWSUserList.pattern_id == pattern_id)
    query.order_by(TpPatternWSUserList.create_time.desc())
    return query.all()
def pattern_id_get_tp_pattern_ws_group_list(pattern_id:str,db: Session):
    query = db.query(TpPatternWSGroupList)
    query = query.filter(TpPatternWSGroupList.del_flag != '2')
    query = query.filter(TpPatternWSGroupList.pattern_id == pattern_id)
    query.order_by(TpPatternWSGroupList.create_time.desc())
    return query.all()

class ConnectionManager:
    def __init__(self):
        self.active_connections = {}  #: List[WebSocket]

    async def connect(self, websocket: WebSocket,pattern_id:str,db: Session):
        await websocket.accept()
        if pattern_id not in self.active_connections:

            self.active_connections[pattern_id] = [websocket]
        else:
            self.active_connections[pattern_id].append(websocket)
        print('连接成功')
        # data = pattern_id_get_tp_pattern_ws_list(pattern_id, db)
        # message = []
        # for info in data:
        #     user = user_id_get_user_info(db, info.create_by)
        #     dept = dept_id_get_dept_info(db, user.dept_id)
        #     message.append({"id": info.id,
        #                     "name": info.name,
        #                     "pattern_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})
        #     message = json.dumps(message)
        #     await websocket.send_text(message)
        #     await websocket.send_text('连接成功')
    def disconnect(self, websocket: WebSocket,pattern_id:str):
        # await websocket.send_text('已断开')
        print('已断开')
        self.active_connections[pattern_id].remove(websocket)
        if not self.active_connections[pattern_id]:
            del self.active_connections[pattern_id]
    async def broadcast(self,pattern_id:str,db: Session):#, message: str
        data = pattern_id_get_tp_pattern_ws_list(pattern_id,db)
        message = []
        for info in data:
            user= user_id_get_user_info(db,info.create_by)
            dept = dept_id_get_dept_info(db,user.dept_id)
            message.append({"id":info.id,
                            "name":info.name,
                            "pattern_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})
        message = json.dumps(message)
        for connection in self.active_connections[pattern_id]:
            await connection.send_text(message)


manager = ConnectionManager()

@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)

        # return JSONResponse(status_code=404, content={
        #     'code': 404,
        #     'msg': '抱歉，您无权限，请联系系统管理员'
        # })
    try:
        data = await websocket.receive_text()
        user_id = valid_websocket_token(data)
        user_list = [i.user_id for i in pattern_id_get_tp_pattern_ws_user_list(pattern_id, db)]
        if user_id not in user_list:
            # await websocket.send_text('抱歉，您无权限，请联系系统管理员')
            manager.disconnect(websocket, pattern_id)
        # await manager.broadcast(pattern_id, db)  # 广播消息给所有连接
        # now_max_time = pattern_id_get_tp_pattern_ws_max_time(pattern_id, db).update_time
        while True:
            # data = await websocket.receive_text()
            # time.sleep(0.5)
            # max_time = pattern_id_get_tp_pattern_ws_max_time(pattern_id, db).update_time
            # if now_max_time<max_time:
            await manager.broadcast(pattern_id,db)  # 广播消息给所有连接
    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()
        # 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:
        user_id_list = body['user_id_list']
        if str(user_id) not in 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)
        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)
        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.offset((page - 1) * pageSize).limit(pageSize).all()
        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, "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.del_flag='2'
        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:
            user_id_list.append(str(user_id))
        for user in user_id_list:
            new_pattern_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_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': '抱歉，您无权限，请联系系统管理员'
                            })
        new_pattern_ws_group = TpPatternWSGroupList(
            group_id=new_guid(),
            group_name = body['group_name'],
            pattern_id=body['pattern_id'],
            pattern_name=body['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.create_by)
            query = query.filter(TpPatternWSList.del_flag != '2')
            query = query.filter(TpPatternWSList.pattern_id == group.group_id)
            # total_items = query.count()
            # 排序
            query = query.order_by(TpPatternWSUserList.create_time.desc())
            # 执行分页查询
            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)
                message.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')})
        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)}")