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

package/lib/feature/fit/ble-key.js

@@ -1,18 +1,141 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
 import { getFitBleKeyListApi, addFitBleKeyApi, updateFitBleKeyApi, removeFitBleKeyApi, renameFitBleKeyApi, } from "../../api/fit";
+import dpCodes from "../../config/dp-code";
+import { fitAddBleKey, fitModifyBleKey } from "../../config/dp-map/ble-key-fit";
+import { publishDpsForRuntime } from "../dp/publish-dps";
+import { getError } from "../../utils/errors";
 import { sdkLog } from "../../utils/sdk-log";
-import { formatWeek } from "../../utils";
+import { UserType } from "../../constant";
+import { getFitUsersForRuntime } from "./users";
+import { formatWeek, parseWeek, transformEffectiveConfigToValidConfig, validateEffectiveConfig, } from "../../utils";
+function normalizeBleKey(item) {
+    const effectiveConfig = {
+        effectiveDate: item.effectiveTime,
+        expiredDate: item.invalidTime,
+    };
+    const schedule = item.scheduleDetails?.[0];
+    if (schedule) {
+        if (schedule.allDay === false) {
+            effectiveConfig.repeat = "week";
+            effectiveConfig.weeks = parseWeek(schedule.workingDay);
+            effectiveConfig.effectiveTime = schedule.effectiveTime;
+            effectiveConfig.expiredTime = schedule.invalidTime;
+        }
+        else {
+            effectiveConfig.repeat = "none";
+        }
+    }
+    return {
+        id: item.id,
+        unlockBindingId: item.unlockBindingId,
+        name: item.name,
+        opModeSubType: item.opModeSubType,
+        effectiveConfig,
+        sn: item.sn,
+        userName: item.userName,
+        devNameList: item.devNameList,
+    };
+}
 export async function getFitBleKeyListForRuntime(runtime) {
     const startedAt = Date.now();
     sdkLog("info", "fit", "getBleKeyListStart", {
         devId: runtime.devId,
     });
     const list = await getFitBleKeyListApi(runtime.devId);
+    const result = (list || []).map(normalizeBleKey);
     sdkLog("info", "fit", "getBleKeyListSuccess", {
         devId: runtime.devId,
         duration: Date.now() - startedAt,
-        data: { count: Array.isArray(list) ? list.length : 0 },
+        data: { count: result.length },
+    });
+    return result;
+}
+async function createFitBleKeyWithPayload(runtime, keyType, startedAt, payload, addToCloud) {
+    const report = await publishDpsForRuntime(runtime, { [dpCodes.bleKeyCreate]: payload }, {
+        checkReport: (dps) => {
+            const raw = dps[dpCodes.bleKeyCreate];
+            if (!raw || raw.length < 44)
+                return false;
+            return { sn: raw.slice(4, 6), status: raw.slice(42, 44) };
+        },
+    });
+    if (report.status !== "00") {
+        sdkLog("warn", "fit", "createBleKeyDeviceFail", {
+            devId: runtime.devId,
+            data: { type: keyType, status: report.status },
+        });
+        throw getError(1042);
+    }
+    try {
+        const result = await addToCloud(parseInt(report.sn, 16));
+        sdkLog("info", "fit", "createBleKeySuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { type: keyType },
+        });
+        return result;
+    }
+    catch (error) {
+        publishDpsForRuntime(runtime, { [dpCodes.bleKeyDelete]: "0000" }, { timeout: 5000 }).catch(() => {
+        });
+        sdkLog("error", "fit", "createBleKeyCloudFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { type: keyType },
+            error,
+        });
+        throw error;
+    }
+}
+export async function createFitPermanentBleKeyForRuntime(runtime, userId) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "createBleKeyStart", {
+        devId: runtime.devId,
+        data: { type: "permanent" },
+    });
+    const users = await getFitUsersForRuntime(runtime);
+    const user = users.find((item) => item.userId === userId);
+    if (!user) {
+        sdkLog("warn", "fit", "createBleKeyUserNotFound", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { userCount: users.length },
+        });
+        throw getError(1048);
+    }
+    const admin = user.userType === UserType.ADMIN;
+    const payload = `000000${admin ? "01" : "00"}${user.userTimeSet}`;
+    return createFitBleKeyWithPayload(runtime, "permanent", startedAt, payload, (sn) => addFitBleKeyApi(runtime.devId, { sn, userId, timeSetType: 10 }));
+}
+export async function createFitTemporaryBleKeyForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "createBleKeyStart", {
+        devId: runtime.devId,
+        data: { type: "temporary" },
     });
-    return list;
+    validateEffectiveConfig(params.effective);
+    const { effective } = params;
+    const payload = dpUtils.format({
+        slaveId: 0,
+        memberId: 0,
+        admin: false,
+        validConfig: transformEffectiveConfigToValidConfig(effective),
+    }, fitAddBleKey);
+    return createFitBleKeyWithPayload(runtime, "temporary", startedAt, payload, (sn) => addFitBleKeyApi(runtime.devId, {
+        sn,
+        effectiveTime: effective.effectiveDate,
+        invalidTime: effective.expiredDate,
+        schedule: [
+            {
+                allDay: effective.repeat !== "week",
+                effectiveTime: effective.effectiveTime ?? 0,
+                invalidTime: effective.expiredTime ?? 0,
+                workingDay: formatWeek(effective.weeks ?? [0]),
+            },
+        ],
+        name: params.name,
+        timeSetType: effective.repeat !== "week" ? 20 : 30,
+    }));
 }
 export async function addFitBleKeyForRuntime(runtime, params) {
     const startedAt = Date.now();
@@ -31,7 +154,7 @@ export async function addFitBleKeyForRuntime(runtime, params) {
     });
     return result;
 }
-export async function updateFitBleKeyForRuntime(runtime, params) {
+export async function updateFitTemporaryBleKeyForRuntime(runtime, params) {
     const startedAt = Date.now();
     const logParams = params ?? {};
     sdkLog("info", "fit", "updateBleKeyStart", {
@@ -41,6 +164,24 @@ export async function updateFitBleKeyForRuntime(runtime, params) {
             hasId: typeof logParams["id"] === "string",
         },
     });
+    validateEffectiveConfig(params.effective);
+    const validConfig = transformEffectiveConfigToValidConfig(params.effective);
+    const payload = dpUtils.format({ slaveId: 0, memberId: 0, admin: false, validConfig }, fitModifyBleKey);
+    const report = await publishDpsForRuntime(runtime, { [dpCodes.bleKeyModify]: payload }, {
+        checkReport: (dps) => {
+            const raw = dps[dpCodes.bleKeyModify];
+            if (!raw || raw.length < 44)
+                return false;
+            return { status: raw.slice(42, 44) };
+        },
+    });
+    if (report.status !== "00") {
+        sdkLog("warn", "fit", "updateBleKeyDeviceFail", {
+            devId: runtime.devId,
+            data: { status: report.status },
+        });
+        throw getError(1042);
+    }
     const schedule = [
         {
             allDay: params.effective.repeat !== "week",

package/lib/feature/fit/device-bv.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const getFitDeviceBvForRuntime: (runtime: LockDeviceRuntime) => Promise<number>;

package/lib/feature/fit/device-bv.js

@@ -0,0 +1,15 @@
+import { getFitDeviceBVApi } from "../../api/fit";
+export const getFitDeviceBvForRuntime = (runtime) => {
+    const cached = runtime.cache.fitDeviceBvCache;
+    if (cached) {
+        return cached;
+    }
+    const pending = getFitDeviceBVApi(runtime.devId).catch((error) => {
+        if (runtime.cache.fitDeviceBvCache === pending) {
+            runtime.cache.fitDeviceBvCache = undefined;
+        }
+        throw error;
+    });
+    runtime.cache.fitDeviceBvCache = pending;
+    return pending;
+};

package/lib/feature/fit/invalid-password.d.ts

@@ -0,0 +1,10 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { type FitInvalidPwdQuery, type FitInvalidPwdListResult } from "../../api/fit";
+export type { FitInvalidPwdQuery, FitInvalidPwdListResult };
+export interface GetFitInvalidPwdListParams extends FitInvalidPwdQuery {
+}
+export interface ClearFitInvalidPwdParams {
+    opMode?: number | string;
+}
+export declare function getFitInvalidPwdListForRuntime(runtime: LockDeviceRuntime, params?: GetFitInvalidPwdListParams): Promise<FitInvalidPwdListResult>;
+export declare function clearFitInvalidPwdForRuntime(runtime: LockDeviceRuntime, params?: ClearFitInvalidPwdParams): Promise<boolean>;

package/lib/feature/fit/invalid-password.js

@@ -0,0 +1,43 @@
+import { clearFitInvalidPwdApi, getFitInvalidPwdListApi, } from "../../api/fit";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+export async function getFitInvalidPwdListForRuntime(runtime, params = {}) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitInvalidPwd", "getListStart", {
+        devId: runtime.devId,
+        data: { hasOpMode: params.opMode !== undefined },
+    });
+    try {
+        const result = await getFitInvalidPwdListApi(runtime.devId, params);
+        return result;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+export async function clearFitInvalidPwdForRuntime(runtime, params = {}) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitInvalidPwd", "clearStart", {
+        devId: runtime.devId,
+        data: { hasOpMode: params.opMode !== undefined },
+    });
+    try {
+        const result = await clearFitInvalidPwdApi(runtime.devId, params.opMode);
+        sdkLog("info", "fitInvalidPwd", "clearSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fitInvalidPwd", "clearFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        if (typeof error?.errorCode === "number") {
+            throw error;
+        }
+        throw getError(1028);
+    }
+}

package/lib/feature/fit/list.d.ts

@@ -1,3 +1,13 @@
+import { type BoundFitLockItem, type UnbindLockItem } from "../../api/fit";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
-export declare function getBoundLockListForRuntime(runtime: LockDeviceRuntime): Promise<import("../../api/fit").BoundFitLockItem[]>;
-export declare function getUnbindLockListForRuntime(runtime: LockDeviceRuntime): Promise<import("../../api/fit").UnbindLockItem[]>;
+export type FitLockUnbindableReason = "ble_version_mismatch" | "security_version_mismatch";
+export interface UnbindLockListItem extends UnbindLockItem {
+    bindable: boolean;
+    unbindableReason?: FitLockUnbindableReason;
+}
+export interface BoundLockListItem extends BoundFitLockItem {
+    securityVersionMismatch: boolean;
+    securityNeedUpdate: boolean;
+}
+export declare function getBoundLockListForRuntime(runtime: LockDeviceRuntime): Promise<BoundLockListItem[]>;
+export declare function getUnbindLockListForRuntime(runtime: LockDeviceRuntime): Promise<UnbindLockListItem[]>;

package/lib/feature/fit/list.js

@@ -1,28 +1,77 @@
 import { getBoundLockListApi, getUnbindLockListApi, } from "../../api/fit";
 import { sdkLog } from "../../utils/sdk-log";
+import { getFitDeviceBvForRuntime } from "./device-bv";
+import { getSecurityUpdatedLockIds, isFitSecurityChannelEnabledForRuntime, } from "./security-channel";
+const isSecurityVersionMismatch = (runtime, lock) => !!lock.isSupportScy && !isFitSecurityChannelEnabledForRuntime(runtime);
+const resolveUnbindableReason = (runtime, lock, fitBv) => {
+    const lockBv = Number(lock.protocolVersion) || 0;
+    if (lockBv && fitBv && lockBv !== fitBv) {
+        return "ble_version_mismatch";
+    }
+    if (isSecurityVersionMismatch(runtime, lock)) {
+        return "security_version_mismatch";
+    }
+    return undefined;
+};
 export async function getBoundLockListForRuntime(runtime) {
     const startedAt = Date.now();
     sdkLog("info", "fit", "getBoundLockListStart", {
         devId: runtime.devId,
     });
     const list = await getBoundLockListApi(runtime.devId);
+    const rawItems = Array.isArray(list) ? list : [];
+    const securityEnabled = isFitSecurityChannelEnabledForRuntime(runtime);
+    const securityUpdatedIds = securityEnabled && rawItems.some((lock) => lock.isSupportScy)
+        ? await getSecurityUpdatedLockIds(runtime.devId)
+        : [];
+    const items = rawItems.map((lock) => ({
+        ...lock,
+        securityVersionMismatch: isSecurityVersionMismatch(runtime, lock),
+        securityNeedUpdate: securityEnabled &&
+            !!lock.isSupportScy &&
+            !securityUpdatedIds.includes(lock.devId),
+    }));
     sdkLog("info", "fit", "getBoundLockListSuccess", {
         devId: runtime.devId,
         duration: Date.now() - startedAt,
-        data: { count: Array.isArray(list) ? list.length : 0 },
+        data: {
+            count: items.length,
+            securityMismatchCount: items.filter((item) => item.securityVersionMismatch).length,
+            securityNeedUpdateCount: items.filter((item) => item.securityNeedUpdate)
+                .length,
+        },
     });
-    return list;
+    return items;
 }
 export async function getUnbindLockListForRuntime(runtime) {
     const startedAt = Date.now();
     sdkLog("info", "fit", "getUnbindLockListStart", {
         devId: runtime.devId,
     });
-    const list = await getUnbindLockListApi(runtime.devId);
+    const [list, fitBv] = await Promise.all([
+        getUnbindLockListApi(runtime.devId),
+        getFitDeviceBvForRuntime(runtime).catch((error) => {
+            sdkLog("warn", "fit", "getUnbindLockListBvFailed", {
+                devId: runtime.devId,
+                error,
+            });
+            return 0;
+        }),
+    ]);
+    const items = (Array.isArray(list) ? list : []).map((lock) => {
+        const unbindableReason = resolveUnbindableReason(runtime, lock, fitBv);
+        return unbindableReason
+            ? { ...lock, bindable: false, unbindableReason }
+            : { ...lock, bindable: true };
+    });
     sdkLog("info", "fit", "getUnbindLockListSuccess", {
         devId: runtime.devId,
         duration: Date.now() - startedAt,
-        data: { count: Array.isArray(list) ? list.length : 0 },
+        data: {
+            count: items.length,
+            fitBv,
+            bindableCount: items.filter((item) => item.bindable).length,
+        },
     });
-    return list;
+    return items;
 }

package/lib/feature/fit/log.d.ts

@@ -0,0 +1,7 @@
+import { type GetLogsResult } from "../log/log";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface GetFitLogsParams {
+    page?: number;
+    pageSize?: number;
+}
+export declare function getFitLogsForRuntime(rt: LockDeviceRuntime, params?: GetFitLogsParams): Promise<GetLogsResult>;

package/lib/feature/fit/log.js

@@ -0,0 +1,123 @@
+import { getFitRecordListApi } from "../../api/log";
+import { closeTypes, dpIdsForUsernameToUnlockName, unlockDp2Type, } from "../log/log";
+import dpCodes from "../../config/dp-code";
+import base64ToHex from "../../utils/base64-to-hex";
+import { handleLocalOperation } from "../../utils/log";
+import { getCurrentUserForRuntime } from "../user/current-user";
+const fitRecordDps = [
+    dpCodes.bluetoothUnlockKit,
+    dpCodes.unlockPasswordKit,
+    dpCodes.unlockCardKit,
+    dpCodes.unlockFingerprintKit,
+    dpCodes.unlockFaceKit,
+    dpCodes.unlockEyeKit,
+    dpCodes.unlockHandKit,
+    dpCodes.unlockFingerVeinKit,
+    dpCodes.unlockTemporaryKit,
+    dpCodes.unlockDoubleKit,
+    dpCodes.unlockOfflinePd,
+    dpCodes.unlockDynamic,
+    dpCodes.lockRecord,
+];
+function parseFitRecord(cfg, raw, currentUserId) {
+    const historyId = raw.historyId ?? raw.id;
+    const time = raw.gmtCreate ?? Number(raw.time);
+    const dpId = typeof raw.dpId === "string" ? Number(raw.dpId) : raw.dpId;
+    let closeValue = undefined;
+    let dpValue = raw.dpValue;
+    const dpCode = cfg.codesById[dpId];
+    let type = dpCode === dpCodes.lockRecord ? "close_record" : "unlock_record";
+    const dpSchema = cfg.dpSchema[dpCode];
+    if (dpSchema?.type === "raw" && typeof dpValue === "string") {
+        try {
+            dpValue = base64ToHex(dpValue);
+        }
+        catch {
+        }
+    }
+    if (type === "close_record") {
+        const rawCloseValue = typeof dpValue === "string" ? dpValue : "";
+        const closeType = parseInt(rawCloseValue.slice(0, 2), 16);
+        closeValue = closeTypes[closeType] || closeTypes[0];
+    }
+    if (dpCode === dpCodes.lockLocalRecord) {
+        type = "local_operation";
+    }
+    let userName = raw.userName;
+    let unlockName = raw.unlockName;
+    if (dpIdsForUsernameToUnlockName.includes(dpId)) {
+        unlockName = raw.userName;
+        userName = "";
+    }
+    const log = {
+        type,
+        logId: String(historyId),
+        userId: raw.userId,
+        dpId,
+        data: dpValue,
+        dpCode,
+        userName: userName || "",
+        unlockName: unlockName || "",
+        avatarUrl: raw.avatarUrl,
+        relateDevName: raw.relateDevName,
+        mediaInfo: raw.mediaInfoList?.map?.((item) => {
+            return {
+                mediaPath: item.mediaPath,
+                fileKey: item.fileKey,
+                fileUrl: item.fileUrl,
+                mediaBucket: item.mediaBucket,
+                mediaKey: item.mediaKey,
+                width: item.positionWidth,
+                height: item.positionHeight,
+                angle: item.positionAngle,
+                isVR: !!item.positionVr,
+                position: item.position,
+            };
+        }),
+        unionUnlockInfo: raw.unionUnlockInfo?.map((item) => ({
+            userId: item.userId,
+            userName: item.userName,
+            unlockName: item.unlockName,
+            sn: item.sn,
+            type: unlockDp2Type[item.opMode],
+        })),
+        closeValue,
+        time,
+        currentUser: +raw.userId === +currentUserId,
+        bindable: raw.memberBindableFlag === 1,
+        unlockMethod: type === "unlock_record" ? unlockDp2Type[dpCode] : undefined,
+        localRecord: handleLocalOperation(raw.localOperateRecordInfo, dpValue),
+    };
+    if (raw.matterRecordInfo) {
+        log.matterRecord = {
+            sn: raw.matterRecordInfo.matterSn,
+            type: raw.matterRecordInfo.matterType,
+            source: raw.matterRecordInfo.matterSource,
+        };
+    }
+    return log;
+}
+export async function getFitLogsForRuntime(rt, params) {
+    const cfg = rt.config;
+    const { page = 1, pageSize = 50 } = params || {};
+    const currentUser = await getCurrentUserForRuntime(rt);
+    const data = await getFitRecordListApi({
+        devId: cfg.devInfo.devId,
+        dpIds: fitRecordDps.reduce((res, item) => {
+            if (cfg.idsByCode[item]) {
+                res.push(cfg.idsByCode[item]);
+            }
+            return res;
+        }, []),
+        offset: (page - 1) * pageSize,
+        limit: pageSize,
+    });
+    if (!data?.datas?.length) {
+        return { list: [], hasMore: false, total: 0 };
+    }
+    return {
+        list: data.datas.map((raw) => parseFitRecord(cfg, raw, currentUser.userId)),
+        hasMore: data.hasNext,
+        total: data.totalCount,
+    };
+}

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

@@ -1,6 +1,6 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { addFitOpenMode } from "../../../api/fit";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { DPCHANGE } from "../../../utils/constant";
 import { getError } from "../../../utils/errors";
 import emitter from "../../../utils/event";
@@ -195,7 +195,7 @@ const handleAddReport = async (dps) => {
                     await addFitOpenMode({
                         devIdList: [addUnlockMethodData.lockDevId],
                         fittingId: rt.devId,
-                        unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                        unlockId: formatCloudUnlockId(addUnlockMethodData.unlockDpId, result.unlockId),
                         unlockName: "",
                         userId: addUnlockMethodData.userId,
                         hijack: false,

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

@@ -1,6 +1,6 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { addFitOpenMode } from "../../../api/fit";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { getError, handleCloudError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import { getFitUnlockMethodBase } from "./internal/base";
@@ -75,7 +75,7 @@ export async function fitAddPasswordForRuntime(rt, params) {
         await addFitOpenMode({
             devIdList: [lockDevId],
             fittingId,
-            unlockId: `${dpId}-${res.unlockId}`,
+            unlockId: formatCloudUnlockId(dpId, res.unlockId),
             unlockName: params.name,
             userId: params.userId,
             hijack: !!params.hijack,

package/lib/feature/fit/method/update-remove.js

@@ -1,14 +1,40 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
-import { removeFitOpenMode, updateFitOpenMode } from "../../../api/fit";
+import { getFitOpenModeList, removeFitOpenMode, updateFitOpenMode, } from "../../../api/fit";
 import dpCodes from "../../../config/dp-code";
 import { fitRemove, fitReportRemove, } from "../../../config/dp-map/unlock-method-fit";
 import { isAdmin } from "../../../utils";
 import { getError, handleCloudError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
-import { getUnlockMethodTypeByDpCodeForRuntime, parallelOnlyForRuntime, } from "../../utils";
-import { getUnlockMethodDetailForRuntime } from "../../unlock/method/detail";
-import { resolveSlaveId } from "../resolve-slave-id";
+import { getUnlockMethodTypeByTypeForRuntime, parallelOnlyForRuntime, } from "../../utils";
 import { sdkLog } from "../../../utils/sdk-log";
+const FIT_DELETABLE_UNLOCK_METHOD_TYPES = [
+    "card",
+    "finger",
+    "face",
+    "hand",
+    "fingerVein",
+];
+async function findFitOpenModeRawById(rt, id) {
+    for (const type of FIT_DELETABLE_UNLOCK_METHOD_TYPES) {
+        let unlockMethodConfig;
+        try {
+            unlockMethodConfig = getUnlockMethodTypeByTypeForRuntime(rt, type);
+        }
+        catch {
+            continue;
+        }
+        const dpId = rt.config.idsByCode[unlockMethodConfig.code];
+        if (!dpId) {
+            continue;
+        }
+        const raw = await getFitOpenModeList(rt.devId, dpId);
+        const hit = (raw ?? []).find((item) => item.unlockBindingId === id);
+        if (hit) {
+            return { raw: hit, unlockMethodConfig };
+        }
+    }
+    return null;
+}
 export async function fitUpdateUnlockMethodForRuntime(rt, params) {
     const startedAt = Date.now();
     sdkLog("info", "fitUnlockMethod", "updateStart", {
@@ -49,19 +75,20 @@ export const fitDeleteUnlockMethodForRuntime = parallelOnlyForRuntime(async func
         devId: rt.devId,
         data: { id, hasLockDevId: typeof lockDevId === "string" },
     });
-    const detail = await getUnlockMethodDetailForRuntime(rt, id);
-    const { lockUserId, unlockId, userType, dpId } = detail;
-    const code = cfg.codesById[dpId];
-    if (!code) {
-        const error = getError(1014);
-        sdkLog("warn", "fitUnlockMethod", "deleteMissingDpCode", {
+    const found = await findFitOpenModeRawById(rt, id);
+    if (!found) {
+        const error = getError(1040);
+        sdkLog("warn", "fitUnlockMethod", "deleteRecordNotFound", {
             devId: rt.devId,
-            data: { id, dpId },
+            data: { id },
             error,
         });
         throw error;
     }
-    const unlockMethodConfig = getUnlockMethodTypeByDpCodeForRuntime(rt, code);
+    const { raw, unlockMethodConfig } = found;
+    const lockUserId = raw.lockUserId;
+    const unlockId = raw.sn;
+    const slaveId = parseInt(raw.devUnlockId, 16);
     const removeDpCode = dpCodes.unlockMethodDel;
     if (!cfg.dpSchema[removeDpCode]) {
         const error = getError(1014);
@@ -72,12 +99,11 @@ export const fitDeleteUnlockMethodForRuntime = parallelOnlyForRuntime(async func
         });
         throw error;
     }
-    const slaveId = await resolveSlaveId(rt, lockDevId);
     const dpData = {
         slaveId,
         type: unlockMethodConfig.id,
         stage: 0,
-        admin: isAdmin(userType),
+        admin: isAdmin(raw.userType),
         memberId: lockUserId,
         unlockId,
         operation: 1,

package/lib/feature/fit/password-list.d.ts

@@ -1,3 +1,4 @@
+import { type RawFitOpenModeScheduleItem } from "../../api/fit";
 import { EffectiveConfig, UnlockMethodType } from "../../interface";
 import { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
 export interface FitPasswordItem {
@@ -22,3 +23,39 @@ export declare const getFitPasswordListForRuntime: (runtime: LockDeviceRuntime)
     devLockId: string;
     effective: EffectiveConfig;
 }[]>;
+export interface FitOnlinePasswordItem {
+    id: number;
+    pwdId: number;
+    sn: number;
+    gmtCreate: number;
+    opModeType: number;
+    opModeSubType: number;
+    name: string;
+    userName: string;
+    mobile: string;
+    hijack: boolean;
+    operate: number;
+    effectiveTime: number;
+    invalidTime: number;
+    devNameList: string[];
+    scheduleDetails: RawFitOpenModeScheduleItem[];
+}
+export interface FitOfflinePasswordItem {
+    id: number | string;
+    pwdId: number;
+    sn: number;
+    gmtCreate: number;
+    opModeType: number;
+    opModeSubType: number;
+    pwdName: string;
+    mayExpired: boolean;
+    gmtStart: number;
+    gmtExpired: number;
+    devNameList: string[];
+    scheduleDetails: RawFitOpenModeScheduleItem[];
+    revokedPwdName: string;
+    revokedPwdEffectiveTime: number;
+    revokedPwdInvalidTime: number;
+}
+export declare const getFitOnlinePasswordListForRuntime: (runtime: LockDeviceRuntime) => Promise<FitOnlinePasswordItem[]>;
+export declare const getFitOfflinePasswordListForRuntime: (runtime: LockDeviceRuntime) => Promise<FitOfflinePasswordItem[]>;