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

package/lib/hooks/useTimerOperateCloud.js

@@ -0,0 +1,233 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+/* eslint-disable @typescript-eslint/ban-types */
+/**
+ * 包含定时的增删改查
+ */
+import { useCallback, useState } from 'react';
+import { device } from '@ray-js/ray';
+import { scheduleLogger as ScheduleLogger } from '../utils/ScheduleLogger';
+import { getDpIdByDpCode } from '../utils/ScheduleUtils';
+import { devIdOrGroupIdCache } from '../utils/ScheduleCache';
+import { CLOUD_TIMER_CATEGORY } from '../constant';
+const {
+  addTimer: addTimerTTT,
+  removeTimer: removeTimerTTT,
+  updateTimer: updateTimerTTT,
+  syncTimerTask: syncTimerTaskTTT,
+  updateTimerStatus: updateTimerStatusTTT
+} = device;
+export const useCloudTimerAdd = isSupportLocalTimer => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    devId,
+    groupId
+  } = devIdOrGroupIdCache.get();
+  const addTimer = useCallback(function (timer) {
+    let category = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : CLOUD_TIMER_CATEGORY;
+    return new Promise((resolve, reject) => {
+      const _dps = {};
+      Object.keys(timer.dps).forEach(i => {
+        const dpVal = timer.dps[i];
+        // eslint-disable-next-line no-self-compare
+        if (+i !== +i) {
+          // 不为数字
+          const dpId = getDpIdByDpCode(i);
+          if (dpVal !== undefined && dpId !== undefined) {
+            _dps[dpId] = dpVal;
+          }
+        } else {
+          _dps[+i] = dpVal;
+        }
+      });
+      const params = {
+        category,
+        timer: _objectSpread(_objectSpread({}, timer), {}, {
+          dps: _dps,
+          time: timer.time
+        }),
+        success: info => {
+          setIsLoading(false);
+          resolve(_objectSpread({
+            timerId: info.timerId || info.id
+          }, params.timer));
+          ScheduleLogger.debug('useCloudTimerAdd success:', info);
+        },
+        fail: error => {
+          setIsLoading(false);
+          reject(error);
+          ScheduleLogger.error('useCloudTimerAdd fail:', error);
+        }
+      };
+      if (groupId) {
+        params.groupId = groupId;
+      } else if (devId) {
+        params.deviceId = devId;
+      }
+      ScheduleLogger.debug('useCloudTimerAdd params:', params);
+      setIsLoading(true);
+      addTimerTTT(params);
+    });
+  }, [isSupportLocalTimer]);
+  return {
+    isLoading,
+    isSupportLocalTimer,
+    addTimer
+  };
+};
+export const useCloudTimerUpdate = isSupportLocalTimer => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    devId,
+    groupId
+  } = devIdOrGroupIdCache.get();
+  const updateTimer = useCallback(timer => {
+    return new Promise((resolve, reject) => {
+      const params = {
+        timer: _objectSpread(_objectSpread({}, timer), {}, {
+          time: timer.time
+        })
+      };
+      if (groupId) {
+        params.groupId = groupId;
+      } else if (devId) {
+        params.deviceId = devId;
+      }
+      ScheduleLogger.debug('useCloudTimerUpdate updateTimer params:', params);
+      setIsLoading(true);
+      updateTimerTTT(_objectSpread(_objectSpread({}, params), {}, {
+        success: info => {
+          setIsLoading(false);
+          resolve(true);
+          ScheduleLogger.debug('useCloudTimerUpdate updateTimer success:', info);
+        },
+        fail: error => {
+          setIsLoading(false);
+          reject(error);
+          ScheduleLogger.error('useCloudTimerUpdate addTimer fail:', error);
+        }
+      }));
+    });
+  }, []);
+  return {
+    isLoading,
+    isSupportLocalTimer,
+    updateTimer
+  };
+};
+export const useCloudTimerRemove = isSupportLocalTimer => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    devId,
+    groupId
+  } = devIdOrGroupIdCache.get();
+  const removeTimer = useCallback(timerId => {
+    return new Promise((resolve, reject) => {
+      setIsLoading(true);
+      const params = {
+        timerId
+      };
+      if (groupId) {
+        params.groupId = groupId;
+      } else if (devId) {
+        params.deviceId = devId;
+      }
+      ScheduleLogger.debug('useCloudTimerRemove removeTimer params:', params);
+      removeTimerTTT(_objectSpread(_objectSpread({}, params), {}, {
+        success: () => {
+          resolve(true);
+          ScheduleLogger.debug('useCloudTimerRemove removeTimer success');
+        },
+        fail: error => {
+          reject(error);
+          ScheduleLogger.error('useCloudTimerRemove removeTimer fail:', error);
+        }
+      }));
+    });
+  }, []);
+  return {
+    isLoading,
+    isSupportLocalTimer,
+    removeTimer
+  };
+};
+export const useCloudTimerList = isSupportLocalTimer => {
+  const [isLoading, setIsLoading] = useState(false);
+  const getTimerList = useCallback(function () {
+    let category = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : CLOUD_TIMER_CATEGORY;
+    setIsLoading(true);
+    const params = {
+      category
+    };
+    const {
+      devId,
+      groupId
+    } = devIdOrGroupIdCache.get();
+    if (groupId) {
+      params.groupId = groupId;
+    } else if (devId) {
+      params.deviceId = devId;
+    }
+    return new Promise((resolve, reject) => {
+      syncTimerTaskTTT(_objectSpread(_objectSpread({}, params), {}, {
+        success: info => {
+          setIsLoading(false);
+          ScheduleLogger.debug('useCloudTimerList success:', info);
+          resolve(info);
+        },
+        fail: error => {
+          setIsLoading(false);
+          ScheduleLogger.error('useCloudTimerList fail:', error);
+          reject(error);
+        }
+      }));
+    });
+  }, []);
+  return {
+    isLoading,
+    isSupportLocalTimer,
+    getTimerList
+  };
+};
+/**
+ * 更新定时开关状态
+ */
+export const useCloudTimerUpdateStatus = isSupportLocalTimer => {
+  const [isLoading, setIsLoading] = useState(false);
+  const updateTimerStatus = useCallback((timerId, status) => {
+    return new Promise((resolve, reject) => {
+      setIsLoading(true);
+      const params = {
+        timerId,
+        status
+      };
+      const {
+        devId,
+        groupId
+      } = devIdOrGroupIdCache.get();
+      if (groupId) {
+        params.groupId = groupId;
+      } else if (devId) {
+        params.deviceId = devId;
+      }
+      updateTimerStatusTTT(_objectSpread(_objectSpread({}, params), {}, {
+        success: () => {
+          setIsLoading(false);
+          resolve(true);
+          ScheduleLogger.debug('useCloudTimerUpdateStatus success');
+        },
+        fail: error => {
+          setIsLoading(false);
+          reject(error);
+          ScheduleLogger.error('useCloudTimerUpdateStatus fail:', error);
+        }
+      }));
+    });
+  }, []);
+  return {
+    isLoading,
+    isSupportLocalTimer,
+    updateTimerStatus
+  };
+};

package/lib/hooks/useTimerOperateLocal.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 包含定时的增删改查
+ */
+import { Dispatch } from 'react';
+import { TTimerDataUpdate, TTimerData, TTimerDataAdd } from '../types';
+import { TActions } from '../context/timer/type';
+export declare const useLocalTimerAdd: (isSupportLocalTimer: boolean) => {
+    isLoading: boolean;
+    isSupportLocalTimer: boolean;
+    addTimer: (timer: TTimerDataAdd) => Promise<boolean>;
+};
+export declare const useLocalTimerUpdate: (isSupportLocalTimer: boolean) => {
+    isLoading: boolean;
+    isSupportLocalTimer: boolean;
+    updateTimer: (data: TTimerDataUpdate) => Promise<boolean>;
+};
+export declare const useLocalTimerRemove: (isSupportLocalTimer: boolean) => {
+    isLoading: boolean;
+    isSupportLocalTimer: boolean;
+    removeTimer: (timerId: string) => Promise<boolean>;
+};
+/**
+ * 获取本地定时器列表并刷新 context
+ */
+export declare const getTimerListWithFlush: (dispatch: Dispatch<any>, actions: TActions) => Promise<void>;
+export declare const useLocalTimerList: (isSupportLocalTimer: boolean) => {
+    isLoading: boolean;
+    isSupportLocalTimer: boolean;
+    getTimerList: () => Promise<{
+        timers: TTimerData[];
+    }>;
+};
+/**
+ * 更新本地定时开关状态
+ */
+export declare const useLocalTimerUpdateStatus: (isSupportLocalTimer: boolean) => {
+    isLoading: boolean;
+    isSupportLocalTimer: boolean;
+    updateTimerStatus: (timerId: string, status: boolean) => Promise<boolean>;
+};

package/lib/hooks/useTimerOperateLocal.js

@@ -0,0 +1,310 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.find.js";
+import "core-js/modules/esnext.iterator.map.js";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/**
+ * 包含定时的增删改查
+ */
+import { useCallback, useState, useEffect } from 'react';
+import { offDpDataChange, onDpDataChange } from '@ray-js/ray';
+import { devIdOrGroupIdCache } from '../utils/ScheduleCache';
+import { scheduleLogger as ScheduleLogger } from '../utils/ScheduleLogger';
+import { LOCAL_TIMER_CATEGORY } from '../constant';
+import { getAll, useLocalTimerCloudProperty } from '../utils/ScheduleCloudProperty';
+import { getTimerState, getTimerReducer } from '../context/timer';
+import { timerReportParser } from '../dpParser';
+
+// 添加本地定时
+export const useLocalTimerAdd = isSupportLocalTimer => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    set
+  } = useLocalTimerCloudProperty();
+  const addTimer = useCallback((timer, timerId) => {
+    return new Promise((resolve, reject) => {
+      ScheduleLogger.debug('useLocalTimerAdd addTimer params:', timer);
+      setIsLoading(true);
+      set(timer, timerId).then(() => {
+        ScheduleLogger.debug('useLocalTimerAdd set success:', timer);
+        resolve(true);
+      }).catch(error => {
+        ScheduleLogger.debug('useLocalTimerAdd set fail:', error);
+        reject(error);
+      }).finally(() => {
+        setIsLoading(false);
+      });
+    });
+  }, []);
+  return {
+    isLoading,
+    addTimer,
+    isSupportLocalTimer
+  };
+};
+
+// 更新本地定时
+export const useLocalTimerUpdate = isSupportLocalTimer => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    devId,
+    groupId
+  } = devIdOrGroupIdCache.get();
+  const {
+    update
+  } = useLocalTimerCloudProperty();
+  const updateTimer = useCallback(timer => {
+    return new Promise((resolve, reject) => {
+      const params = {
+        timer
+      };
+      if (groupId) {
+        params.groupId = groupId;
+      } else if (devId) {
+        params.deviceId = devId;
+      }
+      ScheduleLogger.debug('updateTimer params:', params);
+      setIsLoading(true);
+      update(timer).then(() => {
+        resolve(true);
+      }).catch(error => {
+        reject(error);
+      });
+    });
+  }, [update]);
+  return {
+    isSupportLocalTimer,
+    isLoading,
+    updateTimer
+  };
+};
+
+// 删除本地定时器
+export const useLocalTimerRemove = isSupportLocalTimer => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    remove
+  } = useLocalTimerCloudProperty();
+  const removeTimer = useCallback(timerId => {
+    return new Promise((resolve, reject) => {
+      setIsLoading(true);
+      remove(timerId).then(() => {
+        resolve(true);
+      }).catch(err => {
+        reject(err);
+      });
+    });
+  }, []);
+  return {
+    isSupportLocalTimer,
+    isLoading,
+    removeTimer
+  };
+};
+const getTimerList = () => {
+  return new Promise((resolve, reject) => {
+    getAll().then(res => {
+      ScheduleLogger.debug('useLocalTimerList getAll res:', res);
+      const {
+        properties = {}
+      } = res;
+      const localTimerList = Object.entries(properties || {}).filter(_ref => {
+        let [key] = _ref;
+        return key.startsWith(LOCAL_TIMER_CATEGORY);
+      });
+      const validLocalTimerList = localTimerList.filter(_ref2 => {
+        let [_, value] = _ref2;
+        let v = value;
+        try {
+          if (value === '1') {
+            return false;
+          }
+          if (value === 'null') {
+            return false;
+          }
+          v = JSON.parse(value);
+        } catch (err) {
+          return false;
+        }
+        return v.time;
+      });
+      const _localTimerList = validLocalTimerList.map(_ref3 => {
+        let [key, value] = _ref3;
+        const timerId = key.replace(`${LOCAL_TIMER_CATEGORY}_`, '');
+        const {
+          time,
+          loops,
+          status = false,
+          dps
+        } = JSON.parse(value);
+        return {
+          timerId,
+          time,
+          loops,
+          status,
+          dps,
+          // 为了跟云端数据保持一致，本地定时写死的数据
+          aliasName: '',
+          isAppPush: false
+        };
+      });
+      resolve({
+        timers: _localTimerList
+      });
+    }).catch(err => {
+      ScheduleLogger.error('useLocalTimerList getAll error:', err);
+      reject(err);
+    });
+  });
+};
+const flushRtcTimerList = (timerList, dispatch, actions) => {
+  dispatch(actions === null || actions === void 0 ? void 0 : actions.flushRtcTimerList(timerList));
+};
+
+/**
+ * 获取本地定时器列表并刷新 context
+ */
+export const getTimerListWithFlush = (dispatch, actions) => {
+  return getTimerList().then(res => {
+    return flushRtcTimerList(res.timers, dispatch, actions);
+  });
+};
+const onDpChangeFn = data => {
+  var _data$dps;
+  // 专门处理 timer_report dp 变化
+  if (data !== null && data !== void 0 && (_data$dps = data.dps) !== null && _data$dps !== void 0 && _data$dps[38]) {
+    var _data$dps2;
+    const {
+      rtcTimerList = []
+    } = getTimerState();
+    const {
+      actions,
+      dispatch
+    } = getTimerReducer();
+    const dpValue = data === null || data === void 0 || (_data$dps2 = data.dps) === null || _data$dps2 === void 0 ? void 0 : _data$dps2[38];
+    const dpParsedValue = timerReportParser.parser(dpValue);
+    const timerList = rtcTimerList.map(item => {
+      var _dpParsedValue$find$s, _dpParsedValue$find;
+      return _objectSpread(_objectSpread({}, item), {}, {
+        status: (_dpParsedValue$find$s = dpParsedValue === null || dpParsedValue === void 0 || (_dpParsedValue$find = dpParsedValue.find(i => +i.id === +item.timerId)) === null || _dpParsedValue$find === void 0 ? void 0 : _dpParsedValue$find.status) !== null && _dpParsedValue$find$s !== void 0 ? _dpParsedValue$find$s : false
+      });
+    });
+    dispatch && dispatch(actions.flushRtcTimerList(timerList));
+  }
+};
+
+// 获取本地定时任务列表
+export const useLocalTimerList = isSupportLocalTimer => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    getAll
+  } = useLocalTimerCloudProperty();
+  useEffect(() => {
+    // 监听 dp 变化
+    // 监听 timer_report dp 变化 用来同步本地定时列表状态
+    offDpDataChange(onDpChangeFn);
+    onDpDataChange(onDpChangeFn);
+  }, []);
+  const getTimerList = useCallback(() => {
+    setIsLoading(true);
+    return new Promise((resolve, reject) => {
+      getAll().then(res => {
+        ScheduleLogger.debug('useLocalTimerList getAll res:', res);
+        const {
+          properties = {}
+        } = res;
+        const localTimerList = Object.entries(properties || {}).filter(_ref4 => {
+          let [key] = _ref4;
+          return key.startsWith(LOCAL_TIMER_CATEGORY);
+        });
+        const validLocalTimerList = localTimerList.filter(_ref5 => {
+          let [_, value] = _ref5;
+          let v = value;
+          try {
+            if (value === '1') {
+              return false;
+            }
+            if (value === 'null') {
+              return false;
+            }
+            v = JSON.parse(value);
+          } catch (err) {
+            return false;
+          }
+          return v.time;
+        });
+        const _localTimerList = validLocalTimerList.map(_ref6 => {
+          let [key, value] = _ref6;
+          const timerId = key.replace(`${LOCAL_TIMER_CATEGORY}_`, '');
+          const {
+            time,
+            loops,
+            status = false,
+            dps
+          } = JSON.parse(value);
+          return {
+            timerId,
+            time,
+            loops,
+            status,
+            dps,
+            // 为了跟云端数据保持一致，本地定时写死的数据
+            aliasName: '',
+            isAppPush: false
+          };
+        });
+        resolve({
+          timers: _localTimerList
+        });
+      }).catch(err => {
+        ScheduleLogger.error('useLocalTimerList getAll error:', err);
+        reject(err);
+      });
+    });
+  }, []);
+  return {
+    isLoading,
+    isSupportLocalTimer,
+    getTimerList
+  };
+};
+
+/**
+ * 更新本地定时开关状态
+ */
+export const useLocalTimerUpdateStatus = isSupportLocalTimer => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    updateStatus
+  } = useLocalTimerCloudProperty();
+  const updateTimerStatus = useCallback((timerId, status) => {
+    return new Promise((resolve, reject) => {
+      setIsLoading(true);
+      const {
+        rtcTimerList = []
+      } = getTimerState();
+      const currentTimer = rtcTimerList.find(i => i.timerId === timerId);
+      if (!currentTimer) {
+        ScheduleLogger.warn(`useLocalTimerUpdateStatus: currentTimer with timerId ${timerId} is undefined`);
+        return;
+      }
+      updateStatus(timerId, status).then(() => {
+        ScheduleLogger.debug('updateTimerStatus success');
+        setIsLoading(false);
+        resolve(true);
+      }).catch(error => {
+        ScheduleLogger.error('updateTimerStatus fail:', error);
+        setIsLoading(false);
+        reject(error);
+      });
+    });
+  }, [updateStatus]);
+  return {
+    isLoading,
+    isSupportLocalTimer,
+    updateTimerStatus
+  };
+};

package/lib/hooks/useTimerReportDp.d.ts

@@ -0,0 +1,15 @@
+import { TTimerReport } from '../types';
+export declare function useTimerReportDp(dpCode?: "timer_report"): {
+    dpValue: TTimerReport[];
+    isSupport: boolean;
+    updateDp: (dps: TTimerReport[]) => void;
+};
+/**
+ *  主动拉取定时 timer_report dp 数据
+ *  由于本地定时数据不会主动上报，所以需要主动拉取用来同步定时数据
+ *  @param timerReport 定时上报 dpCode
+ *  @returns refresh 刷新 dp 数据
+ */
+export declare const useTimerReportDpPull: (timerReport?: "timer_report") => {
+    refresh: () => void;
+};

package/lib/hooks/useTimerReportDp.js

@@ -0,0 +1,48 @@
+/* eslint-disable no-param-reassign */
+import { useMemo } from 'react';
+import { useBaseLightDp, useFetchDpDataByMesh } from './useBaseLightDp';
+import { scheduleDpCodes } from '../config/dpCodes';
+import { scheduleLogger as ScheduleLogger } from '../utils/ScheduleLogger';
+import { timerReportParser } from '../dpParser';
+import { useSupport } from './useCommonSupport';
+
+// sigmesh 本地定时状态 dp
+export function useTimerReportDp() {
+  let dpCode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scheduleDpCodes.TIMER_REPORT;
+  const support = useSupport();
+  const {
+    dpValue,
+    updateDp
+  } = useBaseLightDp(dpCode);
+  const _dpValue = useMemo(() => {
+    if (typeof dpValue === 'string') {
+      return timerReportParser.parser(dpValue);
+    }
+    return dpValue;
+  }, [dpValue, timerReportParser]);
+  const isSupport = support.isSupportDp(scheduleDpCodes.TIMER_REPORT);
+  return {
+    isSupport,
+    dpValue: _dpValue,
+    updateDp: timerReportDp => {
+      updateDp(timerReportParser.formatter(timerReportDp));
+    }
+  };
+}
+
+/**
+ *  主动拉取定时 timer_report dp 数据
+ *  由于本地定时数据不会主动上报，所以需要主动拉取用来同步定时数据
+ *  @param timerReport 定时上报 dpCode
+ *  @returns refresh 刷新 dp 数据
+ */
+export const useTimerReportDpPull = function () {
+  let timerReport = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scheduleDpCodes.TIMER_REPORT;
+  ScheduleLogger.debug('useTimerReportDpPull 执行');
+  const {
+    refresh
+  } = useFetchDpDataByMesh([timerReport]);
+  return {
+    refresh
+  };
+};

package/lib/hooks/useTimerSupport.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @description: 判断是否支持倒计时功能
+ * @param dpCodeList: 倒计时 dpCode 列表 string[]
+ * @return {isReady: boolean, isSupport: boolean}
+ */
+export declare const useSupportLocalTimer: (dpCodeList?: string[]) => {
+    isReady: boolean;
+    isSupport: boolean;
+};
+export declare const useSupportCloudTimer: () => boolean;
+export declare const useTimerSupport: () => {
+    isSupport: boolean;
+};

package/lib/hooks/useTimerSupport.js

@@ -0,0 +1,38 @@
+import { useEffect, useState } from 'react';
+import { scheduleDpCodes } from '../config/dpCodes';
+import { useCommonSupport, useSupport } from './useCommonSupport';
+
+/**
+ * @description: 判断是否支持倒计时功能
+ * @param dpCodeList: 倒计时 dpCode 列表 string[]
+ * @return {isReady: boolean, isSupport: boolean}
+ */
+export const useSupportLocalTimer = function () {
+  let dpCodeList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  const _dpCodeList = [scheduleDpCodes.LOCAL_TIMER, scheduleDpCodes.RTC_TIMER, scheduleDpCodes.STRIP_LOCAL_TIMER];
+  const supportIns = useSupport();
+  const isGroup = !!(supportIns !== null && supportIns !== void 0 && supportIns.isGroupDevice());
+  const support = useCommonSupport(_dpCodeList, dpCodeList);
+  return {
+    isReady: support.isReady,
+    isSupport: support.isSupport && !isGroup
+  };
+};
+export const useSupportCloudTimer = () => {
+  const support = useSupport();
+  const [isSupportCloudTimer, setIsSupportCloudTimer] = useState(false);
+  useEffect(() => {
+    const isSupportCloudTimer = support.isSupportCloudTimer();
+    setIsSupportCloudTimer(isSupportCloudTimer);
+  }, [support]);
+  return isSupportCloudTimer;
+};
+export const useTimerSupport = () => {
+  const {
+    isSupport: isSupportLocalTimer
+  } = useSupportLocalTimer();
+  const isSupportCloudTimer = useSupportCloudTimer();
+  return {
+    isSupport: isSupportLocalTimer || isSupportCloudTimer
+  };
+};