更新！

FullCardServer/src/main/java/com/zhongshu/card/server/core/controller/openAPI/ProjectOpenAPIController.java

@@ -38,7 +38,7 @@ public class ProjectOpenAPIController {
     @Operation(summary = "查询设备对应的用户信息", description = "查询设备对应的用户信息")
     @RequestMapping(value = "queryDeviceUsersInfo", method = {RequestMethod.POST})
     public ResultContent queryDeviceUsersInfo(@RequestBody @Valid DevicePerQuery param) {
-        return devicePermissIotService.queryDevicePermiss(param);
+        return devicePermissIotService.getDeviceAboutUserInfos(param);
     }
 
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/devices/DevicePermissDao.java

@@ -1,6 +1,7 @@
 package com.zhongshu.card.server.core.dao.devices;
 
 import com.github.microservice.components.data.mongo.mongo.dao.MongoDao;
+import com.zhongshu.card.client.type.DataState;
 import com.zhongshu.card.server.core.dao.devices.extend.DevicePermissDaoExtend;
 import com.zhongshu.card.server.core.domain.devices.DevicePermiss;
 import com.zhongshu.card.server.core.domain.org.OrganizationUser;
@@ -22,4 +23,7 @@ public interface DevicePermissDao extends MongoDao<DevicePermiss>, DevicePermiss
     DevicePermiss findTopByDeviceIdAndOrganizationUser(String deviceId, OrganizationUser organizationUser);
 
     List<DevicePermiss> findByOrganizationUserIn(List<OrganizationUser> organizationUsers);
+
+    List<DevicePermiss> findByDeviceIdInAndDataState(List<String> deviceIds, DataState dataState);
+
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/projectAbout/OrgUserFaceDao.java

@@ -18,4 +18,6 @@ public interface OrgUserFaceDao extends MongoDao<OrgUserFace> {
 
     List<OrgUserFace> findByUserIdAndProjectOid(String userId, String projectOid);
 
+    List<OrgUserFace> findByProjectOidAndUserIdIn(String projectOid, List<String> userIds);
+
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/school/CardInfoDao.java

@@ -1,6 +1,7 @@
 package com.zhongshu.card.server.core.dao.school;
 
 import com.github.microservice.components.data.mongo.mongo.dao.MongoDao;
+import com.zhongshu.card.client.type.school.CardState;
 import com.zhongshu.card.server.core.dao.school.extend.CardInfoDaoExtend;
 import com.zhongshu.card.server.core.domain.school.CardInfo;
 
@@ -27,5 +28,7 @@ public interface CardInfoDao extends MongoDao<CardInfo>, CardInfoDaoExtend {
 
     List<CardInfo> findByUserIdAndProjectOid(String userId, String projectOid);
 
+    List<CardInfo> findByProjectOidAndUserIdInAndCardState(String projectOid, List<String> userIds, CardState state);
+
     void deleteByUserIdAndOid(String userId, String oid);
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/domain/projectAbout/OrgUserFace.java

@@ -33,7 +33,7 @@ public class OrgUserFace extends SuperMain {
     @Schema(description = "图片名称")
     private String name;
 
-    @Schema(description = "人员图片地址")
+    @Schema(description = "人脸图片地址")
     private String img;
 
     @Schema(description = "是否可使用")

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/devices/DevicePermissIotService.java

@@ -2,12 +2,10 @@ package com.zhongshu.card.server.core.service.devices;
 
 import cn.hutool.json.JSONObject;
 import cn.hutool.json.JSONUtil;
+import com.github.microservice.core.util.os.SystemUtil;
 import com.github.microservice.dataConfig.IotIdentifierConfig;
 import com.github.microservice.models.device.DevicePerQuery;
-import com.github.microservice.models.devicePermiss.DeviceAboutPermiss;
-import com.github.microservice.models.devicePermiss.GateWayPermissModel;
-import com.github.microservice.models.devicePermiss.GateWayQuery;
-import com.github.microservice.models.devicePermiss.UserPermiss;
+import com.github.microservice.models.devicePermiss.*;
 import com.github.microservice.models.iot.IotSendParam;
 import com.github.microservice.net.ResultContent;
 import com.github.microservice.types.FunctionType;
@@ -19,7 +17,6 @@ import com.zhongshu.card.server.core.dao.org.OrganizationDao;
 import com.zhongshu.card.server.core.dao.org.OrganizationUserDao;
 import com.zhongshu.card.server.core.domain.devices.DeviceInfo;
 import com.zhongshu.card.server.core.domain.devices.DevicePermiss;
-import com.zhongshu.card.server.core.domain.org.Organization;
 import com.zhongshu.card.server.core.domain.org.UserAccount;
 import com.zhongshu.card.server.core.domain.projectAbout.OrgUserFace;
 import com.zhongshu.card.server.core.event.DevicePermissChangeEvent;
@@ -31,13 +28,15 @@ import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.ObjectUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
 import org.springframework.context.event.EventListener;
-import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
@@ -78,32 +77,18 @@ public class DevicePermissIotService {
     @Autowired
     private OpenApiRequestService openApiRequestService;
 
-    /**
-     * 查询网关 包含的设备的权限
-     *
-     * @param query
-     * @return
-     */
-    public GateWayPermissModel queryGateWayPermiss(GateWayQuery query) {
-        // 返回模型
-        GateWayPermissModel model = new GateWayPermissModel();
-        model.setSuccess();
-
-        String deviceId = query.getDeviceId();
-        DeviceInfo deviceInfo = deviceInfoDao.findTopByDeviceId(deviceId);
-        Organization project = organizationDao.findTopByCode(query.getProjectCode());
-        if (ObjectUtils.isNotEmpty(deviceInfo) && ObjectUtils.isNotEmpty(project)) {
-            DeviceAboutPermiss aboutPermiss = new DeviceAboutPermiss();
-            aboutPermiss.setDeviceId(deviceId);
-            List<DevicePermiss> devices = devicePermissDao.findByDeviceIdAndProjectOid(deviceId, project.getOid());
-            List<UserPermiss> userPermisses = new ArrayList<>();
-            if (ObjectUtils.isNotEmpty(devices)) {
-                userPermisses = devices.parallelStream().map(this::toModel).collect(Collectors.toUnmodifiableList());
-            }
-            aboutPermiss.setUserPermisses(userPermisses);
-            model.addDevice(aboutPermiss);
-        }
-        return model;
+    @Autowired
+    private DevicePermissService devicePermissService;
+
+    //线程池
+    private ExecutorService executorService = Executors.newFixedThreadPool(
+            SystemUtil.getCpuCoreCount() * 2);
+
+    @Autowired
+    private void init(ApplicationContext applicationContext) {
+        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+            executorService.shutdownNow();
+        }));
     }
 
     /**
@@ -113,85 +98,91 @@ public class DevicePermissIotService {
      * @return
      */
     public ResultContent queryDevicePermiss(DevicePerQuery query) {
-        DeviceAboutPermiss deviceAboutPermiss = new DeviceAboutPermiss();
-        List<String> deviceIds = query.getDeviceIds();
-        if (ObjectUtils.isNotEmpty(deviceIds)) {
+        GateWayPermissModel permissModel = devicePermissService.getDeviceAboutUsers(query.getDeviceIds());
+        permissModel.setSuccess();
+        permissModel.setGateWayId(query.getGateWayId());
+        return ResultContent.buildSuccess(JSONUtil.toJsonStr(permissModel));
+    }
 
-        }
-        return ResultContent.buildSuccess(JSONUtil.toJsonStr(deviceAboutPermiss));
+    public ResultContent getDeviceAboutUserInfos(DevicePerQuery query) {
+        DeviceUsersInfo permissModel = devicePermissService.getDeviceAboutUserInfos(query.getDeviceIds());
+        permissModel.setSuccess();
+        permissModel.setGateWayId(query.getGateWayId());
+        return ResultContent.buildSuccess(JSONUtil.toJsonStr(permissModel));
     }
 
     @EventListener(classes = DevicePermissChangeEvent.class)
-    @Async
     @SneakyThrows
     public void devicePermissChange(DevicePermissChangeEvent event) {
-        log.info("设备权限发生变化...");
-        // 通知物联网 设备权限发生变化
-        List<String> deviceIds = event.getDeviceIds();
-        if (ObjectUtils.isNotEmpty(deviceIds)) {
-            List<DeviceInfo> deviceInfos = deviceInfoDao.findByDeviceIdIn(deviceIds);
-            if (ObjectUtils.isNotEmpty(deviceInfos)) {
-                // 按网关分组
-                HashMap<String, List<String>> map = new HashMap<>();
-                deviceInfos.stream().forEach(it -> {
-                    String deviceId = it.getDeviceId();
-                    String gateWayId = it.getGateWayId();
-                    List<String> arr = List.of(gateWayId.split(","));
-                    if (ObjectUtils.isNotEmpty(arr)) {
-                        arr.stream().forEach(_gateWayId -> {
-                            List<String> _list = map.get(_gateWayId);
-                            if (ObjectUtils.isEmpty(_list)) {
-                                _list = new ArrayList<>();
-                            }
-                            _list.add(deviceId);
-                            map.put(_gateWayId, _list);
-                        });
-                    }
-                });
-
-                // 遍历发送
-                map.keySet().stream().forEach(gateWayId -> {
-                    List<String> _deviceIds = map.get(gateWayId);
-                    try {
-                        while (_deviceIds.size() > 0) {
-                            int index = Math.min(_deviceIds.size(), IotIdentifierConfig.maxNoticeSize);
-                            List<String> subList = _deviceIds.subList(0, index);
-                            _deviceIds = _deviceIds.subList(index, _deviceIds.size());
-
-                            DeviceInfo deviceInfo = deviceInfoDao.findTopByDeviceId(subList.get(0));
-
-                            IotSendParam param = new IotSendParam();
-                            param.setGateWayId(gateWayId);
-                            param.setFunctionType(FunctionType.Server);
-                            param.setIdentifier(IotIdentifierConfig.permissionNotice);
-
-                            // 组装消息内容
-                            JSONObject jsonObject = new JSONObject();
-                            jsonObject.set("deviceIds", subList);
-                            param.setData(jsonObject);
-                            ResultContent resultContent = openApiRequestService.sendIotMessage(
-                                    param, deviceInfo.getProjectOid());
-                            if (resultContent.isSuccess()) {
-
-                            } else {
-                                log.error("网关设备权限通知失败 {} {}", gateWayId, resultContent.getMsg());
-                            }
-                            if (!_deviceIds.isEmpty()) {
-                                TimeUnit.SECONDS.sleep(10);
+        executorService.execute(() -> {
+            log.info("设备权限发生变化...");
+            // 通知物联网 设备权限发生变化
+            List<String> deviceIds = event.getDeviceIds();
+            if (ObjectUtils.isNotEmpty(deviceIds)) {
+                List<DeviceInfo> deviceInfos = deviceInfoDao.findByDeviceIdIn(deviceIds);
+                if (ObjectUtils.isNotEmpty(deviceInfos)) {
+                    // 按网关分组
+                    HashMap<String, List<String>> map = new HashMap<>();
+                    deviceInfos.stream().forEach(it -> {
+                        String deviceId = it.getDeviceId();
+                        String gateWayId = it.getGateWayId();
+                        List<String> arr = List.of(gateWayId.split(","));
+                        if (ObjectUtils.isNotEmpty(arr)) {
+                            arr.stream().forEach(_gateWayId -> {
+                                List<String> _list = map.get(_gateWayId);
+                                if (ObjectUtils.isEmpty(_list)) {
+                                    _list = new ArrayList<>();
+                                }
+                                _list.add(deviceId);
+                                map.put(_gateWayId, _list);
+                            });
+                        }
+                    });
+
+                    // 遍历发送
+                    map.keySet().stream().forEach(gateWayId -> {
+                        List<String> _deviceIds = map.get(gateWayId);
+                        try {
+                            while (_deviceIds.size() > 0) {
+                                int index = Math.min(_deviceIds.size(), IotIdentifierConfig.maxNoticeSize);
+                                List<String> subList = _deviceIds.subList(0, index);
+                                _deviceIds = _deviceIds.subList(index, _deviceIds.size());
+
+                                DeviceInfo deviceInfo = deviceInfoDao.findTopByDeviceId(subList.get(0));
+
+                                IotSendParam param = new IotSendParam();
+                                param.setGateWayId(gateWayId);
+                                param.setFunctionType(FunctionType.Server);
+                                param.setIdentifier(IotIdentifierConfig.permissionNotice);
+
+                                // 组装消息内容
+                                JSONObject jsonObject = new JSONObject();
+                                jsonObject.set("deviceIds", subList);
+                                param.setData(jsonObject);
+                                ResultContent resultContent = openApiRequestService.sendIotMessage(
+                                        param, deviceInfo.getProjectOid());
+                                if (resultContent.isSuccess()) {
+
+                                } else {
+                                    log.error("网关设备权限通知失败 {} {}", gateWayId, resultContent.getMsg());
+                                }
+                                if (!_deviceIds.isEmpty()) {
+                                    TimeUnit.SECONDS.sleep(10);
+                                }
                             }
+                        } catch (Exception e) {
+                            throw new RuntimeException(e);
                         }
-                    } catch (Exception e) {
-                        throw new RuntimeException(e);
-                    }
-                });
+                    });
+                }
             }
-        }
+        });
     }
 
-    public UserPermiss toModel(DevicePermiss devicePermiss) {
-        UserPermiss userPermiss = null;
+    public ProjectUserPermiss toModel(DevicePermiss devicePermiss) {
+        ProjectUserPermiss userPermiss = null;
         if (ObjectUtils.isNotEmpty(devicePermiss)) {
-            userPermiss = new UserPermiss();
+            userPermiss = new ProjectUserPermiss();
             String userId = devicePermiss.getUserId();
             String projectOid = devicePermiss.getProjectOid();
             UserAccount account = devicePermiss.getUserAccount();

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/devices/DevicePermissService.java

@@ -1,8 +1,13 @@
 package com.zhongshu.card.server.core.service.devices;
 
 import com.github.microservice.components.data.base.util.PageEntityUtil;
+import com.github.microservice.models.devicePermiss.DeviceAboutPermiss;
+import com.github.microservice.models.devicePermiss.DeviceUsersInfo;
+import com.github.microservice.models.devicePermiss.GateWayPermissModel;
+import com.github.microservice.models.devicePermiss.ProjectUserPermiss;
 import com.github.microservice.net.ResultContent;
 import com.github.microservice.net.ResultMessage;
+import com.google.common.collect.Lists;
 import com.zhongshu.card.client.model.base.IDsParam;
 import com.zhongshu.card.client.model.devices.DevicePermissModel;
 import com.zhongshu.card.client.model.devices.DevicePermissParam;
@@ -19,14 +24,19 @@ import com.zhongshu.card.server.core.domain.devices.DevicePermiss;
 import com.zhongshu.card.server.core.domain.org.Organization;
 import com.zhongshu.card.server.core.domain.org.OrganizationUser;
 import com.zhongshu.card.server.core.domain.org.UserAccount;
+import com.zhongshu.card.server.core.domain.projectAbout.OrgUserFace;
+import com.zhongshu.card.server.core.domain.school.CardInfo;
 import com.zhongshu.card.server.core.event.DevicePermissChangeEvent;
 import com.zhongshu.card.server.core.event.OrgUserBindUpdateSyncEvent;
 import com.zhongshu.card.server.core.service.base.SuperService;
+import com.zhongshu.card.server.core.service.projectAbout.CardInfoServiceImpl;
+import com.zhongshu.card.server.core.service.projectAbout.OrgUserFaceService;
 import com.zhongshu.card.server.core.service.user.UserAccountServiceImpl;
 import com.zhongshu.card.server.core.util.BeanUtils;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.event.EventListener;
@@ -36,7 +46,10 @@ import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * 设备权限 （绑定用户）管理
@@ -69,6 +82,12 @@ public class DevicePermissService extends SuperService {
     @Autowired
     ApplicationContext applicationContext;
 
+    @Autowired
+    private OrgUserFaceService orgUserFaceService;
+
+    @Autowired
+    private CardInfoServiceImpl cardInfoService;
+
     /**
      * 设备绑定用户
      *
@@ -108,9 +127,9 @@ public class DevicePermissService extends SuperService {
                     permisses.add(permiss);
                 }
                 devicePermissDao.saveAll(permisses);
+
                 // 设备权限发生变化
-                DevicePermissChangeEvent event = new DevicePermissChangeEvent(
-                        this, List.of(deviceId));
+                DevicePermissChangeEvent event = new DevicePermissChangeEvent(this, List.of(deviceId));
                 applicationContext.publishEvent(event);
             }
         }
@@ -125,6 +144,7 @@ public class DevicePermissService extends SuperService {
             permiss.setDeviceType(deviceInfo.getDeviceType());
             permiss.setArea(deviceInfo.getArea());
             permiss.setAreaPaths(deviceInfo.getAreaPaths());
+            permiss.setProjectOid(deviceInfo.getProjectOid());
         }
     }
 
@@ -220,6 +240,95 @@ public class DevicePermissService extends SuperService {
         return ResultContent.buildSuccess();
     }
 
+    /**
+     * 得到设备关联的用户
+     *
+     * @param deviceIds
+     * @return
+     */
+    public GateWayPermissModel getDeviceAboutUsers(List<String> deviceIds) {
+        GateWayPermissModel gateWayPermissModel = new GateWayPermissModel();
+        if (ObjectUtils.isNotEmpty(deviceIds)) {
+            List<DevicePermiss> list = devicePermissDao.findByDeviceIdInAndDataState(deviceIds, DataState.Enable);
+            if (ObjectUtils.isNotEmpty(list)) {
+                List<DeviceAboutPermiss> devices = new ArrayList<DeviceAboutPermiss>();
+                // 以设备分组
+                Map<String, List<DevicePermiss>> groupedItems = list.stream().collect(Collectors.groupingBy(DevicePermiss::getDeviceId));
+                groupedItems.forEach((deviceId, itemsInCategory) -> {
+                    DeviceAboutPermiss aboutPermiss = new DeviceAboutPermiss();
+                    aboutPermiss.setDeviceId(deviceId);
+                    List<String> _userIds = itemsInCategory.stream().map(it -> it.getUserId()).collect(Collectors.toUnmodifiableList());
+                    aboutPermiss.setUserIds(_userIds.stream().distinct().collect(Collectors.toUnmodifiableList()));
+                    devices.add(aboutPermiss);
+                });
+                gateWayPermissModel.setDevices(devices);
+            }
+        }
+        return gateWayPermissModel;
+    }
+
+    public DeviceUsersInfo getDeviceAboutUserInfos(List<String> deviceIds) {
+        DeviceUsersInfo deviceUsersInfo = new DeviceUsersInfo();
+        if (ObjectUtils.isNotEmpty(deviceIds)) {
+            List<DevicePermiss> list = devicePermissDao.findByDeviceIdInAndDataState(deviceIds, DataState.Enable);
+            if (ObjectUtils.isNotEmpty(list)) {
+                List<String> _userIds = list.stream().map(it -> it.getUserId()).collect(Collectors.toUnmodifiableList());
+                List<ProjectUserPermiss> userPermiss = getUserPermiss(list.get(0).getProjectOid(), _userIds.stream().distinct().collect(Collectors.toList()));
+                deviceUsersInfo.setUsers(userPermiss);
+            }
+        }
+        return deviceUsersInfo;
+    }
+
+    /**
+     * 组装用户在项目下的权限数据
+     *
+     * @param projectOid
+     * @param userIds
+     * @return
+     */
+    public List<ProjectUserPermiss> getUserPermiss(String projectOid, List<String> userIds) {
+        if (StringUtils.isNotEmpty(projectOid) && ObjectUtils.isNotEmpty(userIds)) {
+            // 用户信息
+            List<UserAccount> userAccounts = userAccountService.getUserAccounts(userIds);
+            Map<String, UserAccount> userMap = userAccounts.stream().collect(Collectors.toMap(it -> it.getUserId(), it -> it, (v1, v2) -> v1));
+
+            // 人脸信息
+            List<OrgUserFace> userFaces = orgUserFaceService.getUserFaces(projectOid, userIds);
+            Map<String, OrgUserFace> faceMap = userFaces.stream().collect(Collectors.toMap(it -> it.getUserId(), it -> it, (v1, v2) -> v1));
+
+            // 用户的卡片信息
+            List<CardInfo> cardInfos = cardInfoService.getProjectCards(projectOid, userIds);
+            Map<String, List<CardInfo>> cardMap = cardInfos.stream().collect(Collectors.groupingBy(CardInfo::getUserId));
+
+            Map<String, ProjectUserPermiss> map = new HashMap<>();
+            for (String userId : userIds) {
+                ProjectUserPermiss permiss = null;
+                if (map.containsKey(userId)) {
+                    permiss = map.get(userId);
+                } else {
+                    permiss = new ProjectUserPermiss();
+                }
+                permiss.setUserId(userId);
+                UserAccount userAccount = userMap.get(userId);
+                if (ObjectUtils.isNotEmpty(userAccount)) {
+                    permiss.setUserName(userAccount.getName());
+                }
+                OrgUserFace orgUserFace = faceMap.get(userId);
+                if (ObjectUtils.isNotEmpty(orgUserFace)) {
+                    permiss.setFaceImage(orgUserFace.getImg());
+                }
+                List<CardInfo> cardInfoList = cardMap.get(userId);
+                if (ObjectUtils.isNotEmpty(cardInfoList)) {
+                    permiss.setCardNos(cardInfoList.stream().map(it -> it.getCode()).collect(Collectors.toList()));
+                }
+                map.put(userId, permiss);
+            }
+            return List.copyOf(map.values());
+        }
+        return Lists.newArrayList();
+    }
+
     public DevicePermissModel toModel(DevicePermiss entity) {
         DevicePermissModel model = null;
         if (ObjectUtils.isNotEmpty(entity)) {

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/projectAbout/CardInfoServiceImpl.java

@@ -8,6 +8,7 @@ import com.github.microservice.components.data.base.util.PageEntityUtil;
 import com.github.microservice.core.util.bean.BeanUtil;
 import com.github.microservice.net.ResultContent;
 import com.github.microservice.net.ResultMessage;
+import com.google.common.collect.Lists;
 import com.zhongshu.card.client.model.base.OidModel;
 import com.zhongshu.card.client.model.org.OidAboutInfo;
 import com.zhongshu.card.client.model.org.OrganizationUserModel;
@@ -684,6 +685,12 @@ public class CardInfoServiceImpl extends SuperService implements CardInfoService
         return ResultContent.buildSuccess();
     }
 
+    /**
+     * 恢复作废
+     *
+     * @param id
+     * @return
+     */
     @Override
     public ResultContent restoreCardCancel(String id) {
         Assert.hasText(id, "id不能为空");
@@ -702,6 +709,13 @@ public class CardInfoServiceImpl extends SuperService implements CardInfoService
         return ResultContent.buildSuccess();
     }
 
+    public List<CardInfo> getProjectCards(String projectOid, List<String> userIds) {
+        if (StringUtils.isNotEmpty(projectOid) && ObjectUtils.isNotEmpty(userIds)) {
+            return cardInfoDao.findByProjectOidAndUserIdInAndCardState(projectOid, userIds, CardState.Enable);
+        }
+        return Lists.newArrayList();
+    }
+
     /**
      * 导入 学校卡片excel
      *

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/projectAbout/OrgUserFaceService.java

@@ -1,6 +1,7 @@
 package com.zhongshu.card.server.core.service.projectAbout;
 
 import com.github.microservice.net.ResultContent;
+import com.google.common.collect.Lists;
 import com.zhongshu.card.client.model.projectAbout.OrgUserFaceModel;
 import com.zhongshu.card.client.model.projectAbout.OrgUserFaceParam;
 import com.zhongshu.card.server.core.dao.projectAbout.OrgUserFaceDao;
@@ -89,6 +90,20 @@ public class OrgUserFaceService extends SuperService {
         return null;
     }
 
+    /**
+     * 得到用户的人脸信息
+     *
+     * @param projectOid
+     * @param userIds
+     * @return
+     */
+    public List<OrgUserFace> getUserFaces(String projectOid, List<String> userIds) {
+        if (ObjectUtils.isNotEmpty(userIds) && StringUtils.isNotEmpty(projectOid)) {
+            return orgUserFaceDao.findByProjectOidAndUserIdIn(projectOid, userIds);
+        }
+        return Lists.newArrayList();
+    }
+
     public OrgUserFaceModel toModel(OrgUserFace entity) {
         OrgUserFaceModel model = null;
         if (ObjectUtils.isNotEmpty(entity)) {

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/user/UserAccountServiceImpl.java

@@ -508,7 +508,7 @@ public class UserAccountServiceImpl extends SuperService implements UserAccountS
      * @return
      */
     public List<UserAccount> getUserAccounts(List<String> userIds) {
-        List<UserAccount> list = new ArrayList<>(userIds.size());
+        List<UserAccount> list = new ArrayList<>();
         if (ObjectUtils.isNotEmpty(userIds)) {
             list = userCountDao.findByUserIdIn(userIds);
         }