@ray-js/lock-sdk 1.0.3 → 1.1.0-beta.1

package/lib/api/index.d.ts

@@ -1,5 +1,30 @@
+import { DpValue } from "../interface";
 export declare const sendPhoneVerifyCode: (params: {
     account: string;
     devId: string;
 }) => Promise<unknown>;
 export declare const getActiveTime: (devId: string) => Promise<string>;
+interface ProductAbility {
+    abilityCode: string;
+    isOpen: boolean;
+    extConfig: string;
+}
+export declare const getProductAbilities: (devId: string, codes: string[]) => Promise<ProductAbility[]>;
+interface DeviceAdvancedAbility {
+    types: number[];
+}
+export declare const getDeviceAdvancedAbility: (devId: string) => Promise<DeviceAdvancedAbility>;
+export declare const getVoicePwdEnabled: (devId: string) => Promise<number | boolean>;
+interface SetVoicePwdParams {
+    devId: string;
+    open: boolean;
+    pwd: string;
+}
+export declare const setVoicePwd: (params: SetVoicePwdParams) => Promise<boolean>;
+export declare const fetchOfflineDpData: (deviceId: string) => Promise<{
+    dps: string;
+    pushStatus: boolean;
+}[]>;
+export declare const publishOfflineDpData: (deviceId: string, dpData: Record<string, DpValue>) => Promise<unknown>;
+export declare const clearOfflineDpData: (deviceId: string) => Promise<unknown>;
+export {};

package/lib/api/index.js

@@ -1,16 +1,72 @@
 import { THING } from "../utils/constant";
-import { requestCloud } from "../utils/device";
+import { requestApi } from "./request";
 export const sendPhoneVerifyCode = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.user.verifycode.send`,
         version: "1.0",
         data: params,
     });
 };
 export const getActiveTime = (devId) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.active.date`,
         version: "1.0",
         data: { devId },
     });
 };
+export const getProductAbilities = (devId, codes) => {
+    return requestApi({
+        api: "m.life.app.device.product.abilities",
+        version: "1.0",
+        data: { deviceId: devId, abilityCodes: codes },
+    });
+};
+export const getDeviceAdvancedAbility = (devId) => {
+    return requestApi({
+        api: "m.lock.add.value.device.info",
+        version: "1.0",
+        data: { devId },
+    });
+};
+export const getVoicePwdEnabled = (devId) => {
+    return requestApi({
+        api: `${THING}.m.device.lock.voice.pwd.flag`,
+        version: "1.0",
+        data: { devId },
+    });
+};
+export const setVoicePwd = (params) => {
+    return requestApi({
+        api: `${THING}.m.device.lock.voice.pwd.setting`,
+        version: "1.0",
+        data: params,
+    });
+};
+export const fetchOfflineDpData = async (deviceId) => {
+    return await requestApi({
+        api: `${THING}.m.device.cache.dp.get`,
+        data: { devId: deviceId, dpCacheType: 0 },
+        version: "2.0",
+    });
+};
+export const publishOfflineDpData = (deviceId, dpData) => {
+    return requestApi({
+        api: `${THING}.m.device.dp.publish`,
+        data: {
+            devId: deviceId,
+            gwId: deviceId,
+            dpCacheType: 0,
+            validity: 24 * 60 * 60,
+            reason: "none",
+            dps: dpData,
+        },
+        version: "2.0",
+    });
+};
+export const clearOfflineDpData = async (deviceId) => {
+    return requestApi({
+        api: "m.thing.cancel.device.shadow.desired.properties",
+        data: { devId: deviceId },
+        version: "1.0",
+    });
+};

package/lib/api/linkage.js

@@ -1,7 +1,7 @@
 import { THING } from "../utils/constant";
-import { requestCloud } from "../utils/device";
+import { requestApi } from "./request";
 export const getLinkageList = (deviceId, homeId) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.linkage.doorlock.rule.query`,
         version: "2.0",
         data: {
@@ -13,7 +13,7 @@ export const getLinkageList = (deviceId, homeId) => {
     });
 };
 export const saveLinkage = (data, homeId) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.linkage.device.shell.save`,
         version: "2.0",
         data: {
@@ -25,7 +25,7 @@ export const saveLinkage = (data, homeId) => {
     });
 };
 export const enableLinkage = (ruleId, homeId) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.linkage.rule.enable`,
         version: "1.0",
         data: {
@@ -37,7 +37,7 @@ export const enableLinkage = (ruleId, homeId) => {
     });
 };
 export const disableLinkage = (ruleId, homeId) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.linkage.rule.disable`,
         version: "1.0",
         data: {
@@ -49,7 +49,7 @@ export const disableLinkage = (ruleId, homeId) => {
     });
 };
 export const getRemainingMessage = (homeId) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.notification.subscribe.info`,
         version: "1.0",
         data: {
@@ -61,7 +61,7 @@ export const getRemainingMessage = (homeId) => {
     });
 };
 export const getRemainingPhone = (homeId) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.mobile.voice.times.count`,
         version: "1.0",
         data: {},

package/lib/api/lock.d.ts

@@ -1,4 +1,5 @@
 export declare const openDoorByCloud: (deviceId: string, isOpen: boolean) => Promise<unknown>;
+export declare const isConfirmOpenDoorByWifiPro: (deviceId: string, confirm: boolean) => Promise<unknown>;
 export declare const checkRemoteKey: (deviceId: string) => Promise<{
     effectiveTime: number;
     invalidTime: number;

package/lib/api/lock.js

@@ -1,7 +1,7 @@
 import { THING } from "../utils/constant";
-import { requestCloud } from "../utils/device";
+import { requestApi } from "./request";
 export const openDoorByCloud = (deviceId, isOpen) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.zigbee.lock.remotepwd.execute`,
         version: "1.0",
         data: {
@@ -10,8 +10,19 @@ export const openDoorByCloud = (deviceId, isOpen) => {
         },
     });
 };
+export const isConfirmOpenDoorByWifiPro = (deviceId, confirm) => {
+    return requestApi({
+        api: `${THING}.m.device.lock.remote.unlock`,
+        version: "2.0",
+        data: {
+            devId: deviceId,
+            confirm,
+            open: true,
+        },
+    });
+};
 export const checkRemoteKey = async (deviceId) => {
-    return requestCloud({
+    return requestApi({
         api: "m.lock.ble.remote.unlock.check",
         version: "1.0",
         data: {
@@ -20,7 +31,7 @@ export const checkRemoteKey = async (deviceId) => {
     });
 };
 export const getDoorKey = (deviceId) => {
-    return requestCloud({
+    return requestApi({
         api: "m.lock.ble.remote.unlock.get",
         version: "1.0",
         data: {
@@ -29,77 +40,77 @@ export const getDoorKey = (deviceId) => {
     });
 };
 export const getUnlockMethodInfo = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.member.opmode.detail`,
         version: "1.0",
         data: params,
     });
 };
 export const fetchCreatePasswordSN = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.dp.sn.get`,
         version: "1.0",
         data: params,
     });
 };
 export const createUnlockMethod = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.member.opmode.add`,
         version: "5.0",
         data: params,
     });
 };
 export const editUnlockMethod = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.member.opmode.update`,
         version: "5.0",
         data: params,
     });
 };
 export const removeUnlockMethod = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.member.opmode.remove`,
         version: "2.0",
         data: params,
     });
 };
 export const fetchSyncUnlockMethodInfo = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.opmode.sync.rise`,
         version: "2.0",
         data: params,
     });
 };
 export const checkFreeUnlockMethods = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.unlock.waitassign`,
         version: "1.0",
         data: params,
     });
 };
 export const fetchFreeUnlockMethods = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.unlock.assignlist`,
         version: "1.0",
         data: params,
     });
 };
 export const bindUnlockMethodToUser = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.user.unlock.allocate`,
         version: "1.0",
         data: params,
     });
 };
 export const unbindMemberUnlockMethod = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.user.unlock.unbind`,
         version: "1.0",
         data: params,
     });
 };
 export const bindUnlockMethodToUserByRecord = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.user.unlock.bind`,
         version: "1.0",
         data: params,

package/lib/api/log.d.ts

@@ -127,7 +127,12 @@ interface GetMediaUrlParams {
     mediaPath: string;
     mediaBucket: string;
 }
-export declare const getMediaUrl: (params: GetMediaUrlParams) => Promise<{
+interface GetFileUrlParams {
+    devId: string;
+    filePath: string;
+    bucket: string;
+}
+export declare const getMediaUrl: (params: GetMediaUrlParams | GetFileUrlParams) => Promise<{
     mediaUrl: string;
 }>;
 export {};

package/lib/api/log.js

@@ -1,7 +1,7 @@
 import { THING } from "../utils/constant";
-import { requestCloud } from "../utils/device";
+import { requestApi } from "./request";
 export const getLatest2Log = (devId) => {
-    return requestCloud({
+    return requestApi({
         api: "m.lock.log.latest2",
         version: "1.0",
         data: {
@@ -10,28 +10,28 @@ export const getLatest2Log = (devId) => {
     });
 };
 export const getRecordList = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.history.list`,
         version: "1.0",
         data: params,
     });
 };
 export const getAlarmList = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.alarm.list`,
         version: "3.0",
         data: params,
     });
 };
 export const getAlbumMessages = (params) => {
-    return requestCloud({
+    return requestApi({
         api: "m.lock.album.media.list",
         version: "3.0",
         data: params,
     });
 };
 export const getMediaUrl = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.media.path`,
         version: "2.0",
         data: params,

package/lib/api/request.d.ts

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

package/lib/api/request.js

@@ -0,0 +1,57 @@
+import { requestCloud } from "../utils/device";
+const cache = new Map();
+export const requestApi = async (options) => {
+    const key = `${options.api}-${options.version}-${JSON.stringify(options.data)}}`;
+    if (cache.has(key)) {
+        const requestCb = cache.get(key);
+        if (requestCb && Date.now() - requestCb.time <= 1000) {
+            return new Promise((resolve, reject) => {
+                requestCb.callbacks.push((data, error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(data);
+                    }
+                });
+            });
+        }
+    }
+    else {
+        cache.set(key, {
+            time: Date.now(),
+            callbacks: [],
+        });
+    }
+    try {
+        const result = await requestCloud(options);
+        if (cache.has(key)) {
+            const requestCb = cache.get(key);
+            if (requestCb && requestCb.callbacks.length) {
+                requestCb.callbacks.forEach((callback) => {
+                    try {
+                        callback(result, null);
+                    }
+                    catch (error) { }
+                });
+            }
+            cache.delete(key);
+        }
+        return result;
+    }
+    catch (error) {
+        if (cache.has(key)) {
+            const requestCb = cache.get(key);
+            if (requestCb && requestCb.callbacks.length) {
+                requestCb.callbacks.forEach((callback) => {
+                    try {
+                        callback(null, error);
+                    }
+                    catch (error) { }
+                });
+            }
+            cache.delete(key);
+        }
+        throw error;
+    }
+};

package/lib/api/setting.d.ts

@@ -1,3 +1,3 @@
 declare const getDeviceProperties: (deviceId: string, props: string[]) => Promise<Record<string, any>>;
-declare const setDeviceProperties: (devId: string, data: Record<string, any>) => Promise<void>;
+declare const setDeviceProperties: (devId: string, data: Record<string, any>) => Promise<unknown>;
 export { setDeviceProperties, getDeviceProperties };

package/lib/api/setting.js

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

package/lib/api/temp.d.ts

@@ -21,6 +21,27 @@ export interface CreateTempPasswordResult {
     tyNum?: number;
 }
 export declare const createTemporaryPassword: (params: CreateTempPasswordParams) => Promise<CreateTempPasswordResult>;
+interface CreateOnlineUnlimitedParams {
+    devId: string;
+    effectiveTime: number;
+    invalidTime: number;
+    name: string;
+    password: string;
+    availTime: number;
+    schedule: {
+        allDay: boolean;
+        effectiveTime: number;
+        invalidTime: number;
+        workingDay: number;
+    }[];
+    phone?: string;
+    countryCode?: string;
+}
+export interface CreateOnlineUnlimitedResult {
+    pwdId: string;
+    name: string;
+}
+export declare const createOnlineUnlimited: (params: CreateOnlineUnlimitedParams) => Promise<CreateOnlineUnlimitedResult>;
 export interface ValidateTempPwdParams {
     password: string;
     devId: string;
@@ -67,6 +88,22 @@ interface DeleteTempPasswordParams {
     dpTunnel: number;
 }
 export declare const deleteTempPassword: (params: DeleteTempPasswordParams) => Promise<unknown>;
+export interface RemoveTempOnlineUnlimitedParams {
+    devId: string;
+    pwdId: string;
+    symbolic: boolean;
+    dpTunnel: number;
+}
+export declare const removeTempOnlineUnlimitedAPI: (params: {
+    devId: string;
+    id: string;
+}) => Promise<unknown>;
+export declare const getTempOnlineUnlimitedListAPI: (devId: string) => Promise<EffectivePasswrodItem[]>;
+export declare const getTempOfflineListAPI: (params: {
+    devId: string;
+    pwdType: string;
+    status: string;
+}) => Promise<EffectivePasswrodItem[]>;
 export interface CreateOfflinePasswordParams {
     devId: string;
     pwdType: string;
@@ -85,6 +122,13 @@ export interface OfflinePwdResult {
     unlockBindingId: string;
 }
 export declare const createOfflinePassword: (params: CreateOfflinePasswordParams) => Promise<OfflinePwdResult>;
+interface CreateOfflineOnceParams {
+    devId: string;
+    pwdType: string;
+    gmtStart: string;
+    gmtExpired: string;
+}
+export declare const createOfflineOnceAPI: (params: CreateOfflineOnceParams) => Promise<OfflinePwdResult>;
 interface GetDynapwdParams {
     devId: string;
     adminPwd?: string;
@@ -102,7 +146,7 @@ interface EffectiveListParams {
     devId: string;
     authTypes: string[];
 }
-interface EffectivePasswrodItem {
+export interface EffectivePasswrodItem {
     effective: number;
     unlockBindingId: string;
     effectiveTime: number;

package/lib/api/temp.js

@@ -1,98 +1,135 @@
-import { requestCloud } from "../utils/device";
+import { requestApi } from "./request";
 import { THING } from "../utils/constant";
 export const createTemporaryPassword = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.temppwd.create`,
         version: "8.0",
         data: params,
     });
 };
+export const createOnlineUnlimited = (params) => {
+    return requestApi({
+        api: `${THING}.m.device.lock.temppwd.create`,
+        version: "4.0",
+        data: params,
+    });
+};
 export const validateTempPwd = async (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.temppwd.validate`,
         version: "3.0",
         data: params,
     });
 };
 export const updateTemporaryPassword = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.temppwd.update`,
         version: "4.0",
         data: params,
     });
 };
 export const getTempPassword = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.temppwd.detail`,
         version: "1.0",
         data: params,
     });
 };
 export const deleteTempPassword = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.temppwd.remove`,
         version: "2.0",
         data: params,
     });
 };
+export const removeTempOnlineUnlimitedAPI = (params) => {
+    return requestApi({
+        api: `${THING}.m.device.lock.temppwd.del`,
+        version: "2.0",
+        data: params,
+    });
+};
+export const getTempOnlineUnlimitedListAPI = (devId) => {
+    return requestApi({
+        api: `${THING}.m.device.lock.temppwd.list`,
+        version: "2.0",
+        data: {
+            devId,
+        },
+    });
+};
+export const getTempOfflineListAPI = (params) => {
+    return requestApi({
+        api: `${THING}.m.device.lock.offlinepwd.list`,
+        version: "1.0",
+        data: params,
+    });
+};
 export const createOfflinePassword = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.offlinepwd.get`,
         version: "3.0",
         data: params,
     });
 };
+export const createOfflineOnceAPI = (params) => {
+    return requestApi({
+        api: `${THING}.m.device.lock.offlinepwd.get`,
+        version: "1.0",
+        data: params,
+    });
+};
 export const getDynamicPassword = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.dynapwd.get`,
         version: "3.0",
         data: params,
     });
 };
 export const revokeOfflinePassword = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.offlinepwd.revoke`,
         version: "2.0",
         data: params,
     });
 };
 export const fetchEffectiveList = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.auth.list`,
         version: "1.0",
         data: params,
     });
 };
 export const fetchInvalidList = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.auth.list.invalid`,
         version: "1.0",
         data: params,
     });
 };
 export const clearInvalidTempList = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.auth.list.clear`,
         version: "1.0",
         data: params,
     });
 };
 export const reNameTemporary = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.temppwd.name`,
         version: "1.0",
         data: params,
     });
 };
 export const reNameOffline = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.offlinepwd.name.update`,
         version: "2.0",
         data: params,
     });
 };
 export const getSyncTempPasswords = (params) => {
-    return requestCloud({
+    return requestApi({
         api: "m.lock.device.lock.tempwd.sync",
         version: "1.0",
         data: params,