@ray-js/lamp-schedule-core 1.0.0-beta-1

package/lib/conflict/__test__/transform.test.js

@@ -0,0 +1,454 @@
+import { timerDataToSchedule, timerListToScheduleList, wakeUpNodeToSchedule, wakeUpDataToScheduleList, sleepNodeToSchedule, sleepDataToScheduleList, countdownToSchedule, rhythmToSchedule, randomNodeToSchedule, randomDataToScheduleList, cycleNodeToSchedule, cycleDataToScheduleList, transScheduleListToConflictList } from '../transform';
+import { EScheduleFunctionType } from '../../types';
+// 模拟 dayjs 的 format 方法
+jest.mock('dayjs', () => {
+  return jest.fn(() => ({
+    format: jest.fn(() => '10:00'),
+    subtract: jest.fn(() => ({
+      format: jest.fn(() => '09:00')
+    })),
+    add: jest.fn(() => ({
+      format: jest.fn(() => '11:00')
+    }))
+  }));
+});
+
+// 模拟时间工具函数
+jest.mock('../../utils/time', () => ({
+  getBackwardOffsetTimeByHourMins: jest.fn((hour, minute, offset) => `${hour}:${minute + offset}`),
+  getPreOffsetTimeByHourMins: jest.fn((hour, minute, offset) => `${hour}:${minute - offset}`),
+  getTimerStrByMinutes: jest.fn(minutes => {
+    const hour = Math.floor(minutes / 60);
+    const minute = minutes % 60;
+    return `${hour < 10 ? '0' + hour : hour}:${minute < 10 ? '0' + minute : minute}`;
+  })
+}));
+
+// 模拟日志函数
+jest.mock('../../utils/ScheduleLogger', () => ({
+  scheduleLogger: {
+    debug: jest.fn(),
+    error: jest.fn()
+  }
+}));
+describe('transform', () => {
+  describe('timerDataToSchedule', () => {
+    it('应该将定时数据转换为日程对象', () => {
+      const result = timerDataToSchedule({
+        time: '10:00',
+        loops: '1000000',
+        status: true,
+        timerId: '1',
+        dps: {},
+        aliasName: 'aliasName',
+        isAppPush: false
+      });
+      expect(result).toEqual({
+        id: `${EScheduleFunctionType.TIMER}_10:00_1000000`,
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          startTime: '10:00',
+          endTime: '10:00'
+        }
+      });
+    });
+    it('应该处理缺少状态的定时数据', () => {
+      const result = timerDataToSchedule({
+        time: '10:00',
+        loops: '1000000',
+        timerId: '1',
+        dps: {},
+        aliasName: 'aliasName',
+        isAppPush: false
+      });
+      expect(result.data.status).toBe(false);
+    });
+  });
+  describe('timerListToScheduleList', () => {
+    it('应该将定时数据列表转换为日程对象列表', () => {
+      const result = timerListToScheduleList([{
+        time: '10:00',
+        loops: '1000000',
+        timerId: '1',
+        status: true,
+        dps: {},
+        aliasName: 'aliasName',
+        isAppPush: false
+      }, {
+        time: '12:00',
+        loops: '0100000',
+        timerId: '2',
+        status: false,
+        dps: {},
+        aliasName: 'aliasName',
+        isAppPush: false
+      }]);
+      expect(result.length).toBe(2);
+      expect(result[0].id).toBe(`${EScheduleFunctionType.TIMER}_10:00_1000000`);
+      expect(result[1].id).toBe(`${EScheduleFunctionType.TIMER}_12:00_0100000`);
+    });
+  });
+  describe('wakeUpNodeToSchedule', () => {
+    it('应该将唤醒数据转换为日程对象', () => {
+      const result = wakeUpNodeToSchedule({
+        hour: 8,
+        minute: 30,
+        loops: '1000000',
+        onOff: true,
+        step: 2,
+        duration: 3,
+        hue: 0,
+        saturation: 1000,
+        value: 1000,
+        brightness: 1000,
+        temperature: 1000,
+        index: 1
+      });
+      expect(result).toEqual({
+        id: `${EScheduleFunctionType.WAKEUP}_08_30_1000000`,
+        type: EScheduleFunctionType.WAKEUP,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          startTime: '8:20',
+          endTime: '8:45'
+        }
+      });
+    });
+  });
+  describe('wakeUpDataToScheduleList', () => {
+    it('应该将唤醒数据列表转换为日程对象列表', () => {
+      const result = wakeUpDataToScheduleList([{
+        hour: 8,
+        minute: 30,
+        loops: '1000000',
+        onOff: true,
+        step: 2,
+        duration: 3,
+        hue: 0,
+        saturation: 1000,
+        value: 1000,
+        brightness: 1000,
+        temperature: 1000,
+        index: 1
+      }, {
+        hour: 9,
+        minute: 0,
+        loops: '0100000',
+        onOff: false,
+        step: 1,
+        duration: 2,
+        hue: 0,
+        saturation: 1000,
+        value: 1000,
+        brightness: 1000,
+        temperature: 1000,
+        index: 2
+      }]);
+      expect(result.length).toBe(2);
+      expect(result[0].id).toBe(`${EScheduleFunctionType.WAKEUP}_08_30_1000000`);
+      expect(result[1].id).toBe(`${EScheduleFunctionType.WAKEUP}_09_00_0100000`);
+    });
+  });
+  describe('sleepNodeToSchedule', () => {
+    it('应该将入睡数据转换为日程对象', () => {
+      const result = sleepNodeToSchedule({
+        hour: 22,
+        minute: 20,
+        loops: '1000000',
+        onOff: true,
+        step: 2,
+        time: '22:30',
+        hue: 0,
+        saturation: 1000,
+        value: 1000,
+        brightness: 1000,
+        temperature: 1000,
+        index: 2
+      });
+      expect(result).toEqual({
+        id: `${EScheduleFunctionType.SLEEP}_22_20_1000000`,
+        type: EScheduleFunctionType.SLEEP,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          startTime: '22:10',
+          endTime: '22:30'
+        }
+      });
+    });
+  });
+  describe('sleepDataToScheduleList', () => {
+    it('应该将入睡数据列表转换为日程对象列表', () => {
+      const result = sleepDataToScheduleList([{
+        hour: 22,
+        minute: 20,
+        loops: '1000000',
+        onOff: true,
+        step: 2,
+        time: '22:30',
+        hue: 0,
+        saturation: 1000,
+        value: 1000,
+        brightness: 1000,
+        temperature: 1000,
+        index: 2
+      }, {
+        hour: 23,
+        minute: 20,
+        loops: '0100000',
+        onOff: true,
+        step: 2,
+        time: '23:30',
+        hue: 0,
+        saturation: 1000,
+        value: 1000,
+        brightness: 1000,
+        temperature: 1000,
+        index: 2
+      }]);
+      expect(result.length).toBe(2);
+      expect(result[0].id).toBe(`${EScheduleFunctionType.SLEEP}_22_20_1000000`);
+      expect(result[1].id).toBe(`${EScheduleFunctionType.SLEEP}_23_20_0100000`);
+    });
+  });
+  describe('countdownToSchedule', () => {
+    it('应该将倒计时数据转换为日程对象', () => {
+      const result = countdownToSchedule({
+        countdown: 600 // 10分钟
+      });
+      expect(result).toEqual({
+        id: EScheduleFunctionType.COUNTDOWN,
+        type: EScheduleFunctionType.COUNTDOWN,
+        data: {
+          status: true,
+          weeks: [0, 0, 0, 0, 0, 0, 0],
+          startTime: '10:00',
+          endTime: '10:10'
+        }
+      });
+    });
+    it('应该处理倒计时为0的情况', () => {
+      const result = countdownToSchedule({
+        countdown: 0
+      });
+      expect(result.data.status).toBe(false);
+    });
+  });
+  describe('rhythmToSchedule', () => {
+    it('应该将生物节律数据转换为日程对象', () => {
+      const result = rhythmToSchedule({
+        power: true,
+        weeks: [1, 1, 1, 1, 1, 0, 0],
+        version: 1,
+        mode: 1,
+        number: 4,
+        rhythms: []
+      });
+      expect(result).toEqual({
+        id: EScheduleFunctionType.RHYTHM,
+        type: EScheduleFunctionType.RHYTHM,
+        data: {
+          status: true,
+          weeks: [1, 1, 1, 1, 1, 0, 0],
+          startTime: '00:00',
+          endTime: '23:59'
+        }
+      });
+    });
+  });
+  describe('randomNodeToSchedule', () => {
+    it('应该将随机定时数据转换为日程对象', () => {
+      const result = randomNodeToSchedule({
+        startTime: 600,
+        // 10:00
+        endTime: 720,
+        // 12:00
+        loops: '1000000',
+        onOff: true,
+        channel: 1,
+        index: 1,
+        color: {
+          hue: 0,
+          saturation: 1000,
+          value: 1000,
+          brightness: 1000,
+          temperature: 1000
+        }
+      });
+      expect(result).toEqual({
+        id: `${EScheduleFunctionType.RANDOM}_600_720_1000000`,
+        type: EScheduleFunctionType.RANDOM,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          startTime: '10:00',
+          endTime: '12:00'
+        }
+      });
+    });
+  });
+  describe('randomDataToScheduleList', () => {
+    it('应该将随机定时数据列表转换为日程对象列表', () => {
+      const result = randomDataToScheduleList([{
+        startTime: 600,
+        // 10:00
+        endTime: 720,
+        // 12:00
+        loops: '1000000',
+        onOff: true,
+        channel: 1,
+        index: 1,
+        color: {
+          hue: 0,
+          saturation: 1000,
+          value: 1000,
+          brightness: 1000,
+          temperature: 1000
+        }
+      }, {
+        startTime: 780,
+        // 13:00
+        endTime: 840,
+        // 14:00
+        loops: '0100000',
+        onOff: false,
+        channel: 1,
+        index: 1,
+        color: {
+          hue: 0,
+          saturation: 1000,
+          value: 1000,
+          brightness: 1000,
+          temperature: 1000
+        }
+      }]);
+      expect(result.length).toBe(2);
+      expect(result[0].id).toBe(`${EScheduleFunctionType.RANDOM}_600_720_1000000`);
+      expect(result[1].id).toBe(`${EScheduleFunctionType.RANDOM}_780_840_0100000`);
+    });
+  });
+  describe('cycleNodeToSchedule', () => {
+    it('应该将循环定时数据转换为日程对象', () => {
+      const result = cycleNodeToSchedule({
+        startTime: 600,
+        // 10:00
+        endTime: 720,
+        // 12:00
+        loops: '1000000',
+        onOff: true,
+        channel: 1,
+        startTimeDuration: 10,
+        endTimeDuration: 10,
+        index: 1,
+        color: {
+          hue: 0,
+          saturation: 1000,
+          value: 1000,
+          brightness: 1000,
+          temperature: 1000
+        }
+      });
+      expect(result).toEqual({
+        id: `${EScheduleFunctionType.CYCLE}_600_720_1000000`,
+        type: EScheduleFunctionType.CYCLE,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          startTime: '10:00',
+          endTime: '12:00'
+        }
+      });
+    });
+  });
+  describe('cycleDataToScheduleList', () => {
+    it('应该将循环定时数据列表转换为日程对象列表', () => {
+      const result = cycleDataToScheduleList([{
+        startTime: 600,
+        // 10:00
+        endTime: 720,
+        // 12:00
+        loops: '1000000',
+        onOff: true,
+        channel: 1,
+        startTimeDuration: 10,
+        endTimeDuration: 10,
+        index: 1,
+        color: {
+          hue: 0,
+          saturation: 1000,
+          value: 1000,
+          brightness: 1000,
+          temperature: 1000
+        }
+      }, {
+        startTime: 780,
+        // 13:00
+        endTime: 840,
+        // 14:00
+        loops: '0100000',
+        onOff: false,
+        channel: 1,
+        startTimeDuration: 10,
+        endTimeDuration: 10,
+        index: 1,
+        color: {
+          hue: 0,
+          saturation: 1000,
+          value: 1000,
+          brightness: 1000,
+          temperature: 1000
+        }
+      }]);
+      expect(result.length).toBe(2);
+      expect(result[0].id).toBe(`${EScheduleFunctionType.CYCLE}_600_720_1000000`);
+      expect(result[1].id).toBe(`${EScheduleFunctionType.CYCLE}_780_840_0100000`);
+    });
+  });
+  describe('transScheduleListToConflictList', () => {
+    it('应该将折叠的日程列表转换为冲突列表', () => {
+      const foldScheduleList = [{
+        type: EScheduleFunctionType.TIMER,
+        detail: [{
+          time: '10:00',
+          loops: '1000000',
+          status: true,
+          timerId: '1',
+          dps: {},
+          aliasName: '',
+          isAppPush: false
+        }]
+      }, {
+        type: EScheduleFunctionType.RANDOM,
+        detail: [{
+          startTime: 600,
+          endTime: 720,
+          loops: '0100000',
+          onOff: true,
+          channel: 1,
+          index: 1,
+          color: {
+            hue: 0,
+            saturation: 1000,
+            value: 1000,
+            brightness: 1000,
+            temperature: 1000
+          }
+        }]
+      }];
+      const result = transScheduleListToConflictList(foldScheduleList);
+      expect(result.length).toBe(2);
+      expect(result[0].type).toBe(EScheduleFunctionType.TIMER);
+      expect(result[1].type).toBe(EScheduleFunctionType.RANDOM);
+    });
+    it('应该处理未知类型的情况', () => {
+      const result = transScheduleListToConflictList([{
+        type: 'unknown',
+        detail: []
+      }]);
+      expect(result.length).toBe(0);
+    });
+  });
+});

package/lib/conflict/__test__/updateDeviceDp.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/conflict/__test__/updateDeviceDp.js

@@ -0,0 +1,114 @@
+import { updateDeviceDp } from '../updateDeviceDp';
+import { publishDps, publishGroupDpCodes } from '@ray-js/ray';
+import { scheduleLogger as ScheduleLogger } from '../../utils/ScheduleLogger';
+
+// 模拟 ray-js 的 publishDps 和 publishGroupDpCodes
+jest.mock('@ray-js/ray', () => ({
+  publishDps: jest.fn(),
+  publishGroupDpCodes: jest.fn()
+}));
+
+// 模拟日志函数
+jest.mock('../../utils/ScheduleLogger', () => ({
+  scheduleLogger: {
+    debug: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn()
+  }
+}));
+
+// 模拟 getSupportIns 函数
+jest.mock('../../hooks/useCommonSupport', () => ({
+  getSupportIns: jest.fn()
+}));
+
+// 模拟 scheduleDpCodes
+jest.mock('../../config', () => ({
+  scheduleDpCodes: {
+    LOCAL_TIMER: 'local_timer',
+    STRIP_LOCAL_TIMER: 'strip_local_timer',
+    RTC_TIMER: 'rtc_timer',
+    COUNTDOWN: 'countdown',
+    CYCLE_TIMING: 'cycle_timing',
+    RANDOM_TIMING: 'random_timing',
+    RHYTHM_MODE: 'rhythm_mode',
+    SLEEP_MODE: 'sleep_mode',
+    WAKE_UP_MODE: 'wake_up_mode'
+  }
+}));
+describe('DPProcessor', () => {
+  // 在每个测试前重置模拟函数
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // 重置 __deviceCapabilities
+    // @ts-ignore - 访问私有变量进行测试
+    global.__deviceCapabilities = null;
+  });
+  describe('updateDeviceDp', () => {
+    it('应该处理空的 dps 对象', () => {
+      updateDeviceDp('device1', '', {});
+      expect(ScheduleLogger.warn).toHaveBeenCalled();
+      expect(publishDps).not.toHaveBeenCalled();
+      expect(publishGroupDpCodes).not.toHaveBeenCalled();
+    });
+    it('应该处理缺少 devId 和 groupId 的情况', () => {
+      updateDeviceDp('', '', {
+        dp1: true
+      });
+      expect(ScheduleLogger.warn).toHaveBeenCalled();
+      expect(publishDps).not.toHaveBeenCalled();
+      expect(publishGroupDpCodes).not.toHaveBeenCalled();
+    });
+    it('应该为设备发布 DP', () => {
+      const dps = {
+        dp1: true,
+        dp2: 'value'
+      };
+      updateDeviceDp('device1', '', dps);
+      expect(publishDps).toHaveBeenCalledWith({
+        deviceId: 'device1',
+        dps,
+        mode: 2,
+        pipelines: [0, 1, 2, 3, 4, 5, 6],
+        options: {},
+        success: expect.any(Function),
+        fail: expect.any(Function)
+      });
+      expect(publishGroupDpCodes).not.toHaveBeenCalled();
+
+      // 测试成功回调
+      const successCallback = publishDps.mock.calls[0][0].success;
+      successCallback();
+      expect(ScheduleLogger.debug).toHaveBeenCalled();
+
+      // 测试失败回调
+      const failCallback = publishDps.mock.calls[0][0].fail;
+      failCallback('error');
+      expect(ScheduleLogger.error).toHaveBeenCalled();
+    });
+    it('应该为群组发布 DP', () => {
+      const dps = {
+        dp1: true,
+        dp2: 'value'
+      };
+      updateDeviceDp('', 'group1', dps);
+      expect(publishGroupDpCodes).toHaveBeenCalledWith({
+        groupId: 'group1',
+        dpCodes: dps,
+        success: expect.any(Function),
+        fail: expect.any(Function)
+      });
+      expect(publishDps).not.toHaveBeenCalled();
+
+      // 测试成功回调
+      const successCallback = publishGroupDpCodes.mock.calls[0][0].success;
+      successCallback();
+      expect(ScheduleLogger.debug).toHaveBeenCalled();
+
+      // 测试失败回调
+      const failCallback = publishGroupDpCodes.mock.calls[0][0].fail;
+      failCallback('error');
+      expect(ScheduleLogger.error).toHaveBeenCalled();
+    });
+  });
+});

package/lib/conflict/index.d.ts

@@ -0,0 +1,42 @@
+import { TConflictRes, ConflictRule, TFoldScheduleList, TSchedule } from './type';
+/**
+ * 冲突检测
+ */
+export declare class Conflict {
+    static rule: ConflictRule;
+    static isInit: boolean;
+    /**
+     * 添加冲突规则
+     */
+    static addConflictRule(rule: ConflictRule): void;
+    /**
+     * 添加新日程时检测冲突
+     *
+     * @param current - 待添加的日程对象，类型为 Schedule
+     * @returns 返回冲突检测结果对象，包含:
+     *          isConflict - 是否存在冲突的布尔值
+     *          conflictList - 具体的冲突检测结果数组
+     */
+    static add(current: TSchedule): TConflictRes;
+    /**
+     * 删除日程
+     *
+     * @param current - 待添加的日程对象，类型为 Schedule
+     * @returns void
+     */
+    static remove(current: TSchedule): void;
+    /**
+     * 更新新日程时检测冲突
+     *
+     * @param current - 待更新的日程对象，类型为 Schedule
+     * @returns 返回冲突检测结果对象，包含:
+     *          isConflict - 是否存在冲突的布尔值
+     *          conflictList - 具体的冲突检测结果数组
+     */
+    static update(current: TSchedule, prevSchedule: TSchedule): TConflictRes;
+    /**
+     * 当进入面板后，初始化需要冲突判断的计划数据，便于后续增删改冲突判断
+     * @param scheduleList - 需要冲突判断的计划数据
+     */
+    static init(scheduleList: TFoldScheduleList): void;
+}