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

package/lib/feature/fit/method/internal/base.js

@@ -0,0 +1,134 @@
+import dpCodes from "../../../../config/dp-code";
+import { fitAdd, fitReportAdd } from "../../../../config/dp-map/unlock-method-fit";
+import { getPermanentSetting, isAdmin } from "../../../../utils";
+import { getError } from "../../../../utils/errors";
+import { LoopTypes } from "../../../../utils/constant";
+import { sdkLog } from "../../../../utils/sdk-log";
+import { getUnlockMethodTypeByTypeForRuntime } from "../../../utils";
+import { getUserInfoOnDevForRuntime } from "../../../user/user";
+import { getBoundLockListForRuntime } from "../../list";
+import { resolveSlaveId } from "../../resolve-slave-id";
+export function buildValidConfigFromTimeSchedule(timeScheduleInfo) {
+    if (!timeScheduleInfo) {
+        return getPermanentSetting();
+    }
+    const { permanent, effectiveTime, expiredTime, scheduleDetails } = timeScheduleInfo;
+    if (permanent) {
+        return {
+            startTime: effectiveTime ? Math.floor(effectiveTime / 1000) : 0x386cd300,
+            endTime: expiredTime ? Math.floor(expiredTime / 1000) : 0x72bc9b7f,
+            loop: LoopTypes.NONE,
+            loopConfig: 0,
+            weeks: [0, 0, 0, 0, 0, 0, 0],
+            days: [],
+            startHour: 0,
+            startMinute: 0,
+            endHour: 0,
+            endMinute: 0,
+        };
+    }
+    return {
+        startTime: Math.floor((effectiveTime || +new Date()) / 1000),
+        endTime: expiredTime ? Math.floor(expiredTime / 1000) : 0x72bc9b7f,
+        loop: scheduleDetails?.repeat ? LoopTypes.WEEK : LoopTypes.NONE,
+        loopConfig: 0,
+        weeks: scheduleDetails?.repeat
+            ? scheduleDetails.weeks
+            : [0, 0, 0, 0, 0, 0, 0],
+        days: [],
+        startHour: Math.floor((scheduleDetails?.effectiveTime ?? 0) / 60),
+        startMinute: (scheduleDetails?.effectiveTime ?? 0) % 60,
+        endHour: Math.floor((scheduleDetails?.invalidTime ?? 0) / 60),
+        endMinute: (scheduleDetails?.invalidTime ?? 0) % 60,
+    };
+}
+async function resolveLockDevId(rt, lockDevId) {
+    const list = await getBoundLockListForRuntime(rt);
+    if (list.length === 0) {
+        const error = getError(1001);
+        sdkLog("warn", "fitUnlockMethod", "resolveLockEmpty", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    if (lockDevId) {
+        const target = list.find((item) => item.devId === lockDevId);
+        if (!target) {
+            const error = getError(1001);
+            sdkLog("warn", "fitUnlockMethod", "resolveLockNotBound", {
+                devId: rt.devId,
+                data: { lockDevId },
+                error,
+            });
+            throw error;
+        }
+        return target.devId;
+    }
+    if (list.length === 1) {
+        return list[0].devId;
+    }
+    const error = getError(1009, "lockDevId");
+    sdkLog("warn", "fitUnlockMethod", "resolveLockAmbiguous", {
+        devId: rt.devId,
+        data: { count: list.length },
+        error,
+    });
+    throw error;
+}
+export async function getFitUnlockMethodBase(rt, type, userId, lockDevId) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitUnlockMethod", "buildBaseStart", {
+        devId: rt.devId,
+        data: {
+            type,
+            userId,
+            hasLockDevId: typeof lockDevId === "string",
+        },
+    });
+    const unlockMethodConfig = getUnlockMethodTypeByTypeForRuntime(rt, type);
+    const slaveId = await resolveSlaveId(rt, lockDevId);
+    const resolvedLockDevId = await resolveLockDevId(rt, lockDevId);
+    const lockUserInfo = await getUserInfoOnDevForRuntime(rt, {
+        devId: resolvedLockDevId,
+        userId,
+    });
+    const { lockUserId, userType, timeScheduleInfo } = lockUserInfo;
+    const validConfig = buildValidConfigFromTimeSchedule(timeScheduleInfo);
+    const dpData = {
+        slaveId,
+        type: unlockMethodConfig.id,
+        stage: 0,
+        admin: isAdmin(userType),
+        memberId: lockUserId,
+        unlockId: 0xff,
+        validConfig,
+        validNum: 0,
+        pwdLength: 0,
+        pwd: [],
+    };
+    const result = {
+        unlockMethodConfig,
+        fittingId: rt.devId,
+        lockDevId: resolvedLockDevId,
+        slaveId,
+        lockUserId,
+        userType,
+        lockUserInfo,
+        addDpCode: dpCodes.unlockMethodCreate,
+        addDpMap: fitAdd,
+        addDpReportMap: fitReportAdd,
+        dpData,
+    };
+    sdkLog("info", "fitUnlockMethod", "buildBaseSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: {
+            type,
+            lockDevId: resolvedLockDevId,
+            userType,
+            hasSchedule: !!timeScheduleInfo,
+        },
+    });
+    return result;
+}

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

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { FitUnlockMethodItem, GetFitUnlockMethodListParams } from "./types";
+export declare function getFitUnlockMethodListForRuntime(rt: LockDeviceRuntime, params: GetFitUnlockMethodListParams): Promise<FitUnlockMethodItem[]>;

package/lib/feature/fit/method/list.js

@@ -0,0 +1,64 @@
+import { getFitOpenModeList } from "../../../api/fit";
+import { getError } from "../../../utils/errors";
+import { sdkLog } from "../../../utils/sdk-log";
+import { getUnlockMethodTypeByTypeForRuntime } from "../../utils";
+function buildDevices(devIdList, devNameList) {
+    const ids = devIdList ?? [];
+    const names = devNameList ?? [];
+    return ids.map((devId, idx) => ({
+        devId,
+        devName: names[idx] ?? "",
+    }));
+}
+function mapRawToItem(raw, type) {
+    return {
+        id: raw.unlockBindingId,
+        unlockId: parseInt(raw.devUnlockId, 16),
+        unlockName: raw.name,
+        photoUnlock: false,
+        isSpecial: false,
+        type,
+        userName: raw.userName,
+        lockUserId: raw.lockUserId,
+        userType: raw.userType,
+        devices: buildDevices(raw.devIdList, raw.devNameList),
+    };
+}
+export async function getFitUnlockMethodListForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitUnlockMethod", "getListStart", {
+        devId: rt.devId,
+        data: {
+            type: params.type,
+            hasLockDevId: typeof params.lockDevId === "string",
+        },
+    });
+    const cfg = getUnlockMethodTypeByTypeForRuntime(rt, params.type);
+    const dpId = rt.config.idsByCode[cfg.code];
+    if (!dpId) {
+        const error = getError(1014);
+        sdkLog("warn", "fitUnlockMethod", "getListMissingDpId", {
+            devId: rt.devId,
+            data: { type: params.type },
+            error,
+        });
+        throw error;
+    }
+    const raw = await getFitOpenModeList(rt.devId, dpId);
+    const list = (raw ?? []).map((item) => mapRawToItem(item, params.type));
+    if (params.lockDevId) {
+        const filtered = list.filter((item) => item.devices.some((d) => d.devId === params.lockDevId));
+        sdkLog("info", "fitUnlockMethod", "getListSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { type: params.type, count: filtered.length, filtered: true },
+        });
+        return filtered;
+    }
+    sdkLog("info", "fitUnlockMethod", "getListSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { type: params.type, count: list.length, filtered: false },
+    });
+    return list;
+}

package/lib/feature/fit/method/types.d.ts

@@ -0,0 +1,68 @@
+import type { ErrorData, UnlockMethodType } from "../../../interface";
+export interface FitUnlockMethodDevice {
+    devId: string;
+    devName: string;
+}
+export interface FitUnlockMethodItem {
+    id: number;
+    unlockId: number;
+    unlockName: string;
+    photoUnlock: boolean;
+    isSpecial: boolean;
+    type: UnlockMethodType;
+    userName: string;
+    lockUserId: number;
+    userType: number;
+    devices: FitUnlockMethodDevice[];
+}
+export interface GetFitUnlockMethodListParams {
+    type: UnlockMethodType;
+    lockDevId?: string;
+}
+export interface FitAddUnlockMethodBaseParams {
+    lockDevId?: string;
+    userId: string;
+    name: string;
+    hijack?: boolean;
+}
+export interface FitAddPasswordParams extends FitAddUnlockMethodBaseParams {
+    password: string;
+}
+export interface FitStartAddUnlockMethodParams {
+    lockDevId?: string;
+    userId: string;
+    type: UnlockMethodType;
+    timeout?: number;
+}
+export interface FitCancelAddUnlockMethodParams extends FitStartAddUnlockMethodParams {
+}
+export interface FitUpdateUnlockMethodParams {
+    id: number;
+    name: string;
+    hijack?: boolean;
+}
+interface FitStepEvent {
+    type: UnlockMethodType;
+    lockDevId: string;
+    lockUserId: number;
+    stage: "step";
+    step: number;
+    total: number;
+}
+interface FitSuccessEvent {
+    type: UnlockMethodType;
+    lockDevId: string;
+    id: number;
+    name: string;
+    stage: "success";
+}
+interface FitErrorEvent {
+    type: UnlockMethodType;
+    lockDevId: string;
+    lockUserId: number;
+    stage: "fail";
+    error: ErrorData;
+}
+export type FitAddUnlockMethodEvent = FitStepEvent | FitSuccessEvent | FitErrorEvent;
+export type FitAddUnlockMethodListener = (event: FitAddUnlockMethodEvent) => void;
+export {};

package/lib/feature/fit/method/types.js

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

package/lib/feature/fit/method/update-remove.d.ts

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { FitUpdateUnlockMethodParams } from "./types";
+export declare function fitUpdateUnlockMethodForRuntime(rt: LockDeviceRuntime, params: FitUpdateUnlockMethodParams): Promise<void>;
+export declare const fitDeleteUnlockMethodForRuntime: (this: unknown, rt: LockDeviceRuntime, id: number, lockDevId?: string | undefined) => Promise<void>;

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

@@ -0,0 +1,159 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { 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 { sdkLog } from "../../../utils/sdk-log";
+export async function fitUpdateUnlockMethodForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitUnlockMethod", "updateStart", {
+        devId: rt.devId,
+        data: {
+            id: params.id,
+            hasName: typeof params.name === "string",
+            hijack: !!params.hijack,
+        },
+    });
+    try {
+        await updateFitOpenMode({
+            opModeId: params.id,
+            fittingId: rt.devId,
+            unlockName: params.name,
+            hijack: !!params.hijack,
+        });
+        sdkLog("info", "fitUnlockMethod", "updateSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitUnlockMethod", "updateCloudFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}
+export const fitDeleteUnlockMethodForRuntime = parallelOnlyForRuntime(async function fitDeleteUnlockMethodForRuntime(rt, id, lockDevId) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "fitUnlockMethod", "deleteStart", {
+        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", {
+            devId: rt.devId,
+            data: { id, dpId },
+            error,
+        });
+        throw error;
+    }
+    const unlockMethodConfig = getUnlockMethodTypeByDpCodeForRuntime(rt, code);
+    const removeDpCode = dpCodes.unlockMethodDel;
+    if (!cfg.dpSchema[removeDpCode]) {
+        const error = getError(1014);
+        sdkLog("warn", "fitUnlockMethod", "deleteUnsupportedDp", {
+            devId: rt.devId,
+            data: { id, dpCode: removeDpCode },
+            error,
+        });
+        throw error;
+    }
+    const slaveId = await resolveSlaveId(rt, lockDevId);
+    const dpData = {
+        slaveId,
+        type: unlockMethodConfig.id,
+        stage: 0,
+        admin: isAdmin(userType),
+        memberId: lockUserId,
+        unlockId,
+        operation: 1,
+    };
+    const res = await publishDpsForRuntime(rt, {
+        [removeDpCode]: dpUtils.format(dpData, fitRemove),
+    }, {
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[removeDpCode] === "undefined") {
+                return false;
+            }
+            const result = dpUtils.parse(dpDataIn[removeDpCode], fitReportRemove);
+            let hasReport = result.type === unlockMethodConfig.id &&
+                result.slaveId === slaveId;
+            if (cfg.strictMode) {
+                hasReport =
+                    hasReport &&
+                        result.stage === 0 &&
+                        result.memberId === lockUserId &&
+                        result.unlockId === unlockId;
+            }
+            if (hasReport) {
+                if (result.unlockId !== unlockId) {
+                    console.warn(`FitDeleteUnlockMethod: unlockId mismatch, expected ${unlockId}, got ${result.unlockId}`);
+                    sdkLog("warn", "fitUnlockMethod", "deleteReportUnlockIdMismatch", {
+                        devId: rt.devId,
+                        data: { id, type: unlockMethodConfig.type },
+                    });
+                }
+                return result;
+            }
+            return false;
+        },
+    });
+    if (res.status !== 255 && res.status !== 1) {
+        switch (res.status) {
+            case 2:
+                {
+                    const error = getError(1029);
+                    sdkLog("warn", "fitUnlockMethod", "deleteReportFail", {
+                        devId: rt.devId,
+                        duration: Date.now() - startedAt,
+                        data: { id, status: res.status },
+                        error,
+                    });
+                    throw error;
+                }
+            case 0:
+            default:
+                {
+                    const error = getError(1028);
+                    sdkLog("warn", "fitUnlockMethod", "deleteReportFail", {
+                        devId: rt.devId,
+                        duration: Date.now() - startedAt,
+                        data: { id, status: res.status },
+                        error,
+                    });
+                    throw error;
+                }
+        }
+    }
+    try {
+        await removeFitOpenMode(rt.devId, String(id));
+        sdkLog("info", "fitUnlockMethod", "deleteSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { id, type: unlockMethodConfig.type },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitUnlockMethod", "deleteCloudFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { id, type: unlockMethodConfig.type },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+});

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

@@ -0,0 +1,24 @@
+import { EffectiveConfig, UnlockMethodType } from "../../interface";
+import { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface FitPasswordItem {
+    id: number;
+    unlockId: number;
+    unlockName: string;
+    type: UnlockMethodType;
+    userName: string;
+    lockUserId: number;
+    userType: number;
+    devLockId: string;
+    effective: EffectiveConfig;
+}
+export declare const getFitPasswordListForRuntime: (runtime: LockDeviceRuntime) => Promise<{
+    id: number;
+    unlockId: string;
+    unlockName: string;
+    photoUnlock: boolean;
+    userName: string;
+    lockUserId: number;
+    userType: number;
+    devLockId: string;
+    effective: EffectiveConfig;
+}[]>;

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

@@ -0,0 +1,31 @@
+import { getFitPasswordList } from "../../api/fit";
+import { parseWeek } from "../../utils";
+export const getFitPasswordListForRuntime = async (runtime) => {
+    const list = await getFitPasswordList(runtime.devId);
+    return list.map((item) => {
+        const effective = {
+            effectiveDate: item.effectiveTime,
+            expiredDate: item.invalidTime,
+        };
+        if (item.scheduleDetails?.length) {
+            const scheduleDetail = item.scheduleDetails[0];
+            effective.repeat = scheduleDetail.allDay === false ? "week" : "none";
+            if (effective.repeat === "week") {
+                effective.weeks = parseWeek(scheduleDetail.workingDay);
+                effective.effectiveTime = scheduleDetail.effectiveTime;
+                effective.expiredTime = scheduleDetail.invalidTime;
+            }
+        }
+        return {
+            id: item.unlockBindingId,
+            unlockId: item.devUnlockId,
+            unlockName: item.name,
+            photoUnlock: false,
+            userName: item.userName,
+            lockUserId: item.lockUserId,
+            userType: item.userType,
+            devLockId: item.devUnlockId,
+            effective,
+        };
+    });
+};

package/lib/feature/fit/resolve-slave-id.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function resolveSlaveId(runtime: LockDeviceRuntime, lockDevId?: string): Promise<number>;

package/lib/feature/fit/resolve-slave-id.js

@@ -0,0 +1,38 @@
+import { getBoundLockListForRuntime } from "./list";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+export async function resolveSlaveId(runtime, lockDevId) {
+    const list = await getBoundLockListForRuntime(runtime);
+    if (list.length === 0) {
+        const error = getError(1088);
+        sdkLog("warn", "fit", "resolveSlaveIdEmpty", {
+            devId: runtime.devId,
+            error,
+        });
+        throw error;
+    }
+    if (lockDevId) {
+        const target = list.find((item) => item.devId === lockDevId);
+        if (!target) {
+            const error = getError(1089);
+            sdkLog("warn", "fit", "resolveSlaveIdNotBound", {
+                devId: runtime.devId,
+                data: { lockDevId },
+                error,
+            });
+            throw error;
+        }
+        const slaveId = parseInt(target.devUnlockId, 16);
+        sdkLog("info", "fit", "resolveSlaveIdSuccess", {
+            devId: runtime.devId,
+            data: { lockDevId },
+        });
+        return slaveId;
+    }
+    const slaveId = parseInt(list[0].devUnlockId, 16);
+    sdkLog("info", "fit", "resolveSlaveIdDefaultSuccess", {
+        devId: runtime.devId,
+        data: { count: list.length },
+    });
+    return slaveId;
+}

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

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function setFitSettingForRuntime(runtime: LockDeviceRuntime, dpCode: string, value: string | number | boolean): Promise<void>;

package/lib/feature/fit/setting.js

@@ -0,0 +1,27 @@
+import { sdkLog } from "../../utils/sdk-log";
+import { publishDpsOnlyWithRuntime } from "../dp/publish-dps";
+export async function setFitSettingForRuntime(runtime, dpCode, value) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "setSettingStart", {
+        devId: runtime.devId,
+        data: { dpCode, valueType: typeof value },
+    });
+    try {
+        const result = await publishDpsOnlyWithRuntime(runtime, { [dpCode]: value });
+        sdkLog("info", "fit", "setSettingSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { dpCode },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "setSettingFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { dpCode },
+            error,
+        });
+        throw error;
+    }
+}

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

@@ -0,0 +1,27 @@
+export type FitBindOperation = "bind" | "unbind";
+export declare const FIT_BIND_TIMEOUT_MS = 12000;
+export declare const FIT_OPERATION_CODE: Record<FitBindOperation, "00" | "01">;
+export declare const normalizeHex: (value: string) => string;
+export declare function buildTransparentData(operation: FitBindOperation, fit: {
+    fittingUnlockId: string;
+    randomStr: string;
+    devUnlockId: string;
+    devUuid: string;
+}, loginKey: string): string;
+export declare function buildLockCheckCodeTemplate(operation: FitBindOperation, fit: {
+    devUnlockId: string;
+    fittingUnlockId: string;
+    randomStr: string;
+}): string;
+export declare function waitTransparentResult(params: {
+    fittingId: string;
+    expectedOperation: "00" | "01";
+    timeout?: number;
+}): Promise<void>;
+export declare function ensureFitBleOnline(fittingId: string): Promise<boolean>;
+export declare function publishFitTransparentFlow(fittingId: string, keyDeviceId: string, operation: FitBindOperation, fit: {
+    fittingUnlockId: string;
+    randomStr: string;
+    devUnlockId: string;
+    devUuid: string;
+}): Promise<void>;