@ray-js/lock-sdk 1.1.3 → 1.2.0-beta.10

package/lib/feature/unlock/method/add-flow.js

@@ -0,0 +1,403 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { createUnlockMethod } from "../../../api/lock";
+import { parallelOnlyForRuntime } from "../../utils";
+import { sleep } from "../../../utils";
+import { getError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import emitter from "../../../utils/event";
+import { DPCHANGE } from "../../../utils/constant";
+import { getUserInfoForRuntime } from "../../user/user";
+import { getUnlockMethodEvent } from "./add-method-events";
+import { getUnlockMethodBase } from "./internal/base";
+import { getAddUnlockError } from "./internal/errors";
+import { sdkLog } from "../../../utils/sdk-log";
+const ADD_UNLOCK_METHOD_EVENT_RELEASE_DELAY = 16;
+const addUnlockMethodData = {
+    unlockMethodConfig: {},
+    total: 0,
+    dpCode: "",
+    dpMap: {},
+    sn: 0,
+    lockUserId: 0,
+    timeoutId: 0,
+    userId: "",
+    unlockDpId: 0,
+    timeout: 15000,
+    runtime: null,
+    canEmitEvents: true,
+    pendingEvents: [],
+    releaseEmitTimer: 0,
+    eventSessionId: 0,
+};
+let isCancelAddUnlockMethod = false;
+const dispatchAddUnlockMethodEvent = (eventKey, eventData) => {
+    if (emitter.hasListener(eventKey)) {
+        emitter.emit(eventKey, eventData);
+    }
+    else {
+        emitter.cache(eventKey, eventData);
+    }
+};
+const emitAddUnlockMethodEvent = (rt, eventData) => {
+    const eventKey = getUnlockMethodEvent(rt);
+    if (!addUnlockMethodData.canEmitEvents) {
+        addUnlockMethodData.pendingEvents.push({ eventKey, eventData });
+        return;
+    }
+    dispatchAddUnlockMethodEvent(eventKey, eventData);
+};
+const releaseAddUnlockMethodEventsAfterStart = (eventSessionId) => {
+    clearTimeout(addUnlockMethodData.releaseEmitTimer);
+    addUnlockMethodData.releaseEmitTimer = setTimeout(() => {
+        if (addUnlockMethodData.eventSessionId !== eventSessionId) {
+            return;
+        }
+        addUnlockMethodData.releaseEmitTimer = setTimeout(() => {
+            if (addUnlockMethodData.eventSessionId !== eventSessionId) {
+                return;
+            }
+            addUnlockMethodData.canEmitEvents = true;
+            const pendingEvents = addUnlockMethodData.pendingEvents.splice(0);
+            pendingEvents.forEach(({ eventKey, eventData }) => {
+                dispatchAddUnlockMethodEvent(eventKey, eventData);
+            });
+        }, ADD_UNLOCK_METHOD_EVENT_RELEASE_DELAY);
+    }, 0);
+};
+const handleAddTimeout = (timeout = 15000) => {
+    clearTimeout(addUnlockMethodData.timeoutId);
+    addUnlockMethodData.timeoutId = setTimeout(() => {
+        emitter.off(DPCHANGE, handleAddReport);
+        const rt = addUnlockMethodData.runtime;
+        if (!rt)
+            return;
+        emitAddUnlockMethodEvent(rt, {
+            type: addUnlockMethodData.unlockMethodConfig.type,
+            stage: "fail",
+            lockUserId: addUnlockMethodData.lockUserId,
+            error: getError(1002),
+        });
+    }, timeout);
+};
+const handleAddReport = async (dps) => {
+    const rt = addUnlockMethodData.runtime;
+    if (!rt) {
+        return;
+    }
+    const cfg = rt.config;
+    if (dps[addUnlockMethodData.dpCode]) {
+        const result = dpUtils.parse(dps[addUnlockMethodData.dpCode], addUnlockMethodData.dpMap);
+        let eventData = null;
+        if (result.type !== addUnlockMethodData.unlockMethodConfig.id) {
+            return;
+        }
+        if (cfg.strictMode) {
+            if (result.sn !== addUnlockMethodData.sn ||
+                result.memberId !== addUnlockMethodData.lockUserId) {
+                return;
+            }
+        }
+        else {
+            if (result.sn !== addUnlockMethodData.sn) {
+                sdkLog("warn", "unlockMethod", "addReportSnMismatch", {
+                    devId: rt.devId,
+                    data: { type: addUnlockMethodData.unlockMethodConfig.type },
+                });
+            }
+            if (result.memberId !== addUnlockMethodData.lockUserId) {
+                sdkLog("warn", "unlockMethod", "addReportMemberMismatch", {
+                    devId: rt.devId,
+                    data: { type: addUnlockMethodData.unlockMethodConfig.type },
+                });
+            }
+        }
+        const type = addUnlockMethodData.unlockMethodConfig.type;
+        switch (result.stage) {
+            case 0xfc: {
+                handleAddTimeout(addUnlockMethodData.timeout);
+                sdkLog("debug", "unlockMethod", "addStep", {
+                    devId: rt.devId,
+                    data: {
+                        type,
+                        step: result.step,
+                        total: addUnlockMethodData.total,
+                    },
+                });
+                eventData = {
+                    type,
+                    stage: "step",
+                    lockUserId: result.memberId,
+                    step: result.step,
+                    total: addUnlockMethodData.total,
+                };
+                break;
+            }
+            case 0xfd: {
+                clearMonitoringAddReport();
+                sdkLog("warn", "unlockMethod", "addReportFail", {
+                    devId: rt.devId,
+                    data: { type, status: result.status },
+                });
+                eventData = {
+                    stage: "fail",
+                    type,
+                    lockUserId: result.memberId,
+                    error: getAddUnlockError(result.status),
+                };
+                break;
+            }
+            case 0xfe: {
+                clearMonitoringAddReport();
+                if (isCancelAddUnlockMethod) {
+                    isCancelAddUnlockMethod = false;
+                    sdkLog("info", "unlockMethod", "addCancelled", {
+                        devId: rt.devId,
+                        data: { type },
+                    });
+                    return;
+                }
+                sdkLog("warn", "unlockMethod", "addReportFail", {
+                    devId: rt.devId,
+                    data: { type, status: result.status },
+                });
+                eventData = {
+                    stage: "fail",
+                    type,
+                    lockUserId: result.memberId,
+                    error: getAddUnlockError(result.status),
+                };
+                break;
+            }
+            case 0xff: {
+                clearMonitoringAddReport();
+                try {
+                    await sleep(300);
+                    sdkLog("debug", "unlockMethod", "cloudCreateStart", {
+                        devId: rt.devId,
+                        data: { type },
+                    });
+                    let isAddEnabled = true;
+                    if (!cfg.supportMultipleFace && type === "face") {
+                        const user = await getUserInfoForRuntime(rt, {
+                            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: cfg.devInfo.devId,
+                            userId: addUnlockMethodData.userId,
+                            unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                            unlockName: "",
+                            unlockAttr: 0,
+                        });
+                        eventData = {
+                            stage: "success",
+                            type,
+                            id: res.opModeId,
+                            name: res.unlockName,
+                        };
+                        sdkLog("info", "unlockMethod", "addSuccess", {
+                            devId: rt.devId,
+                            data: { type, opModeId: res.opModeId },
+                        });
+                    }
+                }
+                catch (err) {
+                    sdkLog("warn", "unlockMethod", "cloudCreateFail", {
+                        devId: rt.devId,
+                        data: { type },
+                        error: err,
+                    });
+                    eventData = {
+                        stage: "fail",
+                        type,
+                        lockUserId: result.memberId,
+                        error: getError(1053),
+                    };
+                }
+                break;
+            }
+            default:
+        }
+        if (eventData) {
+            emitAddUnlockMethodEvent(rt, eventData);
+        }
+    }
+};
+const clearMonitoringAddReport = () => {
+    clearTimeout(addUnlockMethodData.timeoutId);
+    emitter.off(DPCHANGE, handleAddReport);
+    addUnlockMethodData.runtime = null;
+};
+const monitoringAddReport = (option) => {
+    Object.assign(addUnlockMethodData, option);
+    clearTimeout(addUnlockMethodData.releaseEmitTimer);
+    addUnlockMethodData.canEmitEvents = false;
+    addUnlockMethodData.pendingEvents = [];
+    addUnlockMethodData.eventSessionId += 1;
+    emitter.clearCache(getUnlockMethodEvent(option.runtime));
+    emitter.off(DPCHANGE, handleAddReport);
+    emitter.on(DPCHANGE, handleAddReport);
+    handleAddTimeout(option.timeout);
+    return addUnlockMethodData.eventSessionId;
+};
+export async function startAddUnlockMethodForRuntime(rt, params) {
+    const startedAt = Date.now();
+    const cfg = rt.config;
+    const { unlockMethodConfig, lockUserId, dpData, sn, addDpCode, addDpMap, addDpReportMap, dpId, } = await getUnlockMethodBase(rt, params.type, params.userId);
+    isCancelAddUnlockMethod = false;
+    sdkLog("info", "unlockMethod", "startAdd", {
+        devId: rt.devId,
+        data: {
+            type: params.type,
+            userId: params.userId,
+            dpCode: addDpCode,
+            timeout: params.timeout,
+        },
+    });
+    let addReportMonitoringStarted = false;
+    let addReportMonitoringSessionId = 0;
+    const startAddReportMonitoring = (total) => {
+        if (addReportMonitoringStarted) {
+            return addReportMonitoringSessionId;
+        }
+        addReportMonitoringStarted = true;
+        addReportMonitoringSessionId = monitoringAddReport({
+            runtime: rt,
+            timeout: params.timeout,
+            unlockMethodConfig,
+            total,
+            dpCode: addDpCode,
+            dpMap: addDpReportMap,
+            sn,
+            lockUserId,
+            userId: params.userId,
+            unlockDpId: dpId,
+        });
+        return addReportMonitoringSessionId;
+    };
+    const res = await publishDpsForRuntime(rt, {
+        [addDpCode]: dpUtils.format(dpData, addDpMap),
+    }, {
+        timeout: params.timeout,
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[addDpCode] !== "undefined") {
+                const result = dpUtils.parse(dpDataIn[addDpCode], addDpReportMap);
+                let hasReport = result.type === unlockMethodConfig.id;
+                if (cfg.strictMode) {
+                    hasReport =
+                        hasReport && result.memberId === lockUserId && result.sn === sn;
+                }
+                if (hasReport) {
+                    if (result.memberId !== lockUserId) {
+                        sdkLog("warn", "unlockMethod", "startReportMemberMismatch", {
+                            devId: rt.devId,
+                            data: { type: params.type },
+                        });
+                    }
+                    if (result.sn !== sn) {
+                        sdkLog("warn", "unlockMethod", "startReportSnMismatch", {
+                            devId: rt.devId,
+                            data: { type: params.type },
+                        });
+                    }
+                    if (result.stage === 0) {
+                        startAddReportMonitoring(result.total);
+                    }
+                    return result;
+                }
+                return false;
+            }
+            sdkLog("warn", "unlockMethod", "startInvalidReport", {
+                devId: rt.devId,
+                data: { type: params.type, dpCode: addDpCode },
+            });
+            return false;
+        },
+    });
+    if (res.stage === 0) {
+        const eventSessionId = startAddReportMonitoring(res.total);
+        sdkLog("info", "unlockMethod", "startAddSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { type: params.type, total: res.total },
+        });
+        releaseAddUnlockMethodEventsAfterStart(eventSessionId);
+        return { total: res.total };
+    }
+    if (res.stage === 0xfd) {
+        const error = getAddUnlockError(res.status);
+        sdkLog("warn", "unlockMethod", "startAddRejected", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { type: params.type, status: res.status },
+            error,
+        });
+        throw error;
+    }
+    const error = getError(1027);
+    sdkLog("warn", "unlockMethod", "startAddUnexpectedStage", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { type: params.type, stage: res.stage },
+        error,
+    });
+    throw error;
+}
+export const cancelAddUnlockMethodForRuntime = parallelOnlyForRuntime(async function cancelAddUnlockMethodForRuntime(rt, params) {
+    const cfg = rt.config;
+    sdkLog("info", "unlockMethod", "cancelAdd", {
+        devId: rt.devId,
+        data: { type: params.type, userId: params.userId },
+    });
+    const { dpData, addDpCode, addDpMap, addDpReportMap, unlockMethodConfig, lockUserId, sn, } = await getUnlockMethodBase(rt, params.type, params.userId);
+    dpData.stage = 0xfe;
+    isCancelAddUnlockMethod = true;
+    await publishDpsForRuntime(rt, {
+        [addDpCode]: dpUtils.format(dpData, addDpMap),
+    }, {
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[addDpCode] !== "undefined") {
+                const result = dpUtils.parse(dpDataIn[addDpCode], addDpReportMap);
+                let hasReport = result.type === unlockMethodConfig.id;
+                if (cfg.strictMode) {
+                    hasReport =
+                        hasReport &&
+                            result.stage === 0xfe &&
+                            result.memberId === lockUserId &&
+                            result.sn === sn;
+                }
+                if (hasReport) {
+                    return result;
+                }
+                sdkLog("warn", "unlockMethod", "cancelInvalidReport", {
+                    devId: rt.devId,
+                    data: { type: params.type },
+                });
+            }
+            return false;
+        },
+    });
+    return;
+});

package/lib/feature/unlock/method/add-method-events.d.ts

@@ -0,0 +1,5 @@
+import type { AddUnlockMethodListener } from "./types";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function getUnlockMethodEvent(runtime: LockDeviceRuntime): string;
+export declare const onAddUnlockMethodForRuntime: (runtime: LockDeviceRuntime, listener: AddUnlockMethodListener) => void;
+export declare const offAddUnlockMethodForRuntime: (runtime: LockDeviceRuntime, listener: AddUnlockMethodListener) => void;

package/lib/feature/unlock/method/add-method-events.js

@@ -0,0 +1,11 @@
+import emitter from "../../../utils/event";
+import { UNLOCK_METHOD_EVENT } from "../../../utils/constant";
+export function getUnlockMethodEvent(runtime) {
+    return `${UNLOCK_METHOD_EVENT}_${runtime.devId}`;
+}
+export const onAddUnlockMethodForRuntime = (runtime, listener) => {
+    emitter.on(getUnlockMethodEvent(runtime), listener);
+};
+export const offAddUnlockMethodForRuntime = (runtime, listener) => {
+    emitter.off(getUnlockMethodEvent(runtime), listener);
+};

package/lib/feature/unlock/method/add-password.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { AddPasswordParams } from "./types";
+export declare function addPasswordForRuntime(rt: LockDeviceRuntime, params: AddPasswordParams): Promise<import("../../../api/lock").CreateUnlockMethodResult>;

package/lib/feature/unlock/method/add-password.js

@@ -0,0 +1,99 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { createUnlockMethod } from "../../../api/lock";
+import { encrypt } from "../../../platform/device";
+import { sleep } from "../../../utils";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { getUnlockMethodBase } from "./internal/base";
+import { checkSpecial } from "./internal/special-check";
+import { getAddUnlockError } from "./internal/errors";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function addPasswordForRuntime(rt, params) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "unlockMethod", "addPasswordStart", {
+        devId: rt.devId,
+        data: {
+            userId: params.userId,
+            hasName: typeof params.name === "string",
+            isSpecial: !!params.isSpecial,
+        },
+    });
+    if (!params.password) {
+        const error = getError(1054);
+        sdkLog("warn", "unlockMethod", "addPasswordEmpty", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    const specialInfo = checkSpecial(rt, !!params.isSpecial, params.specialInfo);
+    const { lockUserId, dpData, sn, addDpCode, addDpMap, addDpReportMap, devId, dpId, unlockMethodConfig, } = await getUnlockMethodBase(rt, "password", params.userId);
+    dpData.pwdLength = params.password.length;
+    dpData.pwd = params.password.split("").map(Number);
+    const res = await publishDpsForRuntime(rt, {
+        [addDpCode]: dpUtils.format(dpData, addDpMap),
+    }, {
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[addDpCode] !== "undefined") {
+                const result = dpUtils.parse(dpDataIn[addDpCode], addDpReportMap);
+                let hasReport = result.type === unlockMethodConfig.id &&
+                    [0xff, 0xfd].includes(result.stage);
+                if (cfg.strictMode) {
+                    hasReport =
+                        hasReport && result.memberId === lockUserId && result.sn === sn;
+                }
+                if (hasReport) {
+                    if (result.memberId !== lockUserId) {
+                        sdkLog("warn", "unlockMethod", "addPasswordMemberMismatch", {
+                            devId: rt.devId,
+                        });
+                    }
+                    return result;
+                }
+                return false;
+            }
+            sdkLog("warn", "unlockMethod", "addPasswordInvalidReport", {
+                devId: rt.devId,
+                data: { dpCode: addDpCode },
+            });
+            return false;
+        },
+    });
+    if (res.stage === 0xfd) {
+        const error = getAddUnlockError(res.status);
+        sdkLog("warn", "unlockMethod", "addPasswordDpRejected", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { status: res.status },
+            error,
+        });
+        throw error;
+    }
+    const aesPwd = await encrypt(devId, params.password);
+    await sleep(300);
+    try {
+        const result = await createUnlockMethod({
+            devId: devId,
+            userId: params.userId,
+            unlockId: `${dpId}-${res.unlockId}`,
+            unlockName: params.name,
+            unlockDetail: aesPwd,
+            ...specialInfo,
+        });
+        sdkLog("info", "unlockMethod", "addPasswordSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { opModeId: result.opModeId },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "unlockMethod", "addPasswordCloudFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/unlock/method/bind-unbind.d.ts

@@ -0,0 +1,8 @@
+import type { UnBindUnlockMethodGroup } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { BindUnlockMethodFromLogParams, BindUnlockMethodParams } from "./types";
+export declare function checkUnBindUnlockMethodsForRuntime(rt: LockDeviceRuntime): Promise<boolean>;
+export declare function getUnbindUnlockMethodsForRuntime(rt: LockDeviceRuntime): Promise<UnBindUnlockMethodGroup[]>;
+export declare function bindUnlockMethodForRuntime(rt: LockDeviceRuntime, params: BindUnlockMethodParams): Promise<boolean>;
+export declare function unbindUnlockMethodForRuntime(rt: LockDeviceRuntime, id: number): Promise<void>;
+export declare function bindUnlockMethodFromLogForRuntime(rt: LockDeviceRuntime, params: BindUnlockMethodFromLogParams): Promise<boolean>;

package/lib/feature/unlock/method/bind-unbind.js

@@ -0,0 +1,113 @@
+import { bindUnlockMethodToUser, bindUnlockMethodToUserByRecord, checkFreeUnlockMethods, fetchFreeUnlockMethods, unbindMemberUnlockMethod, } from "../../../api/lock";
+import { getUnlockMethodTypeByDpCodeForRuntime, getUnlockMethodTypeByTypeForRuntime, } from "../../utils";
+import { getError } from "../../../utils/errors";
+import { getUnlockMethodDetailForRuntime } from "./detail";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function checkUnBindUnlockMethodsForRuntime(rt) {
+    const data = await checkFreeUnlockMethods({
+        devId: rt.config.devInfo.devId,
+    });
+    sdkLog("debug", "unlockMethod", "checkUnbind", {
+        devId: rt.devId,
+        data: { hasUnbind: data === true || data === 1 },
+    });
+    return data === true || data === 1;
+}
+export async function getUnbindUnlockMethodsForRuntime(rt) {
+    const cloudData = await fetchFreeUnlockMethods({
+        devId: rt.config.devInfo.devId,
+    });
+    sdkLog("debug", "unlockMethod", "getUnbindList", {
+        devId: rt.devId,
+        data: { groupCount: cloudData.length },
+    });
+    const list = cloudData.map((item) => {
+        const unlockMethodConfig = getUnlockMethodTypeByDpCodeForRuntime(rt, item.standardDp);
+        return {
+            type: unlockMethodConfig.type,
+            list: item.unlockInfo.map((unlock) => {
+                return {
+                    unlockId: Number(unlock.unlockId.split("-")[1]),
+                    unlockName: unlock.unlockName,
+                    id: unlock.opmodeId,
+                    unlockSn: unlock.unlockSn,
+                    type: unlockMethodConfig.type,
+                    dpId: Number(item.opmode),
+                    dpCode: item.standardDp,
+                };
+            }),
+        };
+    });
+    return list;
+}
+export async function bindUnlockMethodForRuntime(rt, params) {
+    const cfg = rt.config;
+    sdkLog("info", "unlockMethod", "bindStart", {
+        devId: rt.devId,
+        data: { userId: params.userId, count: params.unlockList.length },
+    });
+    const unlockIds = params.unlockList.map((item) => {
+        const unlockMethodConfig = getUnlockMethodTypeByTypeForRuntime(rt, item.type);
+        const dpId = cfg.idsByCode[unlockMethodConfig.code];
+        return `${dpId}-${item.unlockId}`;
+    });
+    const result = await bindUnlockMethodToUser({
+        devId: cfg.devInfo.devId,
+        userId: params.userId,
+        unlockIds: unlockIds,
+    });
+    sdkLog("info", "unlockMethod", "bindSuccess", {
+        devId: rt.devId,
+        data: { userId: params.userId, count: unlockIds.length },
+    });
+    return result;
+}
+export async function unbindUnlockMethodForRuntime(rt, id) {
+    const cfg = rt.config;
+    sdkLog("info", "unlockMethod", "unbindStart", {
+        devId: rt.devId,
+        data: { id },
+    });
+    const detail = await getUnlockMethodDetailForRuntime(rt, id);
+    if (!detail.isBound) {
+        const error = getError(1050);
+        sdkLog("warn", "unlockMethod", "unbindNotBound", {
+            devId: rt.devId,
+            data: { id },
+            error,
+        });
+        throw error;
+    }
+    await unbindMemberUnlockMethod({
+        devId: cfg.devInfo.devId,
+        userId: detail.userId,
+        unlockIds: [`${detail.dpId}-${detail.unlockId}`],
+    });
+    sdkLog("info", "unlockMethod", "unbindSuccess", {
+        devId: rt.devId,
+        data: { id, userId: detail.userId },
+    });
+    return;
+}
+export async function bindUnlockMethodFromLogForRuntime(rt, params) {
+    const { idsByCode } = rt.config;
+    sdkLog("info", "unlockMethod", "bindFromLogStart", {
+        devId: rt.devId,
+        data: { userId: params.userId, count: params.unlockList.length },
+    });
+    const unlockIds = params.unlockList.map((item) => {
+        const unlockMethodConfig = getUnlockMethodTypeByTypeForRuntime(rt, item.type);
+        const dpId = idsByCode[unlockMethodConfig.code];
+        return `${dpId}-${item.unlockId}`;
+    });
+    const result = await bindUnlockMethodToUserByRecord({
+        devId: rt.config.devInfo.devId,
+        userId: params.userId,
+        unlockIds: unlockIds,
+    });
+    sdkLog("info", "unlockMethod", "bindFromLogSuccess", {
+        devId: rt.devId,
+        data: { userId: params.userId, count: unlockIds.length },
+    });
+    return result;
+}

package/lib/feature/unlock/method/detail.d.ts

@@ -0,0 +1,3 @@
+import type { UnlockMethodDetail } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function getUnlockMethodDetailForRuntime(rt: LockDeviceRuntime, id: number): Promise<UnlockMethodDetail>;