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

package/lib/feature/unlock/method/detail.js

@@ -0,0 +1,35 @@
+import { getUnlockMethodInfo } from "../../../api/lock";
+import { getUnlockMethodTypeByDpCodeForRuntime } from "../../utils";
+import { handleCloudError } from "../../../utils/errors";
+export async function getUnlockMethodDetailForRuntime(rt, id) {
+    const cfg = rt.config;
+    try {
+        const cloudData = await getUnlockMethodInfo({
+            devId: cfg.devInfo.devId,
+            opModeId: id,
+        });
+        const detail = {
+            isBound: cloudData.allocateFlag === 1,
+            type: getUnlockMethodTypeByDpCodeForRuntime(rt, cfg.codesById[Number(cloudData.opmode)])?.type,
+            phase: cloudData.phase,
+            dpId: Number(cloudData.opmode),
+            isSpecial: cloudData.unlockAttr === 1,
+            unlockName: cloudData.unlockName,
+            userId: cloudData.userId,
+            unlockId: Number(cloudData.opmodeValue),
+            lockUserId: cloudData.lockUserId,
+            id: cloudData.opmodeId,
+            userType: cloudData.userType,
+            notifyInfo: {
+                appSend: !!cloudData.notifyInfo?.appSend,
+                msgSend: !!cloudData.notifyInfo?.msgPhone,
+                msgPhone: cloudData.notifyInfo?.msgPhone,
+                countryCode: cloudData.notifyInfo?.countryCode,
+            },
+        };
+        return detail;
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { UnlockGuide, UnlockMethodType } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function getUnlockGuideForRuntime(rt: LockDeviceRuntime, type: UnlockMethodType): Promise<UnlockGuide | null>;

package/lib/feature/unlock/method/guide.js

@@ -0,0 +1,48 @@
+import { getFileRemoteUrl } from "../../../api";
+import { getDeviceAdvancedAbilitiesForRuntime } from "../../misc/capability";
+const guileTypeMap = {
+    card: ["addCard", "addCardPic"],
+    finger: ["addFingerprint", "addFingerprintPic"],
+    face: ["addFace", "addFacePic"],
+    fingerVein: ["addFingervein", "addFingerveinPic"],
+    hand: ["addPalmvein", "addPalmveinPic"],
+    eye: ["addIris", "addIrisPic"],
+};
+export async function getUnlockGuideForRuntime(rt, type) {
+    if (type === "password") {
+        return null;
+    }
+    const { unlockGuide } = await getDeviceAdvancedAbilitiesForRuntime(rt);
+    if (unlockGuide.support) {
+        const [videoKey, picKey] = guileTypeMap[type] || ["", ""];
+        const resources = [];
+        let videoUrlPath = "";
+        let picUrlPath = "";
+        if (unlockGuide.config[picKey]) {
+            picUrlPath = unlockGuide.config[picKey].url;
+            resources.push({
+                objectKey: picUrlPath,
+            });
+        }
+        if (unlockGuide.config[videoKey]) {
+            videoUrlPath = unlockGuide.config[videoKey].url;
+            resources.push({
+                objectKey: videoUrlPath,
+            });
+        }
+        if (resources.length === 0) {
+            return null;
+        }
+        const { signedUrls } = await getFileRemoteUrl({
+            biz: "hulk_video_tutorial_video",
+            resources,
+        });
+        const expireTime = Date.now() + 30 * 60 * 1000;
+        return {
+            videoUrl: signedUrls[videoUrlPath],
+            picUrl: signedUrls[picUrlPath],
+            expireTime,
+        };
+    }
+    return null;
+}

package/lib/feature/unlock/method/internal/base.d.ts

@@ -0,0 +1,109 @@
+import type { DpMap } from "@ray-js/tuya-dp-transform";
+import type { DpMapDataType, UnlockMethodType } from "../../../../interface";
+import type { LockDeviceRuntime } from "../../../../runtime/LockDeviceRuntime";
+export declare function getUnlockMethodBase(rt: LockDeviceRuntime, type: UnlockMethodType, userId: string): Promise<{
+    unlockMethodConfig: import("../../../../interface").UnlockMethodConfig;
+    devId: string;
+    userType: import("../../../..").UserType;
+    lockUserId: number;
+    sn: number;
+    dpId: number;
+    addDpCode: "unlock_method_create_w" | "unlock_method_create";
+    addDpMap: DpMap;
+    addDpReportMap: DpMap;
+    dpData: DpMapDataType<readonly [{
+        readonly name: "type";
+    }, {
+        readonly name: "stage";
+    }, {
+        readonly name: "admin";
+        readonly type: "boolean";
+        readonly defaultValue: false;
+    }, {
+        readonly name: "memberId";
+    }, {
+        readonly name: "unlockId";
+    }, {
+        readonly name: "validConfig";
+        readonly type: "child";
+        readonly bytes: 17;
+        readonly childMap: readonly [{
+            readonly name: "startTime";
+            readonly bytes: 4;
+        }, {
+            readonly name: "endTime";
+            readonly bytes: 4;
+        }, {
+            readonly name: "loop";
+        }, {
+            readonly name: "loopConfig";
+            readonly condition: {
+                readonly type: "and";
+                readonly conditions: readonly [{
+                    readonly prop: "validConfig.loop";
+                    readonly value: 2;
+                    readonly operation: "neq";
+                }, {
+                    readonly prop: "loop";
+                    readonly value: 3;
+                    readonly operation: "neq";
+                }];
+            };
+            readonly bytes: 4;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "weeks";
+            readonly condition: {
+                readonly prop: "validConfig.loop";
+                readonly value: 2;
+            };
+            readonly type: "custom";
+            readonly bytes: 4;
+            readonly parse: (value: number) => number[];
+            readonly format: (value: number[]) => string;
+            readonly defaultValue: readonly [0, 0, 0, 0, 0, 0, 0];
+        }, {
+            readonly name: "days";
+            readonly condition: {
+                readonly prop: "validConfig.loop";
+                readonly value: 3;
+            };
+            readonly type: "bits";
+            readonly bytes: 4;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "startHour";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "startMinute";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "endHour";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "endMinute";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }];
+    }, {
+        readonly name: "validNum";
+    }, {
+        readonly name: "pwdLength";
+    }, {
+        readonly name: "pwd";
+        readonly type: "number";
+        readonly limit: "pwdLength";
+        readonly loop: true;
+        readonly defaultValue: readonly [];
+    }, {
+        readonly name: "sn";
+        readonly bytes: 2;
+    }]>;
+}>;

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

@@ -0,0 +1,89 @@
+import { fetchCreatePasswordSN } from "../../../../api/lock";
+import dpCodes from "../../../../config/dp-code";
+import { add as addMap, reportAdd as reportAddMap, } from "../../../../config/dp-map/unlock-method";
+import { add as addBigMap, reportAdd as reportAddBigMap, } from "../../../../config/dp-map/unlock-method-big";
+import { getUnlockMethodTypeByTypeForRuntime } from "../../../utils";
+import { getPermanentSetting, isAdmin } from "../../../../utils";
+import { LoopTypes } from "../../../../utils/constant";
+import { getUserInfoForRuntime } from "../../../user/user";
+export async function getUnlockMethodBase(rt, type, userId) {
+    const { idsByCode, devInfo: { devId }, supportBigData, } = rt.config;
+    const unlockMethodConfig = getUnlockMethodTypeByTypeForRuntime(rt, type);
+    const addDpCode = supportBigData
+        ? dpCodes.unlockMethodCreateW
+        : dpCodes.unlockMethodCreate;
+    const dpId = idsByCode[unlockMethodConfig.code];
+    const [user, sn] = await Promise.all([
+        getUserInfoForRuntime(rt, {
+            userId: userId,
+        }),
+        fetchCreatePasswordSN({
+            devId: devId,
+            dpId,
+        }),
+    ]);
+    const { userType, lockUserId, timeScheduleInfo } = user;
+    let validConfig;
+    if (timeScheduleInfo) {
+        const { permanent, effectiveTime, expiredTime, scheduleDetails } = timeScheduleInfo;
+        if (permanent) {
+            validConfig = {
+                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,
+            };
+        }
+        else {
+            validConfig = {
+                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,
+            };
+        }
+    }
+    else {
+        validConfig = getPermanentSetting();
+    }
+    const dpData = {
+        type: unlockMethodConfig.id,
+        stage: 0,
+        admin: isAdmin(userType),
+        memberId: lockUserId,
+        unlockId: supportBigData ? 0xffff : 0xff,
+        validConfig,
+        validNum: 0,
+        pwdLength: 0,
+        pwd: [],
+        sn,
+    };
+    return {
+        unlockMethodConfig,
+        devId,
+        userType,
+        lockUserId,
+        sn,
+        dpId,
+        addDpCode,
+        addDpMap: (supportBigData ? addBigMap : addMap),
+        addDpReportMap: (supportBigData ? reportAddBigMap : reportAddMap),
+        dpData,
+    };
+}

package/lib/feature/unlock/method/internal/errors.d.ts

@@ -0,0 +1,5 @@
+export declare const getAddUnlockError: (status: number) => import("../../../..").ErrorData | {
+    devCode: number;
+    errorCode: number;
+    errorMsg: string;
+};

package/lib/feature/unlock/method/internal/errors.js

@@ -0,0 +1,13 @@
+import { getError } from "../../../../utils/errors";
+export const getAddUnlockError = (status) => {
+    if (status >= 0 && status <= 10) {
+        return getError(1015 + status);
+    }
+    if (status === 0xfe) {
+        return getError(1026);
+    }
+    return {
+        ...getError(1016),
+        devCode: status,
+    };
+};

package/lib/feature/unlock/method/internal/special-check.d.ts

@@ -0,0 +1,13 @@
+import type { NotifyInfo } from "../../../../interface";
+import type { LockDeviceRuntime } from "../../../../runtime/LockDeviceRuntime";
+import type { SpecialUnlockMethodInfo } from "../types";
+export declare function checkSpecialSupportPhoneForRuntime(rt: LockDeviceRuntime): boolean;
+export declare const checkSpecial: (rt: LockDeviceRuntime, isSpecial: boolean, params?: SpecialUnlockMethodInfo, oldSetting?: NotifyInfo) => {
+    unlockAttr: number;
+    notifyInfo: {
+        appSend: boolean;
+        msgPhone: string | undefined;
+        countryCode: string | undefined;
+        msgPhoneVerifyCode: string | undefined;
+    };
+};

package/lib/feature/unlock/method/internal/special-check.js

@@ -0,0 +1,38 @@
+import dpCodes from "../../../../config/dp-code";
+import { getError } from "../../../../utils/errors";
+export function checkSpecialSupportPhoneForRuntime(rt) {
+    return !!rt.config.dpSchema[dpCodes.message];
+}
+export const checkSpecial = (rt, isSpecial, params, oldSetting) => {
+    const supportedPhone = checkSpecialSupportPhoneForRuntime(rt);
+    if (isSpecial) {
+        if (!params?.appSend) {
+            if (!supportedPhone) {
+                throw getError(1057);
+            }
+            else if (!params?.msgSend) {
+                throw getError(1058);
+            }
+        }
+        if (supportedPhone && params?.msgSend) {
+            if (!params.msgPhone) {
+                throw getError(1066);
+            }
+            if (!params.countryCode) {
+                throw getError(1056);
+            }
+            if (params.msgPhone !== oldSetting?.msgPhone && !params.verifyCode) {
+                throw getError(1055);
+            }
+        }
+    }
+    return {
+        unlockAttr: isSpecial ? 1 : 0,
+        notifyInfo: {
+            appSend: !!params?.appSend,
+            msgPhone: supportedPhone && params?.msgSend ? params?.msgPhone : undefined,
+            countryCode: supportedPhone && params?.msgSend ? params?.countryCode : undefined,
+            msgPhoneVerifyCode: supportedPhone && params?.msgSend ? params?.verifyCode : undefined,
+        },
+    };
+};

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

@@ -0,0 +1,70 @@
+import type { ErrorData, UnlockMethodType } from "../../../interface";
+export interface SpecialUnlockMethodInfo {
+    appSend?: boolean;
+    msgSend?: boolean;
+    msgPhone?: string;
+    verifyCode?: string;
+    countryCode?: string;
+}
+export interface AddUnlockMethodBaseParams {
+    userId: string;
+    name: string;
+    isSpecial?: boolean;
+    specialInfo?: SpecialUnlockMethodInfo;
+}
+export interface AddPasswordParams extends AddUnlockMethodBaseParams {
+    password: string;
+}
+export interface updateUnlockMethodParams {
+    id: number;
+    name: string;
+    isSpecial?: boolean;
+    specialInfo?: SpecialUnlockMethodInfo;
+}
+export interface StartAddUnlockMethodParams {
+    type: UnlockMethodType;
+    userId: string;
+    timeout?: number;
+}
+export interface CancelAddUnlockMethodParams extends StartAddUnlockMethodParams {
+}
+export interface BindUnlockMethodParams {
+    userId: string;
+    unlockList: {
+        type: UnlockMethodType;
+        unlockId: number;
+    }[];
+}
+interface BindUnlockMethodFromLogItem {
+    type: UnlockMethodType;
+    unlockId: number;
+}
+export interface BindUnlockMethodFromLogParams {
+    userId: string;
+    unlockList: BindUnlockMethodFromLogItem[];
+}
+export interface SendVerifyCodeParams {
+    account: string;
+}
+interface StepEvent {
+    type: UnlockMethodType;
+    lockUserId: number;
+    stage: "step";
+    step: number;
+    total: number;
+}
+interface SuccessEvent {
+    type: UnlockMethodType;
+    id: number;
+    name: string;
+    stage: "success";
+}
+interface ErrorEvent {
+    type: UnlockMethodType;
+    lockUserId: number;
+    stage: "fail";
+    error: ErrorData;
+}
+export type AddUnlockMethodEvent = StepEvent | SuccessEvent | ErrorEvent;
+export type AddUnlockMethodListener = (event: AddUnlockMethodEvent) => void;
+export {};

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

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

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

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { updateUnlockMethodParams } from "./types";
+export declare function updateUnlockMethodForRuntime(rt: LockDeviceRuntime, params: updateUnlockMethodParams): Promise<void>;
+export declare const deleteUnlockMethodForRuntime: (this: unknown, rt: LockDeviceRuntime, id: number) => Promise<void>;

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

@@ -0,0 +1,138 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { editUnlockMethod, removeUnlockMethod } from "../../../api/lock";
+import dpCodes from "../../../config/dp-code";
+import { remove as removeMap, reportRemove as reportRemoveMap, } from "../../../config/dp-map/unlock-method";
+import { remove as removeBigMap, reportRemove as reportRemoveBigMap, } from "../../../config/dp-map/unlock-method-big";
+import { getUnlockMethodTypeByDpCodeForRuntime, parallelOnlyForRuntime, } from "../../utils";
+import { isAdmin } from "../../../utils";
+import { getError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { getUnlockMethodDetailForRuntime } from "./detail";
+import { checkSpecial } from "./internal/special-check";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function updateUnlockMethodForRuntime(rt, params) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "unlockMethod", "updateStart", {
+        devId: rt.devId,
+        data: {
+            id: params.id,
+            hasName: typeof params.name === "string",
+            isSpecial: !!params.isSpecial,
+        },
+    });
+    const detail = await getUnlockMethodDetailForRuntime(rt, params.id);
+    const specialInfo = checkSpecial(rt, !!params.isSpecial, params.specialInfo, detail.notifyInfo);
+    await editUnlockMethod({
+        devId: cfg.devInfo.devId,
+        opModeId: params.id,
+        unlockName: params.name,
+        ...specialInfo,
+    });
+    sdkLog("info", "unlockMethod", "updateSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { id: params.id },
+    });
+    return;
+}
+export const deleteUnlockMethodForRuntime = parallelOnlyForRuntime(async function deleteUnlockMethodForRuntime(rt, id) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "unlockMethod", "deleteStart", {
+        devId: rt.devId,
+        data: { id },
+    });
+    const { lockUserId, unlockId, userType, dpId } = await getUnlockMethodDetailForRuntime(rt, id);
+    const dpCode = cfg.codesById[dpId];
+    const unlockMethodConfig = getUnlockMethodTypeByDpCodeForRuntime(rt, dpCode);
+    const removeDPCode = cfg.supportBigData
+        ? dpCodes.unlockMethodDelW
+        : dpCodes.unlockMethodDel;
+    if (!cfg.dpSchema[removeDPCode]) {
+        const error = getError(1014);
+        sdkLog("warn", "unlockMethod", "deleteUnsupportedDp", {
+            devId: rt.devId,
+            data: { id, dpCode: removeDPCode },
+            error,
+        });
+        throw error;
+    }
+    const dpData = {
+        type: unlockMethodConfig.id,
+        stage: 0,
+        admin: isAdmin(userType),
+        memberId: lockUserId,
+        unlockId,
+        operation: 1,
+    };
+    const res = await publishDpsForRuntime(rt, {
+        [removeDPCode]: dpUtils.format(dpData, (cfg.supportBigData ? removeBigMap : removeMap)),
+    }, {
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[removeDPCode] !== "undefined") {
+                const result = dpUtils.parse(dpDataIn[removeDPCode], (cfg.supportBigData
+                    ? reportRemoveBigMap
+                    : reportRemoveMap));
+                let hasReport = result.type === unlockMethodConfig.id;
+                if (cfg.strictMode) {
+                    hasReport =
+                        hasReport &&
+                            result.stage === 0 &&
+                            result.memberId === lockUserId &&
+                            result.unlockId === unlockId;
+                }
+                if (hasReport) {
+                    if (result.unlockId !== unlockId) {
+                        sdkLog("warn", "unlockMethod", "deleteReportUnlockIdMismatch", {
+                            devId: rt.devId,
+                            data: { id, type: unlockMethodConfig.type },
+                        });
+                    }
+                    return result;
+                }
+                sdkLog("warn", "unlockMethod", "deleteInvalidReport", {
+                    devId: rt.devId,
+                    data: { id, type: unlockMethodConfig.type },
+                });
+            }
+            return false;
+        },
+    });
+    if (res.status !== 255 && res.status !== 1) {
+        switch (res.status) {
+            case 2:
+                {
+                    const error = getError(1029);
+                    sdkLog("warn", "unlockMethod", "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", "unlockMethod", "deleteReportFail", {
+                        devId: rt.devId,
+                        duration: Date.now() - startedAt,
+                        data: { id, status: res.status },
+                        error,
+                    });
+                    throw error;
+                }
+        }
+    }
+    await removeUnlockMethod({
+        devId: cfg.devInfo.devId,
+        opmodeId: id,
+    });
+    sdkLog("info", "unlockMethod", "deleteSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { id, type: unlockMethodConfig.type },
+    });
+});

package/lib/feature/unlock/method/verify-code.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { SendVerifyCodeParams } from "./types";
+export declare function sendVerifyCodeForRuntime(rt: LockDeviceRuntime, params: SendVerifyCodeParams): Promise<void>;

package/lib/feature/unlock/method/verify-code.js

@@ -0,0 +1,7 @@
+import { sendPhoneVerifyCode } from "../../../api";
+export function sendVerifyCodeForRuntime(rt, params) {
+    return sendPhoneVerifyCode({
+        ...params,
+        devId: rt.config.devInfo.devId,
+    });
+}

package/lib/feature/unlock/sync/unlock-method.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare const syncUnlockMethodWithRuntime: (runtime: LockDeviceRuntime) => Promise<void>;
+export declare const autoSyncUnlockMethod: (runtime: LockDeviceRuntime) => Promise<void>;