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

package/lib/log.d.ts

@@ -1,41 +0,0 @@
-import { AlbumMessage, LogData, UnlockMethodType } from "./interface";
-export declare const unlockDp2Type: Record<string, UnlockMethodType>;
-export declare const getLatestLogs: () => Promise<{
-    data: LogData[];
-    unreadCount: number;
-}>;
-export declare const onLogsRefresh: (cb: () => void) => void;
-export declare const offLogsRefresh: (cb: () => void) => void;
-interface GetLogsParams {
-    page?: number;
-    pageSize?: number;
-}
-export declare const openDps: string[];
-export declare const getLogs: (params?: GetLogsParams) => Promise<{
-    list: LogData[];
-    hasMore: boolean;
-    total: number;
-}>;
-interface GetAlarmsParams {
-    page?: number;
-    pageSize?: number;
-}
-export declare const getAlarms: (params?: GetAlarmsParams) => Promise<{
-    list: LogData[];
-    hasMore: boolean;
-    total: number;
-}>;
-interface GetAlbumsParams {
-    page?: number;
-    pageSize?: number;
-    startTime?: number;
-    endTime?: number;
-}
-export declare const getAlbums: (params?: GetAlbumsParams) => Promise<{
-    hasMore: boolean;
-    list: AlbumMessage[];
-    allAitypes: number[];
-    types: number[];
-    langMap: string[];
-}>;
-export {};

package/lib/log.js

@@ -1,311 +0,0 @@
-import { getAlarmList, getAlbumMessages, getLatest2Log, getRecordList, } from "./api/log";
-import config from "./config";
-import dpCodes from "./config/dp-code";
-import { getCurrentUser } from "./state";
-import base64ToHex from "./utils/base64-to-hex";
-import { LOGCHANGE } from "./utils/constant";
-import emitter from "./utils/event";
-import { handleLocalOperation } from "./utils/log";
-export const unlockDp2Type = {
-    [dpCodes.unlockFingerprint]: "finger",
-    [dpCodes.unlockPassword]: "password",
-    [dpCodes.unlockCard]: "card",
-    [dpCodes.unlockFace]: "face",
-    [dpCodes.unlockFingerVein]: "fingerVein",
-    [dpCodes.unlockHand]: "hand",
-    [dpCodes.unlockEye]: "eye",
-};
-export const getLatestLogs = async () => {
-    const data = await getLatest2Log(config.devInfo.devId);
-    if (data.operateRecordVOList && data.operateRecordVOList.length) {
-        const list = data.operateRecordVOList.map((item) => {
-            let type = item.logCategory;
-            if (type === "operation" && item.logType === "dev_bind") {
-                type = "dev_bind";
-            }
-            const dpCode = config.codesById[item.dpId];
-            const dpSchema = config.dpSchema[dpCode];
-            let itemData = item.data || "";
-            if (dpSchema?.type === "raw") {
-                itemData = base64ToHex(item.data);
-            }
-            if (typeof itemData === "string" && itemData.includes("[")) {
-                try {
-                    itemData = JSON.parse(itemData)[0];
-                }
-                catch {
-                }
-            }
-            let userName = item.userName;
-            let unlockName = item.unlockName;
-            if (item.dpId === 89 || item.dpId === 69) {
-                unlockName = item.userName;
-                userName = "";
-            }
-            const log = {
-                type,
-                logId: item.logId,
-                dpId: item.dpId,
-                dpCode,
-                data: itemData,
-                userId: item.userId,
-                userName,
-                unlockName,
-                mediaInfo: item.mediaInfoList,
-                unionUnlockInfo: item.unionUnlockInfo?.map((item1) => {
-                    return {
-                        userId: item1.userId,
-                        userName: item1.userName,
-                        unlockName: item.unlockName,
-                        sn: item1.sn,
-                        type: unlockDp2Type[item1.opMode],
-                    };
-                }),
-                closeValue: item.unlockNameRosettaKey?.replace("HISTORY_LOCK_", ""),
-                time: item.time,
-                currentUser: !!item.currentUser,
-                bindable: item.memberBindableFlag,
-            };
-            if (item.matterRecordInfo) {
-                log.matterRecord = {
-                    sn: item.matterRecordInfo.matterSn,
-                    type: item.matterRecordInfo.matterType,
-                    source: item.matterRecordInfo.matterSource,
-                };
-            }
-            return log;
-        });
-        return {
-            data: list,
-            unreadCount: data.unReadCount,
-        };
-    }
-    return {
-        data: [],
-        unreadCount: 0,
-    };
-};
-export const onLogsRefresh = (cb) => {
-    emitter.on(LOGCHANGE, cb);
-};
-export const offLogsRefresh = (cb) => {
-    emitter.off(LOGCHANGE, cb);
-};
-export const openDps = [
-    dpCodes.openInside,
-    dpCodes.lockLocalRecord,
-    dpCodes.unlockPassword,
-    dpCodes.lockRecord,
-    dpCodes.unlockFingerprint,
-    dpCodes.unlockCard,
-    dpCodes.unlockFace,
-    dpCodes.unlockHand,
-    dpCodes.unlockFingerVein,
-    dpCodes.unlockEye,
-    dpCodes.unlockTemporary,
-    dpCodes.unlockDoubleKit,
-    dpCodes.unlockKey,
-    dpCodes.unlockPhoneRemote,
-    dpCodes.unlockVoiceRemote,
-    dpCodes.unlockDoubleKitW,
-    dpCodes.unlockBle,
-    dpCodes.unlockOfflinePd,
-    dpCodes.unlockDynamic,
-    dpCodes.unlockInside,
-    dpCodes.doorOpened,
-    dpCodes.unlockApp,
-    dpCodes.unlockMatterKw,
-];
-const closeTypes = [
-    "UNDEFINED",
-    "APP_REMOTE",
-    "VOICE_REMOTE",
-    "GEO_FENCE",
-    "APP",
-    "FITTINGS",
-    "AUTO",
-    "LOCAL_MANUAL",
-];
-export const getLogs = async (params) => {
-    const { page = 1, pageSize = 50 } = params || {};
-    const currentUser = await getCurrentUser();
-    const data = await getRecordList({
-        devId: config.devInfo.devId,
-        dpIds: openDps.reduce((res, item) => {
-            if (config.idsByCode[item]) {
-                res.push(config.idsByCode[item]);
-            }
-            return res;
-        }, []),
-        offset: (page - 1) * pageSize,
-        limit: pageSize,
-    });
-    if (data.datas.length) {
-        const result = data.datas.map((record) => {
-            let closeValue = undefined;
-            let dpValue = record.dpValue;
-            const dpCode = config.codesById[record.dpId];
-            let type = dpCode === dpCodes.lockRecord ? "close_record" : "unlock_record";
-            const dpSchema = config.dpSchema[dpCode];
-            if (dpSchema.type === "raw") {
-                dpValue = base64ToHex(dpValue);
-            }
-            if (type === "close_record") {
-                const closeType = parseInt(dpValue.slice(0, 2), 16);
-                closeValue = closeTypes[closeType] || closeTypes[0];
-            }
-            if (dpCode === dpCodes.lockLocalRecord) {
-                type = "local_operation";
-            }
-            let userName = record.userName;
-            let unlockName = record.unlockName;
-            if (record.dpId === 89 || record.dpId === 69) {
-                unlockName = record.userName;
-                userName = "";
-            }
-            const log = {
-                type,
-                logId: record.historyId.toString(),
-                userId: record.userId,
-                dpId: record.dpId,
-                data: dpValue,
-                dpCode,
-                userName,
-                unlockName,
-                mediaInfo: record.mediaInfoList,
-                unionUnlockInfo: record.unionUnlockInfo?.map((item) => ({
-                    userId: item.userId,
-                    userName: item.userName,
-                    unlockName: item.unlockName,
-                    sn: item.sn,
-                    type: unlockDp2Type[item.opMode],
-                })),
-                closeValue,
-                time: record.gmtCreate,
-                currentUser: +record.userId === +currentUser.userId,
-                bindable: record.memberBindableFlag === 1,
-                unlockMethod: type === "unlock_record" ? unlockDp2Type[dpCode] : undefined,
-                localRecord: handleLocalOperation(record.localOperateRecordInfo, dpValue),
-            };
-            if (record.matterRecordInfo) {
-                log.matterRecord = {
-                    sn: record.matterRecordInfo.matterSn,
-                    type: record.matterRecordInfo.matterType,
-                    source: record.matterRecordInfo.matterSource,
-                };
-            }
-            return log;
-        });
-        return {
-            list: result,
-            hasMore: data.hasNext,
-            total: data.totalCount,
-        };
-    }
-    return {
-        list: [],
-        hasMore: false,
-        total: 0,
-    };
-};
-const alarmDps = [
-    dpCodes.doorbell,
-    dpCodes.familyCall,
-    dpCodes.alarmReminder,
-    dpCodes.alarmLock,
-    dpCodes.unlockOfflineClear,
-    dpCodes.unlockOfflineClearSingle,
-    dpCodes.hijack,
-];
-export const getAlarms = async (params) => {
-    const { page = 1, pageSize = 50 } = params || {};
-    const currentUser = await getCurrentUser();
-    const data = await getAlarmList({
-        devId: config.devInfo.devId,
-        dpIds: alarmDps.reduce((res, item) => {
-            if (config.idsByCode[item]) {
-                res.push(config.idsByCode[item]);
-            }
-            return res;
-        }, []),
-        offset: (page - 1) * pageSize,
-        limit: pageSize,
-    });
-    if (data.datas.length) {
-        const result = data.datas.map((record) => {
-            let dpId = record.dpId;
-            let dpValue = record.dpValue;
-            let dpCode = config.codesById[dpId];
-            const dpSchema = config.dpSchema[dpCode];
-            if (dpSchema.type === "raw") {
-                dpValue = base64ToHex(dpValue);
-            }
-            const isHijack = record.dps?.some((item) => Object.keys(item)[0] === "98");
-            return {
-                type: "alarm_record",
-                logId: record.historyId.toString(),
-                userId: record.userId,
-                dpId: record.dpId,
-                data: dpValue,
-                dpCode,
-                userName: record.userName,
-                unlockName: record.unlockName,
-                mediaInfo: record.mediaInfoList,
-                time: record.gmtCreate,
-                currentUser: +record.userId === +currentUser.userId,
-                bindable: false,
-                isHijack,
-            };
-        });
-        return {
-            list: result,
-            hasMore: data.hasNext,
-            total: data.totalCount,
-        };
-    }
-    return {
-        list: [],
-        hasMore: false,
-        total: 0,
-    };
-};
-export const getAlbums = async (params) => {
-    const now = Date.now();
-    const beforeYear = now - 365 * 24 * 60 * 60 * 1000;
-    const { page = 1, pageSize = 20, startTime = beforeYear, endTime = now, } = params || {};
-    const data = await getAlbumMessages({
-        devId: config.devInfo.devId,
-        limit: pageSize,
-        offset: (page - 1) * pageSize,
-        safeMode: false,
-        picInclude: true,
-        startTime,
-        endTime,
-    });
-    return {
-        hasMore: data.hasNext,
-        list: data.albumList.map((item) => ({
-            id: item.fileId,
-            mediaPath: item.mediaPath,
-            fileKey: item.fileKey,
-            fileUrl: item.fileUrl,
-            mediaBucket: item.mediaBucket,
-            mediaKey: item.mediaKey,
-            aiTypes: item.aiTypes,
-            describe: item.describe,
-            aiInfos: item.aiDetectResults.map((x) => ({
-                id: x.bizId,
-                type: x.aiType,
-                name: x.eventTypeDesc,
-                desc: x.desc,
-                happenTime: x.happenTime,
-                isCorrected: x.missStep,
-            })),
-            type: item.eventType,
-            createTime: item.uploadMilTime,
-        })),
-        allAitypes: data.allAitypes,
-        types: data.eventTypes,
-        langMap: data.eventLangMap,
-    };
-};

package/lib/media.d.ts

@@ -1,14 +0,0 @@
-interface GetMediaUrlParams {
-    mediaPath: string;
-    mediaBucket: string;
-}
-interface GetFileUrlParams {
-    filePath: string;
-    bucket: string;
-}
-interface MediaUrlResult {
-    mediaUrl: string;
-}
-export declare const getMediaUrl: (params: GetMediaUrlParams | GetFileUrlParams) => Promise<MediaUrlResult>;
-export declare const isSupportMedia: () => boolean;
-export {};

package/lib/media.js

@@ -1,27 +0,0 @@
-import { getMediaUrl as getMediaUrlApi } from "./api/log";
-import config, { hasDp } from "./config";
-import dpCodes from "./config/dp-code";
-import { VedioType } from "./constant";
-export const getMediaUrl = async (params) => {
-    if ("mediaPath" in params && "mediaBucket" in params) {
-        return getMediaUrlApi({
-            devId: config.devInfo.devId,
-            mediaPath: params.mediaPath,
-            mediaBucket: params.mediaBucket,
-        });
-    }
-    else if ("filePath" in params && "bucket" in params) {
-        return getMediaUrlApi({
-            devId: config.devInfo.devId,
-            filePath: params.filePath,
-            bucket: params.bucket,
-        });
-    }
-    throw new Error("Invalid parameters");
-};
-export const isSupportMedia = () => {
-    return (hasDp(dpCodes.linkMode) &&
-        hasDp(dpCodes.initiativeMessage) &&
-        (!hasDp(dpCodes.deviceInfo) ||
-            config.capabilities?.vedioType === VedioType.VEDIO_OR_SNAPSHOT));
-};

package/lib/offline-dps.d.ts

@@ -1,9 +0,0 @@
-import { DpValue, OfflineDps } from "./interface";
-export declare const getOfflineDps: (isForce?: boolean) => Promise<OfflineDps>;
-export declare const checkOfflineDpUpdate: (dps: Record<string, DpValue>, isForce?: boolean) => Promise<void>;
-export declare const getOfflineDpCache: (code: string) => import("./interface").OfflineDpInfo;
-export declare const publishOfflineDps: (dps: Record<string, DpValue>) => Promise<void>;
-export declare const clearOfflineDps: () => Promise<void>;
-export declare const onOfflineDpsUpdate: (callback: (dps: OfflineDps) => void) => void;
-export declare const offOfflineDpsUpdate: (callback: (dps: OfflineDps) => void) => void;
-export declare const isOfflineDpSyncing: (code: string) => boolean;

package/lib/offline-dps.js

@@ -1,76 +0,0 @@
-import { clearOfflineDpData, fetchOfflineDpData, publishOfflineDpData, } from "./api";
-import config from "./config";
-import base64ToHex from "./utils/base64-to-hex";
-import hexToBase64 from "./utils/hex-to-base64";
-import emitter from "./utils/event";
-let cache;
-export const getOfflineDps = async (isForce) => {
-    if (!isForce && cache) {
-        return cache;
-    }
-    const { devInfo, dpSchema } = config;
-    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;
-    }, {});
-    cache = result;
-    return result;
-};
-export const checkOfflineDpUpdate = async (dps, isForce) => {
-    if (!config.supportOfflineDps) {
-        return;
-    }
-    const hasOne = Object.keys(dps).some((code) => cache?.[code]?.pushStatus === false);
-    if (hasOne || isForce) {
-        const res = await getOfflineDps(true);
-        emitter.emit(OFFLINE_DPS_UPDATE, res);
-    }
-};
-export const getOfflineDpCache = (code) => {
-    return cache?.[code];
-};
-export const publishOfflineDps = async (dps) => {
-    const { devInfo, dpSchema } = config;
-    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;
-    }, {});
-    await publishOfflineDpData(devInfo.devId, dpData);
-    checkOfflineDpUpdate({}, true);
-};
-export const clearOfflineDps = async () => {
-    const { devInfo } = config;
-    await clearOfflineDpData(devInfo.devId);
-    checkOfflineDpUpdate({}, true);
-};
-const OFFLINE_DPS_UPDATE = "offline_dps_update";
-export const onOfflineDpsUpdate = (callback) => {
-    emitter.on(OFFLINE_DPS_UPDATE, callback);
-};
-export const offOfflineDpsUpdate = (callback) => {
-    emitter.off(OFFLINE_DPS_UPDATE, callback);
-};
-export const isOfflineDpSyncing = (code) => {
-    const { supportOfflineDps } = config;
-    if (!supportOfflineDps) {
-        return false;
-    }
-    const cache = getOfflineDpCache(code);
-    return cache && cache.pushStatus === false;
-};

package/lib/open/ble-dedicated-dp.d.ts

@@ -1,4 +0,0 @@
-export declare const isDedicatedBleHexSuccess: (raw: string) => boolean;
-export declare const resolveDedicatedBleCommandDp: () => string | null;
-export declare const executeDedicatedBleManualLock: (timeout: number) => Promise<void>;
-export declare const executeDedicatedBleRawAction: (isOpen: boolean, timeout: number) => Promise<void>;

package/lib/open/ble-dedicated-dp.js

@@ -1,148 +0,0 @@
-import dpUtils from "@ray-js/tuya-dp-transform";
-import { getDoorKey } from "../api/lock";
-import config, { hasDp } from "../config";
-import dpCodes from "../config/dp-code";
-import { open as openMap, reportOpen as reportOpenMap, } from "../config/dp-map/open";
-import syncRemoteSerectKey from "../sync/remote-serect-key";
-import { stringToBytes } from "../utils/byte";
-import { decrypt } from "../utils/device";
-import { getError } from "../utils/errors";
-import { publishDps } from "../utils/publishDps";
-import { getOpenDoorMemberId } from "./ble-remote-no-dp-key";
-import { mapRemoteOpenReportStatus } from "./report-status";
-const normalizeHex = (raw) => raw.replace(/\s/g, "").toLowerCase();
-export const isDedicatedBleHexSuccess = (raw) => {
-    const n = normalizeHex(raw);
-    if (n.length < 2) {
-        return false;
-    }
-    return n.startsWith("00") || n.endsWith("00");
-};
-const parseDedicatedBleHexStatus = (raw) => {
-    const n = normalizeHex(raw);
-    if (n.length < 2) {
-        return false;
-    }
-    if (isDedicatedBleHexSuccess(raw)) {
-        return { status: 0 };
-    }
-    if (n.includes("06")) {
-        return { status: 0x06 };
-    }
-    return { status: 0x01 };
-};
-const tryParseStandardUnlockReport = (raw, memberId) => {
-    try {
-        const result = dpUtils.parse(raw, reportOpenMap);
-        if (result.memberId !== memberId) {
-            return false;
-        }
-        if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
-            return false;
-        }
-        return result;
-    }
-    catch {
-        return false;
-    }
-};
-export const resolveDedicatedBleCommandDp = () => {
-    if (hasDp(dpCodes.bleUnlockCheck)) {
-        return dpCodes.bleUnlockCheck;
-    }
-    if (hasDp(dpCodes.bluetoothUnlock)) {
-        return dpCodes.bluetoothUnlock;
-    }
-    if (hasDp(dpCodes.unlockBle)) {
-        return dpCodes.unlockBle;
-    }
-    return null;
-};
-const createDedicatedBleCheckReport = (commandDp, memberId) => {
-    return (dpData) => {
-        if (hasDp(dpCodes.lockMotorState)) {
-            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
-                return { status: 0 };
-            }
-        }
-        if (typeof dpData[commandDp] !== "undefined") {
-            const raw = dpData[commandDp];
-            const standard = tryParseStandardUnlockReport(raw, memberId);
-            if (standard) {
-                return standard;
-            }
-            const hexStatus = parseDedicatedBleHexStatus(raw);
-            if (hexStatus !== false) {
-                return hexStatus;
-            }
-        }
-        if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
-            const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
-            if (result.memberId === memberId) {
-                if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
-                    return false;
-                }
-                return result;
-            }
-        }
-        return false;
-    };
-};
-export const executeDedicatedBleManualLock = async (timeout) => {
-    if (!hasDp(dpCodes.manualLock)) {
-        throw getError(1014);
-    }
-    await publishDps({
-        [dpCodes.manualLock]: true,
-    }, {
-        timeout,
-        checkReport: (dpData) => {
-            if (hasDp(dpCodes.lockMotorState)) {
-                if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
-                    return { status: 0 };
-                }
-            }
-            if (typeof dpData[dpCodes.manualLock] !== "undefined") {
-                return { status: 0 };
-            }
-            return false;
-        },
-    });
-};
-export const executeDedicatedBleRawAction = async (isOpen, timeout) => {
-    if (!isOpen && hasDp(dpCodes.manualLock)) {
-        await executeDedicatedBleManualLock(timeout);
-        return;
-    }
-    const commandDp = resolveDedicatedBleCommandDp();
-    if (!commandDp) {
-        throw getError(1014);
-    }
-    await syncRemoteSerectKey();
-    let pw = "";
-    try {
-        const { password } = await getDoorKey(config.devInfo.devId);
-        pw = await decrypt(config.devInfo.devId, password);
-    }
-    catch {
-        await syncRemoteSerectKey(true);
-        const { password } = await getDoorKey(config.devInfo.devId);
-        pw = await decrypt(config.devInfo.devId, password);
-    }
-    const memberId = await getOpenDoorMemberId();
-    const payload = dpUtils.format({
-        status: Number(isOpen),
-        memberId,
-        key: stringToBytes(pw),
-        type: 3,
-    }, openMap);
-    const response = (await publishDps({
-        [commandDp]: payload,
-    }, {
-        timeout,
-        checkReport: createDedicatedBleCheckReport(commandDp, memberId),
-    }));
-    if (response.status !== 0) {
-        throw mapRemoteOpenReportStatus(response.status);
-    }
-};

package/lib/open/ble-remote-no-dp-key.d.ts

@@ -1,4 +0,0 @@
-import { DpValue } from "../interface";
-export declare const createRemoteNoDpKeyBleCheckReport: (memberId: number) => (dpData: Record<string, DpValue>) => any;
-export declare const executeBleRemoteNoDpKeyAction: (isOpen: boolean, timeout: number, memberId: number) => Promise<void>;
-export declare const getOpenDoorMemberId: () => Promise<number>;