jnpf-java-boot-v6x/jnpf-permission/jnpf-permission-biz/target/classes/jnpf/permission/service/impl/UserRelationServiceImpl.java

package jnpf.permission.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.dynamic.datasource.annotation.DSTransactional;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.google.common.collect.Lists;
import jnpf.base.UserInfo;
import jnpf.base.entity.SuperBaseEntity;
import jnpf.base.service.SuperServiceImpl;
import jnpf.constant.MsgCode;
import jnpf.constant.PermissionConst;
import jnpf.message.entity.SynThirdInfoEntity;
import jnpf.message.service.SynThirdInfoService;
import jnpf.message.util.SynThirdConsts;
import jnpf.permission.entity.OrganizeEntity;
import jnpf.permission.entity.PositionEntity;
import jnpf.permission.entity.UserEntity;
import jnpf.permission.entity.UserRelationEntity;
import jnpf.permission.mapper.UserRelationMapper;
import jnpf.permission.model.position.PosistionCurrentModel;
import jnpf.permission.model.user.page.UserPagination;
import jnpf.permission.model.user.vo.UserListVO;
import jnpf.permission.model.userrelation.UserRelationForm;
import jnpf.permission.service.*;
import jnpf.util.RandomUtil;
import jnpf.util.StringUtil;
import jnpf.util.UserProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 用户关系
 *
 * @author JNPF开发平台组
 * @version V3.1.0
 * @copyright 引迈信息技术有限公司
 * @date 2019年9月26日 上午9:18
 */
@Service
public class UserRelationServiceImpl extends SuperServiceImpl<UserRelationMapper, UserRelationEntity> implements UserRelationService {

    @Autowired
    private UserService userService;
    @Autowired
    private PositionService positionService;
    @Autowired
    private OrganizeService organizeService;
    @Autowired
    private RoleRelationService roleRelationService;
    @Autowired
    private UserRelationService userRelationService;
    @Autowired
    private SynThirdInfoService synThirdInfoService;

    @Override
    public List<UserListVO> getListPage(UserPagination pagination) {
        String objectType = StringUtil.isNotEmpty(pagination.getPositionId()) ? PermissionConst.POSITION : PermissionConst.ORGANIZE;
        String objectId = StringUtil.isNotEmpty(pagination.getPositionId()) ? pagination.getPositionId() : pagination.getOrganizeId();
        //是否显示子孙组织用户
        List<String> orgIds = new ArrayList<>();
        if (Objects.equals(pagination.getShowSubOrganize(), 1)) {
            List<OrganizeEntity> allChild = organizeService.getAllChild(pagination.getOrganizeId());
            orgIds.addAll(allChild.stream().map(OrganizeEntity::getId).collect(Collectors.toList()));
        }

        MPJLambdaWrapper<UserRelationEntity> queryWrapper = JoinWrappers.lambda(UserRelationEntity.class);
        queryWrapper.selectAs(UserEntity::getId, UserListVO::getId);
        queryWrapper.selectAs(UserEntity::getAccount, UserListVO::getAccount);
        queryWrapper.selectAs(UserEntity::getRealName, UserListVO::getRealName);
        queryWrapper.selectAs(UserEntity::getGender, UserListVO::getGender);
        queryWrapper.selectAs(UserEntity::getMobilePhone, UserListVO::getMobilePhone);
        queryWrapper.selectAs(UserEntity::getEnabledMark, UserListVO::getEnabledMark);
        queryWrapper.selectAs(UserEntity::getUnlockTime, UserListVO::getUnlockTime);
        queryWrapper.selectMax(UserRelationEntity::getId, UserListVO::getMaxRelationId);

        queryWrapper.leftJoin(UserEntity.class, UserEntity::getId, UserRelationEntity::getUserId);
        if (!StringUtil.isEmpty(pagination.getKeyword())) {
            queryWrapper.and(
                    t -> t.like(UserEntity::getAccount, pagination.getKeyword())
                            .or().like(UserEntity::getRealName, pagination.getKeyword())
                            .or().like(UserEntity::getMobilePhone, pagination.getKeyword())
            );
        }
        if (pagination.getEnabledMark() != null) {
            queryWrapper.eq(UserEntity::getEnabledMark, pagination.getEnabledMark());
        }

        if (orgIds.size() > 0) {
            queryWrapper.in(UserRelationEntity::getObjectId, orgIds);
        } else {
            queryWrapper.eq(UserRelationEntity::getObjectId, objectId);
        }

        queryWrapper.eq(UserRelationEntity::getObjectType, objectType);

        queryWrapper.orderByDesc("maxRelationId");

        queryWrapper.groupBy(UserEntity::getId, UserEntity::getAccount, UserEntity::getRealName, UserEntity::getGender, UserEntity::getMobilePhone,
                UserEntity::getEnabledMark, UserEntity::getUnlockTime);
        Page<UserListVO> page = new Page<>(pagination.getCurrentPage(), pagination.getPageSize());
        IPage<UserListVO> data = this.selectJoinListPage(page, UserListVO.class, queryWrapper);
        return pagination.setData(data.getRecords(), page.getTotal());
    }

    @Override
    public List<UserRelationEntity> getListByUserId(String userId) {
        return getListByUserIdAll(Collections.singletonList(userId));
    }

    @Override
    public List<UserRelationEntity> getListByUserIdAndObjType(String userId, String objectType) {
        QueryWrapper<UserRelationEntity> query = new QueryWrapper<>();
        query.lambda().in(UserRelationEntity::getUserId, userId);
        query.lambda().in(UserRelationEntity::getObjectType, objectType);
        query.lambda().orderByAsc(UserRelationEntity::getSortCode).orderByDesc(UserRelationEntity::getCreatorTime);
        return this.list(query);
    }

    @Override
    public List<UserRelationEntity> getListByUserIdAll(List<String> userId) {
        if (userId.size() > 0) {
            QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().in(UserRelationEntity::getUserId, userId);
            return this.list(queryWrapper);
        }
        return new ArrayList<>();
    }

    @Override
    public List<UserRelationEntity> getListByObjectId(String objectId) {
        return getListByObjectId(objectId, null);
    }

    @Override
    public List<UserRelationEntity> getListByObjectType(String objectType) {
        QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(UserRelationEntity::getObjectType, objectType);
        return this.list(queryWrapper);
    }

    @Override
    public List<UserRelationEntity> getListByObjectId(String objectId, String objectType) {
        QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(UserRelationEntity::getObjectId, objectId);
        if (objectType != null) {
            queryWrapper.lambda().eq(UserRelationEntity::getObjectType, objectType);
        }
        queryWrapper.lambda().orderByAsc(UserRelationEntity::getSortCode).orderByDesc(UserRelationEntity::getCreatorTime);
        return this.list(queryWrapper);
    }

    @Override
    public List<UserRelationEntity> getListByObjectIdAll(List<String> objectId) {
        List<UserRelationEntity> list = new ArrayList<>();
        if (objectId.size() > 0) {
            QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().in(UserRelationEntity::getObjectId, objectId);
            list = this.list(queryWrapper);
        }
        return list;
    }

    @Override
    public void deleteAllByObjId(String objId) {
        QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(UserRelationEntity::getObjectId, objId);
        this.remove(queryWrapper);
    }

    @Override
    public void deleteAllByUserId(String userId) {
        QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(UserRelationEntity::getUserId, userId);
        queryWrapper.lambda().ne(UserRelationEntity::getObjectType, PermissionConst.GROUP);
        userRelationService.remove(queryWrapper);
    }

    @Override
    public void createByList(List<UserRelationEntity> userRelationEntityList) {
        userRelationEntityList.forEach(t -> {
            this.save(t);
        });
    }

    @Override
    public UserRelationEntity getInfo(String id) {
        QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(UserRelationEntity::getId, id);
        return this.getOne(queryWrapper);
    }

    @Override
    @DSTransactional
    public void save(String objectId, List<UserRelationEntity> entitys) {
        List<UserRelationEntity> existList = this.getListByObjectId(objectId);
        List<UserRelationEntity> relationList = new ArrayList<>();
        for (int i = 0; i < entitys.size(); i++) {
            UserRelationEntity entity = entitys.get(i);
            entity.setId(RandomUtil.uuId());
            entity.setSortCode(Long.parseLong(i + ""));
            entity.setCreatorUserId(UserProvider.getUser().getUserId());
            if (existList.stream().filter(t -> t.getUserId().equals(entity.getUserId())).count() == 0) {
                relationList.add(entity);
            }
        }
        for (UserRelationEntity entity : relationList) {
            this.save(entity);
        }
    }

    @Override
    public void save(List<UserRelationEntity> list) {
        for (UserRelationEntity entity : list) {
            this.save(entity);
        }
    }

    @Override
    @DSTransactional
    public void delete(UserRelationForm form) {
        List<String> userIds = form.getUserIds();
        String type = form.getObjectType();
        if (CollectionUtil.isEmpty(userIds)) {
            return;
        }
        QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(UserRelationEntity::getObjectId, form.getObjectId());
        queryWrapper.lambda().eq(UserRelationEntity::getObjectType, type);
        queryWrapper.lambda().in(UserRelationEntity::getUserId, userIds);
        List<UserRelationEntity> list = this.list(queryWrapper);
        if (CollectionUtil.isEmpty(list)) {
            return;
        }

        if (PermissionConst.POSITION.equals(type)) {
            PositionEntity info = positionService.getInfo(form.getObjectId());
            //如果责任人被移除则清空责任人
            if (StringUtil.isNotEmpty(info.getDutyUser()) && userIds.contains(info.getDutyUser())) {
                info.setDutyUser(null);
                positionService.updateById(info);
            }
            //岗位时顺便移除组织关系
            for (String userId : userIds) {
                queryWrapper = new QueryWrapper<>();
                queryWrapper.lambda().eq(UserRelationEntity::getObjectId, info.getOrganizeId());
                queryWrapper.lambda().eq(UserRelationEntity::getObjectType, PermissionConst.ORGANIZE);
                queryWrapper.lambda().in(UserRelationEntity::getUserId, userId);
                List<UserRelationEntity> orgList = this.list(queryWrapper);
                if (CollectionUtil.isNotEmpty(orgList)) {
                    list.add(orgList.get(0));
                }
            }
        }
        for (UserRelationEntity item : list) {
            this.removeById(item);
        }

        if (PermissionConst.POSITION.equals(type)) {
            userService.delCurUser(MsgCode.PS010.get(), form.getUserIds());
        }
    }


    @Override
    @DSTransactional
    public void saveObjectId(String objectId, UserRelationForm userRelationForm) {
        UserInfo userInfo = UserProvider.getUser();
        //调整岗位（直接替换用户全部岗位绑定信息）
        if (Objects.equals(userRelationForm.getActionType(), 1)) {
            List<UserRelationEntity> listByUserIdAll = userRelationService.getListByUserIdAll(userRelationForm.getUserIds());
            //用户列表绑定的关系数据
            List<UserRelationEntity> collect = listByUserIdAll.stream().filter(t -> Objects.equals(t.getObjectType(), userRelationForm.getObjectType())).collect(Collectors.toList());
            //替换：：直接移除原有数据添加新的数据
            removeBatchByIds(collect);
            List<UserRelationEntity> list = new ArrayList<>();
            for (String userId : userRelationForm.getUserIds()) {
                UserRelationEntity entity = new UserRelationEntity();
                entity.setId(RandomUtil.uuId());
                entity.setObjectId(objectId);
                entity.setObjectType(userRelationForm.getObjectType());
                entity.setCreatorUserId(userInfo.getUserId());
                entity.setUserId(userId);
                list.add(entity);
            }
            save(list);
            return;
        }

        // 修改前的岗位绑定人员ID
        List<UserRelationEntity> listByObjectId = userRelationService.getListByObjectId(objectId, userRelationForm.getObjectType());
        List<String> beforeUserIds = listByObjectId.stream().map(UserRelationEntity::getUserId).collect(Collectors.toList());
        // 调整前后，岗位全部用户
        List<String> allUser = new ArrayList<>(userRelationForm.getUserIds());
        allUser.addAll(beforeUserIds);
        userRelationForm.setUserIds(userService.getUserList(allUser).stream().map(UserEntity::getId).collect(Collectors.toList()));

        //清除原有成员数据
        deleteAllByObjId(objectId);
        List<UserRelationEntity> list = new ArrayList<>();
        int i = 0;
        for (String userId : userRelationForm.getUserIds()) {
            UserRelationEntity entity = new UserRelationEntity();
            entity.setId(RandomUtil.uuId());
            entity.setSortCode(Long.parseLong(i + ""));
            entity.setObjectId(objectId);
            entity.setObjectType(userRelationForm.getObjectType());
            entity.setCreatorUserId(userInfo.getUserId());
            entity.setUserId(userId);
            list.add(entity);
            i++;
        }
        save(objectId, list);

        // 移除数据库不在最终用户列表里的人
        List<String> allUpdateIds = beforeUserIds.stream().filter(b -> !userRelationForm.getUserIds()
                .contains(b)).collect(Collectors.toList());

        userService.delCurUser(MsgCode.PS010.get(), allUpdateIds);
    }

    @Override
    public List<UserRelationEntity> getRelationByUserIds(List<String> userIds) {
        if (userIds.size() == 0) {
            return new ArrayList<>();
        }
        QueryWrapper<UserRelationEntity> query = new QueryWrapper<>();
        query.lambda().in(UserRelationEntity::getUserId, userIds);
        return this.list(query);
    }

    @Override
    public List<UserRelationEntity> getListByObjectType(String userId, String objectType) {
        QueryWrapper<UserRelationEntity> query = new QueryWrapper<>();
        query.lambda().eq(UserRelationEntity::getUserId, userId);
        if (StringUtil.isNotEmpty(objectType)) {
            query.lambda().eq(UserRelationEntity::getObjectType, objectType);
        }
        query.lambda().orderByAsc(UserRelationEntity::getSortCode).orderByDesc(UserRelationEntity::getCreatorTime);
        return this.list(query);
    }

    @Override
    public List<UserRelationEntity> getAllOrgRelationByUserId(String userId) {
        return this.getListByObjectType(userId, PermissionConst.ORGANIZE);
    }

    @Override
    public List<PosistionCurrentModel> getObjectVoList() {
        UserInfo user = UserProvider.getUser();
        String userId = user.getUserId();
        String majorPosId = user.getPositionId();
        // 岗位遵循一对多关系
        List<PositionEntity> positionList = positionService.getListByUserId(userId);
        if (positionList.size() > 0) {
            List<PosistionCurrentModel> voList = new ArrayList<>();
            for (PositionEntity p : positionList) {
                PosistionCurrentModel model = new PosistionCurrentModel();
                OrganizeEntity orgInfo = organizeService.getInfo(p.getOrganizeId());
                model.setId(p.getId());
                model.setPositionId(p.getId());
                model.setFullName(p.getFullName());
                model.setOrganizeId(orgInfo.getId());
                model.setOrgTreeName(orgInfo.getOrgNameTree());

                //上级岗位
                if (StringUtil.isNotEmpty(p.getParentId())) {
                    PositionEntity pPosition = positionService.getInfo(p.getParentId());
                    if (pPosition != null) {
                        model.setParentId(pPosition.getId());
                        model.setParentName(pPosition.getFullName());
                        UserEntity dutyUser = userService.getInfo(pPosition.getDutyUser());
                        if (dutyUser != null) {
                            model.setManagerId(dutyUser.getId());
                            model.setManagerName(dutyUser.getRealName());
                        }
                    }
                } else {
                    //没有上级岗位的时候--岗位为空，上级责任人去组织上级责任岗位的责任人
                    OrganizeEntity pOrgInfo = organizeService.getInfo(orgInfo.getParentId());
                    if (pOrgInfo != null) {
                        PositionEntity dutyPos = positionService.getInfo(pOrgInfo.getDutyPosition());
                        if (dutyPos != null) {
                            UserEntity dutyUser = userService.getInfo(dutyPos.getDutyUser());
                            if (dutyUser != null) {
                                model.setManagerId(dutyUser.getId());
                                model.setManagerName(dutyUser.getRealName());
                            }
                        }
                    }
                }
                model.setManagerId(p.getId());

                if (p.getId().equals(majorPosId)) {
                    model.setIsDefault(true);
                } else {
                    model.setIsDefault(false);
                }
                voList.add(model);
            }
            return voList;
        }
        return Collections.EMPTY_LIST;
    }

    @Override
    public Boolean existByObj(String objectType, String objectId) {
        return existByObj(objectType, Arrays.asList(objectId));
    }

    @Override
    public Boolean existByObj(String objectType, List<String> objectId) {
        if (CollectionUtil.isEmpty(objectId)) return false;
        QueryWrapper<UserRelationEntity> query = new QueryWrapper<>();
        query.lambda()
                .eq(UserRelationEntity::getObjectType, objectType)
                .in(UserRelationEntity::getObjectId, objectId);
        return this.count(query) > 0;
    }

    @Override
    public List<UserRelationEntity> getListByRoleId(String roleId) {
        List<UserRelationEntity> list = new ArrayList<>();
        roleRelationService.getListByRoleId(roleId, PermissionConst.ORGANIZE).forEach(o -> {
            QueryWrapper<UserRelationEntity> query = new QueryWrapper<>();
            query.lambda()
                    .eq(UserRelationEntity::getObjectType, PermissionConst.ORGANIZE)
                    .eq(UserRelationEntity::getObjectId, o.getObjectId());
            list.addAll(this.list(query));
        });
        return list;
    }

    @Override
    public List<UserRelationEntity> getListByUserId(String userId, String objectType) {
        QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(UserRelationEntity::getUserId, userId);
        queryWrapper.lambda().eq(UserRelationEntity::getObjectType, objectType);
        return this.list(queryWrapper);
    }

    @Override
    public List<UserRelationEntity> getListByOrgId(List<String> orgIdList) {
        if (CollectionUtil.isNotEmpty(orgIdList)) {
            QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().eq(UserRelationEntity::getObjectType, PermissionConst.ORGANIZE);
            List<List<String>> lists = Lists.partition(orgIdList, 1000);
            queryWrapper.lambda().and(t->{
                for (List<String> ids : lists) {
                    t.or().in(UserRelationEntity::getObjectId, ids);
                }
            });
            return this.list(queryWrapper);
        }
        return new ArrayList<>();
    }

    @Override
    public void syncDingUserRelation(String sysObjId, List<Long> deptIdList, String thirdType) {
        // 查询对应的中间表，获取到对应的本地组织id
        QueryWrapper<SynThirdInfoEntity> wrapper = new QueryWrapper<>();
        wrapper.lambda().in(SynThirdInfoEntity::getThirdObjId, deptIdList);
        wrapper.lambda().eq(SynThirdInfoEntity::getThirdType, thirdType);
        wrapper.lambda().eq(SynThirdInfoEntity::getDataType, Integer.valueOf(SynThirdConsts.DATA_TYPE_ORG));
        List<SynThirdInfoEntity> synThirdInfoLists = synThirdInfoService.getBaseMapper().selectList(wrapper);
        HashMap<String, String> map = new HashMap<>();
        for (SynThirdInfoEntity obj : synThirdInfoLists) {
            map.put(obj.getThirdObjId(), obj.getSysObjId());
        }
        // 已经存在的数据
        List<String> collect = synThirdInfoLists.stream().map(SynThirdInfoEntity::getSysObjId).collect(Collectors.toList());
        QueryWrapper<UserRelationEntity> relationWrapper = new QueryWrapper<>();
        if (CollectionUtil.isNotEmpty(collect)) {
            relationWrapper.lambda().in(UserRelationEntity::getObjectId, collect);
        }
        relationWrapper.lambda().eq(UserRelationEntity::getObjectType, PermissionConst.ORGANIZE);
        relationWrapper.lambda().eq(UserRelationEntity::getUserId, sysObjId);
        List<UserRelationEntity> userRelationEntities = this.getBaseMapper().selectList(relationWrapper);
        ArrayList<UserRelationEntity> entities = new ArrayList<>();
        List<UserRelationEntity> relationEntities = userRelationEntities.stream()
                .filter(t -> collect.contains(t.getObjectId()))
                .collect(Collectors.toList());
        List<PositionEntity> positionEntities = positionService.getList(true);
        if (CollectionUtil.isEmpty(relationEntities)) {
            for (String string : collect) {
                UserRelationEntity userRelationEntity = new UserRelationEntity();

                userRelationEntity.setObjectType(PermissionConst.ORGANIZE);
                userRelationEntity.setUserId(sysObjId);
                userRelationEntity.setObjectId(string);

                List<PositionEntity> positionEntityList = positionEntities.stream()
                        .filter(t -> t.getOrganizeId().equals(string)
                                && t.getDefaultMark().equals(1)).collect(Collectors.toList());
                if (CollectionUtil.isNotEmpty(positionEntityList)) {
                    UserRelationEntity positionUserRelation = new UserRelationEntity();
                    positionUserRelation.setObjectType(PermissionConst.POSITION);
                    positionUserRelation.setObjectId(positionEntityList.get(0).getId());
                    positionUserRelation.setUserId(sysObjId);
                    entities.add(positionUserRelation);
                }

                entities.add(userRelationEntity);
            }
        }
        userRelationService.saveBatch(entities);

//        UserEntity adminAccount = userService.getUserByAccount(ADMIN_KEY);
//        String adminId = adminAccount == null ? null : adminAccount.getId();
//        for (Long id : deptIdList) {
//            String objectId = String.valueOf(id);
//            entity = new UserRelationEntity();
//            entity.setId(RandomUtil.uuId());
//            entity.setObjectId(map.get(objectId));
//            entity.setCreatorUserId(adminId);
//            entity.setSortCode(0L);
//            entity.setUserId(sysObjId);
//            entity.setObjectType("Organize");
//            list.add(entity);
//        }
//        this.saveBatch(list);
    }

    @Override
    public List<UserEntity> getUserProgeny(List<String> idList, String enableMark) {
        //查询用户子孙下级。不包含当前岗位的用户
        if (CollectionUtil.isEmpty(idList)) return new ArrayList<>();
        QueryWrapper<PositionEntity> query = new QueryWrapper<>();
        query.lambda()
                .eq(enableMark != null, PositionEntity::getEnabledMark, enableMark)
                .and(t -> idList.forEach(id -> t.like(PositionEntity::getPositionIdTree, id).or()))
                .notIn(PositionEntity::getId, idList)
                .orderByAsc(PositionEntity::getSortCode, PositionEntity::getCreatorTime);
        List<PositionEntity> list = positionService.list(query).stream().distinct().collect(Collectors.toList());
        return getUserEntities(list);


    }

    @Override
    public List<UserEntity> getUserAndSub(List<String> idList, String enableMark) {
        if (CollectionUtil.isEmpty(idList)) return new ArrayList<>();
        List<PositionEntity> byParentIds = positionService.getListByParentIds(idList);
        return getUserEntities(byParentIds);
    }

    private List<UserEntity> getUserEntities(List<PositionEntity> byParentIds) {
        if (CollectionUtil.isEmpty(byParentIds)) return new ArrayList<>();
        List<UserRelationEntity> listByObjectIdAll = this.getListByObjectIdAll(byParentIds.stream()
                .map(SuperBaseEntity.SuperIBaseEntity::getId).collect(Collectors.toList()));
        return userService.getUserList(listByObjectIdAll.stream()
                .map(UserRelationEntity::getUserId).collect(Collectors.toList()));
    }

}