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

package/lib/hooks/useTimerOperate.d.ts

@@ -0,0 +1,68 @@
+import { TTimerDataAdd, TTimerDataUpdate, TRtcTimer } from '../types';
+/**
+ * 添加定时
+ */
+export declare const useTimerAdd: () => {
+    isReady: boolean;
+    isLoading: boolean;
+    addTimer: (timer: TTimerDataAdd) => Promise<unknown>;
+} | {
+    isReady: boolean;
+    isLoading: boolean;
+    addTimer: (timer: TTimerDataAdd, category: string) => Promise<TTimerDataUpdate>;
+};
+export declare const useTimerAddWithFlush: () => {
+    isLoading: boolean;
+    isReady: boolean;
+    addTimerWithFlush: (timer: TTimerDataAdd, category?: string) => Promise<TRtcTimer>;
+};
+/**
+ * 更新定时
+ */
+export declare const useTimerUpdate: () => {
+    isLoading: boolean;
+    isReady: boolean;
+    updateTimer: (timer: TTimerDataUpdate, oldTimerData: TTimerDataUpdate) => Promise<boolean>;
+};
+export declare const useTimerUpdateWithFlush: () => {
+    isLoading: boolean;
+    updateTimerWithFlush: (data: TTimerDataUpdate, oldTimerData: TTimerDataUpdate, cloudTimerCategory: string) => Promise<boolean>;
+};
+/**
+ * 删除定时
+ */
+export declare const useTimerRemove: () => {
+    isLoading: boolean;
+    isReady: boolean;
+    removeTimer: (timerId: string) => Promise<boolean>;
+};
+export declare const useTimerRemoveWithFlush: () => {
+    isLoading: boolean;
+    removeTimerWithFlush: (timerId: string, category: string) => Promise<boolean>;
+};
+/**
+ * 获取定时列表
+ */
+export declare const useTimerList: () => {
+    isReady: boolean;
+    isLoading: boolean;
+    getTimerList: (category?: string | undefined) => Promise<{
+        timers: TTimerDataUpdate[];
+    }>;
+};
+/**
+ *更新定时状态， 开或关
+ */
+export declare const useTimerUpdateStatus: () => {
+    isSupportLocalTimer: true;
+    isLoading: boolean;
+    updateTimerStatus: (timerId: string, status: boolean) => Promise<unknown>;
+} | {
+    isSupportLocalTimer: boolean;
+    isLoading: boolean;
+    updateTimerStatus: (timerId: string, status: boolean) => Promise<boolean>;
+};
+export declare const useTimerUpdateStatusWithFlush: () => {
+    isLoading: boolean;
+    updateStatusTimerWithFlush: (timerId: string, status: boolean, category: string) => Promise<boolean>;
+};

package/lib/hooks/useTimerOperate.js

@@ -0,0 +1,403 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.find.js";
+import "core-js/modules/esnext.iterator.map.js";
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+import { useState } from 'react';
+import { useSupportLocalTimer } from './useTimerSupport';
+import { useCloudTimerAdd, useCloudTimerList, useCloudTimerRemove, useCloudTimerUpdate, useCloudTimerUpdateStatus } from './useTimerOperateCloud';
+import { useLocalTimerAdd, useLocalTimerList, useLocalTimerRemove, useLocalTimerUpdate, useLocalTimerUpdateStatus } from './useTimerOperateLocal';
+import { useTimerDp } from './useTimerDp';
+import { getTimerState } from '../context/timer';
+import { findMinMissingNum } from '../utils/common';
+import { useTimerListFlush } from './useTimeFlush';
+import { scheduleLogger } from '../utils/ScheduleLogger';
+import { CLOUD_TIMER_CATEGORY } from '../constant';
+import { useSupport } from './useCommonSupport';
+
+/**
+ * 添加定时
+ */
+export const useTimerAdd = () => {
+  const support = useSupport();
+  const {
+    isSupport: isSupportLocalTimer,
+    isReady
+  } = useSupportLocalTimer();
+  const {
+    isLoading: isLocalLoading,
+    addTimer: addLocalTimer
+  } = useLocalTimerAdd(isSupportLocalTimer);
+  const {
+    isLoading: isCloudLoading,
+    addTimer: addCloudTimer
+  } = useCloudTimerAdd(isSupportLocalTimer);
+  const {
+    updateDp
+  } = useTimerDp();
+  const isGroup = support.isGroupDevice();
+  if (isSupportLocalTimer && !isGroup) {
+    return {
+      isReady,
+      isLoading: isLocalLoading,
+      addTimer: timer => {
+        return new Promise((resolve, reject) => {
+          addLocalTimer(timer).then(() => {
+            const dpTimer = {
+              status: true,
+              time: timer.time,
+              loops: timer.loops,
+              dps: timer.dps
+            };
+            // 如果未提供 timerId 则生成一个
+            if (!dpTimer.timerId) {
+              const {
+                rtcTimerList = []
+              } = getTimerState();
+              const minTimerId = findMinMissingNum(rtcTimerList.map(i => i.timerId));
+              dpTimer.timerId = `${minTimerId}`;
+            }
+            updateDp(dpTimer);
+            resolve(dpTimer);
+          }).catch(err => {
+            reject(err);
+          });
+        });
+      }
+    };
+  }
+  return {
+    isReady,
+    isLoading: isCloudLoading,
+    addTimer: (timer, category) => {
+      return addCloudTimer(timer, category);
+    }
+  };
+};
+
+// 添加定时并刷新定时列表
+export const useTimerAddWithFlush = () => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    getTimerList
+  } = useTimerList();
+  const {
+    flushTimerList,
+    isReady: isListFlushReady
+  } = useTimerListFlush();
+  const {
+    addTimer,
+    isReady: isAddReady
+  } = useTimerAdd();
+  return {
+    isReady: isAddReady && isListFlushReady,
+    isLoading,
+    addTimerWithFlush: function (timer) {
+      let category = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : CLOUD_TIMER_CATEGORY;
+      return new Promise((resolve, reject) => {
+        setIsLoading(true);
+        let _newTimer = null;
+        addTimer(timer, category).then(newTimer => {
+          _newTimer = newTimer;
+          return getTimerList(category);
+        }).then(res => {
+          res.timers && flushTimerList(res.timers);
+          setIsLoading(false);
+          resolve(_newTimer);
+        }).catch(err => {
+          setIsLoading(false);
+          reject(err);
+        });
+      });
+    }
+  };
+};
+
+/**
+ * 更新定时
+ */
+export const useTimerUpdate = () => {
+  const {
+    isSupport: isSupportLocalTimer,
+    isReady
+  } = useSupportLocalTimer();
+  const {
+    isLoading: isLocalLoading,
+    updateTimer: updateLocalTimer
+  } = useLocalTimerUpdate(isSupportLocalTimer);
+  const {
+    isLoading: isCloudLoading,
+    updateTimer: updateCloudTimer
+  } = useCloudTimerUpdate(isSupportLocalTimer);
+  const {
+    updateDp
+  } = useTimerDp();
+  const support = useSupport();
+  const isGroup = support.isGroupDevice();
+  if (isSupportLocalTimer && !isGroup) {
+    return {
+      isReady,
+      isLoading: isLocalLoading,
+      updateTimer: timer => {
+        return new Promise((resolve, reject) => {
+          updateLocalTimer(timer).then(() => {
+            const timerData = _objectSpread(_objectSpread({}, timer), {}, {
+              time: timer.time
+            });
+            updateDp(timerData);
+            resolve(true);
+          }).catch(err => {
+            reject(err);
+          });
+        });
+      }
+    };
+  }
+  return {
+    isReady,
+    isLoading: isCloudLoading,
+    updateTimer: updateCloudTimer
+  };
+};
+
+// 添加定时并刷新定时列表
+export const useTimerUpdateWithFlush = () => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    getTimerList
+  } = useTimerList();
+  const {
+    flushTimerList
+  } = useTimerListFlush();
+  const {
+    updateTimer
+  } = useTimerUpdate();
+  return {
+    isLoading,
+    updateTimerWithFlush: (timer, oldTimerData, cloudTimerCategory) => {
+      return new Promise((resolve, reject) => {
+        setIsLoading(true);
+        updateTimer(timer, oldTimerData).then(() => {
+          return getTimerList(cloudTimerCategory);
+        }).then(res => {
+          flushTimerList(res.timers);
+          setIsLoading(false);
+          resolve(true);
+        }).catch(err => {
+          setIsLoading(false);
+          reject(err);
+        });
+      });
+    }
+  };
+};
+
+/**
+ * 删除定时
+ */
+export const useTimerRemove = () => {
+  const {
+    isSupport: isSupportLocalTimer,
+    isReady
+  } = useSupportLocalTimer();
+  const {
+    isLoading: isLocalLoading,
+    removeTimer: removeLocalTimer
+  } = useLocalTimerRemove(isSupportLocalTimer);
+  const {
+    isLoading: isCloudLoading,
+    removeTimer: removeCloudTimer
+  } = useCloudTimerRemove(isSupportLocalTimer);
+  const {
+    updateDp
+  } = useTimerDp();
+  const support = useSupport();
+  const isGroup = support.isGroupDevice();
+  if (isSupportLocalTimer && !isGroup) {
+    return {
+      isReady,
+      isLoading: isLocalLoading,
+      removeTimer: timerId => {
+        return new Promise((resolve, reject) => {
+          scheduleLogger.debug('removeLocalTimer', timerId);
+          removeLocalTimer(timerId).then(res => {
+            const {
+              rtcTimerList
+            } = getTimerState();
+            const currentTimer = rtcTimerList.find(i => i.timerId === timerId);
+            const dpData = {
+              timerId: currentTimer.timerId,
+              dps: _objectSpread(_objectSpread({}, currentTimer.dps), {}, {
+                power: false
+              }),
+              loops: '',
+              // 删除时不需要
+              time: currentTimer.time,
+              status: false
+            };
+            updateDp(dpData);
+            resolve(res);
+          }).catch(err => {
+            reject(err);
+          });
+        });
+      }
+    };
+  }
+  return {
+    isReady,
+    isLoading: isCloudLoading,
+    removeTimer: removeCloudTimer
+  };
+};
+
+// 删除定时并重新获取定时列表
+export const useTimerRemoveWithFlush = () => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    removeTimer
+  } = useTimerRemove();
+  const {
+    flushTimerList
+  } = useTimerListFlush();
+  const {
+    getTimerList
+  } = useTimerList();
+  return {
+    isLoading,
+    removeTimerWithFlush: (timerId, category) => {
+      return new Promise((resolve, reject) => {
+        scheduleLogger.debug('removeTimerWithFlush', timerId);
+        setIsLoading(true);
+        removeTimer(timerId).then(() => {
+          return getTimerList(category);
+        }).then(result => {
+          flushTimerList(result.timers);
+          setIsLoading(false);
+          resolve(true);
+        }).catch(error => {
+          setIsLoading(false);
+          reject(error);
+        });
+      });
+    }
+  };
+};
+
+/**
+ * 获取定时列表
+ */
+export const useTimerList = () => {
+  const {
+    isSupport: isSupportLocalTimer,
+    isReady
+  } = useSupportLocalTimer();
+  const {
+    isLoading: isLocalLoading,
+    getTimerList: getLocalTimerList
+  } = useLocalTimerList(isSupportLocalTimer);
+  const {
+    isLoading: isCloudLoading,
+    getTimerList: getCloudTimerList
+  } = useCloudTimerList(isSupportLocalTimer);
+  const support = useSupport();
+  const isGroup = support.isGroupDevice();
+  if (isSupportLocalTimer && !isGroup) {
+    return {
+      isReady,
+      isLoading: isLocalLoading,
+      getTimerList: getLocalTimerList
+    };
+  }
+  return {
+    isReady,
+    isLoading: isCloudLoading,
+    getTimerList: getCloudTimerList
+  };
+};
+
+/**
+ *更新定时状态， 开或关
+ */
+export const useTimerUpdateStatus = () => {
+  const {
+    isSupport: isSupportLocalTimer
+  } = useSupportLocalTimer();
+  const {
+    isLoading: isLocalLoading,
+    updateTimerStatus: updateLocalTimerStatus
+  } = useLocalTimerUpdateStatus(isSupportLocalTimer);
+  const {
+    isLoading: isCloudLoading,
+    updateTimerStatus: updateCloudTimerStatus
+  } = useCloudTimerUpdateStatus(isSupportLocalTimer);
+  const {
+    updateDp
+  } = useTimerDp();
+  const support = useSupport();
+  const isGroup = support.isGroupDevice();
+  if (isSupportLocalTimer && !isGroup) {
+    return {
+      isSupportLocalTimer,
+      isLoading: isLocalLoading,
+      updateTimerStatus: (timerId, status) => {
+        return new Promise((resolve, reject) => {
+          updateLocalTimerStatus(timerId, status).then(res => {
+            const {
+              rtcTimerList = []
+            } = getTimerState();
+            const currentTimer = rtcTimerList.find(item => item.timerId === timerId);
+            const dpTimer = {
+              timerId: `${currentTimer.timerId}`,
+              status,
+              time: currentTimer.time,
+              loops: currentTimer.loops,
+              dps: currentTimer.dps
+            };
+            updateDp(dpTimer);
+            resolve(res);
+          }).catch(err => {
+            reject(err);
+          });
+        });
+      }
+    };
+  }
+  return {
+    isSupportLocalTimer,
+    isLoading: isCloudLoading,
+    updateTimerStatus: updateCloudTimerStatus
+  };
+};
+
+// 更新定时状态并重新获取定时列表
+export const useTimerUpdateStatusWithFlush = () => {
+  const [isLoading, setIsLoading] = useState(false);
+  const {
+    flushTimerList
+  } = useTimerListFlush();
+  const {
+    getTimerList
+  } = useTimerList();
+  const {
+    updateTimerStatus
+  } = useTimerUpdateStatus();
+  return {
+    isLoading,
+    updateStatusTimerWithFlush: (timerId, status, category) => {
+      return new Promise((resolve, reject) => {
+        setIsLoading(true);
+        updateTimerStatus(timerId, status).then(() => {
+          return getTimerList(category);
+        }).then(result => {
+          flushTimerList(result.timers);
+          setIsLoading(false);
+          resolve(true);
+        }).catch(error => {
+          setIsLoading(false);
+          reject(error);
+        });
+      });
+    }
+  };
+};

package/lib/hooks/useTimerOperateCloud.d.ts

@@ -0,0 +1,31 @@
+import { TTimerDataUpdate, TTimerData, TTimerDataAdd } from '../types';
+export declare const useCloudTimerAdd: (isSupportLocalTimer: boolean) => {
+    isLoading: boolean;
+    isSupportLocalTimer: boolean;
+    addTimer: (timer: TTimerDataAdd, category: string) => Promise<TTimerData>;
+};
+export declare const useCloudTimerUpdate: (isSupportLocalTimer: boolean) => {
+    isLoading: boolean;
+    isSupportLocalTimer: boolean;
+    updateTimer: (timer: TTimerDataUpdate) => Promise<boolean>;
+};
+export declare const useCloudTimerRemove: (isSupportLocalTimer: boolean) => {
+    isLoading: boolean;
+    isSupportLocalTimer: boolean;
+    removeTimer: (timerId: string) => Promise<boolean>;
+};
+export declare const useCloudTimerList: (isSupportLocalTimer: boolean) => {
+    isLoading: boolean;
+    isSupportLocalTimer: boolean;
+    getTimerList: (category?: string) => Promise<{
+        timers: TTimerData[];
+    }>;
+};
+/**
+ * 更新定时开关状态
+ */
+export declare const useCloudTimerUpdateStatus: (isSupportLocalTimer: boolean) => {
+    isLoading: boolean;
+    isSupportLocalTimer: boolean;
+    updateTimerStatus: (timerId: string, status: boolean) => Promise<boolean>;
+};