CameraMachine/python/sockets/message_handler.py

from .connect_manager import ConnectionManager
from models import WebSocket
import json, asyncio
from mcu.DeviceControl import DeviceControl, checkMcuConnection
from mcu.BlueToothMode import BlueToothMode
from databases import DeviceConfig, SqlQuery, CRUD, PhotoRecord, SysConfigs
from mcu.capture.module_digicam import DigiCam
from mcu.capture.smart_shooter_class import SmartShooter
from models import RecordUpdate
from sqlalchemy.exc import NoResultFound
import os, datetime

async def updateDataRecord(PhotoFilename, id):
    await asyncio.sleep(0.01)
    create_time = datetime.datetime.fromtimestamp(os.path.getctime(PhotoFilename))
    data = {"id": id, "image_path": PhotoFilename, "photo_create_time": create_time}
    # record_model = PhotoRecord(**data)
    session = SqlQuery()
    record_model = CRUD(PhotoRecord)
    model = record_model.read(session, conditions={"id": id})
    if model == None:
        print(f"smart shooter 拍照记录更新失败,记录id:{id},不存在")
    else:
        # 走编辑逻辑
        record_model.updateConditions(session, conditions={"id": id}, **data)
        print(f"smart shooter 拍照记录更新成功,记录id:{id}")


# socket消息发送逻辑处理方法
async def handlerSend(
    manager: ConnectionManager,
    receiveData: str,
    websocket: WebSocket,
    smart_shooter: SmartShooter,
):
    loop = asyncio.get_event_loop()
    receiveData = json.loads(receiveData)
    # 处理消息发送逻辑
    receiveData = json.loads(receiveData.get("text"))
    jsonType = receiveData.get("type")
    code = receiveData.get("code")
    msg = receiveData.get("msg")
    data = receiveData.get("data")

    async def MsgCallback(msg):
        msg_id = msg.get("msg_id")
        match msg_id:
            case "PhotoUpdated":
                PhotoFilename = msg.get("PhotoFilename")
                PhotoLocation = msg.get("PhotoLocation")
                PhotoOrigin = msg.get("PhotoOrigin")
                if (PhotoFilename != "" and PhotoFilename != None) and (
                    PhotoLocation == "Local Disk"
                ):
                    # temp_photo_name = PhotoFilename
                    # 更新拍照记录
                    print("PhotoFilename", PhotoFilename, PhotoOrigin)
                    if PhotoOrigin != "" and PhotoOrigin != "external":
                        goods_art_no, id = PhotoOrigin.split(",")
                        loop.create_task(
                            updateDataRecord(PhotoFilename, id), name="PhotoFilename"
                        )
                    data = manager.jsonMessage(
                        code=0,
                        msg=f"照片获取成功",
                        data={"photo_file_name": PhotoFilename},
                        msg_type="smart_shooter_photo_take",
                    )
                    await manager.send_personal_message(data, websocket)
            case "LiveviewUpdated":
                CameraLiveviewImage = msg.get("CameraLiveviewImage", None)
                # base64_to_image(CameraLiveviewImage, "liveview.jpg")
                # print("收到直播画面：CameraLiveviewImage")
                data = manager.jsonMessage(
                    code=1,
                    msg=f"预览数据发送",
                    data={"smart_shooter_preview": CameraLiveviewImage},
                    msg_type="smart_shooter_enable_preview",
                )
                await manager.send_personal_message(data, websocket)

    # 构建监听条件
    smart_shooter.callback_listen = MsgCallback
    loop.create_task(
        smart_shooter.connect_listen(),
        name="smart_shooter_connect_listen",
    )
    match jsonType:
        case "ping":
            """发送心跳"""
            data = manager.jsonMessage("pong")
            await manager.send_personal_message(data, websocket)
        case "pong":
            """发送心跳"""
            pass
        case "forward_message":
            data = receiveData.get("data")
            dictMsg = {"code": code, "msg": msg, "data": data}
            await manager.broadcast(dictMsg)
        case "connect_mcu":
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            device_ctrl.mcu_exit = False
            # if device_ctrl.serial_ins.check_connect():
            #     print("未连接")
            loop.create_task(checkMcuConnection(device_ctrl), name="mcu")
        case "connect_bluetooth":
            blue_tooth = BlueToothMode(websocket_manager=manager)
            blue_tooth.bluetooth_exit = False
            # await  blue_tooth.main_func()
            print("连接蓝牙信息")
            loop.create_task(blue_tooth.main_func(), name="blue_tooth")
            # loop.close()
        case "init_mcu":
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            # 是否强制初始化
            is_force_init = data.get("value", False)
            loop.create_task(device_ctrl.initDevice(is_force_init), name="init_mcu")
        case "control_mcu":
            device_name = data.get("device_name")
            value = data.get("value")
            if (device_name == "" or device_name == None) or (
                value == "" or value == None
            ):
                data = manager.jsonMessage(code=1, msg="参数错误", msg_type="mcu")
                await manager.send_personal_message(data, websocket)
                return
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            await device_ctrl.controlDevice(device_name, value)
        case "stop_action":
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            if device_ctrl.is_runn_action == True:
                print("动作执行中，停止")
                device_ctrl.is_stop_action = True
            else:
                print("动作没有执行，略过")
        case "run_mcu":
            msg_type = "run_mcu"
            action_info = data.get("action", "执行左脚程序")
            goods_art_no = data.get("goods_art_no", None)
            if goods_art_no == None or goods_art_no == "":
                # 判断货号是否存在
                data = manager.jsonMessage(
                    code=1, msg="goods_art_no不能为空", msg_type=msg_type
                )
                await manager.send_personal_message(data, websocket)
                return
            session = SqlQuery()
            sys_configs = CRUD(SysConfigs)
            action_configs = sys_configs.read(
                session, conditions={"key": "action_configs"}
            )
            action_configs_json = json.loads(action_configs.value)
            action_flag = "left"
            if "右" in action_info:
                action_flag = "right"
            tab_id = action_configs_json.get(action_flag)
            photoRecord = CRUD(PhotoRecord)
            goods_art_record = photoRecord.read(
                session, conditions={"goods_art_no": goods_art_no}
            )
            if goods_art_record != None:
                data = manager.jsonMessage(
                    code=1,
                    msg=f"货号[{goods_art_no}]已存在,请勿重复拍摄~",
                    msg_type=msg_type,
                )
                await manager.send_personal_message(data, websocket)
                return
            crud = CRUD(DeviceConfig)
            condtions = {"tab_id": tab_id}
            all_devices = crud.read_all(
                session, conditions=condtions, order_by="action_index", ascending=True
            )
            if len(all_devices) == 0:
                # 判断是否有可用配置
                data = manager.jsonMessage(code=1, msg="当前没有可用配置")
                await manager.send_personal_message(data, websocket, msg_type=msg_type)
                return
            action_list = [device.model_dump() for device in all_devices]
            print("handl send smart_shooter", smart_shooter)
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            loop.create_task(
                device_ctrl.run_mcu_config(
                    action_list, goods_art_no, action_info, smart_shooter
                ),
                name="run_mcu_config",
            )
        case "run_mcu_single":
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            loop.create_task(
                device_ctrl.run_mcu_config_single(
                    data, None, "run_mcu_single", -1, smart_shooter
                ),
                name="run_mcu_single",
            )
        case "handler_take_picture":
            blue_tooth = BlueToothMode(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            loop.create_task(
                blue_tooth.remote_control_v2.handlerTakePhoto(smart_shooter),
                name="run_mcu_config",
            )
        case "re_take_picture":  # 重拍
            msg_type = "re_take_picture"
            record_id = data.get("record_id")
            session = SqlQuery()
            photoRecord = CRUD(PhotoRecord)
            goods_art_record = photoRecord.read(session, conditions={"id": record_id})
            if goods_art_record == None:
                data = manager.jsonMessage(
                    code=1,
                    msg=f"记录不存在，请核实后重新操作~",
                    msg_type=msg_type,
                )
                await manager.send_personal_message(data, websocket)
                return
            action_id = goods_art_record.action_id
            goods_art_no = goods_art_record.goods_art_no
            image_index = goods_art_record.image_index
            crud = CRUD(DeviceConfig)
            condtions = {"id": action_id}
            device_action = crud.read(session, conditions=condtions)
            if device_action == None:
                # 判断是否有可用配置
                data = manager.jsonMessage(code=1, msg="当前没有可用配置")
                await manager.send_personal_message(data, websocket, msg_type=msg_type)
                return
            print("device_action", device_action)
            # 清除图片记录,执行重拍
            reset_data = {"image_path": None}
            photoRecord.update(session, record_id, **reset_data)
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            loop.create_task(
                device_ctrl.run_mcu_config_single(
                    device_action.model_dump(),
                    goods_art_no,
                    msg_type=msg_type,
                    image_index=image_index,
                    smart_shooter=smart_shooter,
                    action_id=record_id,
                ),
                name="run_mcu_config_single",
            )
        case "get_deviation":
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            loop.create_task(
                device_ctrl.getDeviationInfo(),
                name="get_deviation",
            )
        case "set_deviation":
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            value = data.get("value", None)
            action_name = data.get("action_name", None)
            loop.create_task(
                device_ctrl.set_deviation_cmd(value, action_name, "set"),
                name="set_deviation",
            )
        case "move_deviation":
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            value = data.get("value", None)
            action_name = data.get("action_name", None)
            loop.create_task(
                device_ctrl.set_deviation_cmd(value, action_name, "move"),
                name="move_deviation",
            )
        case "get_mcu_other_info":
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            loop.create_task(
                device_ctrl.getMcuOtherInfo(),
                name="mcu_other_set_get",
            )
        case "set_mcu_other_info":
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            loop.create_task(
                device_ctrl.setMcuOtherInfo(data),
                name="setMcuOtherInfo",
            )
        case "send_command":
            device_ctrl = DeviceControl(
                websocket_manager=manager, smart_shooter=smart_shooter
            )
            loop.create_task(
                device_ctrl.sendCommand(data.get("command", None)),
                name="sendCommand",
            )
        case "smart_shooter_getinfo":
            """
            获取相机信息,是否连接
            """
            loop.create_task(
                smart_shooter.GetCameraInfo(msg_type="smart_shooter_getinfo"),
                name="smart_shooter_getinfo",
            )
        case "smart_shooter_enable_preview":
            """
            启动相机或关闭实时预览
            """
            value = data.get("value", True)
            loop.create_task(
                smart_shooter.EnableCameraPreview(
                    enable_status=value, msg_type="smart_shooter_enable_preview"
                ),
                name="smart_shooter_enable_preview",
            )
        case "smart_shooter_photo_take":
            """
            获取相机信息,是否连接
            """
            loop.create_task(
                smart_shooter.CameraShooter(msg_type="smart_shooter_photo_take"),
                name="smart_shooter_photo_take",
            )
        case _:
            data = manager.jsonMessage(code=1, msg="未知消息")
            await manager.send_personal_message(data, websocket)
            return