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

package/lib/unlock-method.js

@@ -0,0 +1,723 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.map.js";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { bindUnlockMethodToUser, bindUnlockMethodToUserByRecord, checkFreeUnlockMethods, createUnlockMethod, removeUnlockMethod, editUnlockMethod, fetchCreatePasswordSN, fetchFreeUnlockMethods, getUnlockMethodInfo, unbindMemberUnlockMethod } from "./api/lock";
+import { getUserDetail } from "./api/user";
+import config from "./config";
+import dpCodes from "./config/dp-code";
+import { add as addMap, reportAdd as reportAddMap, remove as removeMap, reportRemove as reportRemoveMap } from "./config/dp-map/unlock-method";
+import { add as addBigMap, reportAdd as reportAddBigMap, remove as removeBigMap, reportRemove as reportRemoveBigMap } from "./config/dp-map/unlock-method-big";
+import { validConfigDpMap } from "./config/dp-map/common";
+import { getPermanentSetting, getUnlockMethodTypeByDpCode, getUnlockMethodTypeByType, isAdmin, parallelOnly, sleep } from "./utils";
+import { getError } from "./utils/errors";
+import { publishDps } from "./utils/publishDps";
+import { encrypt } from "./utils/device";
+import emitter from "./utils/event";
+import { DPCHANGE, UNLOCK_METHOD_EVENT } from "./utils/constant";
+import { sendPhoneVerifyCode } from "./api";
+const getAddUnlockError = status => {
+  if (status >= 0 && status <= 10) {
+    return getError(1015 + status);
+  }
+  if (status === 0xfe) {
+    return getError(1026);
+  }
+  return getError(1016);
+};
+
+/**
+ * 获取开锁方式详细信息
+ * @param {number} id 开锁方式 id
+ * @returns
+ */
+export const getUnlockMethodDetail = async id => {
+  var _cloudData$notifyInfo, _cloudData$notifyInfo2, _cloudData$notifyInfo3;
+  const cloudData = await getUnlockMethodInfo({
+    devId: config.devInfo.devId,
+    opModeId: id
+  });
+  const detail = {
+    isBound: cloudData.allocateFlag === 1,
+    phase: cloudData.phase,
+    dpId: Number(cloudData.opmode),
+    isSpecial: cloudData.unlockAttr === 1,
+    unlockName: cloudData.unlockName,
+    userId: cloudData.userId,
+    unlockId: Number(cloudData.opmodeValue),
+    lockUserId: cloudData.lockUserId,
+    id: cloudData.opmodeId,
+    userType: cloudData.userType,
+    notifyInfo: {
+      appSend: !!((_cloudData$notifyInfo = cloudData.notifyInfo) !== null && _cloudData$notifyInfo !== void 0 && _cloudData$notifyInfo.appSend),
+      msgPhone: (_cloudData$notifyInfo2 = cloudData.notifyInfo) === null || _cloudData$notifyInfo2 === void 0 ? void 0 : _cloudData$notifyInfo2.msgPhone,
+      countryCode: (_cloudData$notifyInfo3 = cloudData.notifyInfo) === null || _cloudData$notifyInfo3 === void 0 ? void 0 : _cloudData$notifyInfo3.countryCode
+    }
+  };
+  return detail;
+};
+const getUnlockMethodBase = async (type, userId) => {
+  const {
+    idsByCode,
+    devInfo: {
+      devId
+    },
+    supportBigData,
+    dpSchema
+  } = config;
+  const unlockMethodConfig = getUnlockMethodTypeByType(type);
+  const addDpCode = supportBigData ? dpCodes.unlockMethodCreateW : dpCodes.unlockMethodCreate;
+  const dpId = idsByCode[unlockMethodConfig.code];
+  const [user, sn] = await Promise.all([getUserDetail({
+    devId: devId,
+    userId: userId
+  }), fetchCreatePasswordSN({
+    devId: devId,
+    dpId
+  })]);
+  const {
+    userType,
+    lockUserId,
+    userTimeSet
+  } = user;
+  let validConfig;
+  // 处理时效配置
+  if (userTimeSet) {
+    validConfig = dpUtils.parse(userTimeSet,
+    // @ts-expect-error
+    validConfigDpMap.childMap);
+  } else {
+    validConfig = getPermanentSetting();
+  }
+
+  // 组装开始入录数据
+  const dpData = {
+    type: unlockMethodConfig.id,
+    stage: 0,
+    admin: isAdmin(userType),
+    memberId: lockUserId,
+    unlockId: supportBigData ? 0xffff : 0xff,
+    validConfig,
+    validNum: 0,
+    pwdLength: 0,
+    pwd: [],
+    sn
+  };
+  return {
+    unlockMethodConfig,
+    devId,
+    userType,
+    lockUserId,
+    sn,
+    dpId,
+    addDpCode,
+    addDpMap: supportBigData ? addBigMap : addMap,
+    addDpReportMap: supportBigData ? reportAddBigMap : reportAddMap,
+    dpData
+  };
+};
+const checkSpecial = (isSpecial, params, oldSetting) => {
+  const supportedPhone = checkSpecialSupportPhone();
+  if (isSpecial) {
+    if (!(params !== null && params !== void 0 && params.appSend)) {
+      if (!supportedPhone) {
+        throw getError(1057);
+      } else if (!(params !== null && params !== void 0 && params.msgPhone)) {
+        throw getError(1058);
+      }
+    }
+    if (supportedPhone && params !== null && params !== void 0 && params.msgPhone) {
+      if (!params.countryCode) {
+        throw getError(1056);
+      }
+      if (params.msgPhone !== (oldSetting === null || oldSetting === void 0 ? void 0 : oldSetting.msgPhone) && !params.verifyCode) {
+        throw getError(1055);
+      }
+    }
+  }
+  return {
+    unlockAttr: isSpecial ? 1 : 0,
+    notifyInfo: {
+      appSend: !!(params !== null && params !== void 0 && params.appSend),
+      msgPhone: supportedPhone ? params === null || params === void 0 ? void 0 : params.msgPhone : undefined,
+      countryCode: supportedPhone ? params === null || params === void 0 ? void 0 : params.countryCode : undefined,
+      msgPhoneVerifyCode: supportedPhone ? params === null || params === void 0 ? void 0 : params.verifyCode : undefined
+    }
+  };
+};
+
+/**
+ * 检查是否支持短信通知
+ * @returns 是否支持短信通知
+ */
+export const checkSpecialSupportPhone = () => {
+  return !!config.dpSchema[dpCodes.message];
+};
+
+/**
+ * 添加开锁密码
+ */
+export const addPassword = async params => {
+  // 数据验证
+  if (!params.password) {
+    throw getError(1054);
+  }
+  const specialInfo = checkSpecial(!!params.isSpecial, params.specialInfo);
+  const {
+    lockUserId,
+    dpData,
+    sn,
+    addDpCode,
+    addDpMap,
+    addDpReportMap,
+    devId,
+    dpId,
+    unlockMethodConfig
+  } = await getUnlockMethodBase("password", params.userId);
+  dpData.pwdLength = params.password.length;
+  dpData.pwd = params.password.split("").map(Number);
+  const res = await publishDps({
+    [addDpCode]: dpUtils.format(dpData, addDpMap)
+  }, {
+    checkReport: dpData => {
+      if (typeof dpData[addDpCode] !== "undefined") {
+        const result = dpUtils.parse(dpData[addDpCode], addDpReportMap);
+        console.log("AddPassword checkReport", result);
+        let hasReport = result.type === unlockMethodConfig.id && [0xff, 0xfd].includes(result.stage);
+        // 是否严格模式
+        if (config.strictMode) {
+          hasReport = hasReport && result.memberId === lockUserId && result.sn === sn;
+        }
+        if (hasReport) {
+          if (result.memberId !== lockUserId) {
+            console.warn(`AddPassword: lockUserId mismatch, expected ${lockUserId}, got ${result.memberId}`);
+          }
+          return result;
+        }
+        return false;
+      }
+      console.warn("AddPassword: An invalid value may have been reported");
+      return false;
+    }
+  });
+  if (res.stage === 0xfd) {
+    // 0xfd 表示添加失败
+    throw getAddUnlockError(res.status);
+  }
+
+  // 保存云端数据
+  const aesPwd = await encrypt(devId, params.password);
+
+  // 收到上报成功后，隔 300毫秒再保存云端
+  await sleep(300);
+  return await createUnlockMethod(_objectSpread({
+    devId: devId,
+    userId: params.userId,
+    unlockId: `${dpId}-${res.unlockId}`,
+    unlockName: params.name,
+    unlockDetail: aesPwd
+  }, specialInfo));
+};
+const addUnlockMethodData = {
+  unlockMethodConfig: {},
+  total: 0,
+  dpCode: "",
+  dpMap: {},
+  sn: 0,
+  lockUserId: 0,
+  timeoutId: 0,
+  userId: "",
+  // 云端用户 id
+  unlockDpId: 0
+};
+const handleAddTimeout = () => {
+  clearTimeout(addUnlockMethodData.timeoutId);
+  // @ts-expect-error
+  addUnlockMethodData.timeoutId = setTimeout(() => {
+    emitter.off(DPCHANGE, handleAddReport);
+    // 超时处理
+    emitter.emit(UNLOCK_METHOD_EVENT, {
+      type: addUnlockMethodData.unlockMethodConfig.type,
+      stage: "fail",
+      lockUserId: addUnlockMethodData.lockUserId,
+      error: getError(1002)
+    });
+  }, 15000);
+};
+const handleAddReport = async dps => {
+  if (dps[addUnlockMethodData.dpCode]) {
+    const result = dpUtils.parse(dps[addUnlockMethodData.dpCode], addUnlockMethodData.dpMap);
+    let eventData = null;
+    if (result.type !== addUnlockMethodData.unlockMethodConfig.id) {
+      // 开锁方式类型不匹配或sn（消息uuid）不匹配，忽略此次上报
+      return;
+    }
+    if (config.strictMode) {
+      // 严格模式下，严格匹配协议规则
+      if (result.sn !== addUnlockMethodData.sn || result.memberId !== addUnlockMethodData.lockUserId) {
+        return;
+      }
+    } else {
+      // 非严格模式下，告警不匹配
+      if (result.sn !== addUnlockMethodData.sn) {
+        // sn 不匹配，告警
+        console.warn(`AddUnlockMethod: sn mismatch, expected ${addUnlockMethodData.sn}, got ${result.sn}`);
+      }
+      if (result.memberId !== addUnlockMethodData.lockUserId) {
+        // 成员 id 不匹配，告警
+        console.warn(`AddUnlockMethod: lockUserId mismatch, expected ${addUnlockMethodData.lockUserId}, got ${result.memberId}`);
+      }
+    }
+    const type = addUnlockMethodData.unlockMethodConfig.type;
+    switch (result.stage) {
+      case 0xfc:
+        {
+          // 重新计时
+          handleAddTimeout();
+          // 录入中
+          eventData = {
+            type,
+            stage: "step",
+            lockUserId: result.memberId,
+            step: result.step,
+            total: addUnlockMethodData.total
+          };
+          break;
+        }
+      case 0xfd:
+        {
+          clearMonitoringAddReport();
+          // 录入失败
+          eventData = {
+            stage: "fail",
+            type,
+            lockUserId: result.memberId,
+            error: getAddUnlockError(result.status)
+          };
+          break;
+        }
+      case 0xfe:
+        {
+          clearMonitoringAddReport();
+          if (isCancelAddUnlockMethod) {
+            // 主动取消录入，则不处理
+            isCancelAddUnlockMethod = false;
+            return;
+          }
+          // 取消录入
+          eventData = {
+            stage: "fail",
+            type,
+            lockUserId: result.memberId,
+            error: getAddUnlockError(result.status)
+          };
+          break;
+        }
+      case 0xff:
+        {
+          clearMonitoringAddReport();
+          try {
+            // 收到上报成功后，隔 300毫秒再保存云端
+            await sleep(300);
+            // 直接添加云端接口，确保云端数据与设备侧一致
+            const res = await createUnlockMethod({
+              devId: config.devInfo.devId,
+              userId: addUnlockMethodData.userId,
+              unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+              unlockName: "",
+              unlockAttr: 0
+            });
+            eventData = {
+              stage: "success",
+              type,
+              id: res.opModeId,
+              name: res.unlockName
+            };
+          } catch {
+            eventData = {
+              stage: "fail",
+              type,
+              lockUserId: result.memberId,
+              error: getError(1053)
+            };
+          }
+          break;
+        }
+      default:
+      // 其他状态，则不处理
+    }
+    if (eventData) {
+      if (emitter.hasListener(UNLOCK_METHOD_EVENT)) {
+        emitter.emit(UNLOCK_METHOD_EVENT, eventData);
+      } else {
+        // 由于存在上报录入开始后，紧跟着会上报失败，因此项无监听器时则暂存数据
+        emitter.cache(UNLOCK_METHOD_EVENT, eventData);
+      }
+    }
+  }
+};
+const clearMonitoringAddReport = () => {
+  console.log("clearMonitoringAddReport");
+  clearTimeout(addUnlockMethodData.timeoutId);
+  // 清除监听器
+  emitter.off(DPCHANGE, handleAddReport);
+};
+const monitoringAddReport = option => {
+  // 缓存添加开锁方式的数据
+  Object.assign(addUnlockMethodData, option);
+  // 先移除之前的监听器，确保不会重复添加
+  emitter.clearCache(UNLOCK_METHOD_EVENT);
+  emitter.off(DPCHANGE, handleAddReport);
+  emitter.on(DPCHANGE, handleAddReport);
+  // 超时处理
+  handleAddTimeout();
+};
+export const startAddUnlockMethod = async params => {
+  const {
+    unlockMethodConfig,
+    lockUserId,
+    dpData,
+    sn,
+    addDpCode,
+    addDpMap,
+    addDpReportMap,
+    dpId
+  } = await getUnlockMethodBase(params.type, params.userId);
+  isCancelAddUnlockMethod = false;
+  const res = await publishDps({
+    [addDpCode]: dpUtils.format(dpData, addDpMap)
+  }, {
+    checkReport: dpData => {
+      if (typeof dpData[addDpCode] !== "undefined") {
+        const result = dpUtils.parse(dpData[addDpCode], addDpReportMap);
+        let hasReport = result.type === unlockMethodConfig.id;
+        // 是否严格模式
+        if (config.strictMode) {
+          hasReport = hasReport && result.memberId === lockUserId && result.sn === sn;
+        }
+        if (hasReport) {
+          if (result.memberId !== lockUserId) {
+            console.warn(`StartAddUnlockMethod: lockUserId mismatch, expected ${lockUserId}, got ${result.memberId}`);
+          }
+          // 由于有些锁对sn 的支持不一样，这里不强制 sn 相等
+          if (result.sn !== sn) {
+            console.warn("AddPassword: An invalid sn may have been reported");
+          }
+          return result;
+        }
+        return false;
+      }
+      console.warn("AddPassword: An invalid value may have been reported");
+      return false;
+    }
+  });
+  if (res.stage === 0) {
+    // 触发 dp 上报监听
+    monitoringAddReport({
+      unlockMethodConfig,
+      total: res.total,
+      dpCode: addDpCode,
+      dpMap: addDpReportMap,
+      sn,
+      lockUserId,
+      userId: params.userId,
+      unlockDpId: dpId
+    });
+    return {
+      total: res.total
+    };
+  }
+  if (res.stage === 0xfd) {
+    // 0xfd 表示添加失败
+    throw getAddUnlockError(res.status);
+  }
+  throw getError(1027);
+};
+
+// /**
+//  * 添加开锁方式
+//  * @param {AddUnlockMethodParams} params 入参
+//  * @returns
+//  */
+// export const addUnlockMethod = async (params: AddUnlockMethodParams) => {
+//   const specialInfo = checkSpecial(!!params.isSpecial, params.specialInfo);
+//   const recordDpCode = getUnlockMethodTypeByType(params.type).code;
+
+//   const dpId = config.idsByCode[recordDpCode];
+
+//   return await createUnlockMethod({
+//     devId: config.devInfo.devId,
+//     userId: params.userId,
+//     unlockId: `${dpId}-${params.unlockId}`,
+//     unlockName: params.name,
+//     ...specialInfo,
+//   });
+// };
+
+/**
+ * 更新开锁方式
+ * 仅支持更新开锁方式名称和特殊开锁方式的通知信息
+ * @param {updateUnlockMethodParams} params 入参
+ * @returns
+ */
+export const updateUnlockMethod = async params => {
+  // 获取开锁方式的详细信息
+  const detail = await getUnlockMethodDetail(params.id);
+  // 数据验证
+  const specialInfo = checkSpecial(!!params.isSpecial, params.specialInfo, detail.notifyInfo);
+  return await editUnlockMethod(_objectSpread({
+    devId: config.devInfo.devId,
+    opModeId: params.id,
+    unlockName: params.name
+  }, specialInfo));
+};
+// 标记是否主动取消录入
+let isCancelAddUnlockMethod = false;
+/**
+ * 取消添加开锁方式
+ * @param {CancelAddUnlockMethodParams} params 入参
+ * @returns
+ */
+export const cancelAddUnlockMethod = parallelOnly(async params => {
+  // 获取 dp 数据
+  const {
+    dpData,
+    addDpCode,
+    addDpMap,
+    addDpReportMap,
+    unlockMethodConfig,
+    lockUserId,
+    sn
+  } = await getUnlockMethodBase(params.type, params.userId);
+  dpData.stage = 0xfe; // 设置 stage 为 0xfe，表示取消添加
+  isCancelAddUnlockMethod = true;
+  await publishDps({
+    [addDpCode]: dpUtils.format(dpData, addDpMap)
+  }, {
+    checkReport: dpData => {
+      if (typeof dpData[addDpCode] !== "undefined") {
+        const result = dpUtils.parse(dpData[addDpCode], addDpReportMap);
+        let hasReport = result.type === unlockMethodConfig.id;
+        // 是否严格模式
+        if (config.strictMode) {
+          hasReport = hasReport && result.stage === 0xfe && result.memberId === lockUserId && result.sn === sn;
+        }
+        if (hasReport) {
+          return result;
+        }
+        console.warn("CancelAddUnlockMethod: An invalid value may have been reported");
+      }
+      return false;
+    }
+  });
+  return true;
+});
+
+/**
+ * 删除开锁方式
+ * @param {number} id 开锁方式 id
+ */
+export const deleteUnlockMethod = parallelOnly(async id => {
+  const {
+    lockUserId,
+    unlockId,
+    userType,
+    dpId
+  } = await getUnlockMethodDetail(id);
+  const dpCode = config.codesById[dpId];
+  const unlockMethodConfig = getUnlockMethodTypeByDpCode(dpCode);
+  // 获取对应的 dp
+  const removeDPCode = config.supportBigData ? dpCodes.unlockMethodDelW : dpCodes.unlockMethodDel;
+  if (!config.dpSchema[removeDPCode]) {
+    throw getError(1014);
+  }
+  const dpData = {
+    type: unlockMethodConfig.id,
+    stage: 0,
+    admin: isAdmin(userType),
+    memberId: lockUserId,
+    unlockId,
+    target: 1
+  };
+  const res = await publishDps({
+    [removeDPCode]: dpUtils.format(dpData, config.supportBigData ? removeBigMap : removeMap)
+  }, {
+    checkReport: dpData => {
+      if (typeof dpData[removeDPCode] !== "undefined") {
+        const result = dpUtils.parse(dpData[removeDPCode], config.supportBigData ? reportRemoveBigMap : reportRemoveMap);
+        let hasReport = result.type === unlockMethodConfig.id;
+        // 是否严格模式
+        if (config.strictMode) {
+          hasReport = hasReport && result.stage === 0 && result.memberId === lockUserId && result.unlockId === unlockId;
+        }
+        if (hasReport) {
+          if (result.unlockId !== unlockId) {
+            console.warn(`RemoveUnlockMethod: unlockId mismatch, expected ${unlockId}, got ${result.unlockId}`);
+          }
+          return result;
+        }
+        console.warn("RemoveUnlockMethod: An invalid value may have been reported");
+      }
+      return false;
+    }
+  });
+  if (res.status !== 255 && res.status !== 1) {
+    switch (res.status) {
+      case 2:
+        throw getError(1029);
+      case 0:
+      default:
+        throw getError(1028);
+    }
+  }
+  await removeUnlockMethod({
+    devId: config.devInfo.devId,
+    opmodeId: id
+  });
+});
+
+/**
+ * 检测是否有未绑定的开锁方式
+ * @returns
+ */
+export const checkUnBindUnlockMethods = async () => {
+  const data = await checkFreeUnlockMethods({
+    devId: config.devInfo.devId
+  });
+  // 由于atop 返回的值，双端不一致，这里处理下
+  return data === true || data === 1;
+};
+
+/**
+ * 获取未关联开锁方式列表
+ */
+export const getUnbindUnlockMethods = async () => {
+  const cloudData = await fetchFreeUnlockMethods({
+    devId: config.devInfo.devId
+  });
+
+  // 转化数据
+  const list = cloudData.map(item => {
+    const unlockMethodConfig = getUnlockMethodTypeByDpCode(item.standardDp);
+    return {
+      type: unlockMethodConfig.type,
+      list: item.unlockInfo.map(unlock => {
+        return {
+          unlockId: Number(unlock.unlockId.split("-")[1]),
+          unlockName: unlock.unlockName,
+          id: unlock.opmodeId,
+          unlockSn: unlock.unlockSn,
+          type: unlockMethodConfig.type,
+          dpId: Number(item.opmode),
+          dpCode: item.standardDp
+        };
+      })
+    };
+  });
+  return list;
+};
+
+/**
+ * 绑定未关联开锁方式到用户入参
+ */
+
+/**
+ * 绑定未关联开锁方式到用户
+ * @param params
+ * @returns
+ */
+export const bindUnlockMethod = params => {
+  const unlockIds = params.unlockList.map(item => {
+    const unlockMethodConfig = getUnlockMethodTypeByType(item.type);
+    const dpId = config.idsByCode[unlockMethodConfig.code];
+    return `${dpId}-${item.unlockId}`;
+  });
+  return bindUnlockMethodToUser({
+    devId: config.devInfo.devId,
+    userId: params.userId,
+    unlockIds: unlockIds
+  });
+};
+
+/**
+ * 解绑用户的开锁方式
+ * @param {number} id 开锁方式 id
+ * @returns
+ */
+export const unbindUnlockMethod = async id => {
+  const detail = await getUnlockMethodDetail(id);
+  if (!detail.isBound) {
+    throw getError(1050);
+  }
+  return unbindMemberUnlockMethod({
+    devId: config.devInfo.devId,
+    userId: detail.userId,
+    unlockIds: [`${detail.dpId}-${detail.unlockId}`]
+  });
+};
+/**
+ * 绑定开门记录中未关联开锁方式到用户
+ * @param {UnbindUnlockMethodParams} params
+ * @returns
+ */
+export const bindUnlockMethodFromLog = params => {
+  const {
+    idsByCode
+  } = config;
+  const unlockIds = params.unlockList.map(item => {
+    const unlockMethodConfig = getUnlockMethodTypeByType(item.type);
+    const dpId = idsByCode[unlockMethodConfig.code];
+    return `${dpId}-${item.unlockId}`;
+  });
+  return bindUnlockMethodToUserByRecord({
+    devId: config.devInfo.devId,
+    userId: params.userId,
+    unlockIds: unlockIds
+  });
+};
+/**
+ *
+ * @param params
+ * @returns
+ */
+export const sendVerifyCode = params => {
+  return sendPhoneVerifyCode(_objectSpread(_objectSpread({}, params), {}, {
+    devId: config.devInfo.devId
+  }));
+};
+
+/**
+ * 添加开锁方式步骤事件类型
+ */
+
+/**
+ * 添加开锁方式成员事件类型
+ */
+
+/**
+ * 添加开锁方式错误事件类型
+ */
+
+/**
+ * 添加开锁方式监听器事件类型
+ */
+
+/**
+ * 添加开锁方式步骤监听器类型
+ */
+
+/**
+ * 注册开锁方式步骤监听器
+ * @param {AddUnlockMethodListener} listener 监听器
+ */
+export const onAddUnlockMethod = listener => {
+  emitter.on(UNLOCK_METHOD_EVENT, listener);
+};
+
+/**
+ * 注销开锁方式步骤监听器
+ * @param {AddUnlockMethodListener} listener 监听器
+ */
+export const offAddUnlockMethod = listener => {
+  emitter.off(UNLOCK_METHOD_EVENT, listener);
+};