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

package/lib/utils/ScheduleUtils.js

@@ -0,0 +1,51 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.find.js";
+/* eslint-disable no-console */
+
+import { getScheduleCache } from './ScheduleCache';
+
+/**
+ * 根据dpId获取dpCode
+ * @param dpId dpId
+ * @returns dpCode
+ */
+export const getDpCodeByDpId = dpId => {
+  const devInfo = getScheduleCache('devInfo');
+  const groupInfo = getScheduleCache('groupInfo');
+
+  // 优先从设备信息中查找
+  if (devInfo !== null && devInfo !== void 0 && devInfo.schema) {
+    const dp = devInfo.schema.find(item => +item.id === +dpId);
+    if (dp) return dp.code;
+  }
+
+  // 如果设备信息中没有找到，则从群组信息中查找
+  if (groupInfo !== null && groupInfo !== void 0 && groupInfo.schema) {
+    const dp = groupInfo.schema.find(item => +item.id === +dpId);
+    if (dp) return dp.code;
+  }
+  return null;
+};
+
+/**
+ * 根据dpCode获取dpId
+ * @param dpCode dpCode
+ * @returns dpId
+ */
+export const getDpIdByDpCode = dpCode => {
+  const devInfo = getScheduleCache('devInfo');
+  const groupInfo = getScheduleCache('groupInfo');
+
+  // 优先从设备信息中查找
+  if (devInfo !== null && devInfo !== void 0 && devInfo.schema) {
+    const dp = devInfo.schema.find(item => item.code === dpCode);
+    if (dp) return dp.id;
+  }
+
+  // 如果设备信息中没有找到，则从群组信息中查找
+  if (groupInfo !== null && groupInfo !== void 0 && groupInfo.schema) {
+    const dp = groupInfo.schema.find(item => item.code === dpCode);
+    if (dp) return dp.id;
+  }
+  return null;
+};

package/lib/utils/__test__/ScheduleCloudProperty.test.d.ts

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

package/lib/utils/__test__/ScheduleCloudProperty.test.js

@@ -0,0 +1,320 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { renderHook } from '@testing-library/react-hooks';
+import { getDevProperty, saveDevProperty, requestCloud, getDeviceProperty } from '@ray-js/ray';
+import { saveList, save, update, get, getAll, remove, useCloudProperty, useLocalTimerCloudProperty } from '../ScheduleCloudProperty';
+import { devIdOrGroupIdCache } from '../ScheduleCache';
+import { scheduleLogger } from '../ScheduleLogger';
+import { getTimerState } from '../../context/timer';
+import { findMinMissingNum } from '../common';
+import { LOCAL_TIMER_CATEGORY } from '../../constant';
+
+// 模拟依赖
+jest.mock('@ray-js/ray', () => ({
+  getDevProperty: jest.fn(),
+  saveDevProperty: jest.fn(),
+  requestCloud: jest.fn(),
+  getDeviceProperty: jest.fn()
+}));
+jest.mock('../ScheduleLogger', () => ({
+  scheduleLogger: {
+    debug: jest.fn(),
+    error: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn()
+  }
+}));
+jest.mock('../ScheduleCache', () => ({
+  devIdOrGroupIdCache: {
+    get: jest.fn()
+  },
+  getScheduleCache: jest.fn(),
+  setScheduleCache: jest.fn(),
+  clearScheduleCache: jest.fn()
+}));
+jest.mock('../../context/timer', () => ({
+  getTimerState: jest.fn()
+}));
+jest.mock('../common', () => ({
+  findMinMissingNum: jest.fn()
+}));
+describe('ScheduleCloudProperty', () => {
+  const mockDevId = 'device123';
+  const mockCode = 'testCode';
+  const mockValue = {
+    timerId: '22',
+    id: 1,
+    name: 'test',
+    time: '10:00',
+    loops: '1111111',
+    dps: {},
+    aliasName: '',
+    isAppPush: false
+  };
+  const mockTimerId = '1';
+  jest.spyOn(require('../ScheduleCloudProperty'), 'saveList');
+  beforeEach(() => {
+    jest.clearAllMocks();
+    devIdOrGroupIdCache.get.mockReturnValue({
+      devId: mockDevId,
+      groupId: 'group456'
+    });
+    saveDevProperty.mockResolvedValue(true);
+    getDevProperty.mockResolvedValue([{
+      code: mockCode,
+      value: mockValue
+    }]);
+    requestCloud.mockImplementation(_ref => {
+      let {
+        success
+      } = _ref;
+      return success({
+        properties: {}
+      });
+    });
+    getDeviceProperty.mockImplementation(_ref2 => {
+      let {
+        success
+      } = _ref2;
+      return success({
+        properties: {}
+      });
+    });
+    getTimerState.mockReturnValue({
+      rtcTimerList: [{
+        timerId: '2'
+      }]
+    });
+    findMinMissingNum.mockReturnValue(1);
+  });
+  describe('saveList', () => {
+    it('应该保存云端定时任务列表', async () => {
+      const dataList = [{
+        code: mockCode,
+        value: mockValue
+      }];
+      const result = await saveList(dataList);
+      expect(devIdOrGroupIdCache.get).toHaveBeenCalled();
+      expect(saveDevProperty).toHaveBeenCalledWith({
+        devId: mockDevId,
+        bizType: 99,
+        propertyList: JSON.stringify(dataList)
+      });
+      expect(result).toBe(true);
+      expect(scheduleLogger.debug).toHaveBeenCalled();
+    });
+  });
+  describe('save', () => {
+    it('应该保存单个云端定时任务', async () => {
+      const result = await save(mockCode, mockValue);
+      expect(devIdOrGroupIdCache.get).toHaveBeenCalled();
+      expect(saveDevProperty).toHaveBeenCalledWith({
+        devId: mockDevId,
+        bizType: 99,
+        propertyList: JSON.stringify([{
+          code: mockCode,
+          value: mockValue
+        }])
+      });
+      expect(result).toBe(true);
+      expect(scheduleLogger.debug).toHaveBeenCalled();
+    });
+  });
+  describe('update', () => {
+    it('应该更新云端定时任务', async () => {
+      const result = await update(mockCode, mockValue);
+      expect(saveDevProperty).toHaveBeenCalledWith({
+        devId: mockDevId,
+        bizType: 99,
+        propertyList: JSON.stringify([{
+          code: mockCode,
+          value: mockValue
+        }])
+      });
+      expect(result).toBe(true);
+    });
+  });
+  describe('get', () => {
+    it('应该获取云端定时任务', async () => {
+      const result = await get(mockCode);
+      expect(devIdOrGroupIdCache.get).toHaveBeenCalled();
+      expect(getDevProperty).toHaveBeenCalledWith({
+        devId: mockDevId,
+        code: mockCode,
+        bizType: 99
+      });
+      expect(result).toEqual({
+        code: mockCode,
+        value: mockValue
+      });
+      expect(scheduleLogger.debug).toHaveBeenCalled();
+    });
+    it('当没有匹配的结果时应该返回null', async () => {
+      getDevProperty.mockResolvedValue([{
+        code: 'otherCode',
+        value: mockValue
+      }]);
+      const result = await get(mockCode);
+      expect(result).toBeNull();
+    });
+  });
+  describe('getAll', () => {
+    it('当有groupId时应该调用getDevAllProperty', async () => {
+      const result = await getAll();
+      expect(devIdOrGroupIdCache.get).toHaveBeenCalled();
+      expect(requestCloud).toHaveBeenCalled();
+      expect(result).toEqual({
+        properties: {}
+      });
+    });
+    it('当没有groupId时应该调用getDeviceProperty', async () => {
+      devIdOrGroupIdCache.get.mockReturnValue({
+        devId: mockDevId,
+        groupId: ''
+      });
+      const result = await getAll();
+      expect(devIdOrGroupIdCache.get).toHaveBeenCalled();
+      expect(getDeviceProperty).toHaveBeenCalledWith({
+        deviceId: mockDevId,
+        success: expect.any(Function),
+        fail: expect.any(Function)
+      });
+      expect(result).toEqual({
+        properties: {}
+      });
+    });
+  });
+  describe('remove', () => {
+    it('应该删除云端定时任务', async () => {
+      const result = await remove(mockTimerId, mockCode);
+      expect(devIdOrGroupIdCache.get).toHaveBeenCalled();
+      expect(saveDevProperty).toHaveBeenCalledWith({
+        devId: mockDevId,
+        bizType: 99,
+        propertyList: JSON.stringify([{
+          code: mockCode,
+          value: null
+        }])
+      });
+      expect(result).toBe(true);
+      expect(scheduleLogger.debug).toHaveBeenCalled();
+    });
+  });
+  describe('useCloudProperty', () => {
+    it('应该返回正确的方法', () => {
+      const {
+        result
+      } = renderHook(() => useCloudProperty(mockCode));
+      expect(result.current).toHaveProperty('get');
+      expect(result.current).toHaveProperty('getAll');
+      expect(result.current).toHaveProperty('remove');
+      expect(result.current).toHaveProperty('set');
+      expect(result.current).toHaveProperty('update');
+    });
+    it('get方法应该调用get函数', async () => {
+      const {
+        result
+      } = renderHook(() => useCloudProperty(mockCode));
+      await result.current.get();
+      expect(getDevProperty).toHaveBeenCalled();
+    });
+    it('set方法应该调用save函数', async () => {
+      const {
+        result
+      } = renderHook(() => useCloudProperty(mockCode));
+      await result.current.set(mockValue);
+      expect(saveDevProperty).toHaveBeenCalled();
+    });
+    it('update方法应该调用update函数', async () => {
+      const {
+        result
+      } = renderHook(() => useCloudProperty(mockCode));
+      await result.current.update(mockValue);
+      expect(saveDevProperty).toHaveBeenCalled();
+    });
+    it('remove方法应该调用remove函数', async () => {
+      const {
+        result
+      } = renderHook(() => useCloudProperty(mockCode));
+      await result.current.remove(mockTimerId);
+      expect(saveDevProperty).toHaveBeenCalled();
+    });
+  });
+  describe('useLocalTimerCloudProperty', () => {
+    it('应该返回正确的方法', () => {
+      const {
+        result
+      } = renderHook(() => useLocalTimerCloudProperty());
+      expect(result.current).toHaveProperty('getAll');
+      expect(result.current).toHaveProperty('remove');
+      expect(result.current).toHaveProperty('set');
+      expect(result.current).toHaveProperty('update');
+      expect(result.current).toHaveProperty('updateList');
+      expect(result.current).toHaveProperty('updateStatus');
+    });
+    it('remove方法应该使用正确的key', async () => {
+      const {
+        result
+      } = renderHook(() => useLocalTimerCloudProperty());
+      await result.current.remove(mockTimerId);
+      expect(saveDevProperty).toHaveBeenCalledWith({
+        devId: mockDevId,
+        bizType: 99,
+        propertyList: JSON.stringify([{
+          code: `${LOCAL_TIMER_CATEGORY}_${mockTimerId}`,
+          value: 'null'
+        }])
+      });
+    });
+    it('set方法应该使用正确的key和timerId', async () => {
+      const {
+        result
+      } = renderHook(() => useLocalTimerCloudProperty());
+      await result.current.set(mockValue, mockTimerId);
+      expect(saveDevProperty).toHaveBeenCalledWith({
+        devId: mockDevId,
+        bizType: 99,
+        propertyList: JSON.stringify([{
+          code: `${LOCAL_TIMER_CATEGORY}_${mockTimerId}`,
+          value: mockValue
+        }])
+      });
+    });
+    it('update方法应该使用正确的key', async () => {
+      const updateValue = _objectSpread(_objectSpread({}, mockValue), {}, {
+        timerId: mockTimerId
+      });
+      const {
+        result
+      } = renderHook(() => useLocalTimerCloudProperty());
+      await result.current.update(updateValue);
+      expect(saveDevProperty).toHaveBeenCalledWith({
+        devId: mockDevId,
+        bizType: 99,
+        propertyList: JSON.stringify([{
+          code: `${LOCAL_TIMER_CATEGORY}_${mockTimerId}`,
+          value: updateValue
+        }])
+      });
+    });
+    it('updateList方法应该调用saveList函数', async () => {
+      const updateValues = [_objectSpread(_objectSpread({}, mockValue), {}, {
+        timerId: mockTimerId
+      })];
+      const {
+        result
+      } = renderHook(() => useLocalTimerCloudProperty());
+      await result.current.updateList(updateValues);
+      expect(saveList).toHaveBeenCalledWith([{
+        code: `${LOCAL_TIMER_CATEGORY}_${mockTimerId}`,
+        value: updateValues[0]
+      }]);
+    });
+    it('updateStatus方法应该更新状态', async () => {
+      const {
+        result
+      } = renderHook(() => useLocalTimerCloudProperty());
+      await result.current.updateStatus(mockTimerId, true);
+      expect(saveDevProperty).toHaveBeenCalled();
+    });
+  });
+});

package/lib/utils/__test__/ScheduleSupport.test.d.ts

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

package/lib/utils/__test__/ScheduleSupport.test.js

@@ -0,0 +1,211 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { Support, DeviceCapability, getBitValue } from '../ScheduleSupport';
+import { setScheduleCache, getScheduleCache } from '../ScheduleCache';
+import { getDpCodeByDpId, getDpIdByDpCode } from '../ScheduleUtils';
+
+// 模拟依赖
+jest.mock('../ScheduleCache', () => ({
+  setScheduleCache: jest.fn(),
+  getScheduleCache: jest.fn(),
+  clearScheduleCache: jest.fn()
+}));
+jest.mock('../dpState', () => ({
+  setDpState: jest.fn(),
+  clearDpState: jest.fn()
+}));
+jest.mock('../ScheduleUtils', () => ({
+  getDpCodeByDpId: jest.fn(),
+  getDpIdByDpCode: jest.fn()
+}));
+describe('ScheduleSupport', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  describe('getBitValue', () => {
+    it('应该正确获取数字指定位的值', () => {
+      expect(getBitValue(0b1010, 0)).toBe(0); // 第0位是0
+      expect(getBitValue(0b1010, 1)).toBe(1); // 第1位是1
+      expect(getBitValue(0b1010, 2)).toBe(0); // 第2位是0
+      expect(getBitValue(0b1010, 3)).toBe(1); // 第3位是1
+      expect(getBitValue(0b1010, 4)).toBe(0); // 第4位是0（超出范围）
+    });
+    it('当数字为0时应该返回0', () => {
+      expect(getBitValue(0, 0)).toBe(0);
+      expect(getBitValue(0, 1)).toBe(0);
+      expect(getBitValue(0, 10)).toBe(0);
+    });
+  });
+  describe('DeviceCapability枚举', () => {
+    it('应该定义了正确的设备能力枚举值', () => {
+      expect(DeviceCapability.WIFI).toBe(0);
+      expect(DeviceCapability.ZIGBEE).toBe(12);
+      expect(DeviceCapability.SIGMESH).toBe(15);
+      expect(DeviceCapability.BLUETOOTH).toBe(10);
+    });
+  });
+  describe('Support类', () => {
+    let support;
+    const mockDevInfo = {
+      devId: 'test-device-id',
+      capability: 12,
+      dps: {
+        1: true
+      },
+      schema: [{
+        id: 1,
+        code: 'switch_led'
+      }, {
+        id: 2,
+        code: 'bright_value'
+      }]
+    };
+    const mockGroupInfo = {
+      groupId: 'test-group-id',
+      capability: DeviceCapability.ZIGBEE,
+      dps: {
+        1: true
+      },
+      schema: [{
+        id: 1,
+        code: 'switch_led'
+      }, {
+        id: 2,
+        code: 'bright_value'
+      }]
+    };
+    beforeEach(() => {
+      support = new Support({
+        devId: 'test-device-id'
+      });
+      // 模拟getScheduleCache返回null，表示缓存中没有数据
+      getScheduleCache.mockReturnValue(null);
+    });
+    describe('初始化', () => {
+      it('应该正确初始化设备信息', () => {
+        support.setDevInfo(mockDevInfo);
+        expect(setScheduleCache).toHaveBeenCalledWith('devInfo', mockDevInfo);
+      });
+      it('应该正确初始化群组信息', () => {
+        support.setGroupDevInfo(mockGroupInfo);
+        expect(setScheduleCache).toHaveBeenCalledWith('devInfo', mockGroupInfo);
+      });
+    });
+    describe('设备信息获取', () => {
+      it('getCachedDevInfo应该返回缓存的设备信息', () => {
+        getScheduleCache.mockReturnValue(mockDevInfo);
+        const result = support.getCachedDevInfo();
+        expect(result).toEqual(mockDevInfo);
+        expect(getScheduleCache).toHaveBeenCalledWith('devInfo');
+      });
+      it('getDevInfo应该返回设备信息', () => {
+        getScheduleCache.mockReturnValue(mockDevInfo);
+        const result = support.getDevInfo();
+        expect(result).toEqual(mockDevInfo);
+      });
+      it('getGroupDevInfo应该返回群组信息', () => {
+        support.setGroupDevInfo('mock-group-id');
+        const result = support.getGroupDevInfo();
+        expect(result).toEqual(mockGroupInfo);
+      });
+    });
+    describe('设备类型判断', () => {
+      beforeEach(() => {
+        getScheduleCache.mockReturnValue(mockDevInfo);
+      });
+      it('isWifiDevice应该正确判断WIFI设备', () => {
+        // 修改capability
+        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
+          capability: 1 << DeviceCapability.WIFI
+        }));
+        expect(support.isWifiDevice()).toBe(true);
+      });
+      it('isZigbeeDevice应该正确判断ZIGBEE设备', () => {
+        // 修改capability
+        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
+          capability: 1 << DeviceCapability.ZIGBEE
+        }));
+        expect(support.isZigbeeDevice()).toBe(true);
+      });
+      it('isSigMeshDevice应该正确判断SIGMESH设备', () => {
+        expect(support.isSigMeshDevice()).toBe(false);
+
+        // 修改capability
+        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
+          capability: 1 << DeviceCapability.SIGMESH
+        }));
+        expect(support.isSigMeshDevice()).toBe(true);
+      });
+      it('isBleDevice应该正确判断BLE设备', () => {
+        expect(support.isBleDevice()).toBe(false);
+
+        // 修改capability
+        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
+          capability: 1 << DeviceCapability.BLUETOOTH
+        }));
+        expect(support.isBleDevice()).toBe(true);
+      });
+    });
+    describe('设备能力判断', () => {
+      it('hasCapability应该正确判断设备能力', () => {
+        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
+          capability: 1 << DeviceCapability.WIFI | 1 << DeviceCapability.ZIGBEE
+        }));
+        expect(support.hasCapability(DeviceCapability.WIFI)).toBe(true);
+        expect(support.hasCapability(DeviceCapability.ZIGBEE)).toBe(true);
+        expect(support.hasCapability(DeviceCapability.SIGMESH)).toBe(false);
+      });
+      it('isGroupDevice应该正确判断是否为群组设备', () => {
+        // 没有groupId时返回false
+        getScheduleCache.mockReturnValue(mockDevInfo);
+        expect(support.isGroupDevice()).toBe(false);
+
+        // 有groupId时返回true
+        getScheduleCache.mockReturnValue(mockGroupInfo);
+        expect(support.isGroupDevice()).toBe(true);
+      });
+      it('isSupportCloudTimer应该正确判断是否支持云端定时', () => {
+        // 设置支持云端定时的设备信息
+        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
+          panelConfig: {
+            bic: [{
+              code: 'timer',
+              selected: true
+            }]
+          }
+        }));
+        expect(support.isSupportCloudTimer()).toBe(true);
+
+        // 测试不支持云端定时的情况
+        getScheduleCache.mockReturnValue(_objectSpread(_objectSpread({}, mockDevInfo), {}, {
+          panelConfig: {
+            bic: [{
+              code: 'timer',
+              selected: false
+            }]
+          }
+        }));
+        expect(support.isSupportCloudTimer()).toBe(false);
+      });
+    });
+    describe('DP点支持判断', () => {
+      beforeEach(() => {
+        getScheduleCache.mockReturnValue(mockDevInfo);
+        getDpCodeByDpId.mockImplementation(dpId => {
+          if (dpId === 1) return 'switch_led';
+          if (dpId === 2) return 'bright_value';
+          return null;
+        });
+        getDpIdByDpCode.mockImplementation(dpCode => {
+          if (dpCode === 'switch_led') return 1;
+          if (dpCode === 'bright_value') return 2;
+          return null;
+        });
+      });
+      it('supportDp应该正确判断是否支持DP点（通过dpCode）', () => {
+        expect(support.supportDp('switch_led')).toBe(true);
+        expect(support.supportDp('bright_value')).toBe(true);
+        expect(support.supportDp('unsupported_dp')).toBe(false);
+      });
+    });
+  });
+});

package/lib/utils/__test__/ScheduleUtils.test.d.ts

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