@ray-js/lock-sdk 1.0.0-beta-1

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

@@ -0,0 +1,60 @@
+import { checkRemoteKey } from "../api/lock";
+import config from "../config";
+import dpCodes from "../config/dp-code";
+import { getCurrentUser, getDpValue } from "../state";
+import { isUseNearChannel } from "../utils";
+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 { ProductCommunicationType } from "../constant";
+
+/**
+ * 同步密钥
+ */
+const syncRemoteSerectKey = async () => {
+  const useNear = isUseNearChannel();
+  if (useNear) {
+    try {
+      const isSupportBle = config.communication.includes(ProductCommunicationType.BLUETOOTH);
+      // 双模下
+      if (config.communication.length > 1 && isSupportBle) {
+        // 如果当前的远程解锁密钥设置 为空、或失败、或主动请求获取，则进行同步
+        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)
+        });
+      }
+    } catch (e) {
+      console.warn(e);
+    }
+  }
+};
+export default syncRemoteSerectKey;

package/lib/sync/t0.d.ts

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

package/lib/sync/t0.js

@@ -0,0 +1,33 @@
+/**
+ * 同步 T0 时间
+ */
+
+import { getActiveTime } from "../api";
+import config from "../config";
+import dpCodes from "../config/dp-code";
+import { ProductCommunicationType } from "../constant";
+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 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()
+      });
+    }
+  }
+};
+export default syncT0;

package/lib/sync/temp.d.ts

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

package/lib/sync/temp.js

@@ -0,0 +1,88 @@
+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 { 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");
+  }
+};
+export const autoSyncTemp = () => {
+  if (isUseNearChannel()) {
+    syncTempFirst && syncTemp();
+  }
+};

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

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

package/lib/sync/unlock-mothod.js

@@ -0,0 +1,54 @@
+import { fetchSyncUnlockMethodInfo } from "../api/lock";
+import config from "../config";
+import dpCodes from "../config/dp-code";
+import { getCurrentUser } from "../state";
+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;
+      }
+    });
+  }
+};
+export const autoSyncUnlockMethod = async () => {
+  try {
+    if (syncUnlockMethodFirst) {
+      await syncUnlockMethod();
+    }
+  } catch (e) {
+    // 不处理
+  }
+};

package/lib/temporary.d.ts

@@ -0,0 +1,226 @@
+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<{
+    list: InvalidPasswordItem[];
+    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 {};