@ray-js/lock-sdk 1.1.1-beta.2 → 1.1.1-beta.20

package/lib/open/ble-remote-no-dp-key.js

@@ -0,0 +1,69 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { getDoorKey } from "../api/lock";
+import config, { hasDp } from "../config";
+import dpCodes from "../config/dp-code";
+import { open as openMap, reportOpen as reportOpenMap, } from "../config/dp-map/open";
+import { getCurrentUser } from "../state";
+import syncRemoteSerectKey from "../sync/remote-serect-key";
+import { stringToBytes } from "../utils/byte";
+import { decrypt } from "../utils/device";
+import { publishDps } from "../utils/publishDps";
+import { mapRemoteOpenReportStatus } from "./report-status";
+export const createRemoteNoDpKeyBleCheckReport = (memberId) => {
+    return (dpData) => {
+        if (hasDp(dpCodes.lockMotorState)) {
+            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                return {
+                    status: 0,
+                };
+            }
+        }
+        if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
+            const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
+            if (result.memberId === memberId) {
+                if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
+                    return false;
+                }
+                return result;
+            }
+            else {
+                console.warn("An incorrect member id was returned");
+            }
+        }
+        return false;
+    };
+};
+export const executeBleRemoteNoDpKeyAction = async (isOpen, timeout, memberId) => {
+    await syncRemoteSerectKey();
+    let pw = "";
+    try {
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    catch {
+        await syncRemoteSerectKey(true);
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    const response = (await publishDps({
+        [dpCodes.remoteNoDpKey]: dpUtils.format({
+            status: Number(isOpen),
+            memberId,
+            key: stringToBytes(pw),
+            type: 3,
+        }, openMap),
+    }, {
+        timeout,
+        checkReport: createRemoteNoDpKeyBleCheckReport(memberId),
+    }));
+    if (response.status !== 0) {
+        throw mapRemoteOpenReportStatus(response.status);
+    }
+};
+export const getOpenDoorMemberId = async () => {
+    const currentUser = await getCurrentUser();
+    if (currentUser.lockUserId !== 0) {
+        return Number(currentUser.lockUserId);
+    }
+    return Number(currentUser.userId);
+};

package/lib/open/report-status.d.ts

@@ -0,0 +1 @@
+export declare const mapRemoteOpenReportStatus: (status: number) => import("..").ErrorData;

package/lib/open/report-status.js

@@ -0,0 +1,23 @@
+import { getError } from "../utils/errors";
+export const mapRemoteOpenReportStatus = (status) => {
+    let error = getError(1004);
+    switch (status) {
+        case 0x02:
+            error = getError(1005);
+            break;
+        case 0x03:
+            error = getError(1006);
+            break;
+        case 0x04:
+            error = getError(1007);
+            break;
+        case 0x05:
+            error = getError(1008);
+            break;
+        case 0x06:
+            error = getError(1070);
+            break;
+        default:
+    }
+    return error;
+};

package/lib/open.js

@@ -42,18 +42,18 @@ export const checkRemoteEnabled = parallelMerge(async () => {
     if (deviceStatus.type !== "online") {
         throw getError(1001);
     }
-    if (deviceStatus.onlineType === "local") {
-        if (!hasThread) {
-            throw getError(1064);
-        }
+    const isLocalOnline = deviceStatus.onlineTypes.length === 1 &&
+        deviceStatus.onlineTypes.includes("local");
+    const isThreadLocalOnline = hasThread && isLocalOnline;
+    if (isThreadLocalOnline || deviceStatus.onlineTypes.includes("ble")) {
+        return;
+    }
+    if (isLocalOnline) {
+        throw getError(1064);
     }
     if (dpSchema[dpCodes.remoteNoDpKey] === undefined) {
         throw getError(1045);
     }
-    if ((hasThread && deviceStatus.onlineType === "local") ||
-        deviceStatus.onlineType === "ble") {
-        return;
-    }
     if (!remoteOpenEnabled) {
         throw getError(1046);
     }
@@ -65,7 +65,7 @@ export const checkRemoteEnabled = parallelMerge(async () => {
     }
 });
 const _doAction = async (isOpen, timeout) => {
-    const { devInfo, onlineType, capabilities, communication, dpSchema } = config;
+    const { devInfo, communication } = config;
     await checkRemoteEnabled();
     const deviceStatus = getDeviceStatus();
     const hasThread = hasCapability(ProductCommunicationType.THREAD);
@@ -94,7 +94,7 @@ const _doAction = async (isOpen, timeout) => {
         }
         return false;
     };
-    if (hasThread && deviceStatus.onlineType === "local") {
+    if (hasThread && deviceStatus.onlineTypes.includes("local") && deviceStatus.onlineTypes.length === 1) {
         await publishDps({ [dpCodes.matterLanUnlock]: isOpen }, {
             checkReport: (dps) => {
                 return typeof dps[dpCodes.matterLanUnlock] !== "undefined";

package/lib/other.d.ts

@@ -27,4 +27,5 @@ export declare const connectDevice: () => Promise<unknown>;
 export declare const gotoService: (params?: {
     tab?: "cloudStorage" | "AI";
 }) => Promise<unknown>;
+export declare const validatePwdComplexity: (password: string) => Promise<boolean>;
 export {};

package/lib/other.js

@@ -3,13 +3,14 @@ import config, { hasCapability, hasDp } from "./config";
 import dpCodes from "./config/dp-code";
 import { ProductCommunicationType } from "./constant";
 import { getDeviceStatus, getDpValue } from "./state";
-import { connectBLEDevice, getBLEOnlineState, navigateToMiniProgram, offBleChange, offOnlineChange, onBleChange, onOnlineChange, openPanel, } from "./utils/device";
+import { connectBLEDevice, encrypt, getBLEOnlineState, navigateToMiniProgram, offBleChange, offOnlineChange, onBleChange, onOnlineChange, openPanel, } from "./utils/device";
 import { getError } from "./utils/errors";
 import { publishDps } from "./utils/publishDps";
 import ipc from "./utils/ipc";
 import { DPCHANGE } from "./utils/constant";
 import emitter from "./utils/event";
 import { getOfflineDpCache, publishOfflineDps } from "./offline-dps";
+import { validatePasswordComplexity } from "./api/lock";
 const { alarmLock, unlockFingerprint, unlockPassword, unlockCard, unlockKey, unlockPhoneRemote, unlockTemporary, unlockDynamic, unlockFace, unlockHand, unlockEye, unlockFingerVein, unlockInside, doorOpened, unlockApp, unlockOfflinePd, openInside, lockRecord, unlockDoubleKit, lockLocalRecord, wirelessAwake, } = dpCodes;
 const abilityMap = {
     backHome: "supportBackHome",
@@ -259,7 +260,7 @@ export const connectDevice = async () => {
         }
     }
     if (isSupportBleControl()) {
-        if (deviceStatus.type === "online" && deviceStatus.onlineType === "ble") {
+        if (deviceStatus.type === "online" && deviceStatus.onlineTypes.includes("ble")) {
             return true;
         }
         return await connectBle();
@@ -281,3 +282,10 @@ export const gotoService = async (params) => {
         });
     });
 };
+export const validatePwdComplexity = async (password) => {
+    const encryptedPassword = await encrypt(config.devInfo.devId, password);
+    return validatePasswordComplexity({
+        devId: config.devInfo.devId,
+        password: encryptedPassword,
+    });
+};

package/lib/state.js

@@ -38,7 +38,7 @@ 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,
@@ -46,7 +46,7 @@ export const getDeviceStatus = () => {
         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);
@@ -199,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;
@@ -238,12 +243,14 @@ export const initState = async () => {
     fetchDeviceProperties();
     getDeviceAdvancedAbilities();
     syncRemoteSerectKey();
+    checkOfflineDpUpdate({}, true).then(() => {
+        setTimeout(() => {
+            syncOfflineDps();
+        }, 3000);
+    });
     setTimeout(() => {
         syncT0();
         autoSyncUnlockMethod();
-        checkOfflineDpUpdate({}, true).then(() => {
-            syncOfflineDps();
-        });
     }, 2000);
     setTimeout(() => {
         autoSyncTemp();
@@ -290,6 +297,9 @@ const handleAppShow = () => {
     getCurrentUser(true);
     fetchDeviceProperties();
     checkOfflineDpUpdate({}, true);
+    setTimeout(() => {
+        syncDeleteUsers();
+    }, 1000);
 };
 const handleAppHide = () => { };
 export const addEvents = () => {

package/lib/sync/offline-dps.js

@@ -12,12 +12,7 @@ export const syncOfflineDps = async () => {
                 if (Object.keys(offlineDps).length) {
                     const hasTask = Object.keys(offlineDps).some((code) => offlineDps[code].pushStatus === false);
                     if (hasTask) {
-                        try {
-                            await clearOfflineDpData(config.devInfo.devId);
-                        }
-                        catch (error) {
-                            return;
-                        }
+                        clearOfflineDpData(config.devInfo.devId);
                         const dpData = Object.keys(offlineDps).reduce((acc, code) => {
                             acc[code] = offlineDps[code].value;
                             return acc;

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/unlock-method.js

@@ -18,25 +18,25 @@ export const syncUnlockMethod = async () => {
         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;
+        try {
+            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;
-            },
-        });
+                    return false;
+                },
+            });
+        }
+        catch (error) {
+        }
     }
 };
 export const autoSyncUnlockMethod = async () => {
-    try {
-        if (syncUnlockMethodFirst) {
-            await syncUnlockMethod();
-        }
-    }
-    catch (e) {
+    if (syncUnlockMethodFirst) {
+        await syncUnlockMethod();
     }
 };

package/lib/sync/user.js

@@ -1,40 +1,39 @@
 import { getDeviceStatus } from "../state";
-import { ProductCommunicationType } from "../constant";
-import config, { hasCapability } from "../config";
+import config from "../config";
 import { getUsersSyncLockData } from "../api/user";
 import { deleteUser } from "../utils/user";
-let isSyncDone = false;
+import { isUseNearChannel } from "../utils";
+let isSyncing = false;
 const syncDeleteUsers = async () => {
     const deviceStatus = getDeviceStatus();
     if (deviceStatus.isWifiActive) {
         return;
     }
-    const hasThread = hasCapability(ProductCommunicationType.THREAD);
-    if (hasThread &&
-        (deviceStatus.onlineType === "local" || deviceStatus.onlineType === "cloud")) {
+    if (!isUseNearChannel()) {
         return;
     }
-    if (isSyncDone)
+    if (isSyncing)
         return;
-    if (deviceStatus.type === "online" && deviceStatus.onlineType === "ble") {
-        isSyncDone = true;
-        let count = 0;
-        const handleSync = async () => {
-            try {
-                const { removedUser = [] } = await getUsersSyncLockData(config.devInfo.devId);
-                await Promise.all(removedUser.map((item) => deleteUser(item).catch(() => { })));
-                isSyncDone = false;
+    isSyncing = true;
+    let count = 0;
+    const handleSync = async () => {
+        try {
+            const { removedUser = [] } = await getUsersSyncLockData(config.devInfo.devId);
+            await Promise.all(removedUser.map((item) => deleteUser(item).catch(() => { })));
+            isSyncing = false;
+        }
+        catch (e) {
+            if (e?.innerError?.errorCode === "DEVICE_KEY_NOT_FOUND" && count < 3) {
+                count++;
+                setTimeout(async () => {
+                    await handleSync();
+                }, 2000);
             }
-            catch (e) {
-                if (e?.innerError?.errorCode === "DEVICE_KEY_NOT_FOUND" && count < 3) {
-                    count++;
-                    setTimeout(async () => {
-                        await handleSync();
-                    }, 2000);
-                }
+            else {
+                isSyncing = false;
             }
-        };
-        handleSync();
-    }
+        }
+    };
+    handleSync();
 };
 export default syncDeleteUsers;

package/lib/temporary.js

@@ -3,31 +3,17 @@ import config from "./config";
 import { formatWeek, isUseNearChannel, parallelOnly, parseOfflinePassword, parseWeek, validateEffectiveConfig, } from "./utils";
 import { LoopTypes } from "./utils/constant";
 import { encrypt } from "./utils/device";
-import { getError } from "./utils/errors";
+import { getError, handleCloudError } from "./utils/errors";
 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 isValidPassword = async (params) => {
     const validateResult = await validateTempPwd(params);
     if (!validateResult.valid) {
-        handleError(validateResult);
+        handleCloudError(validateResult);
     }
     return true;
 };
@@ -83,7 +69,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,
@@ -144,7 +130,7 @@ export const createTempCustom = parallelOnly(async (params) => {
             };
         }
         catch (error) {
-            throw handleError(error?.innerError ?? error);
+            throw handleCloudError(error);
         }
     }
 });
@@ -186,7 +172,7 @@ export const removeTempCustom = async (params) => {
         }
     }
     catch (e) {
-        handleError(e?.innerError ?? e);
+        handleCloudError(e);
     }
 };
 export const updateTempCustom = async (params) => {
@@ -220,19 +206,15 @@ export const updateTempCustom = async (params) => {
         });
     }
     catch (error) {
-        handleError(error?.innerError ?? error);
+        handleCloudError(error);
     }
 };
 const getOfflinePassword = async (params) => {
     try {
-        const res = await createOfflinePassword(params);
-        return {
-            ...res,
-            pwd: parseOfflinePassword(res.pwd),
-        };
+        return await createOfflinePassword(params);
     }
     catch (error) {
-        throw handleError(error?.innerError ?? error);
+        throw handleCloudError(error);
     }
 };
 export const createTempLimit = async (params) => {
@@ -500,7 +482,7 @@ const changePasswordPhase = async (unlockBindingId, phase) => {
         });
     }
     catch (e) {
-        handleError(e?.innerError ?? e);
+        handleCloudError(e);
     }
     return true;
 };
@@ -536,7 +518,7 @@ export const renameTemp = async (params) => {
         }
     }
     catch (e) {
-        handleError(e);
+        handleCloudError(e);
     }
 };
 export const saveTempOnlineUnlimited = async (params) => {
@@ -582,7 +564,7 @@ export const saveTempOnlineUnlimited = async (params) => {
         };
     }
     catch (error) {
-        throw handleError(error?.innerError ?? error);
+        throw handleCloudError(error);
     }
 };
 export const createTempOffline = async (params) => {
@@ -640,7 +622,7 @@ export const removeTempOnlineUnlimited = async (id) => {
         });
     }
     catch (error) {
-        throw handleError(error?.innerError ?? error);
+        throw handleCloudError(error);
     }
 };
 const onLinePasswordStatusMap = {
@@ -674,7 +656,7 @@ export const getTempOnlineUnlimitedList = async () => {
         return newPswList;
     }
     catch (error) {
-        throw handleError(error?.innerError ?? error);
+        throw handleCloudError(error);
     }
 };
 const offlinePasswordTypeMap = {
@@ -693,7 +675,7 @@ export const getTempOfflineEffectiveList = async (pwdTypeCode) => {
         return offLineValidPswList;
     }
     catch (error) {
-        throw handleError(error?.innerError ?? error);
+        throw handleCloudError(error);
     }
 };
 export const getTempOfflineInvalidList = async (pwdTypeCode) => {
@@ -706,6 +688,6 @@ export const getTempOfflineInvalidList = async (pwdTypeCode) => {
         return offLineFailurePswList;
     }
     catch (error) {
-        throw handleError(error?.innerError ?? error);
+        throw handleCloudError(error);
     }
 };

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 {};