model-action 1.0.23 → 2.0.0

package/src/modules/Routing.ts

@@ -1,117 +1,128 @@
-
 /**
- * 巡更
+ * 巡检操作方法
  */
-import { Action, } from "./Action";
+import { Action, SendParam } from "./Action";
+
+// 路由巡视动作类型
+export type RoutingActionType = 'start' | 'stop' | 'pause' | 'restart'
+
+// 路由巡视类型
+export type RoutingType = 'videoPatrol'
+
+// 路由巡视参数
+export interface RoutingParam {
+    type: RoutingType;              // 巡视类型，目前只有 videoPatrol
+    id: string;                     // 路线ID，命名规则：园区室外使用 VP-1, VP-2；室内分层建筑使用 A-1（A楼1楼）
+    isPauseAtRouting?: boolean;     // 巡检途中遇到摄像头弹框时是否停下来，默认 false
+    isRolerMoveOnRouting?: boolean; // 巡检途中是否有人在路径上行走，默认 false
+    isViewFollow?: boolean;         // 巡检途中视角是否跟随路径线，默认 false。true时，isRolerMoveOnRouting 应为 false
+}
+
+type RoutingParamType = SendParam & {
+    cmd: "routing";
+    data: {
+        action: RoutingActionType;
+        type?: RoutingType;
+        id?: string;
+        isPauseAtRouting?: boolean;
+        isRolerMoveOnRouting?: boolean;
+        isViewFollow?: boolean;
+    };
+}
 
 export class RoutingAction extends Action {
     /**
-      * 巡检开始
-      * @param {*} id (必须）巡检的唯一ID)
-      * @param {*} type (必须）巡检的类型) 
-      *     videoPatrol => 视频巡更
-      *     cameraRoute => 视角跟随样条线
-      */
-    static videoPatrolStart(id: string, type: string = "videoPatrol", extendParams = {}) {
-        const param: any = {
-            cmd: "routing",
-            action: "start",
-            id,
-            ...extendParams,
+     * 开始路由巡视
+     * 显示指定路线的巡视效果，相机跟随路线，线路是在场景中预设的一条固定的样条线
+     * @param param 路由巡视参数
+     */
+    static start(param: RoutingParam) {
+        // 如果 isViewFollow 为 true，则 isRolerMoveOnRouting 应该为 false
+        if (param.isViewFollow === true && param.isRolerMoveOnRouting === true) {
+            console.warn('当 isViewFollow 为 true 时，isRolerMoveOnRouting 应该为 false');
+        }
+
+        const data: {
+            action: 'start';
+            type: RoutingType;
+            id: string;
+            isPauseAtRouting?: boolean;
+            isRolerMoveOnRouting?: boolean;
+            isViewFollow?: boolean;
+        } = {
+            action: 'start',
+            type: param.type,
+            id: param.id
         };
-        if (type) {
-            param.type = type
+
+        // 可选参数
+        if (param.isPauseAtRouting !== undefined) {
+            data.isPauseAtRouting = param.isPauseAtRouting;
+        }
+        if (param.isRolerMoveOnRouting !== undefined) {
+            data.isRolerMoveOnRouting = param.isRolerMoveOnRouting;
+        }
+        if (param.isViewFollow !== undefined) {
+            data.isViewFollow = param.isViewFollow;
         }
-        this.sendParam(param, '巡更开始')
-    }
 
-    /**
-     * 巡检结束
-     * @param {*} id (必须）巡检的唯一ID)
-    * @param {*} type (必须）巡检的类型)
-     */
-    static videoPatrolStop(id: string, type: string = "videoPatrol", extendParams = {}) {
-        const param: any = {
+        const sendParam: RoutingParamType = {
             cmd: "routing",
-            action: "stop",
-            id,
-            ...extendParams,
+            data
         };
-        if (type) {
-            param.type = type
-        }
-        this.sendParam(param, '巡更结束')
+        this.sendParam(sendParam, '开始路由巡视')
     }
 
     /**
-     * 巡检暂停
-     * @param {*} id (必须）巡检的唯一ID)
-    * @param {*} type (必须）巡检的类型)
+     * 停止路由巡视
+     * 停止并隐藏巡视，整条巡检结束后，必须调用 start 才能重新开始
      */
-    static videoPatrolPause(id: string, type: string = "videoPatrol", extendParams = {}) {
-        const param: any = {
-            cmd: "routing",
-            action: "pause",    
-            id,
-            ...extendParams,
+    static stop() {
+        const data: {
+            action: 'stop';
+        } = {
+            action: 'stop'
         };
-        if (type) {
-            param.type = type
-        }
-        this.sendParam(param, '巡更暂停')
-    }
 
-    /**
-     * 巡检下一步
-     * @param {*} id (必须）巡检的唯一ID)
-    * @param {*} type (必须）巡检的类型)
-    */
-    static videoPatrolNext(id: string, type: string = "videoPatrol", extendParams = {}) {
-        const param: any = {
+        const sendParam: RoutingParamType = {
             cmd: "routing",
-            action: "next",
-            id,
-            ...extendParams,
+            data
         };
-        if (type) {
-            param.type = type
-        }
-        this.sendParam(param, '巡更下一步')
+        this.sendParam(sendParam, '停止路由巡视')
     }
 
     /**
-     * 巡更上一步
-     * @param {*} id (必须）巡检的唯一ID)
-    * @param {*} type (必须）巡检的类型)
+     * 暂停路由巡视
      */
-    static videoPatrolPrev(id: string, type: string = "videoPatrol", extendParams = {}) {
-        const param: any = {
+    static pause() {
+        const data: {
+            action: 'pause';
+        } = {
+            action: 'pause'
+        };
+
+        const sendParam: RoutingParamType = {
             cmd: "routing",
-            action: "last",
-            id,
-            ...extendParams,
+            data
         };
-        if(type){
-            param.type = type
-        }
-        this.sendParam(param, '巡更上一步')
+        this.sendParam(sendParam, '暂停路由巡视')
     }
 
     /**
-     * 巡更重新开始，从暂停点开始
-     * @param {*} id (必须）巡检的唯一ID)
-    * @param {*} type (必须）巡检的类型)
+     * 重新开始路由巡视
+     * 从暂停点继续开始巡视
      */
-    static videoPatrolRestart(id: string, type: string = "videoPatrol", extendParams = {}) {
-        const param: any = {
+    static restart() {
+        const data: {
+            action: 'restart';
+        } = {
+            action: 'restart'
+        };
+
+        const sendParam: RoutingParamType = {
             cmd: "routing",
-            action: "restart",
-            id,
-            ...extendParams,
+            data
         };
-        if (type) {
-            param.type = type
-        }
-        this.sendParam(param, '巡更重新开始，从暂停点开始')
+        this.sendParam(sendParam, '重新开始路由巡视')
     }
 }

package/src/modules/Scene.ts

@@ -1,35 +1,57 @@
-
-
-
 /**
- * 场景方法
+ * 场景操作方法
  */
 import { Action, SendParam } from "./Action";
 
+// 场景操作类型
+export type SceneActionType = 'changeSence' | 'resetSence';
 
-enum SceneActionType{
-    Exit = '0',       //退出独显
-    Enter = '1',      //进入独显
+// 场景编码类型
+export type SceneCode = 'QF' | 'RZ' | string; // QF = 曲阜，RZ = 日照
+
+type SceneParamType = SendParam & {
+    cmd: "sence";
+    data: {
+        action: SceneActionType;
+        code?: SceneCode;
+    };
 }
-type SceneType = {
-    action: SceneActionType,
-    isAdjustLight: boolean   //是否调整灯光
-    tag?: string,           //指定场景需要打的tag，根据项目定义，如果场景中只有一处需要独显，这里可以不传该字段
-} & SendParam
 
 export class SceneAction extends Action {
     /**
-     * 独显某场景模型
-     * @param {*} action 1进入独显 0退出独显
+     * 切换场景
+     * @param code 场景编码
      */
-    static singleShow(action:SceneActionType,isAdjustLight:SceneType['isAdjustLight'] = false,tag:SceneType['tag']) {
-        const param: SceneType = {
-            cmd: "POI",
-            action,
-            tag,
-            isAdjustLight
+    static changeSence(code: SceneCode) {
+        const data: {
+            action: 'changeSence';
+            code: SceneCode;
+        } = {
+            action: 'changeSence',
+            code
+        };
+
+        const sendParam: SceneParamType = {
+            cmd: "sence",
+            data
         };
-        this.sendParam(param, `${action==='0'?'退出':'进入'}独显`);
+        this.sendParam(sendParam, `切换场景 - code: ${code}`);
     }
 
+    /**
+     * 重置场景到初始状态
+     */
+    static resetSence() {
+        const data: {
+            action: 'resetSence';
+        } = {
+            action: 'resetSence'
+        };
+
+        const sendParam: SceneParamType = {
+            cmd: "sence",
+            data
+        };
+        this.sendParam(sendParam, '重置场景到初始状态');
+    }
 }

package/src/modules/Status.ts

@@ -0,0 +1,150 @@
+/**
+ * 状态操作方法
+ */
+import { Action } from "./Action";
+
+// 状态信息
+export interface StatusInfo {
+    id: string;      // 唯一标识
+    state: string;   // 状态值：normal | alarm | color=FFFFFF
+}
+
+// Status命令类型（不继承SendParam，因为data中没有action字段）
+type StatusType = {
+    cmd: "status";
+    data: {
+        isLocation?: boolean;  // 是否定位到第一个ID对应的设备，默认false
+        type?: string;         // 变换状态的类型，非必须，如"POI"
+        infos: StatusInfo[];   // 要切换状态的设备的数据
+    };
+}
+
+export class StatusAction extends Action {
+    /**
+     * 切换指定ID的模型、POI等的状态
+     * @param infos 状态信息数组，包含id和state
+     * @param options 可选参数
+     * @param options.isLocation 是否定位到第一个ID对应的设备，默认false
+     * @param options.type 变换状态的类型，如"POI"
+     */
+    static statusChange(
+        infos: StatusInfo[],
+        options?: {
+            isLocation?: boolean;
+            type?: string;
+        }
+    ) {
+        const data: {
+            isLocation?: boolean;
+            type?: string;
+            infos: StatusInfo[];
+        } = {
+            infos
+        };
+
+        // 如果提供了 isLocation，则添加（默认false，所以只有为true时才添加）
+        if (options?.isLocation !== undefined) {
+            data.isLocation = options.isLocation;
+        }
+
+        // 如果提供了 type，则添加
+        if (options?.type) {
+            data.type = options.type;
+        }
+
+        const param: StatusType = {
+            cmd: "status",
+            data
+        };
+
+        // 生成描述信息
+        let msg = '切换状态';
+        if (options?.type) {
+            msg = `切换${options.type}状态`;
+        }
+        if (infos.length === 1) {
+            msg += ` - ID: ${infos[0].id}, 状态: ${infos[0].state}`;
+        } else {
+            msg += ` - 共${infos.length}个设备`;
+        }
+
+        // 使用类型断言调用sendParam，因为StatusType不严格符合SendParam（缺少action字段）
+        this.sendParam(param as any, msg);
+    }
+
+    /**
+     * 设置设备为正常状态
+     * @param id 设备ID
+     * @param options 可选参数
+     */
+    static setNormal(
+        id: string,
+        options?: {
+            isLocation?: boolean;
+            type?: string;
+        }
+    ) {
+        this.statusChange([{ id, state: 'normal' }], options);
+    }
+
+    /**
+     * 设置设备为报警状态
+     * @param id 设备ID
+     * @param options 可选参数
+     */
+    static setAlarm(
+        id: string,
+        options?: {
+            isLocation?: boolean;
+            type?: string;
+        }
+    ) {
+        this.statusChange([{ id, state: 'alarm' }], options);
+    }
+
+    /**
+     * 设置设备颜色
+     * @param id 设备ID
+     * @param color 颜色值，格式如 "FFFFFF" 或 "93050C"（不需要#前缀）
+     * @param options 可选参数
+     */
+    static setColor(
+        id: string,
+        color: string,
+        options?: {
+            isLocation?: boolean;
+            type?: string;
+        }
+    ) {
+        // 移除可能的#前缀
+        const colorValue = color.startsWith('#') ? color.slice(1) : color;
+        this.statusChange([{ id, state: `color=${colorValue}` }], options);
+    }
+
+    /**
+     * 批量设置多个设备的状态
+     * @param statusMap 状态映射，key为设备ID，value为状态值（normal | alarm | color值）
+     * @param options 可选参数
+     */
+    static batchSetStatus(
+        statusMap: Record<string, string>,
+        options?: {
+            isLocation?: boolean;
+            type?: string;
+        }
+    ) {
+        const infos: StatusInfo[] = [];
+        for (const id in statusMap) {
+            if (statusMap.hasOwnProperty(id)) {
+                const state = statusMap[id];
+                // 如果state是颜色值（6位十六进制），自动添加color=前缀
+                let finalState = state;
+                if (/^[0-9A-Fa-f]{6}$/.test(state) && !state.startsWith('color=')) {
+                    finalState = `color=${state}`;
+                }
+                infos.push({ id, state: finalState });
+            }
+        }
+        this.statusChange(infos, options);
+    }
+}