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

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>;

package/lib/feature/unlock/sync/unlock-method.js

@@ -0,0 +1,79 @@
+import { fetchSyncUnlockMethodInfo } from "../../../api/lock";
+import dpCodes from "../../../config/dp-code";
+import { getCurrentUserForRuntime } from "../../user/current-user";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { reportSync as reportSyncMap } from "../../../config/dp-map/unlock-method";
+import { reportSync as reportSyncBigMap } from "../../../config/dp-map/unlock-method-big";
+import { sdkLog } from "../../../utils/sdk-log";
+import { hasDpForRuntime } from "../../../feature/dp/has-dp";
+export const syncUnlockMethodWithRuntime = async (runtime) => {
+    const rt = runtime;
+    if (!hasDpForRuntime(rt, dpCodes.synchMethod) &&
+        !hasDpForRuntime(rt, dpCodes.synchMethodW)) {
+        return;
+    }
+    const startedAt = Date.now();
+    sdkLog("info", "syncUnlockMethod", "start", {
+        devId: rt.devId,
+    });
+    rt.sync.unlockMethodAutoSyncEnabled = false;
+    const { allOpenDps = "" } = await getCurrentUserForRuntime(rt);
+    const { ins = "", distributed = false } = await fetchSyncUnlockMethodInfo({
+        devId: rt.config.devInfo.devId,
+        dpIds: allOpenDps.split(","),
+    });
+    if (ins && distributed) {
+        const dpCode = rt.config.supportBigData
+            ? dpCodes.synchMethodW
+            : dpCodes.synchMethod;
+        try {
+            await publishDpsForRuntime(rt, { [dpCode]: ins }, {
+                checkReport: (dpData) => {
+                    if (typeof dpData[dpCode] !== "undefined") {
+                        const result = dpUtils.parse(String(dpData[dpCode]), rt.config.supportBigData ? reportSyncBigMap : reportSyncMap);
+                        sdkLog("debug", "syncUnlockMethod", "report", {
+                            devId: rt.devId,
+                            data: { dpCode, stage: result.stage },
+                        });
+                        if (result.stage === 1) {
+                            return true;
+                        }
+                    }
+                    return false;
+                },
+            });
+            sdkLog("info", "syncUnlockMethod", "success", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { dpCode, supportBigData: rt.config.supportBigData },
+            });
+        }
+        catch (error) {
+            sdkLog("warn", "syncUnlockMethod", "fail", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { dpCode, supportBigData: rt.config.supportBigData },
+                error,
+            });
+        }
+    }
+    else {
+        sdkLog("debug", "syncUnlockMethod", "skipped", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { distributed, hasInstruction: !!ins },
+        });
+    }
+};
+export const autoSyncUnlockMethod = async (runtime) => {
+    const rt = runtime;
+    if (rt.sync.unlockMethodAutoSyncEnabled) {
+        await syncUnlockMethodWithRuntime(rt);
+    }
+    else {
+        sdkLog("debug", "syncUnlockMethod", "autoSkipped", {
+            devId: rt.devId,
+        });
+    }
+};

package/lib/feature/user/current-user.d.ts

@@ -0,0 +1,3 @@
+import type { CurrentUser } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const getCurrentUserForRuntime: (runtime: LockDeviceRuntime, isForce?: boolean) => Promise<CurrentUser>;

package/lib/feature/user/current-user.js

@@ -0,0 +1,33 @@
+import { getCurrentUserInfo } from "../../api/user";
+import { getDataWithPreFetchForRuntime } from "../utils";
+import { sdkLog } from "../../utils/sdk-log";
+export const getCurrentUserForRuntime = async (runtime, isForce) => {
+    if (runtime.cache.currentUser && !isForce) {
+        sdkLog("debug", "user", "currentUserCacheHit", {
+            devId: runtime.devId,
+            data: { userType: runtime.cache.currentUser.userType },
+        });
+        return runtime.cache.currentUser;
+    }
+    const startedAt = Date.now();
+    sdkLog("debug", "user", "currentUserFetch", {
+        devId: runtime.devId,
+        data: { force: !!isForce },
+    });
+    if (isForce) {
+        runtime.cache.currentUser = await getCurrentUserInfo(runtime.config.devInfo.devId);
+    }
+    else {
+        runtime.cache.currentUser = await getDataWithPreFetchForRuntime(runtime, "getCurrentUser", () => getCurrentUserInfo(runtime.config.devInfo.devId));
+    }
+    const u = runtime.cache.currentUser;
+    if (u) {
+        u.allOpenDps = u.allOpenDps || "";
+    }
+    sdkLog("debug", "user", "currentUserReady", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { userType: u?.userType, hasAllOpenDps: !!u?.allOpenDps },
+    });
+    return u;
+};

package/lib/feature/user/delete-user-dp.d.ts

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

package/lib/{utils/user.js → feature/user/delete-user-dp.js}

@@ -1,13 +1,13 @@
-import { removeUser } from "../api/user";
-import dpCodes from "../config/dp-code";
+import { removeUser } from "../../api/user";
+import dpCodes from "../../config/dp-code";
 import dpUtils from "@ray-js/tuya-dp-transform";
-import { remove as removeBigMap, reportRemove as reportRemoveBigMap, } from "../config/dp-map/unlock-method-big";
-import { remove as removeMap, reportRemove as reportRemoveMap, } from "../config/dp-map/unlock-method";
-import { publishDps } from "../utils/publishDps";
-import config from "../config";
-export const deleteUser = async (data) => {
+import { remove as removeBigMap, reportRemove as reportRemoveBigMap, } from "../../config/dp-map/unlock-method-big";
+import { remove as removeMap, reportRemove as reportRemoveMap, } from "../../config/dp-map/unlock-method";
+import { publishDpsForRuntime } from "../dp/publish-dps";
+export const deleteUserForRuntime = async (runtime, data) => {
     const { admin, lockUserId, userId } = data;
-    const dpCode = config.supportBigData
+    const cfg = runtime.config;
+    const dpCode = cfg.supportBigData
         ? dpCodes.unlockMethodDelW
         : dpCodes.unlockMethodDel;
     const dpData = {
@@ -15,15 +15,15 @@ export const deleteUser = async (data) => {
         stage: 0,
         admin: !!admin,
         memberId: lockUserId,
-        unlockId: config.supportBigData ? 0xffff : 0xff,
+        unlockId: cfg.supportBigData ? 0xffff : 0xff,
         category: 0,
     };
-    await publishDps({
-        [dpCode]: dpUtils.format(dpData, (config.supportBigData ? removeBigMap : removeMap)),
+    await publishDpsForRuntime(runtime, {
+        [dpCode]: dpUtils.format(dpData, (cfg.supportBigData ? removeBigMap : removeMap)),
     }, {
         checkReport: (dps) => {
             if (dps[dpCode]) {
-                const dpValue = dpUtils.parse(dps[dpCode], (config.supportBigData
+                const dpValue = dpUtils.parse(dps[dpCode], (cfg.supportBigData
                     ? reportRemoveBigMap
                     : reportRemoveMap));
                 if (dpValue.type === 0 &&
@@ -35,5 +35,5 @@ export const deleteUser = async (data) => {
             return false;
         },
     });
-    await removeUser(config.devInfo.devId, userId);
+    await removeUser(cfg.devInfo.devId, userId);
 };

package/lib/feature/user/share-user.d.ts

@@ -0,0 +1,29 @@
+import type { EffectiveConfig, SharedUserInfo } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface AddSharedUserParams {
+    countryCode: string;
+    account: string;
+    name: string;
+    effectiveType: "once" | "permanent" | "limit";
+    effective?: EffectiveConfig;
+    offlineUnlock?: boolean;
+}
+export interface AddSharedUserResult {
+    id: string;
+    name: string;
+    userExist: boolean;
+}
+export declare function addSharedUserForRuntime(rt: LockDeviceRuntime, params: AddSharedUserParams): Promise<AddSharedUserResult>;
+export interface UpdateSharedUserParams {
+    id: string;
+    name: string;
+    offlineUnlock?: boolean;
+    effective?: EffectiveConfig;
+    effectiveType: "once" | "permanent" | "limit";
+}
+export declare function updateSharedUserForRuntime(rt: LockDeviceRuntime, params: UpdateSharedUserParams): Promise<void>;
+export interface RemoveSharedUserParams {
+    id: string;
+}
+export declare function removeSharedUserForRuntime(rt: LockDeviceRuntime, params: RemoveSharedUserParams): Promise<void>;
+export declare function getSharedUserListForRunTime(rt: LockDeviceRuntime): Promise<SharedUserInfo[]>;

package/lib/feature/user/share-user.js

@@ -0,0 +1,228 @@
+import { checkLockShareAvailable } from "../../api/user";
+import { getError } from "../../utils/errors";
+import { formatWeek, parseWeek, validateEffectiveConfig } from "../../utils";
+import { addLockVirtualKey, removeLockVirtualKey, updateLockVirtualKey, } from "../../api/ble";
+import { fetchEffectiveList } from "../../api/temp";
+import { sdkLog } from "../../utils/sdk-log";
+function getTimeSetType(effectiveType, isRepeat) {
+    let timeSetType = 0;
+    if (effectiveType === "permanent") {
+        timeSetType = 10;
+    }
+    else if (effectiveType === "limit") {
+        timeSetType = isRepeat ? 30 : 20;
+    }
+    return timeSetType;
+}
+export async function addSharedUserForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "shareUser", "addStart", {
+        devId: rt.devId,
+        data: {
+            effectiveType: params.effectiveType,
+            offlineUnlock: !!params.offlineUnlock,
+            hasName: typeof params.name === "string",
+        },
+    });
+    if (params.name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "shareUser", "addInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: params.name.length },
+            error,
+        });
+        throw error;
+    }
+    if (params.effectiveType === "limit") {
+        validateEffectiveConfig(params.effective);
+    }
+    const hasEffective = params.effectiveType === "limit";
+    const hasRepeat = !!params.effective && params?.effective?.repeat === "week";
+    const data = {
+        devId: rt.config.devInfo.devId,
+        countryCode: params.countryCode,
+        account: params.account,
+        name: params.name,
+        effectiveTime: hasEffective ? params.effective?.effectiveDate || 0 : 0,
+        invalidTime: hasEffective ? params.effective?.expiredDate || 0 : 0,
+        availTime: params.effectiveType === "once" ? 1 : 0,
+        schedule: hasEffective
+            ? [
+                {
+                    allDay: !hasRepeat,
+                    effectiveTime: hasRepeat ? params.effective?.effectiveTime || 0 : 0,
+                    invalidTime: hasRepeat ? params.effective?.expiredTime || 1439 : 1439,
+                    workingDay: hasRepeat
+                        ? formatWeek(params.effective?.weeks || [])
+                        : 127,
+                },
+            ]
+            : [],
+    };
+    const res = await checkLockShareAvailable(data);
+    const timeSetType = getTimeSetType(params.effectiveType, hasRepeat);
+    if (!res.validateResult) {
+        sdkLog("warn", "shareUser", "addValidateFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { errorCode: res.errorCode, dialogueType: res.dialogueType },
+        });
+        switch (res.errorCode) {
+            case "EMOJI_NOT_SUPPORTED":
+                throw getError(1083);
+            case "LOCK_SHARED_ACCOUNT_NOT_RIGHT":
+                throw getError(1084);
+            case "LOCK_SHARED_VIRTUAL_KEY_NOT_AVAILABLE":
+                throw getError(1085);
+            case "DEVICE_NOT_EXIST":
+                throw getError(1086);
+            case "LOCK_BLE_SHARED_NAME_EXIST":
+                throw getError(1038);
+            default:
+                throw getError(1085);
+        }
+    }
+    const result = await addLockVirtualKey({
+        ...data,
+        offlineUnlock: !!params.offlineUnlock,
+        timeSetType,
+    });
+    sdkLog("info", "shareUser", "addSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: {
+            effectiveType: params.effectiveType,
+            offlineUnlock: !!params.offlineUnlock,
+            userExist: result.userExist,
+        },
+    });
+    return {
+        id: result.unlockBindingId,
+        name: result.name,
+        userExist: result.userExist,
+    };
+}
+export async function updateSharedUserForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "shareUser", "updateStart", {
+        devId: rt.devId,
+        data: {
+            effectiveType: params.effectiveType,
+            offlineUnlock: !!params.offlineUnlock,
+            hasId: !!params.id,
+        },
+    });
+    if (params.name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "shareUser", "updateInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: params.name.length },
+            error,
+        });
+        throw error;
+    }
+    if (params.effectiveType === "limit") {
+        validateEffectiveConfig(params.effective);
+    }
+    const hasEffective = params.effectiveType === "limit";
+    const hasRepeat = !!params.effective && params?.effective?.repeat === "week";
+    const timeSetType = getTimeSetType(params.effectiveType, hasRepeat);
+    const data = {
+        devId: rt.config.devInfo.devId,
+        unlockBindingId: params.id,
+        offlineUnlock: !!params.offlineUnlock,
+        name: params.name,
+        timeSetType,
+        effectiveTime: hasEffective ? params.effective?.effectiveDate || 0 : 0,
+        invalidTime: hasEffective ? params.effective?.expiredDate || 0 : 0,
+        availTime: params.effectiveType === "once" ? 1 : 0,
+        schedule: hasEffective
+            ? [
+                {
+                    allDay: !hasRepeat,
+                    effectiveTime: hasRepeat ? params.effective?.effectiveTime || 0 : 0,
+                    invalidTime: hasRepeat ? params.effective?.expiredTime || 1439 : 1439,
+                    workingDay: hasRepeat
+                        ? formatWeek(params.effective?.weeks || [])
+                        : 127,
+                },
+            ]
+            : [],
+    };
+    await updateLockVirtualKey(data);
+    sdkLog("info", "shareUser", "updateSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: {
+            effectiveType: params.effectiveType,
+            offlineUnlock: !!params.offlineUnlock,
+        },
+    });
+    return;
+}
+export async function removeSharedUserForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "shareUser", "removeStart", {
+        devId: rt.devId,
+        data: { hasId: !!params.id },
+    });
+    await removeLockVirtualKey({
+        devId: rt.config.devInfo.devId,
+        unlockBindingId: params.id,
+    });
+    sdkLog("info", "shareUser", "removeSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+    });
+}
+export async function getSharedUserListForRunTime(rt) {
+    const startedAt = Date.now();
+    const list = await fetchEffectiveList({
+        devId: rt.config.devInfo.devId,
+        authTypes: ["LOCK_BLUE_PASSWORD"],
+    });
+    const result = list.map(({ availTime, name, scheduleDetails, effectiveTime, invalidTime, phase, shareInfo, sn, timeSetType, unlockBindingId, }) => {
+        let effectiveType = "once";
+        if (availTime !== 1) {
+            if (timeSetType === 10) {
+                effectiveType = "permanent";
+            }
+            else if (timeSetType === 20 || timeSetType === 30) {
+                effectiveType = "limit";
+            }
+        }
+        const effectiveConfig = {
+            effectiveDate: effectiveTime,
+            expiredDate: invalidTime,
+            repeat: "none",
+        };
+        if (scheduleDetails?.length) {
+            const scheduleDetail = scheduleDetails[0];
+            effectiveConfig.repeat =
+                scheduleDetail.allDay === false ? "week" : "none";
+            if (effectiveConfig.repeat === "week") {
+                effectiveConfig.weeks = parseWeek(scheduleDetail.workingDay);
+                effectiveConfig.effectiveTime = scheduleDetail.effectiveTime;
+                effectiveConfig.expiredTime = scheduleDetail.invalidTime;
+            }
+        }
+        return {
+            id: unlockBindingId,
+            name,
+            effectiveType,
+            effectiveConfig,
+            phase,
+            account: shareInfo?.account || "",
+            countryCode: shareInfo?.countryCode || "",
+            offlineUnlock: shareInfo?.offlineUnlock || false,
+            lockUserId: shareInfo?.lockUserId || 0,
+            userExist: !!shareInfo?.userName,
+        };
+    });
+    sdkLog("debug", "shareUser", "getListSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { count: result.length },
+    });
+    return result;
+}

package/lib/feature/user/sync-user.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function syncDeleteUsersWithRuntime(runtime: LockDeviceRuntime): Promise<void>;