merage

kimi

2020-05-27 c007f0ca1785db093d48f4846cda82fe8e955765

 src/main/java/com/highdatas/mdm/service/impl/MasterAuthorServiceImpl.java

@@ -1,5 +1,6 @@
package com.highdatas.mdm.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
@@ -16,6 +17,8 @@
import com.highdatas.mdm.util.Constant;
import com.highdatas.mdm.util.ContentBuilder;
import com.highdatas.mdm.util.DbUtils;
import com.highdatas.mdm.util.RedisClient;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -33,12 +36,11 @@
 * @since 2020-03-23
 */
@Service
@Slf4j
public class MasterAuthorServiceImpl extends ServiceImpl<MasterAuthorMapper, MasterAuthor> implements IMasterAuthorService {
    public static final String characterId = "characterId";
    @Autowired
    IMasterAuthorDetailService authorDetailService;
    @Autowired
    ITUserRoleService userRoleService;
    @Autowired
    ISysMenuService menuService;
    @Autowired
@@ -59,9 +61,26 @@
    MasterDataService masterDataService;
    @Autowired
    TableInfoMapper tableInfoMapper;

    @Autowired
    RedisClient redisClient;
    /**
     *
     * @description:  根据权限获取分页对象
     * @param user 用户
     * @param masterAuthor 权限对象
     * @param maintain 数据版本
     * @return: 获取分页对象
     *
     */
    @Override
    public Page getInitPageInfo(MasterAuthor masterAuthor, Maintain maintain, TUser user, boolean getIncrement) {
        String realRedisKey = RedisClient.getRealRedisKey(user.getUserId() + "-" + maintain.getId() + "-" + getIncrement);
        Object redisValObj = redisClient.getRedisValObj(realRedisKey);
        if (redisValObj != null) {
            JSONObject object = (JSONObject) redisValObj;
            Page page = JSONObject.parseObject(object.toJSONString(), Page.class);
            return page;
        }
        Page page = new Page(0);
        List<TableSchemaResult> tableField = tableInfoMapper.getTableField(masterAuthor.getTableName());

@@ -88,7 +107,9 @@
        }
        page.setRecordCount(Long.valueOf(totalCnt).intValue());
        if (totalCnt == 0) {
            return null;
            page.setRecordCount(0);
            redisClient.putRedisValObj(realRedisKey, page);
            return page;
        }
        int pages;
        if (totalCnt % pageSize == 0) {
@@ -97,9 +118,17 @@
            pages =  (Long.valueOf(totalCnt/pageSize).intValue())  + 1;
        }
        page.setPages(pages);

        redisClient.putRedisValObj(realRedisKey, page);
        return page;
    }

    /**
     *
     * @description:  根据角色id获取混合后的权限
     * @param roleIds 角色id
     * @return: 混合后的权限
     *
     */
    @Override
    public HashMap<String, MasterAuthor> merageRoleAuthor(Set<String> roleIds) {
        List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleIds));
@@ -121,19 +150,50 @@
        }
        return resultMap;
    }

    /**
     *
     * @description:  根据用户获取有权限的主题
     * @param character 用户
     * @return: 主题列表
     *
     */
    @Override
    public List<SysMenu> getMenu(Character character) {
        return getMenu(character, false);
    }

    /**
     *
     * @description:  根据用户获取有权限的主题 不包括父主题
     * @param character 用户
     * @return: 不包括夫主题的主题列表
     *
     */
    @Override
    public List<SysMenu> getMenuUnParent(Character character) {
        return getMenuUnParent(character, false);
    }

    /**
     *
     * @description:  根据用户获取有权限的主题 不包括父主题
     * @param character 用户
     * @param isTableMenu 是否已存在表的主题
     * @return: 不包括夫主题的主题列表
     *
     */
    @Override
    public List<SysMenu> getMenuUnParent(Character character, boolean isTableMenu) {
        String key = DbUtils.StrJoinLink(Constant.UnderLine,character.getId(),"menuUnParent",  String.valueOf(isTableMenu));
        List<Object> redisList = redisClient.getRedisList(key);
        if (redisList != null) {
            List<SysMenu> result = new ArrayList<>();
            for (Object o : redisList) {
                JSONObject object = (JSONObject) o;
                SysMenu menu = JSONObject.parseObject(object.toJSONString(), SysMenu.class);
                result.add(menu);
            }
            return result;
        }
        MasterAuthorType type = character.getType();
        List<MasterAuthor> masterAuthors = null;
        switch (type){
@@ -163,11 +223,32 @@
            menuIds = tempList;
        }
        List<SysMenu> sysMenus = menuService.selectBatchIds(menuIds);
        redisClient.putRedisList(key, (sysMenus));
        return sysMenus;
    }

    /**
     *
     * @description:  根据用户获取有权限的主题
     * @param character 用户
     * @param isTableMenu 是否为已经生成表的主题
     * @return: 主题列表
     *
     */
    @Override
    public List<SysMenu> getMenu(Character character, boolean isTableMenu) {

        String key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(),"menu", String.valueOf(isTableMenu));
        List<Object> redisList = redisClient.getRedisList(key);
        if (redisList != null) {
            List<SysMenu> result = new ArrayList<>();
            for (Object o : redisList) {
                JSONObject object = (JSONObject) o;
                SysMenu menu = JSONObject.parseObject(object.toJSONString(), SysMenu.class);
                result.add(menu);
            }
            return result;
        }

        MasterAuthorType type = character.getType();
        List<MasterAuthor> masterAuthors = null;
        switch (type){
@@ -202,13 +283,41 @@
        if (sysMenus == null) {
            return null;
        }
        redisClient.putRedisList(key, (sysMenus));
        return sysMenus;
    }

    /**
     *
     * @description:  根据用户，字段版本获取权限列表
     * @param characterId 用户id
     * @param maintainField 字段版本
     * @return: 不包括夫主题的主题列表
     *
     */
    @Override
    public List<MasterAuthor> getUserAuthor(String characterId, MaintainField maintainField) {
        return getUserAuthor(characterId, maintainField, null);
    }
    /**
     *
     * @description:  根据用户，字段版本获取权限列表
     * @param characterId 用户id
     * @param maintainField 字段版本
     * @param uuid 日志使用
     * @return: 权限列表
     *
     */
    @Override
    public List<MasterAuthor> getUserAuthor(String characterId, MaintainField maintainField, String uuid) {
        Date startDate = new Date();
        Wrapper<MasterAuthor> userWrapper = new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, characterId);

        int i = selectCount(userWrapper);
        boolean isUser;
        if (i == 0) {
            isUser = false;
        }else {
            isUser = true;
        }
        if (maintainField != null) {
            if (maintainField.getId() != null) {
                userWrapper.eq("maintain_field_id", maintainField.getId());
@@ -218,24 +327,48 @@
            }
        }
        List<MasterAuthor> masterAuthors = selectList(userWrapper);
        if (masterAuthors.isEmpty()) {
        Date endDate = new Date();
        log.info(MessageFormat.format("master tag:{0}  select user author:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));

        if (masterAuthors.isEmpty() && !isUser) {
            //user 获取role
            Set<String> roleIdSet = DbUtils.getRoleByUser(characterId);
            Set<String> roleIdSet = DbUtils.getRoleByUser(characterId, uuid);
            if (roleIdSet.isEmpty()) {
                return new ArrayList<>();
            }else {
                Wrapper<MasterAuthor> roleWrapper = new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleIdSet);
                if (maintainField != null) {
                    roleWrapper.eq("maintain_field_id", maintainField.getId()).eq("table_name",maintainField.getTableName());
                    if (!StringUtils.isEmpty(maintainField.getId())) {
                        roleWrapper.eq("maintain_field_id", maintainField.getId());
                    }
                    if (!StringUtils.isEmpty(maintainField.getTableName())) {
                        roleWrapper.eq("table_name",maintainField.getTableName());
                    }
                }
                masterAuthors = selectList(roleWrapper);
            }

            startDate = new Date();
            log.info(MessageFormat.format("master tag:{0}  select role author by user:{1} ms",uuid, (startDate.getTime() - endDate.getTime())));

        }
        List<MasterAuthor> groupAuthors = getUserGroupAuthor(characterId, null);
        List<MasterAuthor> groupAuthors = getUserGroupAuthor(characterId, null, uuid);


        endDate = new Date();
        log.info(MessageFormat.format("master tag:{0}  merage group author:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));

        masterAuthors.addAll(groupAuthors);
        return masterAuthors;
    }

    /**
     *
     * @description:  根据角色，字段版本获取权限列表
     * @param characterId 角色id
     * @param maintainField 字段版本
     * @return: 权限列表
     *
     */
    private List<MasterAuthor> getRoleAuthors(String characterId, MaintainField maintainField) {
        Wrapper<MasterAuthor> roleWrapper = new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).eq(MasterAuthorController.character_id, characterId);
        if (maintainField != null) {
@@ -251,15 +384,24 @@
        return selectList(roleWrapper);
    }

    private List<MasterAuthor> getUserGroupAuthor(String userId, MaintainField maintainField) {
        Set<String> groupIdList = DbUtils.getGroupByUser(userId);
    /**
     *
     * @description:  根据用户，字段版本获取权限列表
     * @param userId 用户id
     * @param maintainField 字段版本
     * @param uuid 日志使用
     * @return: 权限列表
     *
     */
        private List<MasterAuthor> getUserGroupAuthor(String userId, MaintainField maintainField, String uuid) {
        Set<String> groupIdList = DbUtils.getGroupByUser(userId, uuid);
        List<MasterAuthor> result = new ArrayList<>();
        if (groupIdList == null) {
            return result;
        }

        for (String groupId : groupIdList) {
            List<MasterAuthor> oneGroupAuthors = getOneGroupAuthors(groupId, maintainField);
            List<MasterAuthor> oneGroupAuthors = getOneGroupAuthors(groupId, maintainField, uuid);
            if (oneGroupAuthors == null || oneGroupAuthors.isEmpty()) {
                continue;
            }
@@ -268,12 +410,40 @@

        return result;
    }
    /**
     *
     * @description:  根据用户组，字段版本获取权限列表
     * @param groupId 用户组id
     * @param maintainField 字段版本
     * @return: 权限列表
     *
     */
    @Override
    public List<MasterAuthor> getOneGroupAuthors(String groupId, MaintainField maintainField) {
        Wrapper<MasterAuthor> userWrapper = new EntityWrapper<MasterAuthor>().eq("user_group", true).eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, groupId);
        Wrapper<MasterAuthor> roleWrapper = new EntityWrapper<MasterAuthor>().eq("user_group", true).eq(Constant.TYPE, MasterAuthorType.role).eq(MasterAuthorController.character_id, groupId);

        if (maintainField != null) {
        return getOneGroupAuthors(groupId, maintainField, null);
    }
    /**
     *
     * @description:  根据用户组，字段版本获取权限列表
     * @param groupId 用户组id
     * @param maintainField 字段版本
     * @param uuid 日志使用
     * @return: 权限列表
     *
     */
        @Override
    public List<MasterAuthor> getOneGroupAuthors(String groupId, MaintainField maintainField, String uuid) {
            Date startDate = new Date();
            Wrapper<MasterAuthor> userWrapper = new EntityWrapper<MasterAuthor>().eq("user_group", true).eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, groupId);
            Wrapper<MasterAuthor> roleWrapper = new EntityWrapper<MasterAuthor>().eq("user_group", true).eq(Constant.TYPE, MasterAuthorType.role).eq(MasterAuthorController.character_id, groupId);
            int i = selectCount(userWrapper);
            boolean isUser;
            if (i == 0) {
                isUser = false;
            }else {
                isUser = true;
            }
            if (maintainField != null) {
            if (maintainField.getId() != null) {
                userWrapper.eq("maintain_field_id", maintainField.getId());
                roleWrapper.eq("maintain_field_id", maintainField.getId());
@@ -285,27 +455,69 @@

        }
        List<MasterAuthor> groupAuthors = selectList(userWrapper);
        if (groupAuthors.isEmpty()) {
            Set<String> roleByGroup = DbUtils.getRoleByGroup(groupId);
            Date endDate = new Date();
            log.info(MessageFormat.format("master tag:{0}  select group author:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));

            if (groupAuthors.isEmpty()  && !isUser) {
            Set<String> roleByGroup = DbUtils.getRoleByGroup(groupId, uuid);
            if(roleByGroup.isEmpty()) {
                groupAuthors = new ArrayList<>();
            }else {
                groupAuthors = selectList(roleWrapper);
            }
        }

                startDate = new Date();
                log.info(MessageFormat.format("master tag:{0} select role author by group :{1} ms",uuid, (startDate.getTime() - endDate.getTime())));

            }
        return groupAuthors;
    }

    /**
     *
     * @description:  根据用户，字段版本获取字段列表
     * @param character 用户
     * @param maintainId 数据版本id
     * @return: 字段列表
     *
     */
    @Override
    public List<SysField> getField(Character character, String maintainId) {
        return getField(character, maintainId, null);
    }
    /**
     *
     * @description:  根据用户，字段版本获取字段列表
     * @param character 用户
     * @param maintainId 数据版本id
     * @param uuid 日志使用
     * @return: 字段列表
     *
     */
    @Override
    public List<SysField> getField(Character character, String maintainId, String uuid) {
        String key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(),"field", maintainId);
        List<Object> redisList = redisClient.getRedisList(key);
        if (redisList != null) {
            List<SysField> result = new ArrayList<>();
            for (Object o : redisList) {
                JSONObject object = (JSONObject) o;
                SysField sysField = JSONObject.parseObject(object.toJSONString(), SysField.class);
                result.add(sysField);
            }
            return result;
        }
        Maintain maintain = maintainService.selectById(maintainId);
        if (maintain == null){
            return new ArrayList<>();
        }
        Date startDate = new Date();
        boolean isAll = checkUnFilterAuthor(character, maintain.getTableName(), uuid);
        Date endDate = new Date();
        log.info(MessageFormat.format("master tag:{0} field check isAll:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));

        boolean isAll = checkUnFilterAuthor(character, maintain.getTableName());
        if (isAll) {
            List<SysField> total = fieldService.getFieldByMaintain(maintainId);
            redisClient.putRedisList(key, (total));
            return total;
        }

@@ -322,11 +534,14 @@
                masterAuthors = getRoleAuthors(character.getId(), maintainField);
                break;
            case groupInfo:
                masterAuthors = getOneGroupAuthors(character.getId(), maintainField);
                masterAuthors = getOneGroupAuthors(character.getId(), maintainField, uuid);
                break;
            case user:
                masterAuthors = getUserAuthor(character.getId(), maintainField);
                masterAuthors = getUserAuthor(character.getId(), maintainField, uuid);
        }
        startDate = new Date();
        log.info(MessageFormat.format("master tag:{0} field get author:{1} ms",uuid, (startDate.getTime() - endDate.getTime())));

        if (masterAuthors == null || masterAuthors.isEmpty()) {
            return null;
        }
@@ -335,7 +550,7 @@
        List<MasterAuthorDetail> masterAuthorDetails = authorDetailService.selectList(new EntityWrapper<MasterAuthorDetail>().in(Constant.PARENT_ID, authorIds));
        Set<String> codes = masterAuthorDetails.stream().map(masterAuthorDetail -> masterAuthorDetail.getField()).collect(Collectors.toSet());
        if (codes.isEmpty()) {
            return null;
            return new ArrayList<>();
        }
        Wrapper<SysField> wrapper = new EntityWrapper<SysField>().in(Constant.FIELD, codes).eq("table_name", maintain.getTableName());

@@ -347,10 +562,27 @@
        wrapper.orderBy("order_no");

        List<SysField> fieldList = fieldService.selectList(wrapper);
        endDate = new Date();
        log.info(MessageFormat.format("master tag:{0} field get field:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));

        redisClient.putRedisList(key, ((fieldList)));
        return fieldList;
    }

    private boolean checkUnFilterAuthor(Character character, String tableName) {
    /**
     *
     * @description:  检测是否需要筛选数据
     * @param character 用户
     * @param tableName 表名
     * @param uuid 日志使用
     * @return: 是否需要筛选数据
     *
     */
    private boolean checkUnFilterAuthor(Character character, String tableName, String uuid) {
        String key = DbUtils.StrJoinLink(Constant.UnderLine,  character.getId(),"checkUnFilterAuthor", tableName);
        String redisVal = redisClient.getRedisVal(key);
        if (!StringUtils.isEmpty(redisVal)) {
            return Boolean.valueOf(redisVal);
        }
        MasterAuthorType type = character.getType();
        List<MasterAuthor> masterAuthors = null;
        MaintainField maintainField = new MaintainField().setTableName(tableName);
@@ -359,31 +591,51 @@
                masterAuthors = getRoleAuthors(character.getId(), maintainField);
                break;
            case groupInfo:
                masterAuthors = getOneGroupAuthors(character.getId(), maintainField);
                masterAuthors = getOneGroupAuthors(character.getId(), maintainField, uuid);
                break;
            case user:
                masterAuthors = getUserAuthor(character.getId(), maintainField);
                masterAuthors = getUserAuthor(character.getId(), maintainField, uuid);
        }
        if (masterAuthors.isEmpty()) {
            return false;
        }
        long isAll = masterAuthors.stream().filter(masterAuthor -> masterAuthor.getMaintainFieldId().equalsIgnoreCase(Constant.All)).count();
        long isAll = masterAuthors.stream()
                .filter(masterAuthor -> !StringUtils.isEmpty(masterAuthor.getMaintainFieldId()))
                .filter(masterAuthor -> masterAuthor.getMaintainFieldId().equalsIgnoreCase(Constant.All)).count();
        if (isAll > 0) {
            redisClient.putRedisVal(key, "true");
            return true;
        }else {
            redisClient.putRedisVal(key, "false");
            return false;
        }

    }

    /**
     *
     * @description:  检验用户是否拥有数据版本的权限
     * @param character 用户
     * @param maintainId 数据版本id
     * @return: 是否有权限
     *
     */
    @Override
    public boolean checkMaintainAuthor(Character character, String maintainId) {
        return checkMaintainAuthor(character, maintainId, null);
    }
    @Override
    public boolean checkMaintainAuthor(Character character, String maintainId, String uuid) {
        String key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(), "checkMaintainAuthor",  maintainId);
        String redisVal = redisClient.getRedisVal(key);
        if (!StringUtils.isEmpty(redisVal)) {
            return Boolean.valueOf(redisVal);
        }
        Maintain maintain = maintainService.selectById(maintainId);
        if (maintain == null) {
            return false;
        }
        int checked = 0;
        boolean isAll = checkUnFilterAuthor(character, maintain.getTableName());
        boolean isAll = checkUnFilterAuthor(character, maintain.getTableName(), uuid);
        if (isAll){
            return true;
        }
@@ -398,26 +650,60 @@
                masterAuthors = getRoleAuthors(character.getId(), maintainField);
                break;
            case groupInfo:
                masterAuthors = getOneGroupAuthors(character.getId(), maintainField);
                masterAuthors = getOneGroupAuthors(character.getId(), maintainField, uuid);
                break;
            case user:
                masterAuthors = getUserAuthor(character.getId(), maintainField);
                masterAuthors = getUserAuthor(character.getId(), maintainField, uuid);
        }
        if (masterAuthors.isEmpty()) {
            redisClient.putRedisVal(key, "false");
            return false;
        }else {
            redisClient.putRedisVal(key, "true");
            return true;
        }
    }

    /**
     *
     * @description:  根据用户，字段版本获取筛选条件
     * @param character 用户
     * @param maintainId 数据版本id
     * @return: 筛选条件
     *
     */
    @Override
    public String getFilter(Character character, String maintainId) {

        return getFilter(character, maintainId, null);
    }
    /**
     *
     * @description:  根据用户，字段版本获取筛选条件
     * @param character 用户
     * @param maintainId 数据版本id
     * @param uuid 日志使用
     * @return: 筛选条件
     *
     */
    @Override
    public String getFilter(Character character, String maintainId, String uuid) {
        String key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(),"filter",maintainId);
        String redisVal = redisClient.getRedisVal(key);
        if (!StringUtils.isEmpty(redisVal)) {
            return redisVal;
        }
        Maintain maintain = maintainService.selectById(maintainId);
        if (maintain == null){
            return Constant.WHERE_DEFAULTUN;
        }
        boolean isAll = checkUnFilterAuthor(character, maintain.getTableName());
        Date startDate = new Date();

        boolean isAll = checkUnFilterAuthor(character, maintain.getTableName(), uuid);
        Date endDate = new Date();
        log.info(MessageFormat.format("master tag:{0} filter check isAll:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));

        if (isAll) {
            redisClient.putRedisVal(key, Constant.WHERE_DEFAULT);
            return Constant.WHERE_DEFAULT;
        }
        MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
@@ -428,18 +714,23 @@
                masterAuthors = getRoleAuthors(character.getId(), maintainField);
                break;
            case groupInfo:
                masterAuthors = getOneGroupAuthors(character.getId(), maintainField);
                masterAuthors = getOneGroupAuthors(character.getId(), maintainField, uuid);
                break;
            case user:
                masterAuthors = getUserAuthor(character.getId(), maintainField);
                masterAuthors = getUserAuthor(character.getId(), maintainField, uuid);
        }
        startDate = new Date();
        log.info(MessageFormat.format("master tag:{0} filter get author:{1} ms",uuid, (startDate.getTime() - endDate.getTime())));

        if (masterAuthors.isEmpty()) {
            redisClient.putRedisVal(key, Constant.WHERE_DEFAULTUN);
            return Constant.WHERE_DEFAULTUN;
        }

        List<String> authorIds = masterAuthors.stream().map(masterAuthor -> masterAuthor.getId()).collect(Collectors.toList());
        List<MasterAuthorDetail> masterAuthorDetails = authorDetailService.selectList(new EntityWrapper<MasterAuthorDetail>().in(Constant.PARENT_ID, authorIds));
        if (masterAuthorDetails.isEmpty()) {
            redisClient.putRedisVal(key, Constant.WHERE_DEFAULTUN);
            return Constant.WHERE_DEFAULTUN;
        }
        HashMap<String, List<String>> segmentMap = new HashMap<>();
@@ -475,12 +766,25 @@
            builder.append(format);
        }
        String filter = builder.toString();
        endDate = new Date();
        log.info(MessageFormat.format("master tag:{0} filter merage filter:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));

        if (StringUtils.isEmpty(filter)) {
            redisClient.putRedisVal(key, Constant.WHERE_DEFAULT);
            return Constant.WHERE_DEFAULT;
        }

        redisClient.putRedisVal(key, filter);
        return filter;
    }

    /**
     *
     * @description:  根据用户获取最大权限的数据版本
     * @param character 用户
     * @param tableName 表名
     * @return: 最大权限的数据版本
     *
     */
    @Override
    public Maintain getMaxVersionMaintain(Character character, String tableName) {
        List<Maintain> maintainList = maintainService.selectList(new EntityWrapper<Maintain>().eq("table_name", tableName).orderBy("order_no desc"));
@@ -496,7 +800,14 @@
        }
        return null;
    }

    /**
     *
     * @description:  根据用户，字段版本获取数据版本列表
     * @param user 用户
     * @param tableName 数据版本id
     * @return: 数据版本列表
     *
     */
    @Override
    public LinkedHashSet<Maintain> getMaintainSet(String tableName, TUser user) {
        List<MasterAuthor> userAuthor = this.getUserAuthor(user.getUserId(), null);
@@ -510,11 +821,21 @@
                continue;
            }
            List<Maintain> maintainByMaintainField = maintainFieldService.getMaintainByMaintainField(maintainFieldId, tableName);
            maintainSet.addAll(maintainByMaintainField);
            if (maintainByMaintainField != null) {
                maintainSet.addAll(maintainByMaintainField);
            }

        }
        return maintainSet;
    }

    /**
     *
     * @description:  生成版本的需要检测哪些需要自动加上权限
     * @param status 流程状态
     * @param maintainId 数据版本id
     * @return:
     *
     */
    public void dealFlow(String maintainId, ActivitiStatus status) {
        Maintain maintain = maintainService.selectById(maintainId);
        MaintainField maintainFieldByMaintain = fieldService.getMaintainFieldByMaintain(maintainId);
@@ -530,7 +851,14 @@
        }
    }


    /**
     *
     * @description:  两个权限混合
     * @param preMerageMasterAuthor 混合前
     * @param masterAuthor 待混合
     * @return: 混合后的权限
     *
     */
    private MasterAuthor merage(MasterAuthor preMerageMasterAuthor, MasterAuthor masterAuthor) {
        // table name  masterField 一样 只有字段不同了
        List<MasterAuthorDetail> preFields = preMerageMasterAuthor.getFields();