@ray-js/lock-sdk 1.0.1 → 1.0.2

package/lib/sync/remote-serect-key.js

@@ -7,57 +7,41 @@ import { stringToBytes } from "../utils/byte";
 import { decrypt } from "../utils/device";
 import { publishDpsOnly } from "../utils/publishDps";
 import dpUtils from "@ray-js/tuya-dp-transform";
-import { reportSetKey as reportSetKeyMap, setKey as setKeyMap } from "../config/dp-map/open";
+import { reportSetKey as reportSetKeyMap, setKey as setKeyMap, } from "../config/dp-map/open";
 import { ProductCommunicationType } from "../constant";
-
-/**
- * 同步密钥
- * @param force 是否强制同步
- */
-const syncRemoteSerectKey = async force => {
-  const useNear = isUseNearChannel();
-  if (useNear) {
-    try {
-      const isSupportBle = config.communication.includes(ProductCommunicationType.BLUETOOTH);
-      // 双模下
-      if (config.communication.length > 1 && isSupportBle) {
-        if (!force) {
-          // 如果当前的远程解锁密钥设置 为空、或失败、或主动请求获取，则进行同步
-          const keyValue = getDpValue(dpCodes.remoteNoPdSetkey);
-          if (keyValue) {
-            const keyData = dpUtils.parse(getDpValue(dpCodes.remoteNoPdSetkey), reportSetKeyMap);
-            // 已成功同步，则不进行同步
-            if (keyData.status === 0) {
-              return;
+const syncRemoteSerectKey = async (force) => {
+    const useNear = isUseNearChannel();
+    if (useNear) {
+        try {
+            const isSupportBle = config.communication.includes(ProductCommunicationType.BLUETOOTH);
+            if (config.communication.length > 1 && isSupportBle) {
+                if (!force) {
+                    const keyValue = getDpValue(dpCodes.remoteNoPdSetkey);
+                    if (keyValue) {
+                        const keyData = dpUtils.parse(getDpValue(dpCodes.remoteNoPdSetkey), reportSetKeyMap);
+                        if (keyData.status === 0) {
+                            return;
+                        }
+                    }
+                }
+                const { lockUserId, userId } = await getCurrentUser();
+                const { password, invalidTime, effectiveTime } = await checkRemoteKey(config.devInfo.devId);
+                const pw = await decrypt(config.devInfo.devId, password);
+                publishDpsOnly({
+                    [dpCodes.remoteNoPdSetkey]: dpUtils.format({
+                        valid: true,
+                        memberId: lockUserId !== 0 ? lockUserId : userId,
+                        startTime: effectiveTime,
+                        endTime: invalidTime,
+                        validNum: 100,
+                        key: stringToBytes(pw),
+                    }, setKeyMap),
+                });
             }
-          }
         }
-        const {
-          lockUserId,
-          userId
-        } = await getCurrentUser();
-        // 如果为开启，并在蓝牙下的，则同步密钥
-        const {
-          password,
-          invalidTime,
-          effectiveTime
-        } = await checkRemoteKey(config.devInfo.devId);
-        const pw = await decrypt(config.devInfo.devId, password);
-        // 如为开启时，同步密钥
-        publishDpsOnly({
-          [dpCodes.remoteNoPdSetkey]: dpUtils.format({
-            valid: true,
-            memberId: lockUserId !== 0 ? lockUserId : userId,
-            startTime: effectiveTime,
-            endTime: invalidTime,
-            validNum: 100,
-            key: stringToBytes(pw)
-          }, setKeyMap)
-        });
-      }
-    } catch (e) {
-      console.warn(e);
+        catch (e) {
+            console.warn(e);
+        }
     }
-  }
 };
-export default syncRemoteSerectKey;
+export default syncRemoteSerectKey;

package/lib/sync/t0.d.ts

@@ -1,5 +1,2 @@
-/**
- * 同步 T0 时间
- */
 declare const syncT0: () => Promise<void>;
 export default syncT0;

package/lib/sync/t0.js

@@ -1,7 +1,3 @@
-/**
- * 同步 T0 时间
- */
-
 import { getActiveTime } from "../api";
 import config from "../config";
 import dpCodes from "../config/dp-code";
@@ -10,24 +6,21 @@ import { isUseNearChannel } from "../utils";
 import { publishDpsOnly } from "../utils/publishDps";
 let hasSysncT0 = false;
 const isNeedSync = () => {
-  const near = isUseNearChannel();
-  return near || config.devInfo.isOnline && config.communication.includes(ProductCommunicationType.THREAD);
+    const near = isUseNearChannel();
+    return (near ||
+        (config.devInfo.isOnline &&
+            config.communication.includes(ProductCommunicationType.THREAD)));
 };
 const syncT0 = async () => {
-  // 如果已经同步过 T0 时间，则不再重复同步
-  if (hasSysncT0) {
-    return;
-  }
-  // dp 存在，并且设备满足近场通道要求或为 matter 设备时
-  if (config.dpSchema[dpCodes.passwordOfflineTime]) {
-    if (isNeedSync()) {
-      hasSysncT0 = true;
-      const time = await getActiveTime(config.devInfo.devId);
-      // 下发 T0 时间
-      publishDpsOnly({
-        [dpCodes.passwordOfflineTime]: time.toString()
-      });
+    if (hasSysncT0) {
+        return;
+    }
+    if (config.dpSchema[dpCodes.passwordOfflineTime]) {
+        if (isNeedSync()) {
+            hasSysncT0 = true;
+            const time = await getActiveTime(config.devInfo.devId);
+            publishDpsOnly({ [dpCodes.passwordOfflineTime]: time.toString() });
+        }
     }
-  }
 };
-export default syncT0;
+export default syncT0;

package/lib/sync/temp.d.ts

@@ -1,7 +1,2 @@
-/**
- * 同步临时密码
- * 仅在近场通讯时使用
- * @returns
- */
 export declare const syncTemp: () => Promise<void>;
 export declare const autoSyncTemp: () => void;

package/lib/sync/temp.js

@@ -1,88 +1,79 @@
-import "core-js/modules/esnext.iterator.constructor.js";
-import "core-js/modules/esnext.iterator.for-each.js";
-import "core-js/modules/esnext.iterator.map.js";
 import { getSyncTempPasswords } from "../api/temp";
 import config from "../config";
 import dpCodes from "../config/dp-code";
-import { addTempPwd as addTempPwdDpMap, removeTempPwd as removeTempPwdDpMap } from "../config/dp-map/unlock-method";
-import { addTempPwd as addTempPwdBigDpMap, removeTempPwd as removeTempPwdBigDpMap } from "../config/dp-map/unlock-method-big";
+import { addTempPwd as addTempPwdDpMap, removeTempPwd as removeTempPwdDpMap, } from "../config/dp-map/unlock-method";
+import { addTempPwd as addTempPwdBigDpMap, removeTempPwd as removeTempPwdBigDpMap, } from "../config/dp-map/unlock-method-big";
 import { isUseNearChannel, parseWeek } from "../utils";
 import { decrypt } from "../utils/device";
 import { publishDps } from "../utils/publishDps";
 import dpUtils from "@ray-js/tuya-dp-transform";
-
-// 标记是否有同步过，如果同步过，则 SDK 不在主动同步
 let syncTempFirst = true;
-/**
- * 同步临时密码
- * 仅在近场通讯时使用
- * @returns
- */
 export const syncTemp = async () => {
-  try {
-    syncTempFirst = false;
-    const {
-      pwdList
-    } = await getSyncTempPasswords({
-      devId: config.devInfo.devId,
-      isUpt: false
-    });
-    const delDpCode = config.supportBigData ? dpCodes.tempPwdDelW : dpCodes.tempPwdDel;
-    const delDpMap = config.supportBigData ? removeTempPwdBigDpMap : removeTempPwdDpMap;
-    const addDpCode = config.supportBigData ? dpCodes.tempPwdCreateW : dpCodes.tempPwdCreate;
-    const addDpMap = config.supportBigData ? addTempPwdBigDpMap : addTempPwdDpMap;
-    pwdList === null || pwdList === void 0 || pwdList.forEach(async syncItem => {
-      try {
-        // 删除
-        if ((syncItem === null || syncItem === void 0 ? void 0 : syncItem.opt) === 4) {
-          publishDps({
-            [delDpCode]: dpUtils.format({
-              unlockId: syncItem === null || syncItem === void 0 ? void 0 : syncItem.sn
-            }, delDpMap)
-          });
-        }
-        // 添加
-        if ((syncItem === null || syncItem === void 0 ? void 0 : syncItem.opt) === 5) {
-          const {
-            allDay,
-            invalidTime,
-            effectiveTime,
-            workingDay
-          } = syncItem.scheduleList[0];
-          const pwd = await decrypt(config.devInfo.devId, syncItem.password);
-          const pswData = pwd.split("").map(item => Number(item));
-          publishDps({
-            [addDpCode]: dpUtils.format({
-              cloudNo: syncItem.tyNum,
-              valid: true,
-              validConfig: {
-                startTime: syncItem.effectiveTime,
-                endTime: syncItem.invalidTime,
-                loop: allDay ? 0x00 : 0x01,
-                loopConfig: 0,
-                weeks: parseWeek(workingDay),
-                days: 0,
-                startHour: Math.floor(effectiveTime / 60),
-                startMinute: effectiveTime % 60,
-                endHour: Math.floor(invalidTime / 60),
-                endMinute: invalidTime % 60
-              },
-              validNum: 0,
-              pwdLength: pswData.length,
-              pwd: pswData
-            }, addDpMap)
-          });
-        }
-      } catch (e) {
-        console.warn("sync temp password error", e);
-      }
-    });
-  } catch (e) {
-    console.log(e, "sync temp password error");
-  }
+    try {
+        syncTempFirst = false;
+        const { pwdList } = await getSyncTempPasswords({
+            devId: config.devInfo.devId,
+            isUpt: false,
+        });
+        const delDpCode = config.supportBigData
+            ? dpCodes.tempPwdDelW
+            : dpCodes.tempPwdDel;
+        const delDpMap = config.supportBigData
+            ? removeTempPwdBigDpMap
+            : removeTempPwdDpMap;
+        const addDpCode = config.supportBigData
+            ? dpCodes.tempPwdCreateW
+            : dpCodes.tempPwdCreate;
+        const addDpMap = config.supportBigData
+            ? addTempPwdBigDpMap
+            : addTempPwdDpMap;
+        pwdList?.forEach(async (syncItem) => {
+            try {
+                if (syncItem?.opt === 4) {
+                    publishDps({
+                        [delDpCode]: dpUtils.format({
+                            unlockId: syncItem?.sn,
+                        }, delDpMap),
+                    });
+                }
+                if (syncItem?.opt === 5) {
+                    const { allDay, invalidTime, effectiveTime, workingDay } = syncItem.scheduleList[0];
+                    const pwd = await decrypt(config.devInfo.devId, syncItem.password);
+                    const pswData = pwd.split("").map((item) => Number(item));
+                    publishDps({
+                        [addDpCode]: dpUtils.format({
+                            cloudNo: syncItem.tyNum,
+                            valid: true,
+                            validConfig: {
+                                startTime: syncItem.effectiveTime,
+                                endTime: syncItem.invalidTime,
+                                loop: allDay ? 0x00 : 0x01,
+                                loopConfig: 0,
+                                weeks: parseWeek(workingDay),
+                                days: 0,
+                                startHour: Math.floor(effectiveTime / 60),
+                                startMinute: effectiveTime % 60,
+                                endHour: Math.floor(invalidTime / 60),
+                                endMinute: invalidTime % 60,
+                            },
+                            validNum: 0,
+                            pwdLength: pswData.length,
+                            pwd: pswData,
+                        }, addDpMap),
+                    });
+                }
+            }
+            catch (e) {
+                console.warn("sync temp password error", e);
+            }
+        });
+    }
+    catch (e) {
+        console.log(e, "sync temp password error");
+    }
 };
 export const autoSyncTemp = () => {
-  if (isUseNearChannel()) {
-    syncTempFirst && syncTemp();
-  }
-};
+    if (isUseNearChannel()) {
+        syncTempFirst && syncTemp();
+    }
+};

package/lib/sync/unlock-mothod.d.ts

@@ -1,5 +1,2 @@
-/**
- * 同步开锁方式
- */
 export declare const syncUnlockMethod: () => Promise<void>;
 export declare const autoSyncUnlockMethod: () => Promise<void>;

package/lib/sync/unlock-mothod.js

@@ -6,49 +6,37 @@ import { publishDps } from "../utils/publishDps";
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { reportSync as reportSyncMap } from "../config/dp-map/unlock-method";
 import { reportSync as reportSyncBigMap } from "../config/dp-map/unlock-method-big";
-
-// 标记是否有同步过，如果同步过，则 SDK 不在主动同步
 let syncUnlockMethodFirst = true;
-
-/**
- * 同步开锁方式
- */
 export const syncUnlockMethod = async () => {
-  syncUnlockMethodFirst = false;
-  const {
-    allOpenDps = ""
-  } = await getCurrentUser();
-  const {
-    ins = "",
-    distributed = false
-  } = await fetchSyncUnlockMethodInfo({
-    devId: config.devInfo.devId,
-    dpIds: allOpenDps.split(",")
-  });
-  if (ins && distributed) {
-    const dpCode = config.supportBigData ? dpCodes.synchMethodW : dpCodes.synchMethod;
-    // 下发同步dp
-    await publishDps({
-      [dpCode]: ins
-    }, {
-      checkReport: dpData => {
-        if (typeof dpData[dpCode] !== "undefined") {
-          const result = dpUtils.parse(dpData[dpCode], config.supportBigData ? reportSyncBigMap : reportSyncMap);
-          if (result.stage === 1) {
-            return true;
-          }
-        }
-        return false;
-      }
+    syncUnlockMethodFirst = false;
+    const { allOpenDps = "" } = await getCurrentUser();
+    const { ins = "", distributed = false } = await fetchSyncUnlockMethodInfo({
+        devId: config.devInfo.devId,
+        dpIds: allOpenDps.split(","),
     });
-  }
+    if (ins && distributed) {
+        const dpCode = config.supportBigData
+            ? dpCodes.synchMethodW
+            : dpCodes.synchMethod;
+        await publishDps({ [dpCode]: ins }, {
+            checkReport: (dpData) => {
+                if (typeof dpData[dpCode] !== "undefined") {
+                    const result = dpUtils.parse(dpData[dpCode], config.supportBigData ? reportSyncBigMap : reportSyncMap);
+                    if (result.stage === 1) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+        });
+    }
 };
 export const autoSyncUnlockMethod = async () => {
-  try {
-    if (syncUnlockMethodFirst) {
-      await syncUnlockMethod();
+    try {
+        if (syncUnlockMethodFirst) {
+            await syncUnlockMethod();
+        }
     }
-  } catch (e) {
-    // 不处理
-  }
-};
+    catch (e) {
+    }
+};

package/lib/temporary.d.ts

@@ -1,193 +1,61 @@
 import { EffectiveConfig, TemporaryPasswordType, TempPasswordResult } from "./interface";
 interface CreateCustomParams {
-    /**
-     * 密码内容，必须是数字
-     */
     password: string;
-    /**
-     * 密码名称，长度不能超过20个字符
-     */
     name?: string;
-    /**
-     * 密码时效配置
-     */
     effective: EffectiveConfig;
 }
-/**
- * 创建自定义临时密码
- * @param {CreateCustomParams} params - 创建临时密码的参数
- * @returns {Promise<boolean>} - 返回创建结果
- * @throws {ErrorData} - 如果创建失败，将抛出错误
- */
 export declare const createTempCustom: (params: CreateCustomParams) => Promise<TempPasswordResult>;
 interface RemoveCustomProps {
     unlockBindingId: string;
 }
-/**
- * 删除自定义密码
- * @param {RemoveCustomProps} params
- * @returns
- */
 export declare const removeTempCustom: (params: RemoveCustomProps) => Promise<unknown>;
 interface UpdateTempPasswordParams {
-    /**
-     * 密码 id
-     */
     unlockBindingId: string;
-    /**
-     * 密码名称，长度不能超过20个字符
-     */
     name: string;
-    /**
-     * 密码时效配置
-     */
     effective: EffectiveConfig;
 }
-/**
- * 更新自定义临时密码
- * 注意，当前只支持更新名称和时效配置，且只支持走云端更新。
- * @param {UpdateTempPasswordParams} params 更新临时密码的参数
- * @returns {Promise<void>} - 返回更新结果
- * @throws {ErrorData} - 如果更新失败，将抛出错误
- */
 export declare const updateTempCustom: (params: UpdateTempPasswordParams) => Promise<boolean | undefined>;
 interface CreateLimitParams {
-    /**
-     * 密码名称，长度不能超过20个字符
-     */
     name: string;
-    /**
-     * 密码生效开始时间，单位为秒
-     */
     effectiveTime: number;
-    /**
-     * 密码生效结束时间，单位为秒
-     */
     invalidTime: number;
 }
-/**
- * 创建临时限时密码
- */
 export declare const createTempLimit: (params: CreateLimitParams) => Promise<TempPasswordResult>;
 interface CreateOnceParams {
-    /**
-     * 密码名称，长度不能超过20个字符
-     */
     name?: string;
 }
-/**
- * 创建一次性密码
- * @param {CreateOnceParams} params - 创建一次性密码的参数
- * @returns {Promise<OfflinePwdResult>} - 返回创建结果
- * @throws {ErrorData} - 如果创建失败，将抛出错误
- */
 export declare const createTempOnce: (params: CreateOnceParams) => Promise<TempPasswordResult>;
-/**
- * 创建动态密码
- */
 export declare const createTempDynamic: () => Promise<TempPasswordResult>;
 interface CreateClearParams {
     name?: string;
     unlockBindingId?: string;
     clearAll: boolean;
 }
-/**
- * 生成清除密码
- * 可支持清除所有或某个限时密码
- * @param {CreateClearParams} params
- * @returns {Promise<OfflinePwdResult>} - 返回清除密码结果
- * @throws {ErrorData} - 如果生成清除密码失败，将抛出错误
- */
 export declare const createTempClear: (params: CreateClearParams) => Promise<TempPasswordResult>;
-/**
- * 临时密码的状态
- * effective - 生效
- * toBeEffective - 待生效
- * expired - 已失效
- * frozen - 冻结
- * freezing - 冻结中
- * synchronizing - 同步中
- * synchronized - 已同步
- * deleted - 已删除
- * toBeDeleted - 待删除
- * synchronizationFailed - 同步失败
- */
 type ValidPasswordStatus = "effective" | "toBeEffective" | "frozen" | "freezing" | "synchronizing" | "toBeDeleted";
-/**
- *密码的无效原因
- * synchronizationFailed - 同步失败
- * passwordFull - 密码已满
- * deleted - 已删除
- */
 type InvalidReason = "synchronizationFailed" | "passwordFull" | "deleted";
 interface PasswrodBaseInfo {
-    /**
-     * 解锁绑定 ID
-     */
     unlockBindingId: string;
-    /**
-     * 生效配置
-     */
     effectiveConfig: EffectiveConfig;
-    /**
-     * 密码名称
-     */
     name: string;
-    /**
-     * 密码类型
-     * "custom" - 自定义密码
-     * "once" - 一次性密码
-     * "limit" - 限时密码
-     * "clear" - 清除密码
-     * "clearOne" - 清除单个密码
-     */
     type: TemporaryPasswordType;
-    /**
-     * 密码 sn
-     */
     sn: number;
-    /**
-     * 当前密码是否被标记被清除
-     */
     hasClearPwd: boolean;
-    /**
-     * 清除单个密码的信息
-     * 密码类型为 "clearOne" 时有效
-     */
     clearInfo?: {
-        /**
-         * 单个密码名称
-         */
         name: string;
-        /**
-         * 单个密码生效配置
-         */
         effectiveConfig: EffectiveConfig;
     };
 }
 export interface EffectivePasswrodItem extends PasswrodBaseInfo {
-    /**
-     * 密码状态
-     */
     status: ValidPasswordStatus;
 }
-/**
- * 获取有效的临时密码列表
- */
 export declare const getTempEffectiveList: () => Promise<EffectivePasswrodItem[]>;
 export interface InvalidPasswordItem extends PasswrodBaseInfo {
     status: "expired";
     invalidReason: InvalidReason;
 }
 interface GetInvalidListParams {
-    /**
-     * 分页
-     */
     page?: number;
-    /**
-     * 每页记录数
-     * 默认值为 200
-     */
     pageSize?: number;
 }
 export declare const getTempInvalidList: (params?: GetInvalidListParams) => Promise<{
@@ -195,32 +63,15 @@ export declare const getTempInvalidList: (params?: GetInvalidListParams) => Prom
     hasMore: boolean;
     total: number;
 }>;
-/**
- * 清空无效的临时密码列表
- */
 export declare const clearTempInvalidList: () => Promise<boolean>;
 interface FreezeParams {
     unlockBindingId: string;
 }
-/**
- * 冻结临时密码
- * @param params
- * @returns
- */
 export declare const freezeTemp: (params: FreezeParams) => Promise<boolean>;
-/**
- * 解冻临时密码
- * @param params
- * @returns
- */
 export declare const unfreezeTemp: (params: FreezeParams) => Promise<boolean>;
 interface RenameParams {
     unlockBindingId: string;
     name: string;
 }
-/**
- * 重命名密码名称
- * @param {RenameParams} params
- */
 export declare const renameTemp: (params: RenameParams) => Promise<void>;
 export {};