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

package/lib/user.js

@@ -1,4 +1,4 @@
-import { getUserDetail, getUserList } from "./api/user";
+import { getUserDetail, 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";
@@ -8,62 +8,67 @@ import DpUtils from "@ray-js/tuya-dp-transform";
 import { getError } from "./utils/errors";
 import { updateUserTimeSchedule, addNormalUser, removeNormalUser, } from "./api/user";
 import { validConfigDpMap } from "./config/dp-map/common";
-import { formatTimestampToMilliseconds, formatWeek, isAdmin, parseWeek, unlockMethodConfigs, validateEffectiveConfig, } from "./utils";
+import { formatTimestampToMilliseconds, formatWeek, getPermanentSetting, isAdmin, isUseNearChannel, parseWeek, unlockMethodConfigs, validateEffectiveConfig, } from "./utils";
 import { getCurrentHomeInfo, isSupportShortLink } from "./utils/device";
 import { LoopTypes } from "./utils/constant";
 import { getCurrentUser } from "./state";
-const concactUserList = (list, result) => {
-    return list.reduce((acc, item) => {
-        const { timeScheduleInfo, unlockDetail, ...rest } = item;
-        let scheduleInfo = {
-            permanent: true,
-        };
-        if (!item.timeScheduleInfo.permanent &&
-            item.timeScheduleInfo.scheduleDetails &&
-            item.timeScheduleInfo.scheduleDetails.length > 0) {
-            Object.assign(timeScheduleInfo, {
-                effectiveTime: formatTimestampToMilliseconds(item.timeScheduleInfo.effectiveTime || 0),
-                expiredTime: formatTimestampToMilliseconds(item.timeScheduleInfo.expiredTime || 0),
-                scheduleDetails: {
-                    repeat: !item.timeScheduleInfo.scheduleDetails[0].allDay,
-                    effectiveTime: item.timeScheduleInfo.scheduleDetails[0].effectiveTime,
-                    invalidTime: item.timeScheduleInfo.scheduleDetails[0].invalidTime,
-                    timeZoneId: item.timeScheduleInfo.scheduleDetails[0].timeZoneId,
-                    weeks: parseWeek(item.timeScheduleInfo.scheduleDetails[0].workingDay),
-                },
-            });
-        }
-        let unlockDetails = unlockDetail.map((detail) => {
-            const unlockList = detail.unlockList.map((unlockItem) => {
-                return {
-                    unlockId: unlockItem.unlockId.split("-")[1],
-                    unlockName: unlockItem.unlockName,
-                    id: unlockItem.opModeId,
-                    isBound: unlockItem.allocateFlag === 1,
-                    photoUnlock: unlockItem.photoUnlock,
-                    isSpecial: unlockItem.unlockAttr === 1,
-                };
-            });
-            const unlockMethodConfig = unlockMethodConfigs.find((item) => item.code === detail.dpCode);
+import { deleteUser } from "./utils/user";
+import { UserType } from "./constant";
+const handleUserDetail = (user) => {
+    const { timeScheduleInfo, unlockDetail, ...rest } = user;
+    let scheduleInfo = {
+        permanent: true,
+    };
+    if (!timeScheduleInfo.permanent &&
+        timeScheduleInfo.scheduleDetails &&
+        timeScheduleInfo.scheduleDetails.length > 0) {
+        Object.assign(scheduleInfo, {
+            permanent: false,
+            effectiveTime: formatTimestampToMilliseconds(timeScheduleInfo.effectiveTime || 0),
+            expiredTime: formatTimestampToMilliseconds(timeScheduleInfo.expiredTime || 0),
+            scheduleDetails: {
+                repeat: !timeScheduleInfo.scheduleDetails[0].allDay,
+                effectiveTime: timeScheduleInfo.scheduleDetails[0].effectiveTime,
+                invalidTime: timeScheduleInfo.scheduleDetails[0].invalidTime,
+                timeZoneId: timeScheduleInfo.scheduleDetails[0].timeZoneId,
+                weeks: parseWeek(timeScheduleInfo.scheduleDetails[0].workingDay),
+            },
+        });
+    }
+    let unlockDetails = unlockDetail.map((detail) => {
+        const unlockList = detail.unlockList.map((unlockItem) => {
             return {
-                count: unlockList.length,
-                dpCode: detail.dpCode,
-                dpId: detail.dpId,
-                type: unlockMethodConfig.type,
-                unlockList,
+                unlockId: +unlockItem.unlockId.split("-")[1],
+                unlockName: unlockItem.unlockName,
+                id: unlockItem.opModeId,
+                isBound: unlockItem.allocateFlag === 1,
+                photoUnlock: unlockItem.photoUnlock,
+                isSpecial: unlockItem.unlockAttr === 1,
             };
         });
-        acc.push({
-            ...rest,
-            timeScheduleInfo: scheduleInfo,
-            unlockDetails,
-            isAccountUser: item.userListType === "group_user",
-        });
+        const unlockMethodConfig = unlockMethodConfigs.find((item) => item.code === detail.dpCode);
+        return {
+            count: unlockList.length,
+            dpCode: detail.dpCode,
+            dpId: detail.dpId,
+            type: unlockMethodConfig.type,
+            unlockList,
+        };
+    });
+    return {
+        ...rest,
+        timeScheduleInfo: scheduleInfo,
+        unlockDetails,
+        isAccountUser: user.userListType === "group_user",
+    };
+};
+const concactUserList = (list, result) => {
+    return list.reduce((acc, item) => {
+        acc.push(handleUserDetail(item));
         return acc;
     }, result);
 };
-export const getUsers = async (params) => {
-    const { page = 1, pageSize = 10, keyword = "" } = params || {};
+const getUserDpCodes = async () => {
     const currentUser = await getCurrentUser();
     const dps = [];
     if (currentUser.allOpenDps) {
@@ -75,6 +80,11 @@ export const getUsers = async (params) => {
             return acc;
         }, dps);
     }
+    return dps;
+};
+export const getUsers = async (params) => {
+    const { page = 1, pageSize = 10, keyword = "" } = params || {};
+    const dps = await getUserDpCodes();
     const res = await getUserList({
         dpCodes: dps.join(","),
         devId: config.devInfo.devId,
@@ -95,18 +105,13 @@ export const getUsers = async (params) => {
     };
 };
 export const getUserInfo = async (params) => {
-    const user = await getUserDetail({
+    const currentUser = await getCurrentUser();
+    const res = await getUserDetailQuery({
         devId: config.devInfo.devId,
         userId: params.userId,
+        dpIds: currentUser.allOpenDps,
     });
-    const data = await getUsers({
-        keyword: user.nickName,
-    });
-    const res = data.list.find((item) => item.userId === params.userId);
-    if (res) {
-        return res;
-    }
-    throw getError(1048);
+    return handleUserDetail(res);
 };
 export const updateUserLimitTime = async (params) => {
     const { userId, lockUserId, permanent, effective } = params;
@@ -134,52 +139,50 @@ export const updateUserLimitTime = async (params) => {
         validNum: 0,
         pwdLength: 0,
         pwd: [],
-        validConfig: {
-            startTime: Math.floor(permanent ? +new Date() / 1000 : effective.effectiveDate),
-            endTime: Math.floor(permanent
-                ? (+new Date() + 3153600000000) / 1000
-                : effective.expiredDate),
-            loop: permanent ? LoopTypes.NONE : loopType,
-            loopConfig: 0,
-            weeks: permanent ||
-                effective?.repeat !== "week" ||
-                effective?.weeks === undefined
-                ? [0, 0, 0, 0, 0, 0, 0]
-                : effective.weeks,
-            days: [],
-            startHour: permanent ? 0 : Math.floor(effectiveTime / 60),
-            startMinute: permanent ? 0 : effectiveTime % 60,
-            endHour: permanent ? 0 : Math.floor(expiredTime / 60),
-            endMinute: permanent ? 0 : expiredTime % 60,
-        },
+        validConfig: permanent
+            ? getPermanentSetting()
+            : {
+                startTime: effective.effectiveDate,
+                endTime: effective.expiredDate,
+                loop: loopType,
+                loopConfig: 0,
+                weeks: effective?.repeat !== "week" || effective?.weeks === undefined
+                    ? [0, 0, 0, 0, 0, 0, 0]
+                    : effective.weeks,
+                days: [],
+                startHour: Math.floor(effectiveTime / 60),
+                startMinute: effectiveTime % 60,
+                endHour: Math.floor(expiredTime / 60),
+                endMinute: expiredTime % 60,
+            },
     };
-    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");
+    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");
+                        }
                     }
                 }
-            }
-            return false;
-        },
-    }));
-    if (res.status !== 255) {
-        throw getError(1011);
-    }
-    try {
+                return false;
+            },
+        }));
+        if (res.status !== 255) {
+            throw getError(1011);
+        }
         await updateUserTimeSchedule({
             devId: config.devInfo.devId,
             userId: userId,
@@ -241,11 +244,8 @@ export const openFamilyUserDetail = async (userId) => {
         const url = `tuyaSmart://member_info?homeId=${homeId}&memberId=${userId}&role=${role}`;
         ty.router({
             url: url,
-            success: (d) => {
-                console.log("openFamilyUserDetail success");
-            },
             fail: (e) => {
-                console.log("openFamilyUserDetail fail", e);
+                console.error("openFamilyUserDetail fail", e);
             },
         });
         return;
@@ -268,6 +268,17 @@ export const removeUser = async (userId) => {
     if (!config.supportBigData) {
         throw getError(1060);
     }
+    const res = await getUserDetail({
+        devId: config.devInfo.devId,
+        userId,
+    });
+    if (isUseNearChannel()) {
+        return deleteUser({
+            userId,
+            lockUserId: res.lockUserId,
+            admin: res.userType === UserType.ADMIN || res.userType === UserType.OWNER,
+        });
+    }
     return removeNormalUser({
         devId: config.devInfo.devId,
         userId,

package/lib/utils/device.d.ts

@@ -5,6 +5,7 @@ export declare const setDeviceProperty: (devId: string, code: string, value: str
 export declare const publishDeviceDps: (params: {
     deviceId: string;
     dps: Record<string, boolean | number | string>;
+    pipelines?: number[];
 }) => Promise<unknown>;
 export declare const registerDevice: (devIds: string[]) => void;
 export declare const registerBleStatus: (devId: string) => void;

package/lib/utils/device.js

@@ -131,7 +131,7 @@ export const requestCloud = (options) => {
                 resolve(d);
             },
             fail: (err) => {
-                reject(err.innerError ?? err);
+                reject(err ?? err);
             },
         });
     });

package/lib/utils/errors.js

@@ -63,6 +63,9 @@ const errors = {
     1062: "Device does not support active connection",
     1063: "Password length only supports 4-6 digits",
     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",
 };
 export const getError = (code, ...places) => {
     if (errors[code]) {

package/lib/utils/index.d.ts

@@ -107,7 +107,7 @@ export declare const parseOfflinePassword: (value: string) => string;
 export declare const formatTimestampToMilliseconds: (timestamp: number) => number;
 export declare const unlockMethodConfigs: UnlockMethodConfig[];
 export declare const getUnlockMethodTypeByDpCode: (dpCode: string) => UnlockMethodConfig;
-export declare const getUnlockMethodTypeById: (id: number) => UnlockMethodConfig;
+export declare const getUnlockMethodTypeById: (id: number | string) => UnlockMethodConfig;
 export declare const getUnlockMethodTypeByType: (type: string) => UnlockMethodConfig;
 export declare const parallelMerge: <T extends (...args: any[]) => Promise<any>>(cb: T) => (...args: Parameters<T>) => ReturnType<T>;
 export declare const parallelOnly: <T extends (...args: any[]) => Promise<any>>(cb: T) => (...args: Parameters<T>) => ReturnType<T>;

package/lib/utils/index.js

@@ -49,7 +49,8 @@ export function getCapabilities(capability) {
     });
 }
 export const formatWeek = (value) => {
-    return parseInt([...value].reverse().join(""), 2);
+    const temp = value.slice(0, 7);
+    return parseInt(temp.reverse().join(""), 2);
 };
 export const parseWeek = (value) => {
     return Number(value)
@@ -64,7 +65,7 @@ export const getPermanentSetting = () => {
     const now = Math.floor(+new Date() / 1000);
     return {
         startTime: now,
-        endTime: now + 3153600000,
+        endTime: 0x72bc9b7f,
         loop: LoopTypes.NONE,
         loopConfig: 0,
         weeks: [0, 0, 0, 0, 0, 0, 0],
@@ -258,18 +259,20 @@ onBackgroundFetchData(preFetchKeys, (res) => {
     });
 });
 export const getDataWithPreFetch = async (key, apiCb) => {
-    if (preFetchData[key]) {
-        return preFetchData[key];
-    }
-    try {
-        const result = await getBackgroundFetchData([key]);
-        if (result &&
-            result.fetchedData[key] &&
-            result.fetchedData[key].fetchedData) {
-            return result.fetchedData[key].fetchedData;
+    if (config.preFetch) {
+        if (preFetchData[key]) {
+            return preFetchData[key];
+        }
+        try {
+            const result = await getBackgroundFetchData([key]);
+            if (result &&
+                result.fetchedData[key] &&
+                result.fetchedData[key].fetchedData) {
+                return result.fetchedData[key].fetchedData;
+            }
+        }
+        catch {
         }
-    }
-    catch {
     }
     return apiCb();
 };

package/lib/utils/publishDps.js

@@ -7,7 +7,7 @@ import { getError } from "./errors";
 export const publishDpsOnly = async (dpData) => {
     const { devInfo, idsByCode } = config;
     const option = {};
-    if (config.onlineType === 0) {
+    if (config.deviceStatus.type === "offline") {
         throw getError(1001);
     }
     if (isOnlineByType(config.onlineType, 2)) {

package/lib/utils/user.d.ts

@@ -0,0 +1,2 @@
+import { RemovedUserData } from "../api/user";
+export declare const deleteUser: (data: RemovedUserData) => Promise<void>;

package/lib/utils/user.js

@@ -0,0 +1,39 @@
+import { 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";
+import config from "../config";
+export 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);
+};

package/package.json

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

package/lib/dp-interface.d.ts

@@ -1,7 +0,0 @@
-export interface UpdateUserEffectiveData {
-    type: 0;
-    stage: number;
-    admin: boolean;
-    memberId: number;
-    unlockId: 255;
-}

package/lib/dp-interface.js

@@ -1 +0,0 @@
-export {};

package/lib/sync/unlock-mothod.d.ts

@@ -1,2 +0,0 @@
-export declare const syncUnlockMethod: () => Promise<void>;
-export declare const autoSyncUnlockMethod: () => Promise<void>;

package/lib/sync/unlock-mothod.js

@@ -1,42 +0,0 @@
-import { fetchSyncUnlockMethodInfo } from "../api/lock";
-import config from "../config";
-import dpCodes from "../config/dp-code";
-import { getCurrentUser } from "../state";
-import { publishDps } from "../utils/publishDps";
-import dpUtils from "@ray-js/tuya-dp-transform";
-import { reportSync as reportSyncMap } from "../config/dp-map/unlock-method";
-import { reportSync as reportSyncBigMap } from "../config/dp-map/unlock-method-big";
-let syncUnlockMethodFirst = true;
-export const syncUnlockMethod = async () => {
-    syncUnlockMethodFirst = false;
-    const { allOpenDps = "" } = await getCurrentUser();
-    const { ins = "", distributed = false } = await fetchSyncUnlockMethodInfo({
-        devId: config.devInfo.devId,
-        dpIds: allOpenDps.split(","),
-    });
-    if (ins && distributed) {
-        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;
-                    }
-                }
-                return false;
-            },
-        });
-    }
-};
-export const autoSyncUnlockMethod = async () => {
-    try {
-        if (syncUnlockMethodFirst) {
-            await syncUnlockMethod();
-        }
-    }
-    catch (e) {
-    }
-};