@ray-js/lock-sdk 1.1.1-beta.11 → 1.1.1-beta.13

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",

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/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/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();

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

@@ -32,11 +32,7 @@ export const syncUnlockMethod = async () => {
     }
 };
 export const autoSyncUnlockMethod = async () => {
-    try {
-        if (syncUnlockMethodFirst) {
-            await syncUnlockMethod();
-        }
-    }
-    catch (e) {
+    if (syncUnlockMethodFirst) {
+        await syncUnlockMethod();
     }
 };

package/lib/sync/user.js

@@ -1,40 +1,43 @@
 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 { onAppShow } from "../utils/device";
+import { isUseNearChannel } from "../utils";
+let isSyncing = false;
+onAppShow(() => {
+    syncDeleteUsers();
+});
 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/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,40 @@ 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: Math.floor((effectiveTime || +new Date()) / 1000),
+                endTime: Math.floor((expiredTime || 0x72bc9b7f) / 1000),
+                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: Math.floor((expiredTime || 0x72bc9b7f) / 1000),
+                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 +341,8 @@ const handleAddReport = async (dps) => {
                         };
                     }
                 }
-                catch {
+                catch (err) {
+                    console.warn("AddUnlockMethod failed", err);
                     eventData = {
                         stage: "fail",
                         type,
@@ -350,6 +381,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 +407,7 @@ export const startAddUnlockMethod = async (params) => {
     });
     if (res.stage === 0) {
         monitoringAddReport({
+            timeout: params.timeout,
             unlockMethodConfig,
             total: res.total,
             dpCode: addDpCode,

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;

package/lib/user.js

@@ -1,4 +1,4 @@
-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";
@@ -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)) {
@@ -276,8 +279,7 @@ 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/errors.js

@@ -67,6 +67,7 @@ const errors = {
     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]) {

package/package.json

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