@ray-js/lock-sdk 1.1.1-beta.9 → 1.1.1

package/lib/api/user.d.ts

@@ -82,26 +82,6 @@ export declare const getUserList: (params: getUserListParams) => Promise<{
     user: UserListItem[];
     hasNext: boolean;
 }>;
-interface GetUserDetailParams {
-    devId: string;
-    userId: string;
-}
-interface UserDetail {
-    allOpenType: number[];
-    avatarUrl: string;
-    lockUserId: number;
-    nickName: string;
-    phase: number;
-    productAttribute: number;
-    status: number;
-    supportOpenType: number[];
-    uid: string;
-    userContact: string;
-    userId: string;
-    userTimeSet: string;
-    userType: number;
-}
-export declare const getUserDetail: (params: GetUserDetailParams) => Promise<UserDetail>;
 interface GetUserDetailQueryParams {
     devId: string;
     userId: string;

package/lib/api/user.js

@@ -38,13 +38,6 @@ export const getUserList = (params) => {
         data: params,
     });
 };
-export const getUserDetail = (params) => {
-    return requestApi({
-        api: "m.lock.device.member.detail",
-        version: "1.0",
-        data: params,
-    });
-};
 export const getUserDetailQuery = (params) => {
     return requestApi({
         api: "m.lock.user.detail.query",
@@ -55,7 +48,7 @@ export const getUserDetailQuery = (params) => {
 export const getUsersSyncLockData = (deviceId) => {
     return requestApi({
         api: `${THING}.m.device.lock.sync.batch`,
-        version: "2.0",
+        version: "1.0",
         data: {
             devId: deviceId,
         },
@@ -64,7 +57,7 @@ export const getUsersSyncLockData = (deviceId) => {
 export const removeUser = (devId, userId) => {
     return requestApi({
         api: `${THING}.m.device.member.remove`,
-        version: "2.0",
+        version: "1.0",
         data: {
             devId,
             userId,

package/lib/capability.js

@@ -8,7 +8,7 @@ export const isActiveThread = async () => {
     const hasThread = hasCapability(ProductCommunicationType.THREAD);
     if (hasThread) {
         const deviceStatus = getDeviceStatus();
-        if (deviceStatus.onlineType === "cloud" ||
+        if (deviceStatus.onlineTypes.includes("cloud") ||
             config.communication.length === 1) {
             return true;
         }

package/lib/config/dp-map/unlock-method-big.js

@@ -89,7 +89,7 @@ const reportAdd = [
 const remove = [
     ...common,
     {
-        name: "category",
+        name: "operation",
     },
 ];
 const reportRemove = [

package/lib/config/dp-map/unlock-method.d.ts

@@ -161,7 +161,7 @@ declare const remove: readonly [{
 }, {
     readonly name: "unlockId";
 }, {
-    readonly name: "target";
+    readonly name: "operation";
 }];
 declare const reportRemove: ({
     readonly name: "type";
@@ -176,7 +176,7 @@ declare const reportRemove: ({
 } | {
     readonly name: "unlockId";
 } | {
-    readonly name: "target";
+    readonly name: "operation";
 } | {
     name: string;
 })[];
@@ -649,7 +649,7 @@ declare const _default: {
     }, {
         readonly name: "unlockId";
     }, {
-        readonly name: "target";
+        readonly name: "operation";
     }];
     reportRemove: ({
         readonly name: "type";
@@ -664,7 +664,7 @@ declare const _default: {
     } | {
         readonly name: "unlockId";
     } | {
-        readonly name: "target";
+        readonly name: "operation";
     } | {
         name: string;
     })[];

package/lib/config/dp-map/unlock-method.js

@@ -87,7 +87,7 @@ const reportAdd = [
 const remove = [
     ...common,
     {
-        name: "target",
+        name: "operation",
     },
 ];
 const reportRemove = [

package/lib/index.d.ts

@@ -2,6 +2,7 @@ import { hasCapability, hasDp, updateConfig } from "./config";
 import { LockSDKOption } from "./interface";
 import { getCurrentUser, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, getCurrentUserSync, getMediaRotate } from "./state";
 import { syncUnlockMethod } from "./sync/unlock-method";
+import syncDeleteUsers from "./sync/user";
 import { publishDps } from "./utils/publishDps";
 import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache } from "./offline-dps";
 export * from "./user";
@@ -19,4 +20,4 @@ export * from "./linkage";
 export * from "./capability";
 export declare const init: (options?: LockSDKOption) => Promise<void>;
 export declare const destroy: () => void;
-export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };
+export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, syncDeleteUsers, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };

package/lib/index.js

@@ -2,8 +2,9 @@ import config, { hasCapability, hasDp, updateConfig } from "./config";
 import dpCodes from "./config/dp-code";
 import { addEvents, clearState, initState, removeEvents, getCurrentUser, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, getCurrentUserSync, getMediaRotate, } from "./state";
 import { getCapabilities } from "./utils";
-import { getDeviceInfo, getLaunchOptionsSync } from "./utils/device";
+import { getDeviceInfo, getLaunchOptionsSync, trackEvent, } from "./utils/device";
 import { syncUnlockMethod } from "./sync/unlock-method";
+import syncDeleteUsers from "./sync/user";
 import { publishDps } from "./utils/publishDps";
 import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, } from "./offline-dps";
 export * from "./user";
@@ -63,10 +64,13 @@ export const init = async (options) => {
     config.preFetch = options?.preFetch ?? false;
     config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
     addEvents();
+    trackEvent("t$y_UztB3Lj9Qns375R0r7dA0L5Kr2VytH3J".replace("$", ""), {
+        pid: devInfo.productId,
+    });
     await initState();
 };
 export const destroy = () => {
     clearState();
     removeEvents();
 };
-export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };
+export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, syncDeleteUsers, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };

package/lib/offline-dps.js

@@ -29,14 +29,14 @@ export const checkOfflineDpUpdate = async (dps, isForce) => {
     if (!config.supportOfflineDps) {
         return;
     }
-    const hasOne = Object.keys(dps).some((code) => cache[code]?.pushStatus === false);
+    const hasOne = Object.keys(dps).some((code) => cache?.[code]?.pushStatus === false);
     if (hasOne || isForce) {
         const res = await getOfflineDps(true);
         emitter.emit(OFFLINE_DPS_UPDATE, res);
     }
 };
 export const getOfflineDpCache = (code) => {
-    return cache[code];
+    return cache?.[code];
 };
 export const publishOfflineDps = async (dps) => {
     const { devInfo, dpSchema } = config;
@@ -52,20 +52,12 @@ export const publishOfflineDps = async (dps) => {
         return acc;
     }, {});
     await publishOfflineDpData(devInfo.devId, dpData);
-    try {
-        await checkOfflineDpUpdate({}, true);
-    }
-    catch {
-    }
+    checkOfflineDpUpdate({}, true);
 };
 export const clearOfflineDps = async () => {
     const { devInfo } = config;
     await clearOfflineDpData(devInfo.devId);
-    try {
-        await checkOfflineDpUpdate({}, true);
-    }
-    catch {
-    }
+    checkOfflineDpUpdate({}, true);
 };
 const OFFLINE_DPS_UPDATE = "offline_dps_update";
 export const onOfflineDpsUpdate = (callback) => {

package/lib/open/ble-dedicated-dp.d.ts

@@ -0,0 +1,4 @@
+export declare const isDedicatedBleHexSuccess: (raw: string) => boolean;
+export declare const resolveDedicatedBleCommandDp: () => string | null;
+export declare const executeDedicatedBleManualLock: (timeout: number) => Promise<void>;
+export declare const executeDedicatedBleRawAction: (isOpen: boolean, timeout: number) => Promise<void>;

package/lib/open/ble-dedicated-dp.js

@@ -0,0 +1,148 @@
+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 syncRemoteSerectKey from "../sync/remote-serect-key";
+import { stringToBytes } from "../utils/byte";
+import { decrypt } from "../utils/device";
+import { getError } from "../utils/errors";
+import { publishDps } from "../utils/publishDps";
+import { getOpenDoorMemberId } from "./ble-remote-no-dp-key";
+import { mapRemoteOpenReportStatus } from "./report-status";
+const normalizeHex = (raw) => raw.replace(/\s/g, "").toLowerCase();
+export const isDedicatedBleHexSuccess = (raw) => {
+    const n = normalizeHex(raw);
+    if (n.length < 2) {
+        return false;
+    }
+    return n.startsWith("00") || n.endsWith("00");
+};
+const parseDedicatedBleHexStatus = (raw) => {
+    const n = normalizeHex(raw);
+    if (n.length < 2) {
+        return false;
+    }
+    if (isDedicatedBleHexSuccess(raw)) {
+        return { status: 0 };
+    }
+    if (n.includes("06")) {
+        return { status: 0x06 };
+    }
+    return { status: 0x01 };
+};
+const tryParseStandardUnlockReport = (raw, memberId) => {
+    try {
+        const result = dpUtils.parse(raw, reportOpenMap);
+        if (result.memberId !== memberId) {
+            return false;
+        }
+        if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
+            return false;
+        }
+        return result;
+    }
+    catch {
+        return false;
+    }
+};
+export const resolveDedicatedBleCommandDp = () => {
+    if (hasDp(dpCodes.bleUnlockCheck)) {
+        return dpCodes.bleUnlockCheck;
+    }
+    if (hasDp(dpCodes.bluetoothUnlock)) {
+        return dpCodes.bluetoothUnlock;
+    }
+    if (hasDp(dpCodes.unlockBle)) {
+        return dpCodes.unlockBle;
+    }
+    return null;
+};
+const createDedicatedBleCheckReport = (commandDp, memberId) => {
+    return (dpData) => {
+        if (hasDp(dpCodes.lockMotorState)) {
+            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                return { status: 0 };
+            }
+        }
+        if (typeof dpData[commandDp] !== "undefined") {
+            const raw = dpData[commandDp];
+            const standard = tryParseStandardUnlockReport(raw, memberId);
+            if (standard) {
+                return standard;
+            }
+            const hexStatus = parseDedicatedBleHexStatus(raw);
+            if (hexStatus !== false) {
+                return hexStatus;
+            }
+        }
+        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;
+            }
+        }
+        return false;
+    };
+};
+export const executeDedicatedBleManualLock = async (timeout) => {
+    if (!hasDp(dpCodes.manualLock)) {
+        throw getError(1014);
+    }
+    await publishDps({
+        [dpCodes.manualLock]: true,
+    }, {
+        timeout,
+        checkReport: (dpData) => {
+            if (hasDp(dpCodes.lockMotorState)) {
+                if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                    return { status: 0 };
+                }
+            }
+            if (typeof dpData[dpCodes.manualLock] !== "undefined") {
+                return { status: 0 };
+            }
+            return false;
+        },
+    });
+};
+export const executeDedicatedBleRawAction = async (isOpen, timeout) => {
+    if (!isOpen && hasDp(dpCodes.manualLock)) {
+        await executeDedicatedBleManualLock(timeout);
+        return;
+    }
+    const commandDp = resolveDedicatedBleCommandDp();
+    if (!commandDp) {
+        throw getError(1014);
+    }
+    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 memberId = await getOpenDoorMemberId();
+    const payload = dpUtils.format({
+        status: Number(isOpen),
+        memberId,
+        key: stringToBytes(pw),
+        type: 3,
+    }, openMap);
+    const response = (await publishDps({
+        [commandDp]: payload,
+    }, {
+        timeout,
+        checkReport: createDedicatedBleCheckReport(commandDp, memberId),
+    }));
+    if (response.status !== 0) {
+        throw mapRemoteOpenReportStatus(response.status);
+    }
+};

package/lib/open/ble-remote-no-dp-key.d.ts

@@ -0,0 +1,4 @@
+import { DpValue } from "../interface";
+export declare const createRemoteNoDpKeyBleCheckReport: (memberId: number) => (dpData: Record<string, DpValue>) => any;
+export declare const executeBleRemoteNoDpKeyAction: (isOpen: boolean, timeout: number, memberId: number) => Promise<void>;
+export declare const getOpenDoorMemberId: () => Promise<number>;

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/other.js

@@ -260,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();

package/lib/state.js

@@ -243,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();
@@ -295,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/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,65 @@
 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;
-            }
-            catch (e) {
-                if (e?.innerError?.errorCode === "DEVICE_KEY_NOT_FOUND" && count < 3) {
+    isSyncing = true;
+    let count = 0;
+    const handleSync = async () => {
+        try {
+            const { removedUser = [] } = await getUsersSyncLockData(config.devInfo.devId);
+            const deleteSerialCollectFailures = async (users) => {
+                const failed = [];
+                for (const item of users) {
+                    try {
+                        await deleteUser(item);
+                    }
+                    catch {
+                        failed.push(item);
+                    }
+                }
+                return failed;
+            };
+            let failed = await deleteSerialCollectFailures(removedUser);
+            if (failed.length > 0) {
+                failed = await deleteSerialCollectFailures(failed);
+                if (failed.length > 0 && count < 3) {
                     count++;
                     setTimeout(async () => {
                         await handleSync();
                     }, 2000);
                 }
+                else {
+                    isSyncing = false;
+                }
             }
-        };
-        handleSync();
-    }
+            else {
+                isSyncing = false;
+            }
+        }
+        catch (e) {
+            if (e?.innerError?.errorCode === "DEVICE_KEY_NOT_FOUND" && count < 3) {
+                count++;
+                setTimeout(async () => {
+                    await handleSync();
+                }, 2000);
+            }
+            else {
+                isSyncing = false;
+            }
+        }
+    };
+    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;
 };
@@ -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.js

@@ -1,17 +1,15 @@
 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 { DPCHANGE, LoopTypes, UNLOCK_METHOD_EVENT } from "./utils/constant";
 import { getFileRemoteUrl, sendPhoneVerifyCode } from "./api";
 import { getUserInfo } from "./user";
 import { getDeviceAdvancedAbilities } from "./capability";
@@ -22,7 +20,10 @@ const getAddUnlockError = (status) => {
     if (status === 0xfe) {
         return getError(1026);
     }
-    return getError(1016);
+    return {
+        ...getError(1016),
+        devCode: status,
+    };
 };
 export const getUnlockMethodDetail = async (id) => {
     const cloudData = await getUnlockMethodInfo({
@@ -58,8 +59,7 @@ const getUnlockMethodBase = async (type, userId) => {
         : dpCodes.unlockMethodCreate;
     const dpId = idsByCode[unlockMethodConfig.code];
     const [user, sn] = await Promise.all([
-        getUserDetail({
-            devId: devId,
+        getUserInfo({
             userId: userId,
         }),
         fetchCreatePasswordSN({
@@ -67,10 +67,42 @@ const getUnlockMethodBase = async (type, userId) => {
             dpId,
         }),
     ]);
-    const { userType, lockUserId, userTimeSet } = user;
+    const { userType, lockUserId, timeScheduleInfo } = user;
     let validConfig;
-    if (userTimeSet) {
-        validConfig = dpUtils.parse(userTimeSet, validConfigDpMap.childMap);
+    if (timeScheduleInfo) {
+        const { permanent, effectiveTime, expiredTime, scheduleDetails } = timeScheduleInfo;
+        if (permanent) {
+            validConfig = {
+                startTime: effectiveTime
+                    ? Math.floor(effectiveTime / 1000)
+                    : 0x386cd300,
+                endTime: expiredTime ? Math.floor(expiredTime / 1000) : 0x72bc9b7f,
+                loop: LoopTypes.NONE,
+                loopConfig: 0,
+                weeks: [0, 0, 0, 0, 0, 0, 0],
+                days: [],
+                startHour: 0,
+                startMinute: 0,
+                endHour: 0,
+                endMinute: 0,
+            };
+        }
+        else {
+            validConfig = {
+                startTime: Math.floor((effectiveTime || +new Date()) / 1000),
+                endTime: expiredTime ? Math.floor(expiredTime / 1000) : 0x72bc9b7f,
+                loop: scheduleDetails?.repeat ? LoopTypes.WEEK : LoopTypes.NONE,
+                loopConfig: 0,
+                weeks: scheduleDetails?.repeat
+                    ? scheduleDetails?.weeks
+                    : [0, 0, 0, 0, 0, 0, 0],
+                days: [],
+                startHour: Math.floor((scheduleDetails?.effectiveTime ?? 0) / 60),
+                startMinute: (scheduleDetails?.effectiveTime ?? 0) % 60,
+                endHour: Math.floor((scheduleDetails?.invalidTime ?? 0) / 60),
+                endMinute: (scheduleDetails?.invalidTime ?? 0) % 60,
+            };
+        }
     }
     else {
         validConfig = getPermanentSetting();
@@ -311,7 +343,8 @@ const handleAddReport = async (dps) => {
                         };
                     }
                 }
-                catch {
+                catch (err) {
+                    console.warn("AddUnlockMethod failed", err);
                     eventData = {
                         stage: "fail",
                         type,
@@ -350,6 +383,7 @@ export const startAddUnlockMethod = async (params) => {
     const res = await publishDps({
         [addDpCode]: dpUtils.format(dpData, addDpMap),
     }, {
+        timeout: params.timeout,
         checkReport: (dpData) => {
             if (typeof dpData[addDpCode] !== "undefined") {
                 const result = dpUtils.parse(dpData[addDpCode], addDpReportMap);
@@ -375,6 +409,7 @@ export const startAddUnlockMethod = async (params) => {
     });
     if (res.stage === 0) {
         monitoringAddReport({
+            timeout: params.timeout,
             unlockMethodConfig,
             total: res.total,
             dpCode: addDpCode,
@@ -446,7 +481,7 @@ export const deleteUnlockMethod = parallelOnly(async (id) => {
         admin: isAdmin(userType),
         memberId: lockUserId,
         unlockId,
-        target: 1,
+        operation: 1,
     };
     const res = await publishDps({
         [removeDPCode]: dpUtils.format(dpData, (config.supportBigData ? removeBigMap : removeMap)),

package/lib/user.d.ts

@@ -1,4 +1,4 @@
-import { EffectiveConfig, UnlockMethodBaseInfo, UserInfo } from "./interface";
+import { EffectiveConfig, UserInfo } from "./interface";
 interface getUsersParams {
     page?: number;
     pageSize?: number;
@@ -11,27 +11,7 @@ export declare const getUsers: (params?: getUsersParams) => Promise<{
 interface getUserInfoParams {
     userId: string;
 }
-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";
-}>;
+export declare const getUserInfo: (params: getUserInfoParams) => Promise<UserInfo>;
 interface updateUserLimitTimeParams {
     userId: string;
     lockUserId: number;
@@ -39,12 +19,12 @@ interface updateUserLimitTimeParams {
     effective?: EffectiveConfig;
     offlineUnlock?: boolean;
 }
-export declare const updateUserLimitTime: (params: updateUserLimitTimeParams) => Promise<boolean>;
+export declare const updateUserLimitTime: (params: updateUserLimitTimeParams) => Promise<true | undefined>;
 export declare const openAddFamilyUser: () => Promise<unknown>;
 export declare const openFamilyUserDetail: (userId: string) => Promise<undefined>;
 interface AddUserParams {
     name: string;
 }
-export declare const addUser: (params: AddUserParams) => Promise<import("./api/user").AddNormalUserResponse>;
+export declare const addUser: (params: AddUserParams) => Promise<void>;
 export declare const removeUser: (userId: string) => Promise<void>;
 export {};

package/lib/user.js

@@ -1,11 +1,11 @@
-import { getUserDetail, getUserDetailQuery, getUserList, } from "./api/user";
+import { getUserDetailQuery, getUserList } from "./api/user";
 import config from "./config";
 import { update as updateMap, reportUpdate as reportUpdateMap, } from "./config/dp-map/unlock-method";
 import { update as updateMapBig, reportUpdate as reportUpdateMapBig, } 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";
-import { getError } from "./utils/errors";
+import { getError, handleCloudError } from "./utils/errors";
 import { updateUserTimeSchedule, addNormalUser, removeNormalUser, } from "./api/user";
 import { validConfigDpMap } from "./config/dp-map/common";
 import { formatTimestampToMilliseconds, formatWeek, getPermanentSetting, isAdmin, isUseNearChannel, parseWeek, unlockMethodConfigs, validateEffectiveConfig, } from "./utils";
@@ -118,8 +118,11 @@ export const updateUserLimitTime = async (params) => {
     if (!permanent) {
         validateEffectiveConfig(effective);
     }
-    const { userType } = await getUserDetail({
-        devId: config.devInfo.devId,
+    const currentUser = await getCurrentUser();
+    if (!isAdmin(currentUser.userType)) {
+        throw getError(1069);
+    }
+    const { userType } = await getUserInfo({
         userId,
     });
     if (isAdmin(userType)) {
@@ -156,33 +159,33 @@ export const updateUserLimitTime = async (params) => {
                 endMinute: expiredTime % 60,
             },
     };
-    try {
-        const dpCode = config.supportBigData
-            ? dpCodes.unlockMethodEditW
-            : dpCodes.unlockMethodEdit;
-        const res = (await publishDps({
-            [dpCode]: DpUtils.format(dpValue, (config.supportBigData ? updateMapBig : updateMap)),
-        }, {
-            checkReport: (dps) => {
-                if (typeof dps[dpCode] !== "undefined") {
-                    const result = DpUtils.parse(dps[dpCode], (config.supportBigData
-                        ? reportUpdateMapBig
-                        : reportUpdateMap));
-                    if (result.type === 0) {
-                        if (result.memberId === lockUserId) {
-                            return result;
-                        }
-                        else {
-                            console.warn("An incorrect member id was returned");
-                        }
+    const dpCode = config.supportBigData
+        ? dpCodes.unlockMethodEditW
+        : dpCodes.unlockMethodEdit;
+    const res = (await publishDps({
+        [dpCode]: DpUtils.format(dpValue, (config.supportBigData ? updateMapBig : updateMap)),
+    }, {
+        checkReport: (dps) => {
+            if (typeof dps[dpCode] !== "undefined") {
+                const result = DpUtils.parse(dps[dpCode], (config.supportBigData
+                    ? reportUpdateMapBig
+                    : reportUpdateMap));
+                if (result.type === 0) {
+                    if (result.memberId === lockUserId) {
+                        return result;
+                    }
+                    else {
+                        console.warn("An incorrect member id was returned");
                     }
                 }
-                return false;
-            },
-        }));
-        if (res.status !== 255) {
-            throw getError(1011);
-        }
+            }
+            return false;
+        },
+    }));
+    if (res.status !== 255) {
+        throw getError(1011);
+    }
+    try {
         await updateUserTimeSchedule({
             devId: config.devInfo.devId,
             userId: userId,
@@ -201,11 +204,11 @@ export const updateUserLimitTime = async (params) => {
                 ],
             },
         });
+        return true;
     }
     catch (e) {
-        throw getError(1012);
+        handleCloudError(e, 1012);
     }
-    return true;
 };
 export const openAddFamilyUser = async () => {
     const homeInfo = await getCurrentHomeInfo();
@@ -259,17 +262,24 @@ export const addUser = async (params) => {
     if (!params.name) {
         throw getError(1009, "name");
     }
-    return addNormalUser({
-        devId: config.devInfo.devId,
-        name: params.name,
-    });
+    try {
+        await addNormalUser({
+            devId: config.devInfo.devId,
+            name: params.name,
+        });
+    }
+    catch (e) {
+        if (e?.innerError?.errorCode === "DEFINITION_PARAM_NAME_REPEAT") {
+            throw getError(1068);
+        }
+        throw e;
+    }
 };
 export const removeUser = async (userId) => {
     if (!config.supportBigData) {
         throw getError(1060);
     }
-    const res = await getUserDetail({
-        devId: config.devInfo.devId,
+    const res = await getUserInfo({
         userId,
     });
     if (isUseNearChannel()) {

package/lib/utils/device.d.ts

@@ -176,4 +176,5 @@ export declare const onAppShow: (cb: () => void) => void;
 export declare const offAppShow: (cb: () => void) => void;
 export declare const onAppHide: (cb: () => void) => void;
 export declare const offAppHide: (cb: () => void) => void;
+export declare const trackEvent: (event: string, data: Record<string, any>) => void;
 export {};

package/lib/utils/device.js

@@ -364,3 +364,9 @@ export const onAppHide = (cb) => {
 export const offAppHide = (cb) => {
     ty.offAppShow(cb);
 };
+export const trackEvent = (event, data) => {
+    ty.event({
+        eventId: event,
+        event: data,
+    });
+};

package/lib/utils/errors.d.ts

@@ -1,2 +1,3 @@
 import { ErrorData } from "../interface";
 export declare const getError: (code: number, ...places: string[]) => ErrorData;
+export declare const handleCloudError: (err: any, code?: number) => never;

package/lib/utils/errors.js

@@ -65,6 +65,9 @@ const errors = {
     1064: "Non-thread device, not supported in LAN connection to open and close locks",
     1065: "Cloud side has been deleted, but device side synchronization deletion failed",
     1066: "Phone number cannot be empty",
+    1067: "Password limit reached within this period",
+    1068: "There is already a member with the same name",
+    1069: "No permission to modify member validity",
 };
 export const getError = (code, ...places) => {
     if (errors[code]) {
@@ -84,3 +87,36 @@ export const getError = (code, ...places) => {
         errorMsg: "unknow error",
     };
 };
+export const handleCloudError = (err, code) => {
+    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;
+        }
+    }
+    if (code) {
+        throw getError(code);
+    }
+    throw err;
+};

package/lib/utils/index.js

@@ -62,9 +62,8 @@ export const parseWeek = (value) => {
         .slice(0, 7);
 };
 export const getPermanentSetting = () => {
-    const now = Math.floor(+new Date() / 1000);
     return {
-        startTime: now,
+        startTime: 0x386cd300,
         endTime: 0x72bc9b7f,
         loop: LoopTypes.NONE,
         loopConfig: 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.1.1-beta.9",
+  "version": "1.1.1",
   "files": [
     "lib",
     "LICENSE.md"