@ray-js/lock-sdk 1.0.3 → 1.0.4

package/lib/api/lock.d.ts

@@ -1,4 +1,5 @@
 export declare const openDoorByCloud: (deviceId: string, isOpen: boolean) => Promise<unknown>;
+export declare const isConfirmOpenDoorByWifiPro: (deviceId: string, confirm: boolean) => Promise<unknown>;
 export declare const checkRemoteKey: (deviceId: string) => Promise<{
     effectiveTime: number;
     invalidTime: number;

package/lib/api/lock.js

@@ -10,6 +10,17 @@ export const openDoorByCloud = (deviceId, isOpen) => {
         },
     });
 };
+export const isConfirmOpenDoorByWifiPro = (deviceId, confirm) => {
+    return requestCloud({
+        api: `${THING}.m.device.lock.remote.unlock`,
+        version: "2.0",
+        data: {
+            devId: deviceId,
+            confirm,
+            open: true,
+        },
+    });
+};
 export const checkRemoteKey = async (deviceId) => {
     return requestCloud({
         api: "m.lock.ble.remote.unlock.check",

package/lib/api/log.d.ts

@@ -127,7 +127,12 @@ interface GetMediaUrlParams {
     mediaPath: string;
     mediaBucket: string;
 }
-export declare const getMediaUrl: (params: GetMediaUrlParams) => Promise<{
+interface GetFileUrlParams {
+    devId: string;
+    filePath: string;
+    bucket: string;
+}
+export declare const getMediaUrl: (params: GetMediaUrlParams | GetFileUrlParams) => Promise<{
     mediaUrl: string;
 }>;
 export {};

package/lib/api/temp.d.ts

@@ -21,6 +21,27 @@ export interface CreateTempPasswordResult {
     tyNum?: number;
 }
 export declare const createTemporaryPassword: (params: CreateTempPasswordParams) => Promise<CreateTempPasswordResult>;
+interface CreateOnlineUnlimitedParams {
+    devId: string;
+    effectiveTime: number;
+    invalidTime: number;
+    name: string;
+    password: string;
+    availTime: number;
+    schedule: {
+        allDay: boolean;
+        effectiveTime: number;
+        invalidTime: number;
+        workingDay: number;
+    }[];
+    phone?: string;
+    countryCode?: string;
+}
+export interface CreateOnlineUnlimitedResult {
+    pwdId: string;
+    name: string;
+}
+export declare const createOnlineUnlimited: (params: CreateOnlineUnlimitedParams) => Promise<CreateOnlineUnlimitedResult>;
 export interface ValidateTempPwdParams {
     password: string;
     devId: string;
@@ -67,6 +88,22 @@ interface DeleteTempPasswordParams {
     dpTunnel: number;
 }
 export declare const deleteTempPassword: (params: DeleteTempPasswordParams) => Promise<unknown>;
+export interface RemoveTempOnlineUnlimitedParams {
+    devId: string;
+    pwdId: string;
+    symbolic: boolean;
+    dpTunnel: number;
+}
+export declare const removeTempOnlineUnlimitedAPI: (params: {
+    devId: string;
+    id: string;
+}) => Promise<unknown>;
+export declare const getTempOnlineUnlimitedListAPI: (devId: string) => Promise<EffectivePasswrodItem[]>;
+export declare const getTempOfflineListAPI: (params: {
+    devId: string;
+    pwdType: string;
+    status: string;
+}) => Promise<EffectivePasswrodItem[]>;
 export interface CreateOfflinePasswordParams {
     devId: string;
     pwdType: string;
@@ -85,6 +122,13 @@ export interface OfflinePwdResult {
     unlockBindingId: string;
 }
 export declare const createOfflinePassword: (params: CreateOfflinePasswordParams) => Promise<OfflinePwdResult>;
+interface CreateOfflineOnceParams {
+    devId: string;
+    pwdType: string;
+    gmtStart: string;
+    gmtExpired: string;
+}
+export declare const createOfflineOnceAPI: (params: CreateOfflineOnceParams) => Promise<OfflinePwdResult>;
 interface GetDynapwdParams {
     devId: string;
     adminPwd?: string;
@@ -102,7 +146,7 @@ interface EffectiveListParams {
     devId: string;
     authTypes: string[];
 }
-interface EffectivePasswrodItem {
+export interface EffectivePasswrodItem {
     effective: number;
     unlockBindingId: string;
     effectiveTime: number;

package/lib/api/temp.js

@@ -7,6 +7,13 @@ export const createTemporaryPassword = (params) => {
         data: params,
     });
 };
+export const createOnlineUnlimited = (params) => {
+    return requestCloud({
+        api: `${THING}.m.device.lock.temppwd.create`,
+        version: "4.0",
+        data: params,
+    });
+};
 export const validateTempPwd = async (params) => {
     return requestCloud({
         api: `${THING}.m.device.lock.temppwd.validate`,
@@ -35,6 +42,29 @@ export const deleteTempPassword = (params) => {
         data: params,
     });
 };
+export const removeTempOnlineUnlimitedAPI = (params) => {
+    return requestCloud({
+        api: `${THING}.m.device.lock.temppwd.del`,
+        version: "2.0",
+        data: params,
+    });
+};
+export const getTempOnlineUnlimitedListAPI = (devId) => {
+    return requestCloud({
+        api: `${THING}.m.device.lock.temppwd.list`,
+        version: "2.0",
+        data: {
+            devId,
+        },
+    });
+};
+export const getTempOfflineListAPI = (params) => {
+    return requestCloud({
+        api: `${THING}.m.device.lock.offlinepwd.list`,
+        version: "1.0",
+        data: params,
+    });
+};
 export const createOfflinePassword = (params) => {
     return requestCloud({
         api: `${THING}.m.device.lock.offlinepwd.get`,
@@ -42,6 +72,13 @@ export const createOfflinePassword = (params) => {
         data: params,
     });
 };
+export const createOfflineOnceAPI = (params) => {
+    return requestCloud({
+        api: `${THING}.m.device.lock.offlinepwd.get`,
+        version: "1.0",
+        data: params,
+    });
+};
 export const getDynamicPassword = (params) => {
     return requestCloud({
         api: `${THING}.m.device.lock.dynapwd.get`,

package/lib/config/dp-code/index.d.ts

@@ -53,6 +53,10 @@ declare const dpCodes: {
     recordModeAovSwitch: string;
     sdStatus: string;
     updataInfo: string;
+    doorlockStatus: string;
+    unlockInside: string;
+    doorOpened: string;
+    unlockApp: string;
 };
 export declare const latLogDpCodes: string[];
 export default dpCodes;

package/lib/config/dp-code/index.js

@@ -31,7 +31,7 @@ const dpCodes = {
     unlockVoiceRemote: "unlock_voice_remote",
     lockRecord: "lock_record",
     unlockBle: "unlock_ble",
-    bleControl: 'ble_control',
+    bleControl: "ble_control",
     unlockEye: "unlock_eye",
     unlockDoubleKit: "unlock_double_kit",
     unlockDoubleKitW: "unlock_double_kit_w",
@@ -52,7 +52,11 @@ const dpCodes = {
     onlineSwitch: "online_switch",
     recordModeAovSwitch: "record_mode_aov_switch",
     sdStatus: "sd_status",
-    updataInfo: 'updata_info'
+    updataInfo: "updata_info",
+    doorlockStatus: "doorlock_status",
+    unlockInside: "unlock_inside",
+    doorOpened: "door_opened",
+    unlockApp: "unlock_app",
 };
 export const latLogDpCodes = [
     dpCodes.unlockPassword,

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

@@ -1,3 +1,4 @@
+import { DpMap } from "@ray-js/tuya-dp-transform";
 declare const add: ({
     readonly name: "validConfig";
     readonly type: "child";
@@ -489,11 +490,6 @@ declare const reportUpdateTempPwd: ({
     name: string;
     bytes?: undefined;
 })[];
-declare const sync: {
-    name: string;
-    loop: boolean;
-}[];
-declare const reportSync: {
-    name: string;
-}[];
+declare const sync: DpMap;
+declare const reportSync: DpMap;
 export { add, reportAdd, remove, reportRemove, update, updateMemberRole, reportUpdate, addTempPwd, reportAddTempPwd, removeTempPwd, reportRemoveTempPwd, updateTempPwd, reportUpdateTempPwd, sync, reportSync, };

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

@@ -194,7 +194,36 @@ const reportSync = [
         name: "stage",
     },
     {
-        name: "package",
+        name: "messageId",
+        bytes: 2,
+    },
+    {
+        name: "packageNo",
+    },
+    {
+        condition: {
+            prop: "stage",
+            value: 0,
+        },
+        name: "data",
+        loop: true,
+        type: "child",
+        childMap: [
+            {
+                name: "unlockId",
+                bytes: 2,
+            },
+            {
+                name: "unlockType",
+            },
+            {
+                name: "id",
+                bytes: 2,
+            },
+            {
+                name: "status",
+            },
+        ],
     },
 ];
 export { add, reportAdd, remove, reportRemove, update, updateMemberRole, reportUpdate, addTempPwd, reportAddTempPwd, removeTempPwd, reportRemoveTempPwd, updateTempPwd, reportUpdateTempPwd, sync, reportSync, };

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

@@ -187,7 +187,44 @@ const reportSync = [
         name: "stage",
     },
     {
-        name: "package",
+        name: "packageNo",
+    },
+    {
+        condition: {
+            prop: "stage",
+            value: 0,
+        },
+        name: "data",
+        loop: true,
+        type: "child",
+        childMap: [
+            {
+                name: "unlockId",
+            },
+            {
+                name: "unlockType",
+            },
+            {
+                condition: {
+                    prop: "unlockType",
+                    operation: "neq",
+                    value: 0xf0,
+                },
+                name: "memberId",
+            },
+            {
+                condition: {
+                    prop: "unlockType",
+                    operation: "eq",
+                    value: 0xf0,
+                },
+                name: "cloundNo",
+                bytes: 2,
+            },
+            {
+                name: "status",
+            },
+        ],
     },
 ];
 export { add, reportAdd, remove, reportRemove, update, updateMemberRole, reportUpdate, addTempPwd, reportAddTempPwd, removeTempPwd, reportRemoveTempPwd, updateTempPwd, reportUpdateTempPwd, sync, reportSync, };

package/lib/config/index.d.ts

@@ -16,6 +16,7 @@ declare const config: {
     strictMode: boolean;
     imageAngle: number;
     videoAngle: number;
+    supportMultipleFace: boolean;
     deviceStatus: DeviceStatus;
 };
 export default config;

package/lib/config/index.js

@@ -14,6 +14,7 @@ const config = {
     strictMode: true,
     imageAngle: 0,
     videoAngle: 0,
+    supportMultipleFace: false,
     deviceStatus: {
         type: "offline",
         connectEanble: false,

package/lib/interface.d.ts

@@ -266,6 +266,12 @@ export interface TempPasswordResult {
     unlockBindingId: string;
     effectiveConfig: EffectiveConfig;
 }
+export interface CreateOnlineUnlimitedResult {
+    type: "custom";
+    name: string;
+    pwdId: string;
+    effectiveConfig: EffectiveConfig;
+}
 export interface AlbumMessage extends MediaInfo {
     id: string;
     aiInfos: {

package/lib/log.js

@@ -97,6 +97,9 @@ export const openDps = [
     dpCodes.unlockBle,
     dpCodes.unlockOfflinePd,
     dpCodes.unlockDynamic,
+    dpCodes.unlockInside,
+    dpCodes.doorOpened,
+    dpCodes.unlockApp,
 ];
 const closeTypes = [
     "UNDEFINED",

package/lib/media.d.ts

@@ -2,8 +2,12 @@ interface GetMediaUrlParams {
     mediaPath: string;
     mediaBucket: string;
 }
+interface GetFileUrlParams {
+    filePath: string;
+    bucket: string;
+}
 interface MediaUrlResult {
     mediaUrl: string;
 }
-export declare const getMediaUrl: (params: GetMediaUrlParams) => Promise<MediaUrlResult>;
+export declare const getMediaUrl: (params: GetMediaUrlParams | GetFileUrlParams) => Promise<MediaUrlResult>;
 export {};

package/lib/media.js

@@ -1,9 +1,19 @@
 import { getMediaUrl as getMediaUrlApi } from "./api/log";
 import config from "./config";
 export const getMediaUrl = async (params) => {
-    return getMediaUrlApi({
-        devId: config.devInfo.devId,
-        mediaPath: params.mediaPath,
-        mediaBucket: params.mediaBucket,
-    });
+    if ("mediaPath" in params && "mediaBucket" in params) {
+        return getMediaUrlApi({
+            devId: config.devInfo.devId,
+            mediaPath: params.mediaPath,
+            mediaBucket: params.mediaBucket,
+        });
+    }
+    else if ("filePath" in params && "bucket" in params) {
+        return getMediaUrlApi({
+            devId: config.devInfo.devId,
+            filePath: params.filePath,
+            bucket: params.bucket,
+        });
+    }
+    throw new Error("Invalid parameters");
 };

package/lib/open.d.ts

@@ -11,3 +11,9 @@ export declare const getRemoteEnabled: () => boolean;
 export declare const getRemotePermissionList: () => RemotePermission[];
 export declare const getRemotePermission: () => RemotePermission;
 export declare const updateRemotePermission: (permission: RemotePermission) => Promise<void>;
+export declare const agreeOpenDoor: (option?: {
+    timeout?: number;
+} | undefined) => Promise<unknown>;
+export declare const rejectOpenDoor: (option?: {
+    timeout?: number;
+} | undefined) => Promise<unknown>;

package/lib/open.js

@@ -1,5 +1,5 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
-import { getDoorKey, openDoorByCloud } from "./api/lock";
+import { getDoorKey, openDoorByCloud, isConfirmOpenDoorByWifiPro, } from "./api/lock";
 import config from "./config";
 import { isUseNearChannel, parallelMerge, parallelOnly } from "./utils";
 import { decrypt } from "./utils/device";
@@ -160,3 +160,36 @@ export const updateRemotePermission = async (permission) => {
     });
     config.remoteOpenPermission = permission;
 };
+const handleOpenDoor = (confirm, timeout) => {
+    const { devInfo } = config;
+    return new Promise((resolve, reject) => {
+        const handleReport = (dpData) => {
+            if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
+                timeoutTask && clearTimeout(timeoutTask);
+                const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
+                if (result.status !== 0x00) {
+                    reject(getReportError(result.status));
+                }
+                else {
+                    resolve(true);
+                }
+            }
+        };
+        const timeoutTask = setTimeout(() => {
+            emitter.off(DPCHANGE, handleReport);
+            reject(getError(1002));
+        }, timeout);
+        emitter.on(DPCHANGE, handleReport);
+        isConfirmOpenDoorByWifiPro(devInfo.devId, confirm).catch((e) => {
+            timeoutTask && clearTimeout(timeoutTask);
+            emitter.off(DPCHANGE, handleReport);
+            reject(getError(1003));
+        });
+    });
+};
+export const agreeOpenDoor = parallelOnly((option) => {
+    return handleOpenDoor(true, option?.timeout || 15000);
+});
+export const rejectOpenDoor = parallelOnly((option) => {
+    return handleOpenDoor(false, option?.timeout || 15000);
+});

package/lib/other.js

@@ -6,7 +6,7 @@ import { getDpValue } from "./state";
 import { openPanel } from "./utils/device";
 import { getError } from "./utils/errors";
 import { publishDps } from "./utils/publishDps";
-const { alarmLock, unlockFingerprint, unlockPassword, unlockCard, unlockKey, unlockPhoneRemote, } = dpCodes;
+const { alarmLock, unlockFingerprint, unlockPassword, unlockCard, unlockKey, unlockPhoneRemote, unlockTemporary, unlockDynamic, unlockFace, unlockHand, unlockEye, unlockFingerVein, unlockInside, doorOpened, unlockApp, unlockOfflinePd, openInside, lockRecord, unlockDoubleKit, lockLocalRecord, } = dpCodes;
 const abilityMap = {
     backHome: "supportBackHome",
     alarm: "supportAlarm",
@@ -18,6 +18,20 @@ export const openScene = async (options) => {
         unlockCard,
         unlockKey,
         unlockPhoneRemote,
+        unlockTemporary,
+        unlockDynamic,
+        unlockFace,
+        unlockHand,
+        unlockEye,
+        unlockFingerVein,
+        unlockInside,
+        doorOpened,
+        unlockApp,
+        unlockOfflinePd,
+        openInside,
+        lockRecord,
+        unlockDoubleKit,
+        lockLocalRecord,
     ].reduce((acc, item) => {
         const id = config.idsByCode[item];
         if (id) {

package/lib/temporary.d.ts

@@ -74,4 +74,97 @@ interface RenameParams {
     name: string;
 }
 export declare const renameTemp: (params: RenameParams) => Promise<void>;
+interface CreateOnlineUnlimitedParams {
+    password: string;
+    name: string;
+    effective: EffectiveConfig;
+    phone?: string;
+    countryCode?: string;
+}
+export declare const saveTempOnlineUnlimited: (params: CreateOnlineUnlimitedParams) => Promise<{
+    type: string;
+    name: string;
+    pwdId: string;
+    effectiveConfig: EffectiveConfig;
+}>;
+interface CreateOfflineParams {
+    name: string;
+    effective: EffectiveConfig;
+    isOnce: boolean;
+}
+export type OfflineTempType = "once" | "multiple";
+export interface OfflineTempResult {
+    type: OfflineTempType;
+    name: string;
+    password: string;
+    unlockBindingId: string;
+    pwdId: string;
+    effectiveConfig: EffectiveConfig;
+}
+export declare const createTempOffline: (params: CreateOfflineParams) => Promise<{
+    type: string;
+    name: string;
+    password: string;
+    unlockBindingId: string;
+    pwdId: string;
+    effectiveConfig: {
+        effectiveDate: number;
+        expiredDate: number;
+    };
+}>;
+export declare const removeTempOnlineUnlimited: (id: string) => Promise<void>;
+export interface OnlinePasswordItem {
+    effective: number;
+    unlockBindingId: string;
+    effectiveTime: number;
+    invalidTime: number;
+    name: string;
+    phase: number;
+    scheduleDetails: EffectiveConfig;
+    status: "effective" | "synchronizing" | "expired" | "disabled" | "invalid";
+}
+export declare const getTempOnlineUnlimitedList: () => Promise<{
+    status: string;
+    effectiveConfig: EffectiveConfig;
+    effective: number;
+    unlockBindingId: string;
+    effectiveTime: number;
+    failReason: number;
+    invalidTime: number;
+    name: string;
+    phase: number;
+    scheduleDetails: {
+        allDay: boolean;
+        effectiveTime: number;
+        invalidTime: number;
+        timeZoneId: string;
+        workingDay: number;
+    }[];
+    opModeType: number;
+    opModeSubType: number;
+    sn: number;
+    opModeInfo?: {
+        hasClearPwd?: boolean;
+        revokedPwdName?: string;
+        revokedPwdEffectiveTime?: number;
+        revokedPwdInvalidTime?: number;
+    };
+}[]>;
+export interface OfflinePasswordItem {
+    email: string;
+    gmtExpired: number;
+    gmtStart: number;
+    hasClearPwd: boolean;
+    mobile: string;
+    pwd: string;
+    pwdId: string;
+    pwdName: string;
+    pwdTypeCode: "once" | "multiple" | "clear_one" | "clear_all";
+    revokedPwdName: string;
+    status: number;
+    timeZoneId: string;
+}
+export type OfflinePasswordType = "once" | "multiple" | "clear_one" | "clear_all";
+export declare const getTempOfflineEffectiveList: (pwdTypeCode: OfflinePasswordType) => Promise<import("./api/temp").EffectivePasswrodItem[]>;
+export declare const getTempOfflineInvalidList: (pwdTypeCode: OfflinePasswordType) => Promise<import("./api/temp").EffectivePasswrodItem[]>;
 export {};

package/lib/temporary.js

@@ -1,4 +1,4 @@
-import { clearInvalidTempList, createOfflinePassword, createTemporaryPassword, deleteTempPassword, fetchEffectiveList, fetchInvalidList, getDynamicPassword, reNameOffline, reNameTemporary, revokeOfflinePassword, updateTemporaryPassword, validateTempPwd, } from "./api/temp";
+import { clearInvalidTempList, createOfflinePassword, createTemporaryPassword, deleteTempPassword, fetchEffectiveList, fetchInvalidList, getDynamicPassword, reNameOffline, reNameTemporary, revokeOfflinePassword, updateTemporaryPassword, validateTempPwd, createOnlineUnlimited, removeTempOnlineUnlimitedAPI, getTempOnlineUnlimitedListAPI, getTempOfflineListAPI, createOfflineOnceAPI, } from "./api/temp";
 import config from "./config";
 import { formatWeek, isUseNearChannel, parallelOnly, parseOfflinePassword, parseWeek, validateEffectiveConfig, } from "./utils";
 import { LoopTypes } from "./utils/constant";
@@ -511,3 +511,173 @@ export const renameTemp = async (params) => {
         handleError(e);
     }
 };
+export const saveTempOnlineUnlimited = async (params) => {
+    const { password, name, effective, phone, countryCode } = params;
+    if (!PASSWORD_REGEX.test(password)) {
+        throw getError(1030);
+    }
+    if (name && name.length > 20) {
+        throw getError(1031);
+    }
+    validateEffectiveConfig(effective);
+    const { effectiveTime = 0, expiredTime = 1439 } = effective;
+    const aesPwd = await encrypt(config.devInfo.devId, password);
+    const loopType = effective?.repeat
+        ?
+            LoopTypes[effective?.repeat?.toUpperCase()]
+        : LoopTypes.NONE;
+    const schedule = [
+        {
+            allDay: loopType === LoopTypes.NONE,
+            effectiveTime,
+            invalidTime: expiredTime,
+            workingDay: formatWeek(effective?.weeks ?? [0]),
+        },
+    ];
+    try {
+        const res = await createOnlineUnlimited({
+            devId: config.devInfo.devId,
+            effectiveTime: effective.effectiveDate,
+            invalidTime: effective.expiredDate,
+            name: name,
+            password: aesPwd,
+            schedule,
+            availTime: 0,
+            phone,
+            countryCode,
+        });
+        return {
+            type: "custom",
+            name: res.name,
+            pwdId: res.pwdId,
+            effectiveConfig: effective,
+        };
+    }
+    catch (error) {
+        throw handleError(error);
+    }
+};
+export const createTempOffline = async (params) => {
+    const { name, effective, isOnce } = params;
+    if (isOnce) {
+        const res = await createOfflineOnceAPI({
+            devId: config.devInfo.devId,
+            pwdType: "1",
+            gmtStart: "0",
+            gmtExpired: "0",
+        });
+        return {
+            type: "once",
+            name: res.pwdName,
+            password: parseOfflinePassword(res.pwd),
+            unlockBindingId: res.unlockBindingId,
+            pwdId: res.pwdId,
+            effectiveConfig: {
+                effectiveDate: Number(res.gmtStart),
+                expiredDate: Number(res.gmtExpired),
+            },
+        };
+    }
+    else {
+        if (name && name.length > 20) {
+            throw getError(1031);
+        }
+        if (effective.effectiveDate >= effective.expiredDate) {
+            throw getError(1010);
+        }
+        const res = await createOfflineOnceAPI({
+            devId: config.devInfo.devId,
+            pwdType: "0",
+            gmtStart: effective.effectiveDate.toString(),
+            gmtExpired: effective.expiredDate.toString(),
+        });
+        return {
+            type: "multiple",
+            name: res.pwdName,
+            password: parseOfflinePassword(res.pwd),
+            unlockBindingId: res.unlockBindingId,
+            pwdId: res.pwdId,
+            effectiveConfig: {
+                effectiveDate: Number(res.gmtStart),
+                expiredDate: Number(res.gmtExpired),
+            },
+        };
+    }
+};
+export const removeTempOnlineUnlimited = async (id) => {
+    try {
+        await removeTempOnlineUnlimitedAPI({
+            devId: config.devInfo.devId,
+            id,
+        });
+    }
+    catch (error) {
+        throw handleError(error);
+    }
+};
+const onLinePasswordStatusMap = {
+    1: "effective",
+    2: "synchronizing",
+    3: "expired",
+    4: "disabled",
+    5: "invalid",
+};
+export const getTempOnlineUnlimitedList = async () => {
+    try {
+        const pswList = await getTempOnlineUnlimitedListAPI(config.devInfo.devId);
+        const newPswList = pswList?.map((item) => {
+            const status = onLinePasswordStatusMap[item.effective];
+            const effectiveConfig = {
+                effectiveDate: item.effectiveTime,
+                expiredDate: item.invalidTime,
+            };
+            if (item.scheduleDetails?.length) {
+                const scheduleDetail = item.scheduleDetails[0];
+                effectiveConfig.repeat =
+                    scheduleDetail.allDay === false ? "week" : "none";
+                if (effectiveConfig.repeat === "week") {
+                    effectiveConfig.weeks = parseWeek(scheduleDetail.workingDay);
+                    effectiveConfig.effectiveTime = scheduleDetail.effectiveTime;
+                    effectiveConfig.expiredTime = scheduleDetail.invalidTime;
+                }
+            }
+            return { ...item, status, effectiveConfig };
+        });
+        return newPswList;
+    }
+    catch (error) {
+        throw handleError(error);
+    }
+};
+const offlinePasswordTypeMap = {
+    once: "1",
+    multiple: "0",
+    clear_one: "8",
+    clear_all: "9",
+};
+export const getTempOfflineEffectiveList = async (pwdTypeCode) => {
+    try {
+        const offLineValidPswList = await getTempOfflineListAPI({
+            devId: config.devInfo.devId,
+            pwdType: offlinePasswordTypeMap[pwdTypeCode],
+            status: "1",
+        });
+        return offLineValidPswList;
+    }
+    catch (error) {
+        throw handleError(error);
+    }
+};
+export const getTempOfflineInvalidList = async (pwdTypeCode) => {
+    try {
+        const offLineFailurePswList = await getTempOfflineListAPI({
+            devId: config.devInfo.devId,
+            pwdType: offlinePasswordTypeMap[pwdTypeCode],
+            status: "0",
+        });
+        return offLineFailurePswList;
+    }
+    catch (error) {
+        throw handleError(error);
+    }
+};

package/lib/unlock-method.js

@@ -13,6 +13,7 @@ import { encrypt } from "./utils/device";
 import emitter from "./utils/event";
 import { DPCHANGE, UNLOCK_METHOD_EVENT } from "./utils/constant";
 import { sendPhoneVerifyCode } from "./api";
+import { getUserInfo } from "./user";
 const getAddUnlockError = (status) => {
     if (status >= 0 && status <= 10) {
         return getError(1015 + status);
@@ -261,19 +262,48 @@ const handleAddReport = async (dps) => {
                 clearMonitoringAddReport();
                 try {
                     await sleep(300);
-                    const res = await createUnlockMethod({
-                        devId: config.devInfo.devId,
-                        userId: addUnlockMethodData.userId,
-                        unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
-                        unlockName: "",
-                        unlockAttr: 0,
-                    });
-                    eventData = {
-                        stage: "success",
-                        type,
-                        id: res.opModeId,
-                        name: res.unlockName,
-                    };
+                    let isAddEnabled = true;
+                    if (!config.supportMultipleFace && type === "face") {
+                        const user = await getUserInfo({
+                            userId: addUnlockMethodData.userId,
+                        });
+                        const faceData = user.unlockDetails.find((item) => item.type === "face" && item.unlockList.length > 0);
+                        if (faceData) {
+                            const originUnlockId = faceData.unlockList[0].unlockId;
+                            if (originUnlockId !== result.unlockId) {
+                                eventData = {
+                                    stage: "fail",
+                                    type,
+                                    lockUserId: result.memberId,
+                                    error: getError(1061),
+                                };
+                            }
+                            else {
+                                eventData = {
+                                    stage: "success",
+                                    type,
+                                    id: faceData.unlockList[0].id,
+                                    name: faceData.unlockList[0].unlockName,
+                                };
+                            }
+                            isAddEnabled = false;
+                        }
+                    }
+                    if (isAddEnabled) {
+                        const res = await createUnlockMethod({
+                            devId: config.devInfo.devId,
+                            userId: addUnlockMethodData.userId,
+                            unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                            unlockName: "",
+                            unlockAttr: 0,
+                        });
+                        eventData = {
+                            stage: "success",
+                            type,
+                            id: res.opModeId,
+                            name: res.unlockName,
+                        };
+                    }
                 }
                 catch {
                     eventData = {

package/lib/user.d.ts

@@ -10,7 +10,6 @@ export declare const getUsers: (params?: getUsersParams) => Promise<{
 }>;
 interface getUserInfoParams {
     userId: string;
-    nickName: string;
 }
 export declare const getUserInfo: (params: getUserInfoParams) => Promise<UserInfo>;
 interface updateUserLimitTimeParams {
@@ -21,6 +20,8 @@ interface updateUserLimitTimeParams {
     offlineUnlock?: boolean;
 }
 export declare const updateUserLimitTime: (params: updateUserLimitTimeParams) => Promise<boolean>;
+export declare const openAddFamilyUser: () => Promise<unknown>;
+export declare const openFamilyUserDetail: (userId: string) => Promise<undefined>;
 interface AddUserParams {
     name: string;
 }

package/lib/user.js

@@ -9,6 +9,7 @@ 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 { getCurrentHomeInfo, isSupportShortLink } from "./utils/device";
 import { LoopTypes } from "./utils/constant";
 import { getCurrentUser } from "./state";
 const concactUserList = (list, result) => {
@@ -94,8 +95,12 @@ export const getUsers = async (params) => {
     };
 };
 export const getUserInfo = async (params) => {
+    const user = await getUserDetail({
+        devId: config.devInfo.devId,
+        userId: params.userId,
+    });
     const data = await getUsers({
-        keyword: params.nickName,
+        keyword: user.nickName,
     });
     const res = data.list.find((item) => item.userId === params.userId);
     if (res) {
@@ -199,6 +204,54 @@ export const updateUserLimitTime = async (params) => {
     }
     return true;
 };
+export const openAddFamilyUser = async () => {
+    const homeInfo = await getCurrentHomeInfo();
+    let link = await isSupportShortLink("tysh_family_add_member_rn");
+    if (!link) {
+        link = await isSupportShortLink("thingsh_family_add_member_rn");
+    }
+    if (link) {
+        const url = `tuyaSmart://${link}?homeId=${homeInfo.homeId}`;
+        return new Promise((resolve, reject) => {
+            ty.router({
+                url: url,
+                success: (d) => {
+                    resolve(true);
+                },
+                fail: (e) => {
+                    reject(e);
+                },
+            });
+        });
+    }
+    return Promise.reject(getError(1013));
+};
+const userTypeMap = {
+    "10": 1,
+    "20": 0,
+    "40": -1,
+    "50": 2,
+};
+export const openFamilyUserDetail = async (userId) => {
+    const { homeId } = await getCurrentHomeInfo();
+    const { userType: currentUserType } = await getCurrentUser();
+    const role = userTypeMap[currentUserType];
+    let link = await isSupportShortLink("member_info");
+    if (link) {
+        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);
+            },
+        });
+        return;
+    }
+    return Promise.reject(getError(1013));
+};
 export const addUser = async (params) => {
     if (!config.supportBigData) {
         throw getError(1060);

package/lib/utils/errors.js

@@ -59,6 +59,7 @@ const errors = {
     1058: "Special unlock method app message notification or phone SMS must be enabled",
     1059: "Doorbell notification service not enabled",
     1060: "Does not support adding normal members",
+    1061: "Hardware ID does not match When update face",
 };
 export const getError = (code, ...places) => {
     if (errors[code]) {

package/package.json

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