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

package/lib/feature/password/temporary/lists.js

@@ -0,0 +1,157 @@
+import { clearInvalidTempList, fetchEffectiveList, fetchInvalidList, getLimitOfflinePwdListForClear, } from "../../../api/temp";
+import { parseWeek } from "../../../utils";
+import { handleCloudError } from "../../../utils/errors";
+import { PASSWORD_TYPE_MAP } from "./internal/password-type-map";
+export async function getTempEffectiveListForRuntime(rt) {
+    const res = await fetchEffectiveList({
+        devId: rt.config.devInfo.devId,
+        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
+    });
+    return res.map((item) => {
+        const type = PASSWORD_TYPE_MAP[`${item.opModeType}-${item.opModeSubType}`] || "custom";
+        let status = "synchronizing";
+        switch (item.phase) {
+            case 1:
+                status = "effective";
+                if (item.effective === 1) {
+                    status = "toBeEffective";
+                }
+                break;
+            case 2:
+                status = "synchronizing";
+                break;
+            case 3:
+                status = "frozen";
+                break;
+            case 4:
+                status = "freezing";
+                break;
+            case 9:
+                status = "toBeDeleted";
+                break;
+            case 10:
+                status = "synchronizing";
+                break;
+        }
+        const effectiveConfig = {
+            effectiveDate: item.effectiveTime,
+            expiredDate: item.invalidTime,
+        };
+        if (item.scheduleDetails?.length) {
+            const scheduleDetail = item.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;
+            }
+        }
+        const data = {
+            unlockBindingId: item.unlockBindingId,
+            name: item.name,
+            status,
+            type,
+            sn: item.sn,
+            hasClearPwd: item.opModeInfo?.hasClearPwd === true,
+            effectiveConfig,
+        };
+        if (data.type === "clearOne") {
+            data.clearInfo = {
+                name: item.opModeInfo?.revokedPwdName || "",
+                effectiveConfig: {
+                    effectiveDate: item.opModeInfo?.revokedPwdEffectiveTime || 0,
+                    expiredDate: item.opModeInfo?.revokedPwdInvalidTime || 0,
+                },
+            };
+        }
+        return data;
+    });
+}
+export async function getTempInvalidListForRuntime(rt, params) {
+    const res = await fetchInvalidList({
+        devId: rt.config.devInfo.devId,
+        offset: (params?.page || 1) - 1,
+        limit: params?.pageSize || 200,
+    });
+    const list = res.datas.map((item) => {
+        const type = PASSWORD_TYPE_MAP[`${item.opModeType}-${item.opModeSubType}`] || "custom";
+        let status = "expired";
+        let invalidReason = "synchronizationFailed";
+        if (item.phase === 8) {
+            invalidReason = "deleted";
+        }
+        if (item.failReason) {
+            switch (item.phase) {
+                case 1:
+                    invalidReason = "synchronizationFailed";
+                    break;
+                case 2:
+                    invalidReason = "passwordFull";
+                    break;
+            }
+        }
+        const effectiveConfig = {
+            effectiveDate: item.effectiveTime,
+            expiredDate: item.invalidTime,
+        };
+        if (item.scheduleDetails?.length) {
+            const scheduleDetail = item.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;
+            }
+        }
+        const data = {
+            unlockBindingId: item.unlockBindingId,
+            name: item.name,
+            invalidReason,
+            status,
+            type,
+            sn: item.sn,
+            hasClearPwd: item.opModeInfo?.hasClearPwd === true,
+            effectiveConfig,
+        };
+        if (data.type === "clearOne") {
+            data.clearInfo = {
+                name: item.opModeInfo?.revokedPwdName || "",
+                effectiveConfig: {
+                    effectiveDate: item.opModeInfo?.revokedPwdEffectiveTime || 0,
+                    expiredDate: item.opModeInfo?.revokedPwdInvalidTime || 0,
+                },
+            };
+        }
+        return data;
+    });
+    return {
+        list,
+        hasMore: res.hasNext,
+        total: res.totalCount,
+    };
+}
+export async function clearTempInvalidListForRuntime(rt) {
+    try {
+        return await clearInvalidTempList({
+            devId: rt.config.devInfo.devId,
+        });
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}
+export async function getTempLimitListForClearForRuntime(rt) {
+    const res = await getLimitOfflinePwdListForClear({
+        devId: rt.devId,
+    });
+    return res.map((item) => {
+        return {
+            id: item.unlockBindingId,
+            name: item.pwdName,
+            effectiveTime: Number(item.gmtStart),
+            invalidTime: Number(item.gmtExpired),
+        };
+    });
+}

package/lib/feature/password/temporary/offline-create.d.ts

@@ -0,0 +1,7 @@
+import type { TempPasswordResult } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { CreateClearParams, CreateLimitParams, CreateOnceParams } from "./types";
+export declare function createTempLimitForRuntime(rt: LockDeviceRuntime, params: CreateLimitParams): Promise<TempPasswordResult>;
+export declare function createTempOnceForRuntime(rt: LockDeviceRuntime, params: CreateOnceParams): Promise<TempPasswordResult>;
+export declare function createTempDynamicForRuntime(rt: LockDeviceRuntime): Promise<TempPasswordResult>;
+export declare function createTempClearForRuntime(rt: LockDeviceRuntime, params: CreateClearParams): Promise<TempPasswordResult>;

package/lib/feature/password/temporary/offline-create.js

@@ -0,0 +1,192 @@
+import { getDynamicPassword, revokeOfflinePassword, } from "../../../api/temp";
+import { parseOfflinePasswordForRuntime } from "../../utils";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { getOfflinePassword } from "./internal/password-helpers";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function createTempLimitForRuntime(rt, params) {
+    const { name, effectiveTime, invalidTime } = params;
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createOfflineLimitStart", {
+        devId: rt.devId,
+        data: { hasName: typeof name === "string" },
+    });
+    if (name && name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "tempPassword", "createOfflineLimitInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: name.length },
+            error,
+        });
+        throw error;
+    }
+    if (effectiveTime >= invalidTime) {
+        const error = getError(1010);
+        sdkLog("warn", "tempPassword", "createOfflineLimitInvalidTime", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    const res = await getOfflinePassword({
+        devId: rt.config.devInfo.devId,
+        pwdType: "0",
+        pwdName: name,
+        gmtStart: effectiveTime,
+        gmtExpired: invalidTime,
+    });
+    sdkLog("info", "tempPassword", "createOfflineLimitSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+    });
+    return {
+        type: "limit",
+        name: res.pwdName,
+        password: parseOfflinePasswordForRuntime(rt, res.pwd),
+        unlockBindingId: res.unlockBindingId,
+        effectiveConfig: {
+            effectiveDate: res.gmtStart,
+            expiredDate: res.gmtExpired,
+        },
+    };
+}
+export async function createTempOnceForRuntime(rt, params) {
+    const { name } = params;
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createOfflineOnceStart", {
+        devId: rt.devId,
+        data: { hasName: typeof name === "string" },
+    });
+    if (name && name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "tempPassword", "createOfflineOnceInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: name.length },
+            error,
+        });
+        throw error;
+    }
+    const res = await getOfflinePassword({
+        devId: rt.config.devInfo.devId,
+        pwdType: "1",
+        pwdName: name,
+        gmtStart: 0,
+        gmtExpired: 0,
+    });
+    sdkLog("info", "tempPassword", "createOfflineOnceSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+    });
+    return {
+        type: "once",
+        name: res.pwdName,
+        password: parseOfflinePasswordForRuntime(rt, res.pwd),
+        unlockBindingId: res.unlockBindingId,
+        effectiveConfig: {
+            effectiveDate: res.gmtStart,
+            expiredDate: res.gmtExpired,
+        },
+    };
+}
+export async function createTempDynamicForRuntime(rt) {
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createDynamicStart", {
+        devId: rt.devId,
+    });
+    try {
+        const { dynamicPassword } = await getDynamicPassword({
+            devId: rt.config.devInfo.devId,
+        });
+        const now = Math.floor(Date.now() / 1000);
+        sdkLog("info", "tempPassword", "createDynamicSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+        return {
+            type: "dynamic",
+            name: "",
+            password: parseOfflinePasswordForRuntime(rt, dynamicPassword),
+            unlockBindingId: "",
+            effectiveConfig: {
+                effectiveDate: now,
+                expiredDate: now + 5 * 60,
+            },
+        };
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "createDynamicFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}
+export async function createTempClearForRuntime(rt, params) {
+    const { name, unlockBindingId, clearAll } = params;
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createClearStart", {
+        devId: rt.devId,
+        data: { clearAll, hasName: typeof name === "string" },
+    });
+    if (name && name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "tempPassword", "createClearInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: name.length },
+            error,
+        });
+        throw error;
+    }
+    if (!clearAll && !unlockBindingId) {
+        const error = getError(1044);
+        sdkLog("warn", "tempPassword", "createClearMissingBinding", {
+            devId: rt.devId,
+            data: { clearAll },
+            error,
+        });
+        throw error;
+    }
+    try {
+        let res;
+        if (clearAll) {
+            res = await getOfflinePassword({
+                devId: rt.config.devInfo.devId,
+                pwdType: "9",
+                pwdName: name,
+                gmtStart: 0,
+                gmtExpired: 0,
+            });
+        }
+        else {
+            res = await revokeOfflinePassword({
+                devId: rt.config.devInfo.devId,
+                name,
+                unlockBindingId: unlockBindingId,
+            });
+        }
+        sdkLog("info", "tempPassword", "createClearSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { clearAll },
+        });
+        return {
+            type: clearAll ? "clear" : "clearOne",
+            name: res.pwdName,
+            password: parseOfflinePasswordForRuntime(rt, res.pwd),
+            unlockBindingId: res.unlockBindingId,
+            effectiveConfig: {
+                effectiveDate: res.gmtStart,
+                expiredDate: res.gmtExpired,
+            },
+        };
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "createClearFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { clearAll },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}

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

@@ -0,0 +1,107 @@
+import type { EffectiveConfig, TemporaryPasswordType } from "../../../interface";
+export interface CreateCustomParams {
+    password: string;
+    name?: string;
+    effective: EffectiveConfig;
+}
+export interface RemoveCustomProps {
+    unlockBindingId: string;
+    sn: number;
+}
+export interface UpdateTempPasswordParams {
+    unlockBindingId: string;
+    name: string;
+    effective: EffectiveConfig;
+}
+export interface CreateLimitParams {
+    name: string;
+    effectiveTime: number;
+    invalidTime: number;
+}
+export interface CreateOnceParams {
+    name?: string;
+}
+export interface CreateClearParams {
+    name?: string;
+    unlockBindingId?: string;
+    clearAll: boolean;
+}
+export type ValidPasswordStatus = "effective" | "toBeEffective" | "frozen" | "freezing" | "synchronizing" | "toBeDeleted";
+export type InvalidPasswordStatus = "expired";
+export type InvalidReason = "synchronizationFailed" | "passwordFull" | "deleted";
+export interface PasswrodBaseInfo {
+    unlockBindingId: string;
+    effectiveConfig: EffectiveConfig;
+    name: string;
+    type: TemporaryPasswordType;
+    sn: number;
+    hasClearPwd: boolean;
+    clearInfo?: {
+        name: string;
+        effectiveConfig: EffectiveConfig;
+    };
+}
+export interface EffectivePasswrodItem extends PasswrodBaseInfo {
+    status: ValidPasswordStatus;
+}
+export interface InvalidPasswordItem extends PasswrodBaseInfo {
+    status: "expired";
+    invalidReason: InvalidReason;
+}
+export interface GetInvalidListParams {
+    page?: number;
+    pageSize?: number;
+}
+export interface FreezeParams {
+    unlockBindingId: string;
+}
+export interface RenameParams {
+    unlockBindingId: string;
+    name: string;
+}
+export interface CreateOnlineUnlimitedParams {
+    password: string;
+    name: string;
+    effective: EffectiveConfig;
+    phone?: string;
+    countryCode?: string;
+}
+export interface CreateOfflineParams {
+    name: string;
+    effective: EffectiveConfig;
+    isOnce: boolean;
+}
+export type OfflineTempType = "once" | "multiple";
+export interface OfflineTempResult {
+    type: OfflineTempType;
+    name: string;
+    password: string;
+    unlockBindingId: string;
+    pwdId: string;
+    effectiveConfig: EffectiveConfig;
+}
+export interface OnlinePasswordItem {
+    effective: number;
+    unlockBindingId: string;
+    effectiveTime: number;
+    invalidTime: number;
+    name: string;
+    phase: number;
+    scheduleDetails: EffectiveConfig;
+    status: "effective" | "synchronizing" | "expired" | "disabled" | "invalid";
+}
+export interface OfflinePasswordItem {
+    email: string;
+    gmtExpired: number;
+    gmtStart: number;
+    hasClearPwd: boolean;
+    mobile: string;
+    pwd: string;
+    pwdId: string;
+    pwdName: string;
+    pwdTypeCode: "once" | "multiple" | "clear_one" | "clear_all";
+    revokedPwdName: string;
+    status: number;
+    timeZoneId: string;
+}
+export type OfflinePasswordType = "once" | "multiple" | "clear_one" | "clear_all";

package/lib/feature/password/temporary/types.js

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

package/lib/feature/password/temporary/wifi-offline.d.ts

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { CreateOfflineParams, OfflinePasswordType, OfflineTempResult } from "./types";
+export declare function createTempOfflineForRuntime(rt: LockDeviceRuntime, params: CreateOfflineParams): Promise<OfflineTempResult>;
+export declare function getTempOfflineEffectiveListForRuntime(rt: LockDeviceRuntime, pwdTypeCode: OfflinePasswordType): Promise<import("../../../api/temp").EffectivePasswrodItem[]>;
+export declare function getTempOfflineInvalidListForRuntime(rt: LockDeviceRuntime, pwdTypeCode: OfflinePasswordType): Promise<import("../../../api/temp").EffectivePasswrodItem[]>;

package/lib/feature/password/temporary/wifi-offline.js

@@ -0,0 +1,85 @@
+import { createOfflineOnceAPI, getTempOfflineListAPI, } from "../../../api/temp";
+import { parseOfflinePasswordForRuntime } from "../../utils";
+import { getError, handleCloudError } from "../../../utils/errors";
+const offlinePasswordTypeMap = {
+    once: "1",
+    multiple: "0",
+    clear_one: "8",
+    clear_all: "9",
+};
+export async function createTempOfflineForRuntime(rt, params) {
+    const { name, effective, isOnce } = params;
+    try {
+        if (isOnce) {
+            const res = await createOfflineOnceAPI({
+                devId: rt.config.devInfo.devId,
+                pwdType: "1",
+                gmtStart: "0",
+                gmtExpired: "0",
+            });
+            return {
+                type: "once",
+                name: res.pwdName,
+                password: parseOfflinePasswordForRuntime(rt, res.pwd),
+                unlockBindingId: res.unlockBindingId,
+                pwdId: res.pwdId,
+                effectiveConfig: {
+                    effectiveDate: Number(res.gmtStart),
+                    expiredDate: Number(res.gmtExpired),
+                },
+            };
+        }
+        if (name && name.length > 20) {
+            throw getError(1031);
+        }
+        if (effective.effectiveDate >= effective.expiredDate) {
+            throw getError(1010);
+        }
+        const res = await createOfflineOnceAPI({
+            devId: rt.config.devInfo.devId,
+            pwdType: "0",
+            gmtStart: effective.effectiveDate.toString(),
+            gmtExpired: effective.expiredDate.toString(),
+        });
+        return {
+            type: "multiple",
+            name: res.pwdName,
+            password: parseOfflinePasswordForRuntime(rt, res.pwd),
+            unlockBindingId: res.unlockBindingId,
+            pwdId: res.pwdId,
+            effectiveConfig: {
+                effectiveDate: Number(res.gmtStart),
+                expiredDate: Number(res.gmtExpired),
+            },
+        };
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}
+export async function getTempOfflineEffectiveListForRuntime(rt, pwdTypeCode) {
+    try {
+        const offLineValidPswList = await getTempOfflineListAPI({
+            devId: rt.config.devInfo.devId,
+            pwdType: offlinePasswordTypeMap[pwdTypeCode],
+            status: "1",
+        });
+        return offLineValidPswList;
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}
+export async function getTempOfflineInvalidListForRuntime(rt, pwdTypeCode) {
+    try {
+        const offLineFailurePswList = await getTempOfflineListAPI({
+            devId: rt.config.devInfo.devId,
+            pwdType: offlinePasswordTypeMap[pwdTypeCode],
+            status: "0",
+        });
+        return offLineFailurePswList;
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/password/temporary/wifi-online.d.ts

@@ -0,0 +1,28 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { CreateOnlineUnlimitedParams } from "./types";
+import type { EffectiveConfig } from "../../../interface";
+export declare function saveTempOnlineUnlimitedForRuntime(rt: LockDeviceRuntime, params: CreateOnlineUnlimitedParams): Promise<{
+    type: "custom";
+    name: string;
+    pwdId: string;
+    effectiveConfig: EffectiveConfig;
+}>;
+export declare function removeTempOnlineUnlimitedForRuntime(rt: LockDeviceRuntime, id: string): Promise<void>;
+export interface OnlinePasswordItem {
+    status: "effective" | "synchronizing" | "expired" | "disabled" | "invalid";
+    effectiveConfig: EffectiveConfig;
+    unlockBindingId: string;
+    failReason: number;
+    name: string;
+    phase: number;
+    opModeType: number;
+    opModeSubType: number;
+    sn: number;
+    opModeInfo?: {
+        hasClearPwd?: boolean;
+        revokedPwdName?: string;
+        revokedPwdEffectiveTime?: number;
+        revokedPwdInvalidTime?: number;
+    };
+}
+export declare function getTempOnlineUnlimitedListForRuntime(rt: LockDeviceRuntime): Promise<OnlinePasswordItem[]>;