@ray-js/lock-sdk 1.1.0 → 1.1.1-beta.10

package/lib/state.js

@@ -1,4 +1,4 @@
-import config, { hasCapability } from "./config";
+import config, { hasCapability, hasDp } from "./config";
 import { onDpDataChange, onDeviceInfoUpdated, offDeviceInfoUpdated, offDpDataChange, registerDevice, getDeviceOnlineType, onOnlineChange, offOnlineChange, onBleChange, offBleChange, registerBleStatus, getDeviceInfo, onMqttMessage, registerMQTTDeviceListener, registerMQTTProtocolListener, offMqttMessage, onAppShow, onAppHide, } from "./utils/device";
 import { getDeviceProperties } from "./api/setting";
 import { parseCapabilities } from "./parse";
@@ -38,87 +38,75 @@ const updateOnlineType = async () => {
     updateDeviceStatus();
 };
 export const getDeviceStatus = () => {
-    const { onlineType, dpSchema, communication, capabilities, devInfo: { isCloudOnline, isOnline, wifiEnableState }, } = config;
+    const { onlineType, devInfo: { isCloudOnline, isOnline, wifiEnableState }, } = config;
     const status = {
         type: isOnline ? "online" : "offline",
         connectEnable: false,
         onlineType: "unknown",
+        onlineTypes: [],
         isWifiActive: wifiEnableState !== 1,
     };
-    const isBleOnline = !isCloudOnline && isOnlineByType(onlineType, 2);
+    const isBleOnline = isOnlineByType(onlineType, 2);
     const isLocalOnline = !isCloudOnline && isOnlineByType(onlineType, 1);
     const supportWifi = hasCapability(ProductCommunicationType.WIFI);
     const supportBle = hasCapability(ProductCommunicationType.BLUETOOTH);
     const supportThread = hasCapability(ProductCommunicationType.THREAD);
-    const hasWirelessAwakeDp = !!dpSchema[dpCodes.wirelessAwake];
+    const hasWirelessAwakeDp = hasDp(dpCodes.wirelessAwake);
     const wirelessAwake = getDpValue(dpCodes.wirelessAwake);
-    const isDeviceOnline = hasWirelessAwakeDp
-        ? wirelessAwake && isCloudOnline
-        : isCloudOnline;
     status.connectEnable = isSupportBleControl() && !isOnline;
     if (supportWifi) {
         if (!status.connectEnable) {
-            status.connectEnable =
-                hasWirelessAwakeDp && wirelessAwake === false && !isBleOnline;
-        }
-    }
-    switch (communication.length) {
-        case 1: {
-            if (supportWifi) {
-                if (isDeviceOnline) {
-                    status.type = "online";
-                    status.onlineType = "cloud";
-                }
-                if (isSleep()) {
-                    status.type = "sleep";
-                }
+            if (isCloudOnline) {
+                status.connectEnable =
+                    hasWirelessAwakeDp && wirelessAwake === false && !isBleOnline;
             }
-            else if (supportBle) {
-                status.connectEnable = true;
-                if (isOnline) {
-                    status.type = "online";
-                    status.onlineType = "ble";
-                }
-            }
-            break;
         }
-        case 2: {
-            if (supportWifi && supportBle) {
-                if (!isDeviceOnline) {
-                    if (isBleOnline) {
-                        status.type = "online";
-                        status.onlineType = "ble";
-                        break;
-                    }
-                }
-                else {
-                    status.type = "online";
-                    status.onlineType = "cloud";
-                }
-                if (isSleep()) {
-                    status.type = "sleep";
-                }
-                break;
-            }
-            if (supportThread && supportBle) {
-                const isShareThread = isShareThead();
-                if (isLocalOnline || (isShareThread && isOnline)) {
-                    status.type = "online";
-                    status.onlineType = "local";
-                }
-                else if (isCloudOnline) {
-                    status.type = "online";
-                    status.onlineType = "cloud";
-                }
-                else if (isBleOnline) {
-                    status.type = "online";
-                    status.onlineType = "ble";
+    }
+    if (isOnline) {
+        if (isCloudOnline) {
+            if (hasWirelessAwakeDp) {
+                if (wirelessAwake) {
+                    status.onlineTypes.push("cloud");
                 }
                 else {
                     status.type = "offline";
                 }
             }
-            break;
+            else {
+                status.onlineTypes.push("cloud");
+            }
+        }
+        else if (isLocalOnline) {
+            status.onlineTypes.push("local");
+        }
+        if (isBleOnline) {
+            status.onlineTypes.push("ble");
+        }
+    }
+    if (status.onlineTypes.length === 0 && isOnline) {
+        status.onlineTypes.push("unknown");
+    }
+    if (supportThread && supportBle) {
+        const isShareThread = isShareThead();
+        if (isShareThread && isOnline) {
+            status.onlineTypes = ["local"];
+        }
+    }
+    if (status.onlineTypes.includes("ble")) {
+        status.onlineType = "ble";
+    }
+    else if (status.onlineTypes.includes("cloud")) {
+        status.onlineType = "cloud";
+    }
+    else if (status.onlineTypes.includes("local")) {
+        status.onlineType = "local";
+    }
+    else {
+        status.onlineType = "unknown";
+    }
+    if (!isOnline) {
+        if (isSleep()) {
+            status.type = "sleep";
         }
     }
     if (status.type === "sleep") {
@@ -211,24 +199,29 @@ export const permissions = [
     "everyOne",
     "noOne",
 ];
+var DeviceProperties;
+(function (DeviceProperties) {
+    DeviceProperties["REMOTE_UNLOCK_AUTH"] = "REMOTE_UNLOCK_AUTH";
+    DeviceProperties["UNLOCK_PHONE_REMOTE"] = "UNLOCK_PHONE_REMOTE";
+})(DeviceProperties || (DeviceProperties = {}));
+const propsList = [
+    DeviceProperties.REMOTE_UNLOCK_AUTH,
+    DeviceProperties.UNLOCK_PHONE_REMOTE,
+];
 const fetchDeviceProperties = async (isForce) => {
     let result = null;
     if (isForce) {
-        result = await getDeviceProperties(config.devInfo.devId, [
-            "REMOTE_UNLOCK_AUTH",
-            "UNLOCK_PHONE_REMOTE",
-        ]);
+        result = await getDeviceProperties(config.devInfo.devId, propsList);
     }
     else {
         result = await getDataWithPreFetch("getDeviceProperties", () => {
-            return getDeviceProperties(config.devInfo.devId, [
-                "REMOTE_UNLOCK_AUTH",
-                "UNLOCK_PHONE_REMOTE",
-            ]);
+            return getDeviceProperties(config.devInfo.devId, propsList);
         });
     }
-    config.remoteOpenEnabled = result["UNLOCK_PHONE_REMOTE"] === "true";
-    config.remoteOpenPermission = permissions[+result["REMOTE_UNLOCK_AUTH"] || 0];
+    config.remoteOpenEnabled =
+        result[DeviceProperties.UNLOCK_PHONE_REMOTE] === "true";
+    config.remoteOpenPermission =
+        permissions[+result[DeviceProperties.REMOTE_UNLOCK_AUTH] || 0];
 };
 export const initState = async () => {
     const { devInfo: { dps, devId }, dpSchema, } = config;
@@ -247,8 +240,7 @@ export const initState = async () => {
     ]);
     config.imageAngle = rotateInfo.angle;
     config.videoAngle = rotateInfo.actualAngle;
-    fetchDeviceProperties().catch(() => {
-    });
+    fetchDeviceProperties();
     getDeviceAdvancedAbilities();
     syncRemoteSerectKey();
     setTimeout(() => {

package/lib/sync/temp.js

@@ -69,7 +69,7 @@ export const syncTemp = async () => {
         });
     }
     catch (e) {
-        console.log(e, "sync temp password error");
+        console.warn(e, "sync temp password error");
     }
 };
 export const autoSyncTemp = () => {

package/lib/sync/user.js

@@ -1,44 +1,8 @@
 import { getDeviceStatus } from "../state";
 import { ProductCommunicationType } from "../constant";
 import config, { hasCapability } from "../config";
-import { getUsersSyncLockData, removeUser } from "../api/user";
-import dpCodes from "../config/dp-code";
-import dpUtils from "@ray-js/tuya-dp-transform";
-import { remove as removeBigMap, reportRemove as reportRemoveBigMap, } from "../config/dp-map/unlock-method-big";
-import { remove as removeMap, reportRemove as reportRemoveMap, } from "../config/dp-map/unlock-method";
-import { publishDps } from "../utils/publishDps";
-const deleteUser = async (data) => {
-    const { admin, lockUserId, userId } = data;
-    const dpCode = config.supportBigData
-        ? dpCodes.unlockMethodDelW
-        : dpCodes.unlockMethodDel;
-    const dpData = {
-        type: 0,
-        stage: 0,
-        admin: !!admin,
-        memberId: lockUserId,
-        unlockId: config.supportBigData ? 0xffff : 0xff,
-        category: 0,
-    };
-    await publishDps({
-        [dpCode]: dpUtils.format(dpData, (config.supportBigData ? removeBigMap : removeMap)),
-    }, {
-        checkReport: (dps) => {
-            if (dps[dpCode]) {
-                const dpValue = dpUtils.parse(dps[dpCode], (config.supportBigData
-                    ? reportRemoveBigMap
-                    : reportRemoveMap));
-                if (dpValue.type === 0 &&
-                    dpValue.status == 255 &&
-                    dpValue.memberId === lockUserId) {
-                    return true;
-                }
-            }
-            return false;
-        },
-    });
-    await removeUser(config.devInfo.devId, userId);
-};
+import { getUsersSyncLockData } from "../api/user";
+import { deleteUser } from "../utils/user";
 let isSyncDone = false;
 const syncDeleteUsers = async () => {
     const deviceStatus = getDeviceStatus();

package/lib/temporary.d.ts

@@ -7,8 +7,9 @@ interface CreateCustomParams {
 export declare const createTempCustom: (params: CreateCustomParams) => Promise<TempPasswordResult>;
 interface RemoveCustomProps {
     unlockBindingId: string;
+    sn: number;
 }
-export declare const removeTempCustom: (params: RemoveCustomProps) => Promise<unknown>;
+export declare const removeTempCustom: (params: RemoveCustomProps) => Promise<true | undefined>;
 interface UpdateTempPasswordParams {
     unlockBindingId: string;
     name: string;

package/lib/temporary.js

@@ -4,25 +4,41 @@ import { formatWeek, isUseNearChannel, parallelOnly, parseOfflinePassword, parse
 import { LoopTypes } from "./utils/constant";
 import { encrypt } from "./utils/device";
 import { getError } from "./utils/errors";
-import { addTempPwd as addTempPwdDpMap, reportAddTempPwd as reportAddTempPwdDpMap, } from "./config/dp-map/unlock-method";
-import { addTempPwd as addTempPwdBigDpMap, reportAddTempPwd as reportAddTempPwdDBigpMap, } from "./config/dp-map/unlock-method-big";
+import { addTempPwd as addTempPwdDpMap, reportAddTempPwd as reportAddTempPwdDpMap, removeTempPwd as removeTempPwdDpMap, reportRemoveTempPwd as reportRemoveTempPwdDpMap, } from "./config/dp-map/unlock-method";
+import { addTempPwd as addTempPwdBigDpMap, reportAddTempPwd as reportAddTempPwdDBigpMap, removeTempPwd as removeTempPwdBigDpMap, reportRemoveTempPwd as reportRemoveTempPwdBigDpMap, } from "./config/dp-map/unlock-method-big";
 import { publishDps } from "./utils/publishDps";
 import dpCodes from "./config/dp-code";
 import dpUtils from "@ray-js/tuya-dp-transform";
 const PASSWORD_REGEX = /^[0-9]+$/;
-const handleError = (cloudError) => {
-    switch (cloudError.errorCode) {
-        case "USER_PWD_ALREADY_EXIST":
-            throw getError(1037);
-        case "LOCK_PWD_NAME_REPEAT":
-            throw getError(1038);
-        case "START_END_DATE_NOT_RIGHT":
-            throw getError(1039);
-        case "RECORD_NOT_EXIST":
-            throw getError(1040);
-        default:
-            throw cloudError;
+const handleError = (err) => {
+    if (err?.innerError?.errorCode) {
+        let error;
+        switch (err.innerError.errorCode) {
+            case "USER_PWD_ALREADY_EXIST":
+                error = getError(1037);
+                break;
+            case "LOCK_PWD_NAME_REPEAT":
+            case "OFFLINE_PWD_NAME_REPEAT":
+                error = getError(1038);
+                break;
+            case "START_END_DATE_NOT_RIGHT":
+                error = getError(1039);
+                break;
+            case "RECORD_NOT_EXIST":
+                error = getError(1040);
+                break;
+            case "OFFLINE_PWD_EXAUST_IN_PERIOD":
+                error = getError(1067);
+                break;
+            default:
+        }
+        if (error) {
+            error.errorMsg = err.innerError.errorMsg;
+            error.innerError = err.innerError;
+            throw error;
+        }
     }
+    throw err;
 };
 const isValidPassword = async (params) => {
     const validateResult = await validateTempPwd(params);
@@ -83,7 +99,7 @@ export const createTempCustom = parallelOnly(async (params) => {
                 endTime: effective.expiredDate,
                 loop: loopType,
                 loopConfig: 0,
-                weeks: effective.weeks ?? [0, 0, 0, 0, 0, 0, 0],
+                weeks: effective.weeks ? effective.weeks : [0, 0, 0, 0, 0, 0, 0],
                 days: [],
                 startHour: Math.floor(effectiveTime / 60),
                 startMinute: effectiveTime % 60,
@@ -150,12 +166,40 @@ export const createTempCustom = parallelOnly(async (params) => {
 });
 export const removeTempCustom = async (params) => {
     try {
-        return deleteTempPassword({
+        await deleteTempPassword({
             devId: config.devInfo.devId,
             unlockBindingId: params.unlockBindingId,
             symbolic: false,
             dpTunnel: 2,
         });
+        if (isUseNearChannel()) {
+            const dpCode = config.supportBigData
+                ? dpCodes.tempPwdDelW
+                : dpCodes.tempPwdDel;
+            const dpData = {
+                unlockId: params.sn,
+            };
+            const result = await publishDps({
+                [dpCode]: dpUtils.format(dpData, (config.supportBigData
+                    ? removeTempPwdBigDpMap
+                    : removeTempPwdDpMap)),
+            }, {
+                checkReport: (dpData) => {
+                    const reportData = dpData[dpCode];
+                    if (reportData) {
+                        const data = dpUtils.parse(reportData, (config.supportBigData
+                            ? reportRemoveTempPwdBigDpMap
+                            : reportRemoveTempPwdDpMap));
+                        return data;
+                    }
+                    return false;
+                },
+            });
+            if (result.status === 0) {
+                return true;
+            }
+            throw getError(1065);
+        }
     }
     catch (e) {
         handleError(e);

package/lib/unlock-method.d.ts

@@ -1,6 +1,7 @@
-import { ErrorData, UnBindUnlockMethodGroup, UnlockMethodDetail, UnlockMethodType } from "./interface";
+import { ErrorData, UnBindUnlockMethodGroup, UnlockGuide, UnlockMethodDetail, UnlockMethodType } from "./interface";
 export interface SpecialUnlockMethodInfo {
     appSend?: boolean;
+    msgSend?: boolean;
     msgPhone?: string;
     verifyCode?: string;
     countryCode?: string;
@@ -85,4 +86,5 @@ export type AddUnlockMethodEvent = StepEvent | SuccessEvent | ErrorEvent;
 export type AddUnlockMethodListener = (event: AddUnlockMethodEvent) => void;
 export declare const onAddUnlockMethod: (listener: AddUnlockMethodListener) => void;
 export declare const offAddUnlockMethod: (listener: AddUnlockMethodListener) => void;
+export declare const getUnlockGuide: (type: UnlockMethodType) => Promise<UnlockGuide | null>;
 export {};

package/lib/unlock-method.js

@@ -12,8 +12,9 @@ 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";
+import { getFileRemoteUrl, sendPhoneVerifyCode } from "./api";
 import { getUserInfo } from "./user";
+import { getDeviceAdvancedAbilities } from "./capability";
 const getAddUnlockError = (status) => {
     if (status >= 0 && status <= 10) {
         return getError(1015 + status);
@@ -30,6 +31,7 @@ export const getUnlockMethodDetail = async (id) => {
     });
     const detail = {
         isBound: cloudData.allocateFlag === 1,
+        type: getUnlockMethodTypeByDpCode(config.codesById[Number(cloudData.opmode)])?.type,
         phase: cloudData.phase,
         dpId: Number(cloudData.opmode),
         isSpecial: cloudData.unlockAttr === 1,
@@ -41,6 +43,7 @@ export const getUnlockMethodDetail = async (id) => {
         userType: cloudData.userType,
         notifyInfo: {
             appSend: !!cloudData.notifyInfo?.appSend,
+            msgSend: !!cloudData.notifyInfo?.msgPhone,
             msgPhone: cloudData.notifyInfo?.msgPhone,
             countryCode: cloudData.notifyInfo?.countryCode,
         },
@@ -48,7 +51,7 @@ export const getUnlockMethodDetail = async (id) => {
     return detail;
 };
 const getUnlockMethodBase = async (type, userId) => {
-    const { idsByCode, devInfo: { devId }, supportBigData, dpSchema, } = config;
+    const { idsByCode, devInfo: { devId }, supportBigData, } = config;
     const unlockMethodConfig = getUnlockMethodTypeByType(type);
     const addDpCode = supportBigData
         ? dpCodes.unlockMethodCreateW
@@ -104,11 +107,14 @@ const checkSpecial = (isSpecial, params, oldSetting) => {
             if (!supportedPhone) {
                 throw getError(1057);
             }
-            else if (!params?.msgPhone) {
+            else if (!params?.msgSend) {
                 throw getError(1058);
             }
         }
-        if (supportedPhone && params?.msgPhone) {
+        if (supportedPhone && params?.msgSend) {
+            if (!params.msgPhone) {
+                throw getError(1066);
+            }
             if (!params.countryCode) {
                 throw getError(1056);
             }
@@ -121,9 +127,9 @@ const checkSpecial = (isSpecial, params, oldSetting) => {
         unlockAttr: isSpecial ? 1 : 0,
         notifyInfo: {
             appSend: !!params?.appSend,
-            msgPhone: supportedPhone ? params?.msgPhone : undefined,
-            countryCode: supportedPhone ? params?.countryCode : undefined,
-            msgPhoneVerifyCode: supportedPhone ? params?.verifyCode : undefined,
+            msgPhone: supportedPhone && params?.msgSend ? params?.msgPhone : undefined,
+            countryCode: supportedPhone && params?.msgSend ? params?.countryCode : undefined,
+            msgPhoneVerifyCode: supportedPhone && params?.msgSend ? params?.verifyCode : undefined,
         },
     };
 };
@@ -560,3 +566,49 @@ export const onAddUnlockMethod = (listener) => {
 export const offAddUnlockMethod = (listener) => {
     emitter.off(UNLOCK_METHOD_EVENT, listener);
 };
+const guileTypeMap = {
+    card: ["addCard", "addCardPic"],
+    finger: ["addFingerprint", "addFingerprintPic"],
+    face: ["addFace", "addFacePic"],
+    fingerVein: ["addFingervein", "addFingerveinPic"],
+    hand: ["addPalmvein", "addPalmveinPic"],
+    eye: ["addIris", "addIrisPic"],
+};
+export const getUnlockGuide = async (type) => {
+    if (type === "password") {
+        return null;
+    }
+    const { unlockGuide } = await getDeviceAdvancedAbilities();
+    if (unlockGuide.support) {
+        const [videoKey, picKey] = guileTypeMap[type] || ["", ""];
+        const resources = [];
+        let videoUrlPath = "";
+        let picUrlPath = "";
+        if (unlockGuide.config[picKey]) {
+            picUrlPath = unlockGuide.config[picKey].url;
+            resources.push({
+                objectKey: picUrlPath,
+            });
+        }
+        if (unlockGuide.config[videoKey]) {
+            videoUrlPath = unlockGuide.config[videoKey].url;
+            resources.push({
+                objectKey: videoUrlPath,
+            });
+        }
+        if (resources.length === 0) {
+            return null;
+        }
+        const { signedUrls } = await getFileRemoteUrl({
+            biz: "hulk_video_tutorial_video",
+            resources,
+        });
+        const expireTime = Date.now() + 30 * 60 * 1000;
+        return {
+            videoUrl: signedUrls[videoUrlPath],
+            picUrl: signedUrls[picUrlPath],
+            expireTime,
+        };
+    }
+    return null;
+};

package/lib/user.d.ts

@@ -1,4 +1,4 @@
-import { EffectiveConfig, UserInfo } from "./interface";
+import { EffectiveConfig, UnlockMethodBaseInfo, UserInfo } from "./interface";
 interface getUsersParams {
     page?: number;
     pageSize?: number;
@@ -11,7 +11,27 @@ export declare const getUsers: (params?: getUsersParams) => Promise<{
 interface getUserInfoParams {
     userId: string;
 }
-export declare const getUserInfo: (params: getUserInfoParams) => Promise<UserInfo>;
+export declare const getUserInfo: (params: getUserInfoParams) => Promise<{
+    timeScheduleInfo: any;
+    unlockDetails: {
+        count: number;
+        dpCode: string;
+        dpId: number;
+        type: import("./interface").UnlockMethodType;
+        unlockList: UnlockMethodBaseInfo[];
+    }[];
+    isAccountUser: boolean;
+    userId: string;
+    lockUserId: number;
+    avatarUrl: string;
+    backHomeNotifyAttr: number;
+    effectiveFlag: number;
+    nickName: string;
+    offlineUnlock: boolean;
+    userContact: string;
+    userType: 10 | 20 | 30 | 40 | 50;
+    userListType: "panel_user" | "group_user";
+}>;
 interface updateUserLimitTimeParams {
     userId: string;
     lockUserId: number;