@ray-js/lock-sdk 1.1.1-beta.8 → 1.1.1-beta.9

package/lib/api/lock.d.ts

@@ -124,4 +124,9 @@ interface BindUnlockMethodToUserByRecordParams {
     unlockIds: string[];
 }
 export declare const bindUnlockMethodToUserByRecord: (params: BindUnlockMethodToUserByRecordParams) => Promise<boolean>;
+interface ValidatePasswordComplexityParams {
+    devId: string;
+    password: string;
+}
+export declare const validatePasswordComplexity: (params: ValidatePasswordComplexityParams) => Promise<boolean>;
 export {};

package/lib/api/lock.js

@@ -116,3 +116,10 @@ export const bindUnlockMethodToUserByRecord = (params) => {
         data: params,
     });
 };
+export const validatePasswordComplexity = (params) => {
+    return requestApi({
+        api: "m.lock.password.simplicity.check",
+        version: "1.0",
+        data: params,
+    });
+};

package/lib/api/user.d.ts

@@ -102,6 +102,12 @@ interface UserDetail {
     userType: number;
 }
 export declare const getUserDetail: (params: GetUserDetailParams) => Promise<UserDetail>;
+interface GetUserDetailQueryParams {
+    devId: string;
+    userId: string;
+    dpIds: string;
+}
+export declare const getUserDetailQuery: (params: GetUserDetailQueryParams) => Promise<UserListItem>;
 export interface RemovedUserData {
     userId: string;
     lockUserId: number;

package/lib/api/user.js

@@ -40,7 +40,14 @@ export const getUserList = (params) => {
 };
 export const getUserDetail = (params) => {
     return requestApi({
-        api: 'm.lock.device.member.detail',
+        api: "m.lock.device.member.detail",
+        version: "1.0",
+        data: params,
+    });
+};
+export const getUserDetailQuery = (params) => {
+    return requestApi({
+        api: "m.lock.user.detail.query",
         version: "1.0",
         data: params,
     });

package/lib/other.d.ts

@@ -27,4 +27,5 @@ export declare const connectDevice: () => Promise<unknown>;
 export declare const gotoService: (params?: {
     tab?: "cloudStorage" | "AI";
 }) => Promise<unknown>;
+export declare const validatePwdComplexity: (password: string) => Promise<boolean>;
 export {};

package/lib/other.js

@@ -3,13 +3,14 @@ import config, { hasCapability, hasDp } from "./config";
 import dpCodes from "./config/dp-code";
 import { ProductCommunicationType } from "./constant";
 import { getDeviceStatus, getDpValue } from "./state";
-import { connectBLEDevice, getBLEOnlineState, navigateToMiniProgram, offBleChange, offOnlineChange, onBleChange, onOnlineChange, openPanel, } from "./utils/device";
+import { connectBLEDevice, encrypt, getBLEOnlineState, navigateToMiniProgram, offBleChange, offOnlineChange, onBleChange, onOnlineChange, openPanel, } from "./utils/device";
 import { getError } from "./utils/errors";
 import { publishDps } from "./utils/publishDps";
 import ipc from "./utils/ipc";
 import { DPCHANGE } from "./utils/constant";
 import emitter from "./utils/event";
 import { getOfflineDpCache, publishOfflineDps } from "./offline-dps";
+import { validatePasswordComplexity } from "./api/lock";
 const { alarmLock, unlockFingerprint, unlockPassword, unlockCard, unlockKey, unlockPhoneRemote, unlockTemporary, unlockDynamic, unlockFace, unlockHand, unlockEye, unlockFingerVein, unlockInside, doorOpened, unlockApp, unlockOfflinePd, openInside, lockRecord, unlockDoubleKit, lockLocalRecord, wirelessAwake, } = dpCodes;
 const abilityMap = {
     backHome: "supportBackHome",
@@ -281,3 +282,10 @@ export const gotoService = async (params) => {
         });
     });
 };
+export const validatePwdComplexity = async (password) => {
+    const encryptedPassword = await encrypt(config.devInfo.devId, password);
+    return validatePasswordComplexity({
+        devId: config.devInfo.devId,
+        password: encryptedPassword,
+    });
+};

package/lib/user.d.ts

@@ -1,4 +1,4 @@
-import { EffectiveConfig, UserInfo } from "./interface";
+import { EffectiveConfig, UnlockMethodBaseInfo, UserInfo } from "./interface";
 interface getUsersParams {
     page?: number;
     pageSize?: number;
@@ -11,7 +11,27 @@ export declare const getUsers: (params?: getUsersParams) => Promise<{
 interface getUserInfoParams {
     userId: string;
 }
-export declare const getUserInfo: (params: getUserInfoParams) => Promise<UserInfo>;
+export declare const getUserInfo: (params: getUserInfoParams) => Promise<{
+    timeScheduleInfo: any;
+    unlockDetails: {
+        count: number;
+        dpCode: string;
+        dpId: number;
+        type: import("./interface").UnlockMethodType;
+        unlockList: UnlockMethodBaseInfo[];
+    }[];
+    isAccountUser: boolean;
+    userId: string;
+    lockUserId: number;
+    avatarUrl: string;
+    backHomeNotifyAttr: number;
+    effectiveFlag: number;
+    nickName: string;
+    offlineUnlock: boolean;
+    userContact: string;
+    userType: 10 | 20 | 30 | 40 | 50;
+    userListType: "panel_user" | "group_user";
+}>;
 interface updateUserLimitTimeParams {
     userId: string;
     lockUserId: number;

package/lib/user.js

@@ -1,4 +1,4 @@
-import { getUserDetail, getUserList } from "./api/user";
+import { getUserDetail, getUserDetailQuery, getUserList, } from "./api/user";
 import config from "./config";
 import { update as updateMap, reportUpdate as reportUpdateMap, } from "./config/dp-map/unlock-method";
 import { update as updateMapBig, reportUpdate as reportUpdateMapBig, } from "./config/dp-map/unlock-method-big";
@@ -14,59 +14,61 @@ import { LoopTypes } from "./utils/constant";
 import { getCurrentUser } from "./state";
 import { deleteUser } from "./utils/user";
 import { UserType } from "./constant";
-const concactUserList = (list, result) => {
-    return list.reduce((acc, item) => {
-        const { timeScheduleInfo, unlockDetail, ...rest } = item;
-        let scheduleInfo = {
-            permanent: true,
-        };
-        if (!item.timeScheduleInfo.permanent &&
-            item.timeScheduleInfo.scheduleDetails &&
-            item.timeScheduleInfo.scheduleDetails.length > 0) {
-            Object.assign(scheduleInfo, {
-                permanent: false,
-                effectiveTime: formatTimestampToMilliseconds(item.timeScheduleInfo.effectiveTime || 0),
-                expiredTime: formatTimestampToMilliseconds(item.timeScheduleInfo.expiredTime || 0),
-                scheduleDetails: {
-                    repeat: !item.timeScheduleInfo.scheduleDetails[0].allDay,
-                    effectiveTime: item.timeScheduleInfo.scheduleDetails[0].effectiveTime,
-                    invalidTime: item.timeScheduleInfo.scheduleDetails[0].invalidTime,
-                    timeZoneId: item.timeScheduleInfo.scheduleDetails[0].timeZoneId,
-                    weeks: parseWeek(item.timeScheduleInfo.scheduleDetails[0].workingDay),
-                },
-            });
-        }
-        let unlockDetails = unlockDetail.map((detail) => {
-            const unlockList = detail.unlockList.map((unlockItem) => {
-                return {
-                    unlockId: +unlockItem.unlockId.split("-")[1],
-                    unlockName: unlockItem.unlockName,
-                    id: unlockItem.opModeId,
-                    isBound: unlockItem.allocateFlag === 1,
-                    photoUnlock: unlockItem.photoUnlock,
-                    isSpecial: unlockItem.unlockAttr === 1,
-                };
-            });
-            const unlockMethodConfig = unlockMethodConfigs.find((item) => item.code === detail.dpCode);
+const handleUserDetail = (user) => {
+    const { timeScheduleInfo, unlockDetail, ...rest } = user;
+    let scheduleInfo = {
+        permanent: true,
+    };
+    if (!timeScheduleInfo.permanent &&
+        timeScheduleInfo.scheduleDetails &&
+        timeScheduleInfo.scheduleDetails.length > 0) {
+        Object.assign(scheduleInfo, {
+            permanent: false,
+            effectiveTime: formatTimestampToMilliseconds(timeScheduleInfo.effectiveTime || 0),
+            expiredTime: formatTimestampToMilliseconds(timeScheduleInfo.expiredTime || 0),
+            scheduleDetails: {
+                repeat: !timeScheduleInfo.scheduleDetails[0].allDay,
+                effectiveTime: timeScheduleInfo.scheduleDetails[0].effectiveTime,
+                invalidTime: timeScheduleInfo.scheduleDetails[0].invalidTime,
+                timeZoneId: timeScheduleInfo.scheduleDetails[0].timeZoneId,
+                weeks: parseWeek(timeScheduleInfo.scheduleDetails[0].workingDay),
+            },
+        });
+    }
+    let unlockDetails = unlockDetail.map((detail) => {
+        const unlockList = detail.unlockList.map((unlockItem) => {
             return {
-                count: unlockList.length,
-                dpCode: detail.dpCode,
-                dpId: detail.dpId,
-                type: unlockMethodConfig.type,
-                unlockList,
+                unlockId: +unlockItem.unlockId.split("-")[1],
+                unlockName: unlockItem.unlockName,
+                id: unlockItem.opModeId,
+                isBound: unlockItem.allocateFlag === 1,
+                photoUnlock: unlockItem.photoUnlock,
+                isSpecial: unlockItem.unlockAttr === 1,
             };
         });
-        acc.push({
-            ...rest,
-            timeScheduleInfo: scheduleInfo,
-            unlockDetails,
-            isAccountUser: item.userListType === "group_user",
-        });
+        const unlockMethodConfig = unlockMethodConfigs.find((item) => item.code === detail.dpCode);
+        return {
+            count: unlockList.length,
+            dpCode: detail.dpCode,
+            dpId: detail.dpId,
+            type: unlockMethodConfig.type,
+            unlockList,
+        };
+    });
+    return {
+        ...rest,
+        timeScheduleInfo: scheduleInfo,
+        unlockDetails,
+        isAccountUser: user.userListType === "group_user",
+    };
+};
+const concactUserList = (list, result) => {
+    return list.reduce((acc, item) => {
+        acc.push(handleUserDetail(item));
         return acc;
     }, result);
 };
-export const getUsers = async (params) => {
-    const { page = 1, pageSize = 10, keyword = "" } = params || {};
+const getUserDpCodes = async () => {
     const currentUser = await getCurrentUser();
     const dps = [];
     if (currentUser.allOpenDps) {
@@ -78,6 +80,11 @@ export const getUsers = async (params) => {
             return acc;
         }, dps);
     }
+    return dps;
+};
+export const getUsers = async (params) => {
+    const { page = 1, pageSize = 10, keyword = "" } = params || {};
+    const dps = await getUserDpCodes();
     const res = await getUserList({
         dpCodes: dps.join(","),
         devId: config.devInfo.devId,
@@ -98,18 +105,13 @@ export const getUsers = async (params) => {
     };
 };
 export const getUserInfo = async (params) => {
-    const user = await getUserDetail({
+    const currentUser = await getCurrentUser();
+    const res = await getUserDetailQuery({
         devId: config.devInfo.devId,
         userId: params.userId,
+        dpIds: currentUser.allOpenDps,
     });
-    const data = await getUsers({
-        keyword: user.nickName,
-    });
-    const res = data.list.find((item) => item.userId === params.userId);
-    if (res) {
-        return res;
-    }
-    throw getError(1048);
+    return handleUserDetail(res);
 };
 export const updateUserLimitTime = async (params) => {
     const { userId, lockUserId, permanent, effective } = params;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.1.1-beta.8",
+  "version": "1.1.1-beta.9",
   "files": [
     "lib",
     "LICENSE.md"