@ray-js/lock-sdk 1.0.4 → 1.1.0-beta.2

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.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: {
@@ -11,7 +11,7 @@ export const openDoorByCloud = (deviceId, isOpen) => {
     });
 };
 export const isConfirmOpenDoorByWifiPro = (deviceId, confirm) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.remote.unlock`,
         version: "2.0",
         data: {
@@ -22,7 +22,7 @@ export const isConfirmOpenDoorByWifiPro = (deviceId, confirm) => {
     });
 };
 export const checkRemoteKey = async (deviceId) => {
-    return requestCloud({
+    return requestApi({
         api: "m.lock.ble.remote.unlock.check",
         version: "1.0",
         data: {
@@ -31,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: {
@@ -40,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.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.js

@@ -1,56 +1,56 @@
-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 requestCloud({
+    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 requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.temppwd.del`,
         version: "2.0",
         data: params,
     });
 };
 export const getTempOnlineUnlimitedListAPI = (devId) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.temppwd.list`,
         version: "2.0",
         data: {
@@ -59,77 +59,77 @@ export const getTempOnlineUnlimitedListAPI = (devId) => {
     });
 };
 export const getTempOfflineListAPI = (params) => {
-    return requestCloud({
+    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 requestCloud({
+    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,

package/lib/api/user.d.ts

@@ -102,4 +102,25 @@ interface UserDetail {
     userType: number;
 }
 export declare const getUserDetail: (params: GetUserDetailParams) => Promise<UserDetail>;
+export interface RemovedUserData {
+    userId: string;
+    lockUserId: number;
+    admin: boolean;
+}
+interface GetUsersSyncLockResponse {
+    lockRandom: {
+        devUnlockId: string;
+        distributed: boolean;
+        ins: string;
+    };
+    lockFitting: {
+        dpId: number;
+        distributed: boolean;
+        ins: Array<any>;
+    };
+    lockRecord: string;
+    removedUser: Array<RemovedUserData>;
+}
+export declare const getUsersSyncLockData: (deviceId: string) => Promise<GetUsersSyncLockResponse>;
+export declare const removeUser: (devId: string, userId: string) => Promise<unknown>;
 export {};

package/lib/api/user.js

@@ -1,7 +1,7 @@
 import { THING } from "../utils/constant";
-import { requestCloud } from "../utils/device";
+import { requestApi } from "./request";
 export const getCurrentUserInfo = (deviceId) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.member.get`,
         version: "3.0",
         data: {
@@ -11,37 +11,56 @@ export const getCurrentUserInfo = (deviceId) => {
     });
 };
 export const updateUserTimeSchedule = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.user.time.schedule.update`,
         version: "1.0",
         data: params,
     });
 };
 export const addNormalUser = async (params) => {
-    return requestCloud({
+    return requestApi({
         api: "m.smart.scale.history.user.add",
         version: "1.0",
         data: params,
     });
 };
 export const removeNormalUser = async (params) => {
-    return requestCloud({
+    return requestApi({
         api: "m.smart.scale.history.user.delete",
         version: "2.0",
         data: params,
     });
 };
 export const getUserList = (params) => {
-    return requestCloud({
+    return requestApi({
         api: "m.lock.member.family.panel.all.list",
         version: "1.0",
         data: params,
     });
 };
 export const getUserDetail = (params) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.member.detail`,
         version: "4.0",
         data: params,
     });
 };
+export const getUsersSyncLockData = (deviceId) => {
+    return requestApi({
+        api: `${THING}.m.device.lock.sync.batch`,
+        version: "2.0",
+        data: {
+            devId: deviceId,
+        },
+    });
+};
+export const removeUser = (devId, userId) => {
+    return requestApi({
+        api: `${THING}.m.device.member.remove`,
+        version: "2.0",
+        data: {
+            devId,
+            userId,
+        },
+    });
+};

package/lib/api/video.js

@@ -1,7 +1,7 @@
 import { THING } from "../utils/constant";
-import { requestCloud } from "../utils/device";
+import { requestApi } from "./request";
 export const getRotateInfo = (deviceId) => {
-    return requestCloud({
+    return requestApi({
         api: `${THING}.m.device.lock.media.rotate.get`,
         version: "1.0",
         data: {