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

package/lib/feature/password/temporary/custom-dp-create-shared.js

@@ -0,0 +1,64 @@
+import { formatWeek, validateEffectiveConfig } from "../../../utils";
+import { LoopTypes } from "../../../utils/constant";
+import { encrypt } from "../../../platform/device";
+import { getError } from "../../../utils/errors";
+import { PASSWORD_REGEX } from "./internal/password-helpers";
+export async function prepareCustomTempCreateContext(rt, params) {
+    const cfg = rt.config;
+    const { password, name, effective } = params;
+    if (!PASSWORD_REGEX.test(password)) {
+        throw getError(1030);
+    }
+    if (name && name.length > 20) {
+        throw getError(1031);
+    }
+    validateEffectiveConfig(effective);
+    const { effectiveTime = 0, expiredTime = 1439 } = effective;
+    const aesPwd = await encrypt(cfg.devInfo.devId, password);
+    const loopType = effective?.repeat
+        ?
+            LoopTypes[effective?.repeat?.toUpperCase()]
+        : LoopTypes.NONE;
+    const schedule = [
+        {
+            allDay: loopType === LoopTypes.NONE,
+            effectiveTime,
+            invalidTime: expiredTime,
+            workingDay: formatWeek(effective?.weeks ?? [0]),
+        },
+    ];
+    const baseData = {
+        devId: cfg.devInfo.devId,
+        effectiveTime: effective.effectiveDate,
+        invalidTime: effective.expiredDate,
+        name: name,
+        password: aesPwd,
+        schedule,
+    };
+    const validConfig = {
+        startTime: effective.effectiveDate,
+        endTime: effective.expiredDate,
+        loop: loopType,
+        loopConfig: 0,
+        weeks: effective.weeks ? effective.weeks : [0, 0, 0, 0, 0, 0, 0],
+        days: [],
+        startHour: Math.floor(effectiveTime / 60),
+        startMinute: effectiveTime % 60,
+        endHour: Math.floor(expiredTime / 60),
+        endMinute: expiredTime % 60,
+    };
+    return {
+        baseData,
+        effective,
+        validConfig,
+    };
+}
+export function buildTempCustomCreateResult(createdName, passwordPlain, unlockBindingId, effective) {
+    return {
+        type: "custom",
+        name: createdName ?? "",
+        password: passwordPlain,
+        unlockBindingId,
+        effectiveConfig: effective,
+    };
+}

package/lib/feature/password/temporary/custom-dp.d.ts

@@ -0,0 +1,6 @@
+import type { TempPasswordResult } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { CreateCustomParams, RemoveCustomProps, UpdateTempPasswordParams } from "./types";
+export declare const createTempCustomForRuntime: (this: unknown, rt: LockDeviceRuntime, params: CreateCustomParams) => Promise<TempPasswordResult>;
+export declare function removeTempCustomForRuntime(rt: LockDeviceRuntime, params: RemoveCustomProps): Promise<boolean>;
+export declare function updateTempCustomForRuntime(rt: LockDeviceRuntime, params: UpdateTempPasswordParams): Promise<boolean>;

package/lib/feature/password/temporary/custom-dp.js

@@ -0,0 +1,241 @@
+import { createTemporaryPassword, deleteTempPassword, updateTemporaryPassword, } from "../../../api/temp";
+import { isUseNearChannelForRuntime } from "../../misc/is-use-near-channel-for-runtime";
+import { parallelOnlyForRuntime } from "../../utils";
+import { formatWeek, validateEffectiveConfig } from "../../../utils";
+import { LoopTypes } from "../../../utils/constant";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { addTempPwd as addTempPwdDpMap, reportAddTempPwd as reportAddTempPwdDpMap, removeTempPwd as removeTempPwdDpMap, reportRemoveTempPwd as reportRemoveTempPwdDpMap, } from "../../../config/dp-map/unlock-method";
+import { addTempPwd as addTempPwdBigDpMap, reportAddTempPwd as reportAddTempPwdDBigpMap, removeTempPwd as removeTempPwdBigDpMap, reportRemoveTempPwd as reportRemoveTempPwdBigDpMap, } from "../../../config/dp-map/unlock-method-big";
+import dpCodes from "../../../config/dp-code";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { isValidPassword } from "./internal/password-helpers";
+import { prepareCustomTempCreateContext, buildTempCustomCreateResult, } from "./custom-dp-create-shared";
+import { sdkLog } from "../../../utils/sdk-log";
+export const createTempCustomForRuntime = parallelOnlyForRuntime(async function (rt, params) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    const prepared = await prepareCustomTempCreateContext(rt, params);
+    const { baseData, effective, validConfig } = prepared;
+    const useNear = isUseNearChannelForRuntime(rt);
+    sdkLog("info", "tempPassword", "createCustomStart", {
+        devId: rt.devId,
+        data: {
+            route: useNear ? "nearDp" : "cloud",
+            hasName: typeof params.name === "string",
+            repeat: params.effective?.repeat,
+        },
+    });
+    if (!useNear) {
+        try {
+            const res = await createTemporaryPassword({
+                ...baseData,
+                sn: 0,
+                availTime: 0,
+                symbolic: false,
+                dpTunnel: 2,
+            });
+            sdkLog("info", "tempPassword", "createCustomSuccess", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { route: "cloud" },
+            });
+            return buildTempCustomCreateResult(res.name, params.password, res.unlockBindingId, effective);
+        }
+        catch (error) {
+            sdkLog("error", "tempPassword", "createCustomCloudFail", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { route: "cloud" },
+                error,
+            });
+            throw handleCloudError(error);
+        }
+    }
+    await isValidPassword(baseData);
+    const { tyNum, name: createdName } = await createTemporaryPassword({
+        ...baseData,
+        sn: 0,
+        availTime: 0,
+        symbolic: false,
+        dpTunnel: 2,
+    });
+    if (!tyNum) {
+        const error = getError(1043);
+        sdkLog("warn", "tempPassword", "createCustomMissingCloudNo", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+    const targetDpCode = cfg.supportBigData
+        ? dpCodes.tempPwdCreateW
+        : dpCodes.tempPwdCreate;
+    const dpPayload = dpUtils.format({
+        cloudNo: tyNum,
+        valid: true,
+        validConfig,
+        validNum: 0,
+        pwdLength: params.password.length,
+        pwd: params.password.split("").map(Number),
+    }, (cfg.supportBigData ? addTempPwdBigDpMap : addTempPwdDpMap));
+    const result = await publishDpsForRuntime(rt, {
+        [targetDpCode]: dpPayload,
+    }, {
+        checkReport: (dpsIn) => {
+            const dpDataRow = dpsIn;
+            const reportData = dpDataRow[targetDpCode];
+            if (reportData) {
+                const data = dpUtils.parse(dpDataRow[targetDpCode], (cfg.supportBigData
+                    ? reportAddTempPwdDBigpMap
+                    : reportAddTempPwdDpMap));
+                if (data.cloudNo === tyNum) {
+                    return data;
+                }
+            }
+            return false;
+        },
+    });
+    if (result.status === 0) {
+        sdkLog("info", "tempPassword", "createCustomSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { route: "nearDp" },
+        });
+        return buildTempCustomCreateResult(createdName, params.password, result.unlockBindingId, effective);
+    }
+    const error = getError(result.status === 2 ? 1041 : 1042);
+    sdkLog("warn", "tempPassword", "createCustomDpFail", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { status: result.status },
+        error,
+    });
+    throw error;
+});
+export async function removeTempCustomForRuntime(rt, params) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    const useNear = isUseNearChannelForRuntime(rt);
+    sdkLog("info", "tempPassword", "removeCustomStart", {
+        devId: rt.devId,
+        data: { route: useNear ? "cloudAndNearDp" : "cloud", sn: params.sn },
+    });
+    try {
+        await deleteTempPassword({
+            devId: cfg.devInfo.devId,
+            unlockBindingId: params.unlockBindingId,
+            symbolic: false,
+            dpTunnel: 2,
+        });
+        if (useNear) {
+            const dpCode = cfg.supportBigData
+                ? dpCodes.tempPwdDelW
+                : dpCodes.tempPwdDel;
+            const dpData = {
+                unlockId: params.sn,
+            };
+            const result = await publishDpsForRuntime(rt, {
+                [dpCode]: dpUtils.format(dpData, (cfg.supportBigData
+                    ? removeTempPwdBigDpMap
+                    : removeTempPwdDpMap)),
+            }, {
+                checkReport: (dpsIn) => {
+                    const dpDataRow = dpsIn;
+                    const reportData = dpDataRow[dpCode];
+                    if (reportData) {
+                        const data = dpUtils.parse(reportData, (cfg.supportBigData
+                            ? reportRemoveTempPwdBigDpMap
+                            : reportRemoveTempPwdDpMap));
+                        return data;
+                    }
+                    return false;
+                },
+            });
+            if (result.status === 0) {
+                sdkLog("info", "tempPassword", "removeCustomSuccess", {
+                    devId: rt.devId,
+                    duration: Date.now() - startedAt,
+                    data: { route: "cloudAndNearDp" },
+                });
+                return true;
+            }
+            const error = getError(1065);
+            sdkLog("warn", "tempPassword", "removeCustomDpFail", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { status: result.status },
+                error,
+            });
+            throw error;
+        }
+        sdkLog("info", "tempPassword", "removeCustomSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { route: "cloud" },
+        });
+        return true;
+    }
+    catch (e) {
+        sdkLog("error", "tempPassword", "removeCustomFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error: e,
+        });
+        throw handleCloudError(e);
+    }
+}
+export async function updateTempCustomForRuntime(rt, params) {
+    const { unlockBindingId, name, effective } = params;
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "updateCustomStart", {
+        devId: rt.devId,
+        data: {
+            hasName: typeof name === "string",
+            repeat: effective?.repeat,
+        },
+    });
+    if (name && name.length > 20) {
+        throw getError(1031);
+    }
+    validateEffectiveConfig(effective);
+    const loopType = effective?.repeat
+        ?
+            LoopTypes[effective?.repeat?.toUpperCase()]
+        : LoopTypes.NONE;
+    const schedule = [
+        {
+            allDay: loopType === LoopTypes.NONE,
+            effectiveTime: effective?.effectiveTime ?? 0,
+            invalidTime: effective?.expiredTime ?? 0,
+            workingDay: formatWeek(effective?.weeks ?? [0]),
+        },
+    ];
+    try {
+        const result = await updateTemporaryPassword({
+            devId: rt.config.devInfo.devId,
+            effectiveTime: effective.effectiveDate,
+            invalidTime: effective.expiredDate,
+            name: name,
+            schedule,
+            unlockBindingId,
+            symbolic: false,
+            dpTunnel: 2,
+        });
+        sdkLog("info", "tempPassword", "updateCustomSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { hasName: typeof name === "string" },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "updateCustomFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/password/temporary/freeze-ble-key.d.ts

@@ -0,0 +1,4 @@
+import { LockDeviceRuntime } from "../../../runtime";
+import { FreezeParams } from "./types";
+export declare function freezeBLEKeyForRuntime(rt: LockDeviceRuntime, params: FreezeParams): Promise<unknown>;
+export declare function unfreezeBLEKeyForRuntime(rt: LockDeviceRuntime, params: FreezeParams): Promise<unknown>;

package/lib/feature/password/temporary/freeze-ble-key.js

@@ -0,0 +1,7 @@
+import { updateLockVirtualKeyStatus } from "../../../api/ble";
+export async function freezeBLEKeyForRuntime(rt, params) {
+    return updateLockVirtualKeyStatus(rt.config.devInfo.devId, params.unlockBindingId, 4);
+}
+export async function unfreezeBLEKeyForRuntime(rt, params) {
+    return updateLockVirtualKeyStatus(rt.config.devInfo.devId, params.unlockBindingId, 2);
+}

package/lib/feature/password/temporary/freeze-rename.d.ts

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { FreezeParams, RenameParams } from "./types";
+export declare function freezeTempForRuntime(rt: LockDeviceRuntime, params: FreezeParams): Promise<boolean>;
+export declare function unfreezeTempForRuntime(rt: LockDeviceRuntime, params: FreezeParams): Promise<boolean>;
+export declare function renameTempForRuntime(rt: LockDeviceRuntime, params: RenameParams): Promise<void>;

package/lib/feature/password/temporary/freeze-rename.js

@@ -0,0 +1,72 @@
+import { fetchEffectiveList, reNameOffline, reNameTemporary, } from "../../../api/temp";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { changePasswordPhaseForRuntime } from "./internal/change-password-phase";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function freezeTempForRuntime(rt, params) {
+    sdkLog("info", "tempPassword", "freezeStart", {
+        devId: rt.devId,
+        data: { hasBindingId: !!params.unlockBindingId },
+    });
+    return changePasswordPhaseForRuntime(rt, params.unlockBindingId, 4);
+}
+export async function unfreezeTempForRuntime(rt, params) {
+    sdkLog("info", "tempPassword", "unfreezeStart", {
+        devId: rt.devId,
+        data: { hasBindingId: !!params.unlockBindingId },
+    });
+    return changePasswordPhaseForRuntime(rt, params.unlockBindingId, 2);
+}
+export async function renameTempForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "renameStart", {
+        devId: rt.devId,
+        data: {
+            hasBindingId: !!params.unlockBindingId,
+            hasName: typeof params.name === "string",
+        },
+    });
+    const list = await fetchEffectiveList({
+        devId: rt.config.devInfo.devId,
+        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
+    });
+    const password = list.find((item) => item.unlockBindingId === params.unlockBindingId);
+    if (!password) {
+        const error = getError(1051);
+        sdkLog("warn", "tempPassword", "renamePasswordNotFound", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+    try {
+        if (password.opModeType === 1) {
+            await reNameTemporary({
+                devId: rt.config.devInfo.devId,
+                unlockBindingId: params.unlockBindingId,
+                name: params.name,
+            });
+        }
+        else {
+            await reNameOffline({
+                devId: rt.config.devInfo.devId,
+                unlockBindingId: params.unlockBindingId,
+                pwdName: params.name,
+            });
+        }
+        sdkLog("info", "tempPassword", "renameSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { opModeType: password.opModeType },
+        });
+    }
+    catch (e) {
+        sdkLog("error", "tempPassword", "renameFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { opModeType: password.opModeType },
+            error: e,
+        });
+        throw handleCloudError(e);
+    }
+}

package/lib/feature/password/temporary/internal/change-password-phase.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../../../runtime/LockDeviceRuntime";
+export declare function changePasswordPhaseForRuntime(rt: LockDeviceRuntime, unlockBindingId: string, phase: number): Promise<boolean>;

package/lib/feature/password/temporary/internal/change-password-phase.js

@@ -0,0 +1,48 @@
+import { fetchEffectiveList, updateTemporaryPassword, } from "../../../../api/temp";
+import { getError, handleCloudError } from "../../../../utils/errors";
+import { sdkLog } from "../../../../utils/sdk-log";
+export async function changePasswordPhaseForRuntime(rt, unlockBindingId, phase) {
+    const startedAt = Date.now();
+    const list = await fetchEffectiveList({
+        devId: rt.config.devInfo.devId,
+        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
+    });
+    const password = list.find((item) => item.unlockBindingId === unlockBindingId);
+    if (!password) {
+        const error = getError(1051);
+        sdkLog("warn", "tempPassword", "changePhasePasswordNotFound", {
+            devId: rt.devId,
+            data: { phase },
+            error,
+        });
+        throw error;
+    }
+    try {
+        await updateTemporaryPassword({
+            unlockBindingId,
+            schedule: password.scheduleDetails,
+            effectiveTime: password.effectiveTime,
+            invalidTime: password.invalidTime,
+            name: password.name,
+            phase,
+            symbolic: false,
+            dpTunnel: 2,
+            devId: rt.config.devInfo.devId,
+        });
+        sdkLog("info", "tempPassword", "changePhaseSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { phase },
+        });
+    }
+    catch (e) {
+        sdkLog("error", "tempPassword", "changePhaseFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { phase },
+            error: e,
+        });
+        throw handleCloudError(e);
+    }
+    return true;
+}

package/lib/feature/password/temporary/internal/constants.d.ts

@@ -0,0 +1,12 @@
+import type { TemporaryPasswordType } from "../../../../interface";
+import type { OfflinePasswordType } from "../types";
+export declare const PASSWORD_REGEX: RegExp;
+export declare const passwordTypeMap: Record<string, TemporaryPasswordType>;
+export declare const onLinePasswordStatusMap: {
+    readonly 1: "effective";
+    readonly 2: "synchronizing";
+    readonly 3: "expired";
+    readonly 4: "disabled";
+    readonly 5: "invalid";
+};
+export declare const offlinePasswordTypeMap: Record<OfflinePasswordType, string>;

package/lib/feature/password/temporary/internal/constants.js

@@ -0,0 +1,21 @@
+export const PASSWORD_REGEX = /^[0-9]+$/;
+export const passwordTypeMap = {
+    "1-0": "custom",
+    "3-1": "once",
+    "3-0": "limit",
+    "3-8": "clearOne",
+    "3-9": "clear",
+};
+export const onLinePasswordStatusMap = {
+    1: "effective",
+    2: "synchronizing",
+    3: "expired",
+    4: "disabled",
+    5: "invalid",
+};
+export const offlinePasswordTypeMap = {
+    once: "1",
+    multiple: "0",
+    clear_one: "8",
+    clear_all: "9",
+};

package/lib/feature/password/temporary/internal/password-helpers.d.ts

@@ -0,0 +1,4 @@
+import { type CreateOfflinePasswordParams, type ValidateTempPwdParams } from "../../../../api/temp";
+export declare const PASSWORD_REGEX: RegExp;
+export declare function isValidPassword(params: ValidateTempPwdParams): Promise<boolean>;
+export declare function getOfflinePassword(params: CreateOfflinePasswordParams): Promise<import("../../../../api/temp").OfflinePwdResult>;

package/lib/feature/password/temporary/internal/password-helpers.js

@@ -0,0 +1,18 @@
+import { createOfflinePassword, validateTempPwd, } from "../../../../api/temp";
+import { handleCloudError } from "../../../../utils/errors";
+export const PASSWORD_REGEX = /^[0-9]+$/;
+export async function isValidPassword(params) {
+    const validateResult = await validateTempPwd(params);
+    if (!validateResult.valid) {
+        handleCloudError({ innerError: { errorCode: validateResult.errorCode } });
+    }
+    return true;
+}
+export async function getOfflinePassword(params) {
+    try {
+        return await createOfflinePassword(params);
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/password/temporary/internal/password-type-map.d.ts

@@ -0,0 +1,2 @@
+import type { TemporaryPasswordType } from "../../../../interface";
+export declare const PASSWORD_TYPE_MAP: Record<string, TemporaryPasswordType>;

package/lib/feature/password/temporary/internal/password-type-map.js

@@ -0,0 +1,7 @@
+export const PASSWORD_TYPE_MAP = {
+    "1-0": "custom",
+    "3-1": "once",
+    "3-0": "limit",
+    "3-8": "clearOne",
+    "3-9": "clear",
+};

package/lib/feature/password/temporary/lists.d.ts

@@ -0,0 +1,16 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { EffectivePasswrodItem, GetInvalidListParams, InvalidPasswordItem } from "./types";
+export declare function getTempEffectiveListForRuntime(rt: LockDeviceRuntime): Promise<EffectivePasswrodItem[]>;
+export declare function getTempInvalidListForRuntime(rt: LockDeviceRuntime, params?: GetInvalidListParams): Promise<{
+    list: InvalidPasswordItem[];
+    hasMore: boolean;
+    total: number;
+}>;
+export declare function clearTempInvalidListForRuntime(rt: LockDeviceRuntime): Promise<boolean>;
+export interface LimitTempItem {
+    id: string;
+    name: string;
+    effectiveTime: number;
+    invalidTime: number;
+}
+export declare function getTempLimitListForClearForRuntime(rt: LockDeviceRuntime): Promise<LimitTempItem[]>;