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

package/lib/api/lock.js

@@ -2,6 +2,7 @@ import { THING } from "../utils/constant";
 import { requestApi } from "./request";
 export const openDoorByCloud = (deviceId, isOpen) => {
     return requestApi({
+        logName: "openDoorByCloud",
         api: `${THING}.m.zigbee.lock.remotepwd.execute`,
         version: "1.0",
         data: {
@@ -12,6 +13,7 @@ export const openDoorByCloud = (deviceId, isOpen) => {
 };
 export const isConfirmOpenDoorByWifiPro = (deviceId, confirm) => {
     return requestApi({
+        logName: "isConfirmOpenDoorByWifiPro",
         api: `${THING}.m.device.lock.remote.unlock`,
         version: "2.0",
         data: {
@@ -21,8 +23,17 @@ export const isConfirmOpenDoorByWifiPro = (deviceId, confirm) => {
         },
     });
 };
+export const checkUserValidForUnlock = (devId) => {
+    return requestApi({
+        logName: "checkUserValidForUnlock",
+        api: `${THING}.m.device.lock.remote.unlock.available`,
+        version: "1.0",
+        data: { devId },
+    });
+};
 export const checkRemoteKey = async (deviceId) => {
     return requestApi({
+        logName: "checkRemoteKey",
         api: "m.lock.ble.remote.unlock.check",
         version: "1.0",
         data: {
@@ -32,6 +43,7 @@ export const checkRemoteKey = async (deviceId) => {
 };
 export const getDoorKey = (deviceId) => {
     return requestApi({
+        logName: "getDoorKey",
         api: "m.lock.ble.remote.unlock.get",
         version: "1.0",
         data: {
@@ -41,6 +53,7 @@ export const getDoorKey = (deviceId) => {
 };
 export const getUnlockMethodInfo = (params) => {
     return requestApi({
+        logName: "getUnlockMethodInfo",
         api: `${THING}.m.device.member.opmode.detail`,
         version: "1.0",
         data: params,
@@ -48,6 +61,7 @@ export const getUnlockMethodInfo = (params) => {
 };
 export const fetchCreatePasswordSN = (params) => {
     return requestApi({
+        logName: "fetchCreatePasswordSN",
         api: `${THING}.m.device.dp.sn.get`,
         version: "1.0",
         data: params,
@@ -55,6 +69,7 @@ export const fetchCreatePasswordSN = (params) => {
 };
 export const createUnlockMethod = (params) => {
     return requestApi({
+        logName: "createUnlockMethod",
         api: `${THING}.m.device.member.opmode.add`,
         version: "5.0",
         data: params,
@@ -62,6 +77,7 @@ export const createUnlockMethod = (params) => {
 };
 export const editUnlockMethod = (params) => {
     return requestApi({
+        logName: "editUnlockMethod",
         api: `${THING}.m.device.member.opmode.update`,
         version: "5.0",
         data: params,
@@ -69,6 +85,7 @@ export const editUnlockMethod = (params) => {
 };
 export const removeUnlockMethod = (params) => {
     return requestApi({
+        logName: "removeUnlockMethod",
         api: `${THING}.m.device.member.opmode.remove`,
         version: "2.0",
         data: params,
@@ -76,6 +93,7 @@ export const removeUnlockMethod = (params) => {
 };
 export const fetchSyncUnlockMethodInfo = (params) => {
     return requestApi({
+        logName: "fetchSyncUnlockMethodInfo",
         api: `${THING}.m.device.opmode.sync.rise`,
         version: "2.0",
         data: params,
@@ -83,6 +101,7 @@ export const fetchSyncUnlockMethodInfo = (params) => {
 };
 export const checkFreeUnlockMethods = (params) => {
     return requestApi({
+        logName: "checkFreeUnlockMethods",
         api: `${THING}.m.device.unlock.waitassign`,
         version: "1.0",
         data: params,
@@ -90,6 +109,7 @@ export const checkFreeUnlockMethods = (params) => {
 };
 export const fetchFreeUnlockMethods = (params) => {
     return requestApi({
+        logName: "fetchFreeUnlockMethods",
         api: `${THING}.m.device.unlock.assignlist`,
         version: "1.0",
         data: params,
@@ -97,6 +117,7 @@ export const fetchFreeUnlockMethods = (params) => {
 };
 export const bindUnlockMethodToUser = (params) => {
     return requestApi({
+        logName: "bindUnlockMethodToUser",
         api: `${THING}.m.device.user.unlock.allocate`,
         version: "1.0",
         data: params,
@@ -104,6 +125,7 @@ export const bindUnlockMethodToUser = (params) => {
 };
 export const unbindMemberUnlockMethod = (params) => {
     return requestApi({
+        logName: "unbindMemberUnlockMethod",
         api: `${THING}.m.device.user.unlock.unbind`,
         version: "1.0",
         data: params,
@@ -111,6 +133,7 @@ export const unbindMemberUnlockMethod = (params) => {
 };
 export const bindUnlockMethodToUserByRecord = (params) => {
     return requestApi({
+        logName: "bindUnlockMethodToUserByRecord",
         api: `${THING}.m.device.user.unlock.bind`,
         version: "1.0",
         data: params,
@@ -118,6 +141,7 @@ export const bindUnlockMethodToUserByRecord = (params) => {
 };
 export const validatePasswordComplexity = (params) => {
     return requestApi({
+        logName: "validatePasswordComplexity",
         api: "m.lock.password.simplicity.check",
         version: "1.0",
         data: params,

package/lib/api/log.d.ts

@@ -8,36 +8,26 @@ interface UnionUnlockInfo {
 }
 interface LatestLogs {
     unReadCount: number;
-    operateRecordVOList: {
-        currentUser?: boolean;
-        dpId: number;
-        logCategory: "alarm_record" | "close_record" | "unlock_record" | "operation";
-        logId: string;
-        logType: string;
-        memberBindableFlag: boolean;
-        recordType: number;
-        time: number;
-        unlockName: string;
-        userId: string;
-        userName: string;
-        mediaInfoList?: MediaInfo[];
-        unionUnlockInfo?: UnionUnlockInfo[];
-        unlockNameRosettaKey?: string;
-        data: boolean | number | string;
-        matterRecordInfo?: {
-            matterSn: number;
-            matterSource: number;
-            matterType: number;
-        };
-    }[];
+    operateRecordVOList: LockLogListItem[];
 }
 export declare const getLatest2Log: (devId: string) => Promise<LatestLogs>;
+export type LockLogCategory = "operation" | "unlock_record" | "close_record" | "alarm_record";
 interface GetRecordListParams {
     devId: string;
     dpIds: number[];
     limit: number;
     offset: number;
 }
+export interface GetLockLogListParams {
+    devId: string;
+    logCategories?: LockLogCategory[];
+    userIds?: string;
+    onlyShowMediaRecord?: boolean;
+    startTime?: number;
+    endTime?: number;
+    lastRowKey?: string;
+    limit: number;
+}
 interface LogInfo {
     aitypes: string[];
     avatar: string;
@@ -72,6 +62,43 @@ export interface LogsResult {
     totalCount: number;
 }
 export declare const getRecordList: (params: GetRecordListParams) => Promise<LogsResult>;
+export interface LockLogListItem {
+    logId: string;
+    logCategory: LockLogCategory;
+    logType: string;
+    recordType?: number;
+    unlockNameRosettaKey?: string;
+    currentUser?: boolean;
+    userId: string;
+    userName?: string;
+    memberBindableFlag: boolean;
+    unlockName?: string;
+    time: number;
+    relateDevName?: string;
+    relateOpMode?: string;
+    unionUnlockInfo?: UnionUnlockInfo[];
+    mediaInfoList?: MediaInfo[];
+    localOperateRecordInfo?: LocalOperateRecordInfo;
+    data?: boolean | number | string;
+    dpId: number;
+    matterRecordInfo?: {
+        matterSn: number;
+        matterSource: number;
+        matterType: number;
+    };
+}
+export interface GetLockLogListResult {
+    records: LockLogListItem[];
+    hasMore: boolean;
+    lastRowKey: string;
+}
+export declare const getLockLogList: (params: GetLockLogListParams) => Promise<GetLockLogListResult>;
+export interface UploadOperationLogParams {
+    devId: string;
+    logType: string;
+    data: Array<string | number | boolean>;
+}
+export declare const uploadOperationLog: (params: UploadOperationLogParams) => Promise<boolean>;
 interface AlarmData {
     aitypes: string[];
     avatar: string;

package/lib/api/log.js

@@ -2,6 +2,7 @@ import { THING } from "../utils/constant";
 import { requestApi } from "./request";
 export const getLatest2Log = (devId) => {
     return requestApi({
+        logName: "getLatest2Log",
         api: "m.lock.log.latest2",
         version: "1.0",
         data: {
@@ -11,13 +12,31 @@ export const getLatest2Log = (devId) => {
 };
 export const getRecordList = (params) => {
     return requestApi({
+        logName: "getRecordList",
         api: `${THING}.m.device.lock.history.list`,
         version: "1.0",
         data: params,
     });
 };
+export const getLockLogList = (params) => {
+    return requestApi({
+        logName: "getLockLogList",
+        api: `${THING}.m.device.lock.log.list`,
+        version: "1.0",
+        data: params,
+    });
+};
+export const uploadOperationLog = (params) => {
+    return requestApi({
+        logName: "uploadOperationLog",
+        api: `${THING}.m.device.lock.log.upload`,
+        version: "1.0",
+        data: params,
+    });
+};
 export const getAlarmList = (params) => {
     return requestApi({
+        logName: "getAlarmList",
         api: `${THING}.m.device.lock.alarm.list`,
         version: "3.0",
         data: params,
@@ -25,6 +44,7 @@ export const getAlarmList = (params) => {
 };
 export const getAlbumMessages = (params) => {
     return requestApi({
+        logName: "getAlbumMessages",
         api: "m.lock.album.media.list",
         version: "3.0",
         data: params,
@@ -32,6 +52,7 @@ export const getAlbumMessages = (params) => {
 };
 export const getMediaUrl = (params) => {
     return requestApi({
+        logName: "getMediaUrl",
         api: `${THING}.m.device.lock.media.path`,
         version: "2.0",
         data: params,

package/lib/api/notify.d.ts

@@ -0,0 +1,28 @@
+export interface VasNotifyPushConfig {
+    appNotify?: boolean;
+    iosVoip?: boolean;
+    cloudPhone?: boolean;
+}
+export interface VasNotifyScene {
+    enable: boolean;
+    pushConfig?: VasNotifyPushConfig;
+}
+export interface VasNotifyConfig {
+    alert?: boolean | VasNotifyScene;
+    doorBell?: VasNotifyScene;
+    lockDoor?: VasNotifyScene;
+    unlockDoor?: VasNotifyScene & {
+        contacts?: Array<Record<string, any>>;
+    };
+    cloudPhone?: boolean;
+    iosVoip?: boolean;
+    appNotify?: boolean;
+    [k: string]: any;
+}
+export interface UpdateVasNotifyConfigParams {
+    key: string;
+    enable: boolean;
+    userId?: string;
+}
+export declare const getVasNotifyConfigApi: (devId: string) => Promise<VasNotifyConfig>;
+export declare const updateVasNotifyConfigApi: (devId: string, params: UpdateVasNotifyConfigParams) => Promise<VasNotifyConfig>;

package/lib/api/notify.js

@@ -0,0 +1,17 @@
+import { requestApi } from "./request";
+export const getVasNotifyConfigApi = (devId) => {
+    return requestApi({
+        logName: "getVasNotifyConfig",
+        api: "m.lock.vas.notify.config.get",
+        version: "1.0",
+        data: { devId },
+    });
+};
+export const updateVasNotifyConfigApi = (devId, params) => {
+    return requestApi({
+        logName: "updateVasNotifyConfig",
+        api: "m.lock.vas.notify.config.update",
+        version: "1.0",
+        data: { devId, ...params },
+    });
+};

package/lib/api/request.d.ts

@@ -1,6 +1,9 @@
-export declare const requestApi: <T>(options: {
+interface RequestApiOptions {
     api: string;
     version: string;
     data: Record<string, any>;
     extData?: Record<string, any>;
-}) => Promise<T>;
+    logName?: string;
+}
+export declare const requestApi: <T>(options: RequestApiOptions) => Promise<T>;
+export {};

package/lib/api/request.js

@@ -1,10 +1,21 @@
-import { requestCloud } from "../utils/device";
+import { requestCloud } from "../platform/device";
+import { sdkLog } from "../utils/sdk-log";
 const cache = new Map();
+function getLogDevId(data) {
+    const devId = data["devId"] ?? data["deviceId"];
+    return typeof devId === "string" ? devId : undefined;
+}
 export const requestApi = async (options) => {
     const key = `${options.api}-${options.version}-${JSON.stringify(options.data)}}`;
+    const logName = options.logName ?? "unknownApiWrapper";
+    const logDevId = getLogDevId(options.data);
     if (cache.has(key)) {
         const requestCb = cache.get(key);
         if (requestCb && Date.now() - requestCb.time <= 1000) {
+            sdkLog("debug", "api", "cacheHit", {
+                devId: logDevId,
+                data: { name: logName },
+            });
             return new Promise((resolve, reject) => {
                 requestCb.callbacks.push((data, error) => {
                     if (error) {
@@ -23,8 +34,23 @@ export const requestApi = async (options) => {
             callbacks: [],
         });
     }
+    const startedAt = Date.now();
+    sdkLog("debug", "api", "request", {
+        devId: logDevId,
+        data: { name: logName },
+    });
     try {
-        const result = await requestCloud(options);
+        const result = await requestCloud({
+            api: options.api,
+            version: options.version,
+            data: options.data,
+            extData: options.extData,
+        });
+        sdkLog("debug", "api", "success", {
+            devId: logDevId,
+            duration: Date.now() - startedAt,
+            data: { name: logName },
+        });
         if (cache.has(key)) {
             const requestCb = cache.get(key);
             if (requestCb && requestCb.callbacks.length) {
@@ -40,6 +66,12 @@ export const requestApi = async (options) => {
         return result;
     }
     catch (error) {
+        sdkLog("error", "api", "fail", {
+            devId: logDevId,
+            duration: Date.now() - startedAt,
+            data: { name: logName },
+            error,
+        });
         if (cache.has(key)) {
             const requestCb = cache.get(key);
             if (requestCb && requestCb.callbacks.length) {

package/lib/api/screen.d.ts

@@ -0,0 +1,111 @@
+import type { DpData, DpSchema } from "../interface";
+export declare const SCREEN_CLOUD_API: {
+    readonly boundList: "m.lock.accessory.bound.list";
+    readonly bindableLockList: "m.lock.accessory.bindable.lock.list";
+    readonly bindingAdd: "m.lock.accessory.binding.add";
+    readonly bindingResultGet: "m.lock.accessory.binding.result.get";
+    readonly bindingDelete: "m.lock.accessory.binding.delete";
+    readonly unbindingResultGet: "m.lock.accessory.unbinding.result.get";
+    readonly eventList: "m.lock.accessory.event.list";
+};
+export type ScreenBindStatus = "binding" | "bound" | "failed";
+export type ScreenLanStatus = "unknown" | "success" | "failed";
+export type ScreenUnbindStatus = "bound" | "unbound";
+export type ScreenBindableStatus = "binding" | "unbound";
+export interface ScreenLockDeviceInfo {
+    isOnline?: boolean;
+    dpSchema?: DpSchema[];
+    dps?: DpData;
+}
+export interface BoundLockItem extends ScreenLockDeviceInfo {
+    relationId: string;
+    lockDevId: string;
+    name: string;
+    iconUrl: string;
+    lanBound: boolean;
+    bindTime: number;
+}
+export interface BoundLockListResult {
+    bindLimit: number;
+    boundCount: number;
+    items: BoundLockItem[];
+}
+export interface BindableLockItem extends ScreenLockDeviceInfo {
+    lockDevId: string;
+    name: string;
+    iconUrl: string;
+    bindStatus: ScreenBindableStatus;
+    sessionId?: string;
+}
+export interface BindableLockListResult {
+    bindLimit: number;
+    boundCount: number;
+    canBindMore: boolean;
+    items: BindableLockItem[];
+}
+export interface AddBindingResult {
+    relationId: string;
+    status: "binding";
+    sessionId: string;
+}
+export interface BindingResult {
+    relationId: string;
+    status: ScreenBindStatus;
+    lanStatus: ScreenLanStatus;
+    lanFailCode?: string;
+    bindTime?: number;
+}
+export interface DeleteBindingResult {
+    relationId: string;
+}
+export interface UnbindingResult {
+    relationId: string;
+    status: ScreenUnbindStatus;
+}
+export declare const getBoundLockListApi: (params: {
+    accessoryDevId: string;
+}) => Promise<BoundLockListResult>;
+export declare const getBindableLockListApi: (params: {
+    accessoryDevId: string;
+}) => Promise<BindableLockListResult>;
+export declare const addBindingApi: (params: {
+    accessoryDevId: string;
+    lockDevId: string;
+}) => Promise<AddBindingResult>;
+export declare const getBindingResultApi: (params: {
+    accessoryDevId: string;
+    sessionId: string;
+}) => Promise<BindingResult>;
+export declare const deleteBindingApi: (params: {
+    accessoryDevId: string;
+    relationId: string;
+}) => Promise<DeleteBindingResult>;
+export declare const getUnbindingResultApi: (params: {
+    accessoryDevId: string;
+    relationId: string;
+}) => Promise<UnbindingResult>;
+export type ScreenEventLogType = "operation" | "dp";
+export type ScreenEventType = "doorbell_call" | "voice_unlock" | "family_call" | "key_unlock" | "low_battery" | "high_temperature";
+export interface ScreenEventItem {
+    eventId: string;
+    type: ScreenEventLogType;
+    eventType: ScreenEventType;
+    bizId: string;
+    deviceName: string;
+    eventTime: number;
+    relatedDevId: string;
+    relatedDevName: string;
+    extra: Record<string, unknown>;
+}
+export interface ScreenEventListParams {
+    offset?: number;
+    limit?: number;
+}
+export interface ScreenEventListResult {
+    datas: ScreenEventItem[];
+    totalCount: number;
+    hasNext: boolean;
+}
+export declare const getEventListApi: (params: {
+    accessoryDevId: string;
+} & ScreenEventListParams) => Promise<ScreenEventListResult>;

package/lib/api/screen.js

@@ -0,0 +1,52 @@
+import { requestApi } from "./request";
+export const SCREEN_CLOUD_API = {
+    boundList: "m.lock.accessory.bound.list",
+    bindableLockList: "m.lock.accessory.bindable.lock.list",
+    bindingAdd: "m.lock.accessory.binding.add",
+    bindingResultGet: "m.lock.accessory.binding.result.get",
+    bindingDelete: "m.lock.accessory.binding.delete",
+    unbindingResultGet: "m.lock.accessory.unbinding.result.get",
+    eventList: "m.lock.accessory.event.list",
+};
+export const getBoundLockListApi = (params) => requestApi({
+    logName: "getBoundLockListApi",
+    api: SCREEN_CLOUD_API.boundList,
+    version: "1.0",
+    data: { ...params },
+});
+export const getBindableLockListApi = (params) => requestApi({
+    logName: "getBindableLockListApi",
+    api: SCREEN_CLOUD_API.bindableLockList,
+    version: "1.0",
+    data: { ...params },
+});
+export const addBindingApi = (params) => requestApi({
+    logName: "addBindingApi",
+    api: SCREEN_CLOUD_API.bindingAdd,
+    version: "1.0",
+    data: { ...params },
+});
+export const getBindingResultApi = (params) => requestApi({
+    logName: "getBindingResultApi",
+    api: SCREEN_CLOUD_API.bindingResultGet,
+    version: "1.0",
+    data: { ...params },
+});
+export const deleteBindingApi = (params) => requestApi({
+    logName: "deleteBindingApi",
+    api: SCREEN_CLOUD_API.bindingDelete,
+    version: "1.0",
+    data: { ...params },
+});
+export const getUnbindingResultApi = (params) => requestApi({
+    logName: "getUnbindingResultApi",
+    api: SCREEN_CLOUD_API.unbindingResultGet,
+    version: "1.0",
+    data: { ...params },
+});
+export const getEventListApi = (params) => requestApi({
+    logName: "getEventListApi",
+    api: SCREEN_CLOUD_API.eventList,
+    version: "1.0",
+    data: { ...params },
+});

package/lib/api/service.d.ts

@@ -0,0 +1,26 @@
+export interface CloudServiceStatus {
+    isExit: boolean;
+    duration: number;
+    imgDuration: number;
+    hasPurchasedOrder: boolean;
+    isFree: boolean;
+}
+export interface ServiceBenefitPopupItem {
+    name: string;
+    serviceCode: string;
+    catalogCode: string;
+    batchId: string;
+    expireTime: number;
+    usedTimes?: number;
+    numPerDevice?: number;
+    popupType: number;
+}
+export interface ClaimResultItem {
+    success: boolean;
+    errorCode?: string;
+    name?: string;
+    purchasedName?: string;
+}
+export declare const getCloudServiceStatusApi: (devId: string) => Promise<CloudServiceStatus>;
+export declare const getServicePopupListApi: (devId: string) => Promise<ServiceBenefitPopupItem[]>;
+export declare const claimServiceApi: (devId: string, batchId: string) => Promise<ClaimResultItem[]>;

package/lib/api/service.js

@@ -0,0 +1,25 @@
+import { requestApi } from "./request";
+export const getCloudServiceStatusApi = (devId) => {
+    return requestApi({
+        logName: "getCloudServiceStatus",
+        api: "m.lock.media.effect.credential",
+        version: "1.0",
+        data: { devId },
+    });
+};
+export const getServicePopupListApi = (devId) => {
+    return requestApi({
+        logName: "getServicePopupList",
+        api: "m.lock.vas.popup.content",
+        version: "1.0",
+        data: { devId, catalogCodes: "" },
+    });
+};
+export const claimServiceApi = (devId, batchId) => {
+    return requestApi({
+        logName: "claimService",
+        api: "m.lock.vas.collect.trigger",
+        version: "1.0",
+        data: { devId, catalogCodes: "", batchId },
+    });
+};

package/lib/api/setting.js

@@ -2,6 +2,7 @@ import { THING } from "../utils/constant";
 import { requestApi } from "./request";
 const getDeviceProperties = (deviceId, props) => {
     return requestApi({
+        logName: "getDeviceProperties",
         api: `${THING}.m.device.props.fetch`,
         version: "1.0",
         data: {
@@ -12,6 +13,7 @@ const getDeviceProperties = (deviceId, props) => {
 };
 const setDeviceProperties = (devId, data) => {
     return requestApi({
+        logName: "setDeviceProperties",
         api: `${THING}.m.device.props.save`,
         version: "1.0",
         data: {

package/lib/api/temp.d.ts

@@ -6,7 +6,7 @@ interface CreateTempPasswordParams {
     availTime?: number;
     name?: string;
     password?: string;
-    symbolic: boolean;
+    symbolic?: boolean;
     dpTunnel?: number;
     schedule?: {
         allDay: boolean;
@@ -66,8 +66,8 @@ interface UpdateTempPasswordParams {
     invalidTime?: number;
     name?: string;
     phase?: number;
-    symbolic: boolean;
-    dpTunnel: number;
+    symbolic?: boolean;
+    dpTunnel?: number;
     schedule: {
         allDay: boolean;
         effectiveTime: number;
@@ -170,6 +170,17 @@ export interface EffectivePasswrodItem {
         revokedPwdEffectiveTime?: number;
         revokedPwdInvalidTime?: number;
     };
+    availTime?: number;
+    timeSetType?: number;
+    shareInfo?: {
+        account: string;
+        countryCode: string;
+        lockUserId: number;
+        offlineUnlock: boolean;
+        phoneKeyUnlock: boolean;
+        userExist?: boolean;
+        userName: string;
+    };
 }
 export declare const fetchEffectiveList: (params: EffectiveListParams) => Promise<EffectivePasswrodItem[]>;
 interface fetchInvalidListParams {
@@ -224,4 +235,14 @@ interface GetSyncTempPasswordsParams {
     isUpt: boolean;
 }
 export declare const getSyncTempPasswords: (params: GetSyncTempPasswordsParams) => Promise<GetSyncTempPasswordsResult>;
+export interface LimitOfflinePwdItem {
+    unlockBindingId: string;
+    pwdId: string;
+    pwdName: string;
+    gmtStart: string;
+    gmtExpired: string;
+}
+export declare const getLimitOfflinePwdListForClear: (params: {
+    devId: string;
+}) => Promise<LimitOfflinePwdItem[]>;
 export {};