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

package/lib/feature/misc/validate-pwd.d.ts

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

package/lib/feature/misc/validate-pwd.js

@@ -0,0 +1,10 @@
+import { encrypt } from "../../platform/device";
+import { validatePasswordComplexity } from "../../api/lock";
+export async function validatePwdComplexityForRuntime(rt, password) {
+    const devId = rt.config.devInfo.devId;
+    const encryptedPassword = await encrypt(devId, password);
+    return validatePasswordComplexity({
+        devId,
+        password: encryptedPassword,
+    });
+}

package/lib/feature/misc/yu-channel.d.ts

@@ -0,0 +1,6 @@
+import { LockDeviceRuntime } from "../../runtime";
+export declare const isSupportYuChannelForRuntime: (rt: LockDeviceRuntime) => 0 | 1 | 2;
+export declare const isYuChannelOnlineForRuntime: (rt: LockDeviceRuntime) => boolean;
+export declare const updateYuChannelStateForRuntime: (rt: LockDeviceRuntime, enabled: boolean) => Promise<void>;
+export declare const getYuChannelStateForRuntime: (rt: LockDeviceRuntime) => boolean;
+export declare const getYuChannelNodesForRuntime: (rt: LockDeviceRuntime) => Promise<string[]>;

package/lib/feature/misc/yu-channel.js

@@ -0,0 +1,26 @@
+import { isYuDeviceOnlineSync, yuChannelQueryNodes, yuChannelSaveState, } from "../../platform";
+export const isSupportYuChannelForRuntime = (rt) => {
+    if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.support) {
+        return rt.cache.deviceAdvanceAbilityCache?.yuChannel.value;
+    }
+    return 0;
+};
+export const isYuChannelOnlineForRuntime = (rt) => {
+    return isYuDeviceOnlineSync(rt.config.devInfo.devId);
+};
+export const updateYuChannelStateForRuntime = async (rt, enabled) => {
+    await yuChannelSaveState(rt.config.devInfo.devId, enabled);
+    rt.config.devInfo.yuNetState = enabled ? 1 : 0;
+};
+export const getYuChannelStateForRuntime = (rt) => {
+    if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.support) {
+        if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.value === 1) {
+            return true;
+        }
+        return rt.config.devInfo.yuNetState === 1;
+    }
+    return false;
+};
+export const getYuChannelNodesForRuntime = (rt) => {
+    return yuChannelQueryNodes(rt.config.devInfo.devId);
+};

package/lib/feature/offline-dps/index.d.ts

@@ -0,0 +1,10 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { DpValue, OfflineDps } from "../../interface";
+export declare function getOfflineDpsUpdateEvent(runtime: LockDeviceRuntime): string;
+export declare const getOfflineDpsForRuntime: (runtime: LockDeviceRuntime, isForce?: boolean) => Promise<OfflineDps>;
+export declare const checkOfflineDpUpdateForRuntime: (runtime: LockDeviceRuntime, dps: Record<string, DpValue> | undefined, isForce?: boolean) => Promise<void>;
+export declare const getOfflineDpCacheForRuntime: (runtime: LockDeviceRuntime, code: string) => import("../../interface").OfflineDpInfo | undefined;
+export declare const publishOfflineDpsForRuntime: (runtime: LockDeviceRuntime, dps: Record<string, DpValue>) => Promise<void>;
+export declare const clearOfflineDpsForRuntime: (runtime: LockDeviceRuntime) => Promise<void>;
+export declare const onOfflineDpsUpdateForRuntime: (runtime: LockDeviceRuntime, callback: (dps: OfflineDps) => void) => void;
+export declare const offOfflineDpsUpdateForRuntime: (runtime: LockDeviceRuntime, callback: (dps: OfflineDps) => void) => void;

package/lib/feature/offline-dps/index.js

@@ -0,0 +1,133 @@
+import { clearOfflineDpData, fetchOfflineDpData, publishOfflineDpData, } from "../../api";
+import base64ToHex from "../../utils/base64-to-hex";
+import hexToBase64 from "../../utils/hex-to-base64";
+import emitter from "../../utils/event";
+import { sdkLog } from "../../utils/sdk-log";
+const OFFLINE_DPS_UPDATE = "offline_dps_update";
+export function getOfflineDpsUpdateEvent(runtime) {
+    return `${OFFLINE_DPS_UPDATE}_${runtime.devId}`;
+}
+export const getOfflineDpsForRuntime = async (runtime, isForce) => {
+    if (!isForce && runtime.cache.offlineDpCache) {
+        sdkLog("debug", "offlineDps", "cacheHit", {
+            devId: runtime.devId,
+            data: { count: Object.keys(runtime.cache.offlineDpCache).length },
+        });
+        return runtime.cache.offlineDpCache;
+    }
+    const { devInfo, dpSchema } = runtime.config;
+    const startedAt = Date.now();
+    sdkLog("info", "offlineDps", "fetchStart", {
+        devId: runtime.devId,
+        data: { force: !!isForce },
+    });
+    const res = await fetchOfflineDpData(devInfo.devId);
+    const result = res.reduce((acc, item) => {
+        const dps = JSON.parse(item.dps);
+        Object.keys(dps).forEach((code) => {
+            const schema = dpSchema[code];
+            let value = dps[code];
+            if (schema?.type === "raw") {
+                value = base64ToHex(value);
+            }
+            acc[code] = { value, pushStatus: item.pushStatus };
+        });
+        return acc;
+    }, {});
+    runtime.cache.offlineDpCache = result;
+    sdkLog("info", "offlineDps", "fetchSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: {
+            count: Object.keys(result).length,
+            cloudCount: res.length,
+            force: !!isForce,
+        },
+    });
+    return result;
+};
+export const checkOfflineDpUpdateForRuntime = async (runtime, dps, isForce) => {
+    const dpMap = dps ?? {};
+    if (!runtime.config.supportOfflineDps) {
+        return;
+    }
+    const cache = runtime.cache.offlineDpCache;
+    const hasOne = Object.keys(dpMap).some((code) => cache?.[code]?.pushStatus === false);
+    if (hasOne || isForce) {
+        const res = await getOfflineDpsForRuntime(runtime, true);
+        sdkLog("debug", "offlineDps", "emitUpdate", {
+            devId: runtime.devId,
+            data: { count: Object.keys(res).length, force: !!isForce },
+        });
+        emitter.emit(getOfflineDpsUpdateEvent(runtime), res);
+    }
+};
+export const getOfflineDpCacheForRuntime = (runtime, code) => {
+    return runtime.cache.offlineDpCache?.[code];
+};
+export const publishOfflineDpsForRuntime = async (runtime, dps) => {
+    const { devInfo, dpSchema } = runtime.config;
+    const startedAt = Date.now();
+    const dpData = Object.keys(dps).reduce((acc, code) => {
+        const schema = dpSchema[code];
+        if (schema) {
+            let value = dps[code];
+            if (schema.type === "raw") {
+                value = hexToBase64(value);
+            }
+            acc[schema.id] = value;
+        }
+        return acc;
+    }, {});
+    sdkLog("info", "offlineDps", "publishStart", {
+        devId: runtime.devId,
+        data: { codes: Object.keys(dps), count: Object.keys(dpData).length },
+    });
+    try {
+        await publishOfflineDpData(devInfo.devId, dpData);
+        await checkOfflineDpUpdateForRuntime(runtime, {}, true);
+        sdkLog("info", "offlineDps", "publishSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { codes: Object.keys(dps), count: Object.keys(dpData).length },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "offlineDps", "publishFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { codes: Object.keys(dps), count: Object.keys(dpData).length },
+            error,
+        });
+        throw error;
+    }
+};
+export const clearOfflineDpsForRuntime = async (runtime) => {
+    const { devInfo } = runtime.config;
+    const startedAt = Date.now();
+    sdkLog("info", "offlineDps", "clearStart", {
+        devId: runtime.devId,
+    });
+    try {
+        await clearOfflineDpData(devInfo.devId);
+        await checkOfflineDpUpdateForRuntime(runtime, {}, true);
+        sdkLog("info", "offlineDps", "clearSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+        });
+    }
+    catch (error) {
+        sdkLog("error", "offlineDps", "clearFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+};
+export const onOfflineDpsUpdateForRuntime = (runtime, callback) => {
+    emitter.on(getOfflineDpsUpdateEvent(runtime), callback);
+};
+export const offOfflineDpsUpdateForRuntime = (runtime, callback) => {
+    emitter.off(getOfflineDpsUpdateEvent(runtime), callback);
+};

package/lib/feature/password/ble-temp-payload.d.ts

@@ -0,0 +1,3 @@
+import { SyncTempPwdItem } from "../../api/temp";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function buildBleTempPwdSyncPayload(runtime: LockDeviceRuntime, pwdList: SyncTempPwdItem[]): Promise<string>;

package/lib/{sync → feature/password}/ble-temp-payload.js

@@ -1,7 +1,6 @@
-import config from "../config";
-import { formatWeek, parseWeek } from "../utils";
-import { bytesToHex, concatBytes, uintToBytesBE } from "../utils/byte";
-import { decrypt } from "../utils/device";
+import { formatWeek, parseWeek } from "../../utils";
+import { bytesToHex, concatBytes, uintToBytesBE } from "../../utils/byte";
+import { decrypt } from "../../platform/device";
 const SUB_CMD = 0x2003;
 const PROTO_VERSION = 0x01;
 const DATA_TYPE_TEMP_PWD = 0x01;
@@ -41,18 +40,18 @@ function mapState(phase) {
     }
     return 0x01;
 }
-async function resolvePwdBytes(password) {
+async function resolvePwdBytes(devId, password) {
     if (!password) {
         return [];
     }
-    const plainPwd = await decrypt(config.devInfo.devId, password);
+    const plainPwd = await decrypt(devId, password);
     return plainPwd.split("").map((char) => Number(char));
 }
-async function buildItemBody(item, opCode) {
+async function buildItemBody(devId, item, opCode) {
     if (opCode === OP_DEL) {
         return uintToBytesBE(item.sn, 2);
     }
-    const pwdBytes = await resolvePwdBytes(item.password);
+    const pwdBytes = await resolvePwdBytes(devId, item.password);
     const state = mapState(item.phase);
     const timeSet = buildTimeSet(item);
     const availTime = mapAvailTime(item.availTime);
@@ -74,14 +73,15 @@ function cloudOptToOpCode(opt) {
             return null;
     }
 }
-export async function buildBleTempPwdSyncPayload(pwdList) {
+export async function buildBleTempPwdSyncPayload(runtime, pwdList) {
+    const devId = runtime.config.devInfo.devId;
     const items = [];
     for (const item of pwdList) {
         const opCode = cloudOptToOpCode(item.opt);
         if (opCode === null) {
             continue;
         }
-        const body = await buildItemBody(item, opCode);
+        const body = await buildItemBody(devId, item, opCode);
         items.push(concatBytes(new Uint8Array([opCode]), uintToBytesBE(body.length, 2), body));
     }
     const itemsBuf = concatBytes(...items);

package/lib/feature/password/sync-temp.d.ts

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const notifyBleSyncRequest: (runtime: LockDeviceRuntime) => Promise<void>;
+export declare const autoSyncTemp: (runtime: LockDeviceRuntime) => void;
+export declare const handleBleSyncRequestReport: (runtime: LockDeviceRuntime, rawValue: string) => Promise<void>;

package/lib/feature/password/sync-temp.js

@@ -0,0 +1,91 @@
+import { getSyncTempPasswords } from "../../api/temp";
+import dpCodes from "../../config/dp-code";
+import { bleSyncRequestPublish as bleSyncRequestPublishMap, bleSyncRequestReport as bleSyncRequestReportMap, } from "../../config/dp-map/ble-sync";
+import { isUseNearChannelForRuntime } from "../misc/is-use-near-channel-for-runtime";
+import { hasDpForRuntime } from "../dp/has-dp";
+import { publishDpsOnlyWithRuntime } from "../dp/publish-dps";
+import { publishBLETransparentData } from "../../platform/device";
+import { buildBleTempPwdSyncPayload } from "./ble-temp-payload";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { sdkLog } from "../../utils/sdk-log";
+const NOTIFY_DEBOUNCE_MS = 2000;
+const CMD_REQUEST_SYNC = 0x01;
+const DATA_TYPE_TEMP_PWD = 0x01;
+const isBleSyncEligible = (runtime) => isUseNearChannelForRuntime(runtime) &&
+    hasDpForRuntime(runtime, dpCodes.bleSyncRequest);
+export const notifyBleSyncRequest = async (runtime) => {
+    if (!isBleSyncEligible(runtime)) {
+        return;
+    }
+    const { count } = await getSyncTempPasswords({
+        devId: runtime.config.devInfo.devId,
+        isUpt: false,
+    });
+    await publishDpsOnlyWithRuntime(runtime, {
+        [dpCodes.bleSyncRequest]: dpUtils.format({ cmd: count > 0 ? 0x01 : 0x00 }, bleSyncRequestPublishMap),
+    });
+    sdkLog("info", "tempPassword", "bleSyncNotify", {
+        devId: runtime.devId,
+        data: { hasPending: count > 0 },
+    });
+};
+export const autoSyncTemp = (runtime) => {
+    if (!isBleSyncEligible(runtime) || !runtime.sync.tempAutoSyncEnabled) {
+        sdkLog("debug", "tempPassword", "autoSyncSkipped", {
+            devId: runtime.devId,
+            data: {
+                nearChannel: isUseNearChannelForRuntime(runtime),
+                hasDp: hasDpForRuntime(runtime, dpCodes.bleSyncRequest),
+                enabled: runtime.sync.tempAutoSyncEnabled,
+            },
+        });
+        return;
+    }
+    clearTimeout(runtime.infra.tempSyncNotifyTimer);
+    runtime.infra.tempSyncNotifyTimer = setTimeout(() => {
+        runtime.infra.tempSyncNotifyTimer = 0;
+        notifyBleSyncRequest(runtime).catch((e) => {
+            sdkLog("warn", "tempPassword", "bleSyncNotifyFail", {
+                devId: runtime.devId,
+                error: e,
+            });
+        });
+    }, NOTIFY_DEBOUNCE_MS);
+};
+export const handleBleSyncRequestReport = async (runtime, rawValue) => {
+    if (!isBleSyncEligible(runtime) || runtime.sync.tempPayloadSyncing) {
+        return;
+    }
+    const report = dpUtils.parse(rawValue, bleSyncRequestReportMap);
+    if (report.cmd !== CMD_REQUEST_SYNC ||
+        report.dataType !== DATA_TYPE_TEMP_PWD) {
+        return;
+    }
+    runtime.sync.tempPayloadSyncing = true;
+    const startedAt = Date.now();
+    try {
+        const { count, pwdList } = await getSyncTempPasswords({
+            devId: runtime.config.devInfo.devId,
+            isUpt: false,
+        });
+        if (count > 0 && pwdList?.length) {
+            const payload = await buildBleTempPwdSyncPayload(runtime, pwdList);
+            await publishBLETransparentData(runtime.config.devInfo.devId, payload);
+            sdkLog("info", "tempPassword", "bleSyncPayloadSent", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: { count },
+            });
+        }
+    }
+    catch (e) {
+        sdkLog("warn", "tempPassword", "bleSyncPayloadFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error: e,
+        });
+    }
+    finally {
+        runtime.sync.tempPayloadSyncing = false;
+    }
+};

package/lib/feature/password/temporary/custom-dp-ble.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 const updateTempCustomForRuntime: (this: unknown, rt: LockDeviceRuntime, params: UpdateTempPasswordParams) => Promise<boolean>;
+export declare const removeTempCustomForRuntime: (this: unknown, rt: LockDeviceRuntime, params: RemoveCustomProps) => Promise<boolean>;

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

@@ -0,0 +1,263 @@
+import { createTemporaryPassword, deleteTempPassword, fetchEffectiveList, updateTemporaryPassword, } from "../../../api/temp";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { parallelOnlyForRuntime } from "../../utils";
+import { addBleTempPwd as addBleTempPwdDpMap, reportAddBleTempPwd as reportAddBleTempPwdDpMap, updateBleTempPwd as updateBleTempPwdDpMap, reportUpdateTempPwd as reportUpdateTempPwdDpMap, removeTempPwd as removeTempPwdDpMap, reportRemoveTempPwd as reportRemoveTempPwdDpMap, } from "../../../config/dp-map/unlock-method";
+import dpCodes from "../../../config/dp-code";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { formatWeek, validateEffectiveConfig } from "../../../utils";
+import { LoopTypes } from "../../../utils/constant";
+import { sdkLog } from "../../../utils/sdk-log";
+import { isValidPassword } from "./internal/password-helpers";
+import { prepareCustomTempCreateContext, } from "./custom-dp-create-shared";
+function throwBleTempPwdAddDpReportStatus(status) {
+    switch (status) {
+        case 1:
+            throw getError(1042);
+        case 2:
+            throw getError(1041);
+        case 3:
+            throw getError(1037);
+        default:
+            throw getError(1042);
+    }
+}
+async function publishBleTempCustomUpdateNearDp(rt, sn, validConfig) {
+    const targetDpCode = dpCodes.tempPwdEdit;
+    const reportMap = reportUpdateTempPwdDpMap;
+    const dpPayload = dpUtils.format({
+        unlockId: sn,
+        type: 1,
+        validConfig,
+        validNum: 0,
+        pwdLength: 0,
+        pwd: [],
+    }, updateBleTempPwdDpMap);
+    const result = await publishDpsForRuntime(rt, { [targetDpCode]: dpPayload }, {
+        checkReport: (dpsIn) => {
+            const dpDataRow = dpsIn;
+            const reportData = dpDataRow[targetDpCode];
+            if (reportData) {
+                const data = dpUtils.parse(reportData, reportMap);
+                if (data["unlockId"] === sn) {
+                    return data;
+                }
+            }
+            return false;
+        },
+    });
+    if (result.status === 0) {
+        return;
+    }
+    throw getError(1082);
+}
+async function publishBleTempCustomCreateNearDp(rt, params, prepared) {
+    const cfg = rt.config;
+    const { effective, validConfig } = prepared;
+    const targetDpCode = cfg.supportBigData
+        ? dpCodes.tempPwdCreateW
+        : dpCodes.tempPwdCreate;
+    const dpPayload = dpUtils.format({
+        type: 1,
+        validConfig,
+        validNum: 0,
+        pwdLength: params.password.length,
+        pwd: params.password.split("").map(Number),
+    }, addBleTempPwdDpMap);
+    const result = await publishDpsForRuntime(rt, {
+        [targetDpCode]: dpPayload,
+    }, {
+        checkReport: (dpsIn) => {
+            const dpDataRow = dpsIn;
+            const reportData = dpDataRow[targetDpCode];
+            if (reportData) {
+                const data = dpUtils.parse(dpDataRow[targetDpCode], reportAddBleTempPwdDpMap);
+                sdkLog("debug", "tempPassword", "addBleTempPwdReport", {
+                    devId: rt.devId,
+                    data: { status: data.status, unlockId: data.unlockId },
+                });
+                return data;
+            }
+            return false;
+        },
+    });
+    const status = Number(result.status);
+    if (status === 0) {
+        return result.unlockId;
+    }
+    throwBleTempPwdAddDpReportStatus(status);
+}
+export const createTempCustomForRuntime = parallelOnlyForRuntime(async function (rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createBleCustomStart", {
+        devId: rt.devId,
+        data: {
+            hasName: typeof params.name === "string",
+            repeat: params.effective?.repeat,
+        },
+    });
+    const prepared = await prepareCustomTempCreateContext(rt, params);
+    await isValidPassword(prepared.baseData);
+    const unlockId = await publishBleTempCustomCreateNearDp(rt, params, prepared);
+    const result = await createTemporaryPassword({
+        ...prepared.baseData,
+        sn: unlockId,
+        availTime: 0,
+    });
+    sdkLog("info", "tempPassword", "createBleCustomSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { unlockId },
+    });
+    return {
+        type: "custom",
+        name: result.name,
+        password: params.password,
+        unlockBindingId: result.unlockBindingId,
+        effectiveConfig: prepared.effective,
+    };
+});
+export const updateTempCustomForRuntime = parallelOnlyForRuntime(async function (rt, params) {
+    const startedAt = Date.now();
+    const cfg = rt.config;
+    const { unlockBindingId, name, effective } = params;
+    sdkLog("info", "tempPassword", "updateBleCustomStart", {
+        devId: rt.devId,
+        data: {
+            hasName: typeof name === "string",
+            repeat: effective?.repeat,
+        },
+    });
+    if (name && name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "tempPassword", "updateBleCustomInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: name.length },
+            error,
+        });
+        throw error;
+    }
+    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]),
+        },
+    ];
+    const { effectiveTime = 0, expiredTime = 1439 } = effective;
+    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,
+    };
+    const cloudPayload = {
+        devId: cfg.devInfo.devId,
+        effectiveTime: effective.effectiveDate,
+        invalidTime: effective.expiredDate,
+        name,
+        schedule,
+        unlockBindingId,
+    };
+    const list = await fetchEffectiveList({
+        devId: cfg.devInfo.devId,
+        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
+    });
+    const row = list.find((item) => item.unlockBindingId === unlockBindingId);
+    if (!row) {
+        const error = getError(1051);
+        sdkLog("warn", "tempPassword", "updateBleCustomNotFound", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    try {
+        await publishBleTempCustomUpdateNearDp(rt, row.sn, validConfig);
+        const result = await updateTemporaryPassword(cloudPayload);
+        sdkLog("info", "tempPassword", "updateBleCustomSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "updateBleCustomFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+});
+export const removeTempCustomForRuntime = parallelOnlyForRuntime(async function (rt, params) {
+    const startedAt = Date.now();
+    const cfg = rt.config;
+    const dpCode = dpCodes.tempPwdDel;
+    sdkLog("info", "tempPassword", "removeBleCustomStart", {
+        devId: rt.devId,
+        data: { sn: params.sn },
+    });
+    try {
+        const result = await publishDpsForRuntime(rt, {
+            [dpCode]: dpUtils.format({ unlockId: params.sn }, removeTempPwdDpMap),
+        }, {
+            checkReport: (dpsIn) => {
+                const dpDataRow = dpsIn;
+                const reportData = dpDataRow[dpCode];
+                if (reportData) {
+                    const data = dpUtils.parse(reportData, reportRemoveTempPwdDpMap);
+                    sdkLog("debug", "tempPassword", "removeTempPwdReport", {
+                        devId: rt.devId,
+                        data: { unlockId: data.unlockId },
+                    });
+                    if (data["unlockId"] === params.sn) {
+                        return data;
+                    }
+                }
+                return false;
+            },
+        });
+        if (result.status !== 0) {
+            const error = getError(1028);
+            sdkLog("warn", "tempPassword", "removeBleCustomDpFail", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { status: result.status },
+                error,
+            });
+            throw error;
+        }
+        await deleteTempPassword({
+            devId: cfg.devInfo.devId,
+            unlockBindingId: params.unlockBindingId,
+            symbolic: false,
+            dpTunnel: 2,
+        });
+        sdkLog("info", "tempPassword", "removeBleCustomSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+        return true;
+    }
+    catch (e) {
+        sdkLog("error", "tempPassword", "removeBleCustomFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error: e,
+        });
+        throw handleCloudError(e);
+    }
+});

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

@@ -0,0 +1,34 @@
+import type { EffectiveConfig, TempPasswordResult } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import { LoopTypes } from "../../../utils/constant";
+import type { CreateCustomParams } from "./types";
+export interface CustomTempCreatePrepared {
+    baseData: {
+        devId: string;
+        effectiveTime: number;
+        invalidTime: number;
+        name?: string;
+        password: string;
+        schedule: {
+            allDay: boolean;
+            effectiveTime: number;
+            invalidTime: number;
+            workingDay: number;
+        }[];
+    };
+    effective: EffectiveConfig;
+    validConfig: {
+        startTime: number;
+        endTime: number;
+        loop: LoopTypes;
+        loopConfig: number;
+        weeks: number[];
+        days: never[];
+        startHour: number;
+        startMinute: number;
+        endHour: number;
+        endMinute: number;
+    };
+}
+export declare function prepareCustomTempCreateContext(rt: LockDeviceRuntime, params: CreateCustomParams): Promise<CustomTempCreatePrepared>;
+export declare function buildTempCustomCreateResult(createdName: string | undefined, passwordPlain: string, unlockBindingId: string, effective: EffectiveConfig): TempPasswordResult;