no message

kimi42345

2020-03-29 57c62dd3e7d398e253c2db549b819d020040b1a5

no message

 src/main/java/com/highdatas/mdm/controller/MaintainController.java

@@ -15,6 +15,7 @@
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.service.*;
import com.highdatas.mdm.util.Constant;
import com.highdatas.mdm.util.DbUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@@ -63,19 +64,20 @@
    public Result unSubmit(@PathVariable String tableName, @PathVariable Integer pageNo, HttpServletRequest request) throws UnsupportedEncodingException {
        String pageSize = request.getParameter("pageSize");
        String whereSegment = request.getParameter("whereSegment");

        TUser user = DbUtils.getUser(request);
        if (StringUtils.isEmpty(whereSegment)) {
            whereSegment = Constant.WHERE_DEFAULT;
        }else  {
            whereSegment = URLDecoder.decode(whereSegment, "UTF-8");
        }
        return maintainService.getUnSubmitData(tableName, pageNo, pageSize, whereSegment);
        return maintainService.getUnSubmitData(user, tableName, pageNo, pageSize, whereSegment);
    }

    @RequestMapping(value = "{tableName}/unflow/{pageNo}", method = RequestMethod.GET)
    public Result unflow(@PathVariable String tableName, @PathVariable Integer pageNo, HttpServletRequest request) throws UnsupportedEncodingException {
        String pageSize = request.getParameter("pageSize");
        String whereSegment = request.getParameter("whereSegment");
        TUser user = DbUtils.getUser(request);

        if (StringUtils.isEmpty(whereSegment)) {
            whereSegment = Constant.WHERE_DEFAULT;
@@ -83,9 +85,9 @@
            whereSegment = URLDecoder.decode(whereSegment, "UTF-8");
        }
        if (StringUtils.isEmpty(pageSize)) {
            return maintainService.getInvalidVerionData(tableName, whereSegment, pageNo, null);
            return maintainService.getInvalidVerionData(user, tableName, whereSegment, pageNo, null);
        } else {
            return maintainService.getInvalidVerionData(tableName, whereSegment, pageNo, Integer.valueOf(pageSize));
            return maintainService.getInvalidVerionData(user, tableName, whereSegment, pageNo, Integer.valueOf(pageSize));
        }
    }

@@ -225,13 +227,14 @@
    public Result setFlowId(@RequestParam String flowId,@PathVariable Integer pageNo, HttpServletRequest request) {
        String whereSegment = request.getParameter("whereSegment");
        String pageSize = request.getParameter("pageSize");
        TUser user = DbUtils.getUser(request);
        if (StringUtils.isEmpty(whereSegment)) {
            whereSegment = Constant.WHERE_DEFAULT;
        }
        if (StringUtils.isEmpty(pageSize)) {
            return maintainService.tempDataByVersionByFlow(flowId, whereSegment, pageNo, null);
            return maintainService.tempDataByVersionByFlow(user, flowId, whereSegment, pageNo, null);
        }
        return maintainService.tempDataByVersionByFlow(flowId, whereSegment, pageNo, Integer.valueOf(pageSize));
        return maintainService.tempDataByVersionByFlow(user, flowId, whereSegment, pageNo, Integer.valueOf(pageSize));
    }



 src/main/java/com/highdatas/mdm/controller/MaintainFieldController.java

@@ -17,10 +17,7 @@
import com.highdatas.mdm.util.Constant;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;

import java.text.MessageFormat;
import java.util.Comparator;
@@ -62,6 +59,12 @@
        return Result.success(array);
    }

    @RequestMapping(value = "/getMaintainListByMaintainField/{id}", method = RequestMethod.GET)
    public Result getMaintainListByMaintainField(@PathVariable String id, @RequestParam String tableName)  {
        List<Maintain> maintainList = maintainFieldService.getMaintainListByMaintainField(id, tableName);
        return Result.success(maintainList);
    }

    @RequestMapping(value = "/getMaintainListByTable/{tableName}", method = RequestMethod.GET)
    public Result deleteModel(@PathVariable String tableName)  {
        List<MaintainField> maintainFieldList = maintainFieldService.selectList(new EntityWrapper<MaintainField>().eq("table_name", tableName).orderBy("order_no"));

 src/main/java/com/highdatas/mdm/controller/MasterDataController.java

@@ -78,6 +78,7 @@

    @RequestMapping(value = "{tableName}/all/{pageNo}",  method = RequestMethod.GET)
    public Result getByPage(@PathVariable String tableName, @PathVariable Integer pageNo, HttpServletRequest request) throws UnsupportedEncodingException {
        TUser user = DbUtils.getUser(request);
        String pageSizeStr = request.getParameter("pageSize");
        String whereSegment = request.getParameter(Constant.WHERE_SEGMENT);
        String fields = request.getParameter(Constant.FIELDS);
@@ -107,33 +108,41 @@
            }
            version = String.valueOf(maxVersion.getVersion());
        }
        masterAuthorService.getFilter()
        Maintain maintainFromVersion = maintainService.getMaintainFromVersion(tableName, version);
        if (maintainFromVersion == null) {
            return null;
        }
        //ADD Filter
        String filter = masterAuthorService.getFilter(user.getUserId(), maintainFromVersion.getId());
        whereSegment = DbUtils.StrJoin(whereSegment, Constant.AND, filter);

        if (StringUtils.isEmpty(fields)) {
            if (StringUtils.isEmpty(pageSizeStr)) {
                return masterDataService.selectListByPageByVersion(tableName, whereSegment,pageNo,version, findMax);
                return masterDataService.selectListByPageByVersion(user, tableName, whereSegment,pageNo,version, findMax);
            }
            return masterDataService.selectListByPageByVersion(tableName, null, whereSegment,pageNo, Integer.valueOf(pageSizeStr),version,findMax);
            return masterDataService.selectListByPageByVersion(user, tableName, null, whereSegment,pageNo, Integer.valueOf(pageSizeStr),version,findMax);
        }else {
            String[] split = fields.split(Constant.COMMA_TRIM);
            List<String> fieldList = Arrays.stream(split).collect(Collectors.toList());
            if (StringUtils.isEmpty(pageSizeStr)) {
                return masterDataService.selectListByPageByVersion(tableName, fieldList, whereSegment,pageNo, null,version, findMax);
                return masterDataService.selectListByPageByVersion(user, tableName, fieldList, whereSegment,pageNo, null,version, findMax);
            }
            return masterDataService.selectListByPageByVersion(tableName, fieldList, whereSegment,pageNo, Integer.valueOf(pageSizeStr), findMax);
            return masterDataService.selectListByPageByVersion(user, tableName, fieldList, whereSegment,pageNo, Integer.valueOf(pageSizeStr), findMax);

        }
    }
    @RequestMapping(value = "{tableName}/all",  method = RequestMethod.GET)
    public Result<MenuMapping> getAll(@PathVariable String tableName,HttpServletRequest request) {
        TUser user = DbUtils.getUser(request);
        String whereSegment = request.getParameter(Constant.WHERE_SEGMENT);
        String version = request.getParameter(Constant.VERSION);
        if (StringUtils.isEmpty(version)) {
            version = String.valueOf(maintainService.getNowVersion(tableName).getVersion());
        }
        if (StringUtils.isEmpty(whereSegment)) {
            return masterDataService.selectList(tableName,Constant.WHERE_DEFAULT, version);
            return masterDataService.selectList(user, tableName,Constant.WHERE_DEFAULT, version);
        }
        return masterDataService.selectList(tableName,whereSegment, version);
        return masterDataService.selectList(user, tableName,whereSegment, version);
    }

    @RequestMapping(value = "{maintainId}/modify/{operateStr}", method = RequestMethod.POST)

 src/main/java/com/highdatas/mdm/entity/MasterAuthor.java

@@ -33,6 +33,9 @@
    @TableField("field_auto")
    private Boolean fieldAuto;

    @TableField("maintain_auto")
    private Boolean maintainAuto;

    @TableField("character_id")
    private String characterId;

@@ -53,6 +56,15 @@

    private transient List<MasterAuthorDetail> fields;

    public Boolean getMaintainAuto() {
        return maintainAuto;
    }

    public MasterAuthor setMaintainAuto(Boolean maintainAuto) {
        this.maintainAuto = maintainAuto;
        return this;
    }

    public String getMenuId() {
        return menuId;
    }

 src/main/java/com/highdatas/mdm/service/IMaintainFieldService.java

@@ -41,4 +41,5 @@

    JSONArray getMaintainListByTable(String tableName);

    List<Maintain> getMaintainListByMaintainField(String id,String tableName);
}

 src/main/java/com/highdatas/mdm/service/IMaintainService.java

@@ -2,6 +2,7 @@

import com.baomidou.mybatisplus.service.IService;
import com.highdatas.mdm.entity.Maintain;
import com.highdatas.mdm.entity.TUser;
import com.highdatas.mdm.pojo.ActivitiStatus;
import com.highdatas.mdm.pojo.Operate;
import com.highdatas.mdm.pojo.Result;
@@ -32,7 +33,7 @@

    Maintain getInvalidMaxVersion(String tableName);

    Result getInvalidVerionData(String tableName, String where, Integer pageNo, Integer pageSize);
    Result getInvalidVerionData(TUser user, String tableName, String where, Integer pageNo, Integer pageSize);

    Maintain getNowVersion(String tableName);

@@ -67,12 +68,12 @@

    List<String> getCompareVersionMaintains(Maintain unFlowMaxVersion, Maintain maintainFromVersion);

    Result tempDataByVersionByFlow(String flowId, String whereSegment, Integer pageNo, Integer pageSize);
    Result tempDataByVersionByFlow(TUser user, String flowId, String whereSegment, Integer pageNo, Integer pageSize);

    boolean checkNowVersion(String id);
    boolean checkFirstVersion(String id);

    Result getUnSubmitData(String tableName, Integer pageNo, String pageSize, String whereSegment);
    Result getUnSubmitData(TUser user, String tableName, Integer pageNo, String pageSize, String whereSegment);

    Maintain getNextMaintain(String tableName, String userId);
}

 src/main/java/com/highdatas/mdm/service/IMasterAuthorService.java

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

import com.baomidou.mybatisplus.service.IService;
import com.highdatas.mdm.entity.Maintain;
import com.highdatas.mdm.entity.MasterAuthor;
import com.highdatas.mdm.entity.SysField;
import com.highdatas.mdm.entity.SysMenu;
@@ -23,10 +24,11 @@
    List<SysMenu> getMenu(String userId);


    List<SysField> getField(String userId, String maintainFieldId, String maintainId);
    List<SysField> getField(String userId, String maintainId);

    boolean checkMaintainAuthor(String userId, String maintainId);

    String getFilter(String userId, String maintainId);

    Maintain getMaxVersionMaintain(String userId, String tableName);
}

 src/main/java/com/highdatas/mdm/service/MasterDataService.java

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

import com.highdatas.mdm.entity.Maintain;
import com.highdatas.mdm.entity.TUser;
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.pojo.SysAssembleUpdateType;

@@ -19,45 +20,45 @@

    Result selectById(String tableName, String id);

    Result selectList(String tableName);
    Result selectList(TUser user, String tableName);

    Result selectList(String tableName, String whereSegment);
    Result selectList(String tableName, String whereSegment, String version);
    Result selectList(TUser user, String tableName, String whereSegment);
    Result selectList(TUser user, String tableName, String whereSegment, String version);

    Result selectList(String tableName, List<String> fieldList, String whereSegment);
    Result selectList(String tableName, List<String> fieldList, String whereSegment,String version);
    Result selectList(TUser user, String tableName, List<String> fieldList, String whereSegment);
    Result selectList(TUser user, String tableName, List<String> fieldList, String whereSegment,String version);

    Result selectList(String tableName, List<String> fields);
    Result selectList(TUser user, String tableName, List<String> fields);

    Long getCountByVersion(String maintainId, String tableName, String tableTempName, Integer fromOrderNo, Integer toOrderNo, String whereSegment);
    Long getCountByVersion(TUser user, String maintainId, String tableName, String tableTempName, Integer fromOrderNo, Integer toOrderNo, String whereSegment);

    String getFields(String tableName);
    String getFields(String tableName, Maintain maintain);
    String getFields(TUser user, String tableName, Maintain maintain);

    String getFields(String tableName, String alias);
    String getFields(String tableName, String alias, Maintain maintain);
    String getFields(TUser user, String tableName, String alias, Maintain maintain);

    String getTempFields(String tableName, Maintain maintain);
    String getTempFields(String tableName);
    String getTempFields(TUser user, String tableName, Maintain maintain);
    String getTempFields(TUser user, String tableName);

    String getTempFields(String tableName, String alias);
    String getTempFields(String tableName, String alias,  Maintain maintain);
    String getTempFields(TUser user, String tableName, String alias);
    String getTempFields(TUser user, String tableName, String alias,  Maintain maintain);

    Result selectListByPageByVersion(String tableName, Integer pageNo, Integer pageSize, boolean findMax);
    Result selectListByPageByVersion(TUser user, String tableName, Integer pageNo, Integer pageSize, boolean findMax);

    Result selectListByPageByVersion(String tableName, String whereSegment, Integer pageNo, boolean findMax);
    Result selectListByPageByVersion(TUser user, String tableName, String whereSegment, Integer pageNo, boolean findMax);

    Result selectListByPageByVersion(String tableName, Integer pageNo, String version, boolean findMax);
    Result selectListByPageByVersion(TUser user, String tableName, Integer pageNo, String version, boolean findMax);

    Result selectListByPageByVersion(String tableName, Integer pageNo, boolean findMax);
    Result selectListByPageByVersion(TUser user, String tableName, Integer pageNo, boolean findMax);

    Result selectListByPageByVersion(String tableName, String whereSegment, Integer pageno, Integer pageSize, boolean findMax);
    Result selectListByPageByVersion(TUser user, String tableName, String whereSegment, Integer pageno, Integer pageSize, boolean findMax);

    Result selectListByPageByVersion(String tableName, List<String> fieldList, String whereSegment, Integer pageNo, boolean findMax);
    Result selectListByPageByVersion(TUser user, String tableName, List<String> fieldList, String whereSegment, Integer pageNo, boolean findMax);

    Result selectListByPageByVersion(String tableName, List<String> fieldList, Integer pageNo, boolean findMax);
    Result selectListByPageByVersion(TUser user, String tableName, List<String> fieldList, Integer pageNo, boolean findMax);

    Result selectListByPageByVersion(String tableName, List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize, boolean findMax);
    Result selectListByPageByVersion(TUser user, String tableName, List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize, boolean findMax);

    Result insert(String tableName, String fields, String jsonValues);
    Result insert(String tableName, String json);
@@ -83,11 +84,11 @@

    Result delete(String tableName, String whereSegment);

    Result selectListByPageByVersion(String tableName, String whereSegment, Integer pageNo, String version, boolean findMax);
    Result selectListByPageByVersion(TUser user, String tableName, String whereSegment, Integer pageNo, String version, boolean findMax);

    List<Map<String, Object>> selectListByVersion(String tableName, List<String> fieldList, String whereSegment, String version, boolean findMax);
    List<Map<String, Object>> selectListByVersion(TUser user, String tableName, List<String> fieldList, String whereSegment, String version, boolean findMax);

    Result selectListByPageByVersion(String tableName, List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize, String version, boolean findMax);
    Result selectListByPageByVersion(TUser user, String tableName, List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize, String version, boolean findMax);

    Maintain uploadedData(String tableName, SysAssembleUpdateType uploadType, String userId);


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

@@ -258,8 +258,25 @@
        HashMap<String, List<Maintain>> resultMap = getMaintainFieldMapByTable(tableName);

        Set<String> keySet = resultMap.keySet();
        ArrayList<String> keys = new ArrayList<>(keySet);
        Collections.sort(keys, new Comparator<String>() {
            @Override
            public int compare(String maintianFieldId1, String maintianFieldId2) {
                MaintainField maintainField1 = selectById(maintianFieldId1);
                MaintainField maintainField2 = selectById(maintianFieldId2);
                if (maintainField1 == null) {
                    return 1;
                }
                if (maintainField2 == null){
                    return -1;
                }

                return maintainField1.getOrderNo().compareTo(maintainField2.getOrderNo());
            }
        });

        JSONArray array = new JSONArray();
        for (String s : keySet) {
        for (String s : keys) {
            List<Maintain> list = resultMap.get(s);
            Maintain max = list.stream().max(new Comparator<Maintain>() {
                @Override
@@ -276,14 +293,30 @@
            JSONObject object = new JSONObject();
            object.fluentPut("maintainFieldId", s);
            object.fluentPut("version", MessageFormat.format(Constant.extent, min.getVersion(), max.getVersion()));
            object.fluentPut("list", list);

            array.add(object);
        }
        return array;
    }

    @Override
    public List<Maintain> getMaintainListByMaintainField(String id, String tableName) {
        MaintainField maintainField = selectById(id);
        if (maintainField == null) {
            if (!id.equalsIgnoreCase(Constant.Default)){
                return null;
            }else {
                maintainField = new MaintainField().setId(Constant.Default).setTableName(tableName);
            }

        }

        return  getMaintainByMaintainField(maintainField.getId(), maintainField.getTableName());
    }

    private HashMap<String, List<Maintain>> getMaintainFieldMapByTable(String tableName) {
        List<Maintain> maintainList = maintainService.selectList(new EntityWrapper<Maintain>().eq("table_name", tableName).isNotNull("flow_id").orderBy("order_no"));
        List<Maintain> maintainList = maintainService.selectList(new EntityWrapper<Maintain>().eq("table_name", tableName).isNotNull("flow_id").orderBy("order_no desc"));
        HashMap<String, List<Maintain>> resultMap = new HashMap<>();
        for (Maintain maintain : maintainList) {
            ActivitiStatus status = flowsService.getStatusByBusinessId(maintain.getId());

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

@@ -9,6 +9,7 @@
import com.highdatas.mdm.entity.Flows;
import com.highdatas.mdm.entity.Maintain;
import com.highdatas.mdm.entity.MaintainDetail;
import com.highdatas.mdm.entity.TUser;
import com.highdatas.mdm.mapper.MaintainMapper;
import com.highdatas.mdm.mapper.TableInfoMapper;
import com.highdatas.mdm.pojo.*;
@@ -107,7 +108,7 @@
            maintain.deleteById();
            return;
        }
        String fields  = masterDataService.getTempFields(tableName);
        String fields  = masterDataService.getTempFields(null, tableName);
        String tempFields = masterDataService.getFields(tableName + Constant.RECORD);

        String tableTempName = tableName + Constant.RECORD;
@@ -172,7 +173,7 @@
    }

    @Override
    public Result getUnSubmitData(String tableName, Integer pageNo, String pageSize, String whereSegment) {
    public Result getUnSubmitData(TUser user, String tableName, Integer pageNo, String pageSize, String whereSegment) {
        Wrapper<Maintain> versionWrapper = new EntityWrapper<Maintain>().eq("table_name", tableName).isNull("flow_id").orderBy("order_no desc");
        Maintain maintain = selectOne(versionWrapper);
        if (maintain == null) {
@@ -186,7 +187,7 @@
        if (!StringUtils.isEmpty(pageSize)) {
            page.setPageSize(Integer.valueOf(pageSize));
        }
        String tempFields = masterDataService.getTempFields(tableName);
        String tempFields = masterDataService.getTempFields(user, tableName);
        List<Map<String, Object>> maps = maintainMapper.selectUnSubmitData(tempName, tempFields, whereSegment, DbUtils.quotedStr(maintainId), page.getLimitSQL());
        JSONObject object = new JSONObject();
        object.fluentPut("records", maps);
@@ -295,13 +296,13 @@
    }

    @Override
    public Result getInvalidVerionData(String tableName, String where, Integer pageNo, Integer pageSize) {
    public Result getInvalidVerionData(TUser user, String tableName, String where, Integer pageNo, Integer pageSize) {
        Maintain invalidVersion = getInvalidMaxVersion(tableName);
        if (invalidVersion == null) {
            return Result.success(null);
        }
        String tableTempName = tableName + Constant.RECORD;
        String tempFields = masterDataService.getTempFields(tableName);
        String tempFields = masterDataService.getTempFields(user, tableName);
        Long count = maintainMapper.countInvalidVersionData(tableTempName, where, invalidVersion.getOrderNo());
        Page page = new Page(count);
        page.setPageNo(pageNo);
@@ -448,7 +449,7 @@
    }

    @Override
    public Result tempDataByVersionByFlow(String flowId, String whereSegment, Integer pageNo, Integer pageSize) {
    public Result tempDataByVersionByFlow(TUser user, String flowId, String whereSegment, Integer pageNo, Integer pageSize) {
        Flows flows = flowsService.selectById(flowId);
        if (flows == null) {
            return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
@@ -458,7 +459,7 @@
        if (maintain == null) {
            return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
        }
        String fields  = masterDataService.getTempFields(maintain.getTableName());
        String fields  = masterDataService.getTempFields(user, maintain.getTableName());
        String tableTempName = maintain.getTableName() + Constant.RECORD;
        long total = maintainMapper.countTempDataByVersionByFlow(tableTempName, flowId, whereSegment);


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

@@ -1,11 +1,14 @@
package com.highdatas.mdm.service.impl;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.highdatas.mdm.controller.MasterAuthorController;
import com.highdatas.mdm.entity.*;
import com.highdatas.mdm.mapper.MasterAuthorMapper;
import com.highdatas.mdm.pojo.ActivitiStatus;
import com.highdatas.mdm.pojo.MasterAuthorType;
import com.highdatas.mdm.service.*;
import com.highdatas.mdm.util.Constant;
@@ -15,6 +18,7 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.security.CodeSigner;
import java.text.MessageFormat;
import java.util.*;
import java.util.stream.Collectors;
@@ -42,6 +46,8 @@
    IMaintainFieldService maintainFieldService;
    @Autowired
    IMaintainService maintainService;
    @Autowired
    IFlowsService flowsService;

    @Override
    public HashMap<String, MasterAuthor> merageRoleAuthor(List<String> roleIds) {
@@ -82,17 +88,29 @@
    }

    @Override
    public List<SysField> getField(String userId, String maintainFieldId, String maintainId) {
        if (maintainFieldId.equalsIgnoreCase(Constant.All)) {
    public List<SysField> getField(String userId, String maintainId) {
        Maintain maintain = maintainService.selectById(maintainId);
        if (maintain == null){
            return new ArrayList<>();
        }
        boolean isAll = checkUnFilterAuthor(userId, maintain.getTableName());
        if (isAll) {
            List<SysField> total = fieldService.getFieldByMaintain(maintainId);
            return total;
        }
        List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.user).eq(this.characterId, userId).eq("maintain_field_id", maintainFieldId));

        MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
        if (maintainField == null){
            return new ArrayList<>();
        }
        String maintainFieldId = maintainField.getId();

        List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, userId).eq("maintain_field_id", maintainFieldId));
        if (masterAuthors.size() == 0) {
            //user 获取role
            List<TUserRole> roles = userRoleService.selectList(new EntityWrapper<TUserRole>().eq("user_id", userId));
            List<String> roleIds = roles.stream().map(tUserRole -> tUserRole.getRoleId()).collect(Collectors.toList());
            masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(this.characterId, roleIds).eq("maintain_field_id", maintainFieldId));
            masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleIds).eq("maintain_field_id", maintainFieldId));
        }
        if (masterAuthors.isEmpty()) {
            return null;
@@ -103,9 +121,9 @@
        if (codes.isEmpty()) {
            return null;
        }
        Wrapper<SysField> wrapper = new EntityWrapper<SysField>().in(Constant.FIELD, codes);
        Wrapper<SysField> wrapper = new EntityWrapper<SysField>().in(Constant.FIELD, codes).eq("table_name", maintain.getTableName());

        if (maintainFieldId.equalsIgnoreCase(Constant.Default)) {
        if (!maintainFieldId.equalsIgnoreCase(Constant.Default)) {
            wrapper.eq("maintain_field_id", maintainFieldId);
        }else {
            wrapper.isNull("maintain_field_id");
@@ -117,19 +135,35 @@
        return fieldList;
    }

    private boolean checkUnFilterAuthor(String userId, String tableName) {
        List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, userId).eq("table_name", tableName));
        long isAll = masterAuthors.stream().filter(masterAuthor -> masterAuthor.getMaintainFieldId().equalsIgnoreCase(Constant.All)).count();
        if (isAll > 0) {
            return true;
        }
        if (!masterAuthors.isEmpty()) {
            return false;
        }
        Set<String> roleByUser = DbUtils.getRoleByUser(userId);
        isAll = selectCount(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleByUser).eq("table_name", tableName).eq("maintain_field_id", Constant.All_UPCASE));
        if (isAll > 0) {
            return true;
        }

        return false;
    }

    @Override
    public boolean checkMaintainAuthor(String userId, String maintainId) {
        Maintain maintain = maintainService.selectById(maintainId);
        if (maintain == null) {
            return false;
        }
        int checked = selectCount(new EntityWrapper<MasterAuthor>()
                .eq(Constant.TYPE, MasterAuthorType.user)
                .eq(MasterAuthorController.character_id, userId)
                .eq("table_name", maintain.getTableName())
                .eq("maintain_field_id", Constant.All));
        if(checked > 0) {
        int checked = 0;
        boolean isAll = checkUnFilterAuthor(userId, maintain.getTableName());
        if (isAll){
            return true;

        }
        MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
        if (maintainField == null) {
@@ -159,17 +193,23 @@

    @Override
    public String getFilter(String userId, String maintainId) {
        MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
        if (maintainField)
        if (maintainFieldId.equalsIgnoreCase(Constant.All)) {
        Maintain maintain = maintainService.selectById(maintainId);
        if (maintain == null){
            return Constant.WHERE_DEFAULTUN;
        }
        boolean isAll = checkUnFilterAuthor(userId, maintain.getTableName());
        if (isAll) {
            return Constant.WHERE_DEFAULT;
        }
        List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.user).eq(this.characterId, userId).eq("maintain_field_id", maintainFieldId));
        MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
        String maintainFieldId = maintainField.getId();

        List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, userId).eq("maintain_field_id", maintainFieldId));
        if (masterAuthors.size() == 0) {
            //user 获取role
            List<TUserRole> roles = userRoleService.selectList(new EntityWrapper<TUserRole>().eq("user_id", userId));
            List<String> roleIds = roles.stream().map(tUserRole -> tUserRole.getRoleId()).collect(Collectors.toList());
            masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(this.characterId, roleIds).eq("maintain_field_id", maintainFieldId));
            masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleIds).eq("maintain_field_id", maintainFieldId));
        }
        if (masterAuthors.isEmpty()){
            return Constant.WHERE_DEFAULTUN;
@@ -190,8 +230,11 @@
            }

            Boolean preAll = segmentAllMap.get(field);
            if (preAll && segmentMap.containsKey(field)) {
            if (preAll) {
                if (segmentMap.containsKey(field)) {
                segmentMap.remove(field);
                }
                continue;
            }

            String val = detail.getVal();
@@ -205,13 +248,29 @@
            String val = vals.stream()
                    .filter(s -> !StringUtils.isEmpty(s))
                    .map(s -> DbUtils.quotedStr(s)).collect(Collectors.joining(Constant.COMMA));
            String format = MessageFormat.format(Constant.MYSQL_UUID, code, val);
            String format = MessageFormat.format(Constant.InSql, code, val);
            builder.append(format);
        }
        String filter = builder.toString();
        return filter;
    }

    @Override
    public Maintain getMaxVersionMaintain(String userId, String tableName) {
        List<Maintain> maintainList = maintainService.selectList(new EntityWrapper<Maintain>().eq("table_name", tableName).orderBy("order_no desc"));
        for (Maintain maintain : maintainList) {
            ActivitiStatus status = flowsService.getStatusByBusinessId(maintain.getId());
            if (!status.equals(ActivitiStatus.open)) {
                continue;
            }
            boolean b = checkMaintainAuthor(userId, maintain.getId());
            if (b) {
                return maintain;
            }
        }
        return null;
    }

    private MasterAuthor merage(MasterAuthor preMerageMasterAuthor, MasterAuthor masterAuthor) {
        // table name  masterField 一样 只有字段不同了
        List<MasterAuthorDetail> preFields = preMerageMasterAuthor.getFields();

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

@@ -47,6 +47,9 @@
    RedisClient redisClient;
    @Autowired
    IMaintainFieldService maintainFieldService;
    @Autowired
    IMasterAuthorService masterAuthorService;

    @Resource
    protected DataSource dataSource;

@@ -75,41 +78,40 @@
    }

    @Override
    public Result selectList(String tableName) {
        return selectList(tableName, null,null, (maintainService.getNowVersion(tableName).getVersion()));
    public Result selectList(TUser user, String tableName) {
        return selectList(user, tableName, null,null, (maintainService.getNowVersion(tableName).getVersion()));
    }


    @Override
    public Result selectList(String tableName, String whereSegment) {
        return selectList(tableName, whereSegment, (maintainService.getNowVersion(tableName).getVersion()));
    public Result selectList(TUser user, String tableName, String whereSegment) {
        return selectList(user,tableName, whereSegment, (maintainService.getNowVersion(tableName).getVersion()));
    }

    @Override
    public Result selectList(String tableName, String whereSegment, String version) {
        return selectList(tableName, null, whereSegment, version);
    public Result selectList(TUser user,String tableName, String whereSegment, String version) {
        return selectList(user, tableName, null, whereSegment, version);
    }

    @Override
    public Result selectList(String tableName, List<String> fieldList, String whereSegment) {
        return selectList(tableName, fieldList, whereSegment, maintainService.getNowVersion(tableName).getVersion());
    public Result selectList(TUser user, String tableName, List<String> fieldList, String whereSegment) {
        return selectList(user, tableName, fieldList, whereSegment, maintainService.getNowVersion(tableName).getVersion());
    }

    @Override
    public Result selectList(String tableName,List<String> fieldList, String whereSegment, String version) {
    public Result selectList(TUser user, String tableName,List<String> fieldList, String whereSegment, String version) {
        try{
            JSONObject object = new JSONObject();

            //TODO only add  version
            Maintain maintainFromVersion = maintainService.getMaintainFromVersion(tableName, version);
            String fields;
            if (fieldList == null || fieldList.size() == 0) {
                fields = getFields(tableName);
                fields = getFields(user, tableName, maintainFromVersion);
            } else {
                fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA));
            }
            //std
            List<Map<String, Object>> select = mapper.select(tableName, fields, whereSegment);
            //TODO only add  version
            Maintain maintainFromVersion = maintainService.getMaintainFromVersion(tableName, version);

            List<Map<String, Object>> maps = maintainService.selectVersionOperatorByType(tableName, maintainFromVersion.getId(), Operate.create);

@@ -124,8 +126,8 @@


    @Override
    public Result selectList(String tableName, List<String> fields) {
        return selectList(tableName,fields,Constant.WHERE_DEFAULT,(maintainService.getNowVersion(tableName).getVersion()));
    public Result selectList(TUser user, String tableName, List<String> fields) {
        return selectList(user, tableName,fields,Constant.WHERE_DEFAULT,(maintainService.getNowVersion(tableName).getVersion()));
    }

    public Long getCount(String tableName, String whereSegment) {
@@ -143,20 +145,24 @@
    }

    @Override
    public Long getCountByVersion (String maintainId, String tableName,String tableTempName,Integer fromOrderNo, Integer toOrderNo, String whereSegment) {
    public Long getCountByVersion (TUser user, String maintainId, String tableName,String tableTempName,Integer fromOrderNo, Integer toOrderNo, String whereSegment) {
        try{
            Maintain maintain = maintainService.selectById(maintainId);

            String fields = getFields(tableName, maintain);
            String Hfields = getFields(tableName, Constant.H, maintain);
            String tempFields = getTempFields(tableName, maintain);
            String A1fields = getFields(tableName, Constant.A1, maintain);
            String A2fields = getFields(tableName, Constant.A2, maintain);
            String tempHFields = getTempFields(tableName, Constant.H, maintain);
            String fields = getFields(user,tableName, maintain);
            String Hfields = getFields(user, tableName, Constant.H, maintain);
            String tempFields = getTempFields(user, tableName, maintain);
            String A1fields = getFields(user, tableName, Constant.A1, maintain);
            String A2fields = getFields(user, tableName, Constant.A2, maintain);
            String tempHFields = getTempFields(user, tableName, Constant.H, maintain);
            if (StringUtils.isEmpty(whereSegment)) {
                whereSegment = Constant.WHERE_DEFAULT;
            }
            Long count = mapper.getCountByVersion(tableName, tableTempName, fields, tempFields, Hfields, A1fields,A2fields,tempHFields, fromOrderNo, toOrderNo, DbUtils.quotedStr(maintainId), whereSegment);
            Long count;
            if (StringUtils.isEmpty(fields)) {
                return 0L;
            }
            count = mapper.getCountByVersion(tableName, tableTempName, fields, tempFields, Hfields, A1fields,A2fields,tempHFields, fromOrderNo, toOrderNo, DbUtils.quotedStr(maintainId), whereSegment);
            return count;
        }
        catch (Exception e) {
@@ -165,16 +171,16 @@
        }
    }

    public Long getCountByMaxVersion (String maintainId, String tableName,String tableTempName,Integer fromOrderNo, Integer toOrderNo, String whereSegment) {
    public Long getCountByMaxVersion (TUser user, String maintainId, String tableName,String tableTempName,Integer fromOrderNo, Integer toOrderNo, String whereSegment) {
        try{
            Maintain maintain = maintainService.selectById(maintainId);

            String fields = getFields(tableName, maintain);
            String Hfields = getFields(tableName, Constant.H, maintain);
            String tempFields = getTempFields(tableName, maintain);
            String A1fields = getFields(tableName, Constant.A1, maintain);
            String A2fields = getFields(tableName, Constant.A2, maintain);
            String tempHFields = getTempFields(tableName, Constant.H, maintain);
            String fields = getFields(user, tableName, maintain);
            String Hfields = getFields(user, tableName, Constant.H, maintain);
            String tempFields = getTempFields(user, tableName, maintain);
            String A1fields = getFields(user, tableName, Constant.A1, maintain);
            String A2fields = getFields(user, tableName, Constant.A2, maintain);
            String tempHFields = getTempFields(user, tableName, Constant.H, maintain);
            if (StringUtils.isEmpty(whereSegment)) {
                whereSegment = Constant.WHERE_DEFAULT;
            }
@@ -194,9 +200,9 @@
    }

    @Override
    public String getFields(String tableName, Maintain maintain) {
    public String getFields(TUser user, String tableName, Maintain maintain) {

        return getFields(tableName, null, maintain);
        return getFields(user, tableName, null, maintain);
    }

    private String getCaseWhenFields(String tableName) {
@@ -233,9 +239,17 @@
    }

    @Override
    public String getFields(String tableName, String alias, Maintain maintain) {
        List<SysField> fields = fieldService.getFieldByMaintain(maintain.getId());
    public String getFields(TUser user, String tableName, String alias, Maintain maintain) {
        List<SysField> fields;
        if (user == null) {
            fields = fieldService.getFieldByMaintain(maintain.getId());
        }else {
            fields = masterAuthorService.getField(user.getUserId(), maintain.getId());
        }
        ContentBuilder contentBuilder = new ContentBuilder(Constant.COMMA);
        if (fields == null) {
            return Constant.EMPTY_Str;
        }
        if (!fields.contains(Constant.ID)) {
            fields.add(new SysField().setField(Constant.ID));
        }
@@ -258,17 +272,18 @@
    }

    @Override
    public String getTempFields(String tableName, Maintain maintain) {
        return getTempFields(tableName, null, maintain);
    public String getTempFields(TUser user, String tableName, Maintain maintain) {
        return getTempFields(user, tableName, null, maintain);
    }

    @Override
    public String getTempFields(String tableName) {
        return getTempFields(tableName, Constant.EMPTY_Str);
    public String getTempFields(TUser user, String tableName) {
        return getTempFields(user, tableName, Constant.EMPTY_Str);
    }
    @Override
    public String getTempFields(String tableName, String alias) {
    public String getTempFields(TUser user, String tableName, String alias) {
        List<TableSchemaResult> tableField = mapper.getTableField(tableName);

        ContentBuilder contentBuilder = new ContentBuilder(Constant.COMMA);
        for (TableSchemaResult tableSchemaResult : tableField) {
            String fieldName = tableSchemaResult.getFieldName();
@@ -290,8 +305,16 @@
    }

    @Override
    public String getTempFields(String tableName, String alias, Maintain maintain) {
        List<SysField> fields = fieldService.getFieldByMaintain(maintain.getId());
    public String getTempFields(TUser user, String tableName, String alias, Maintain maintain) {
        List<SysField> fields;
        if (user == null) {
            fields = fieldService.getFieldByMaintain(maintain.getId());
        }else {
            fields = masterAuthorService.getField(user.getUserId(), maintain.getId());
        }
        if (fields == null) {
            return Constant.EMPTY_Str;
        }
        ContentBuilder contentBuilder = new ContentBuilder(Constant.COMMA);
        if (!fields.contains(Constant.ID)) {
            fields.add(new SysField().setField(Constant.ID));
@@ -317,45 +340,45 @@
    }

    @Override
    public Result selectListByPageByVersion(String tableName, Integer pageNo, Integer pageSize, boolean findMax) {
        return selectListByPageByVersion(tableName,Constant.WHERE_DEFAULT,pageNo,pageSize, findMax);
    public Result selectListByPageByVersion(TUser user, String tableName, Integer pageNo, Integer pageSize, boolean findMax) {
        return selectListByPageByVersion(user, tableName,Constant.WHERE_DEFAULT,pageNo,pageSize, findMax);
    }

    @Override
    public Result selectListByPageByVersion(String tableName, String whereSegment, Integer pageNo, boolean findMax) {
        return selectListByPageByVersion(tableName,null, whereSegment,pageNo, null, String.valueOf(maintainService.getNowVersion(tableName).getVersion()), findMax);
    public Result selectListByPageByVersion(TUser user, String tableName, String whereSegment, Integer pageNo, boolean findMax) {
        return selectListByPageByVersion(user, tableName,null, whereSegment,pageNo, null, String.valueOf(maintainService.getNowVersion(tableName).getVersion()), findMax);
    }

    @Override
    public Result selectListByPageByVersion(String tableName, Integer pageNo, String version, boolean findMax) {
        return selectListByPageByVersion(tableName,null,Constant.WHERE_DEFAULT,pageNo, null, version, findMax);
    public Result selectListByPageByVersion(TUser user, String tableName, Integer pageNo, String version, boolean findMax) {
        return selectListByPageByVersion(user, tableName,null,Constant.WHERE_DEFAULT,pageNo, null, version, findMax);
    }
    @Override
    public Result selectListByPageByVersion(String tableName, Integer pageNo, boolean findMax) {
        return selectListByPageByVersion(tableName,null,Constant.WHERE_DEFAULT,pageNo, null, String.valueOf(maintainService.getNowVersion(tableName).getVersion()), findMax);
    public Result selectListByPageByVersion(TUser user, String tableName, Integer pageNo, boolean findMax) {
        return selectListByPageByVersion(user, tableName,null,Constant.WHERE_DEFAULT,pageNo, null, String.valueOf(maintainService.getNowVersion(tableName).getVersion()), findMax);
    }

    @Override
    public Result selectListByPageByVersion(String tableName, String whereSegment, Integer pageNo, Integer pageSize, boolean findMax) {
        return selectListByPageByVersion(tableName,null,whereSegment,pageNo,pageSize, findMax);
    public Result selectListByPageByVersion(TUser user, String tableName, String whereSegment, Integer pageNo, Integer pageSize, boolean findMax) {
        return selectListByPageByVersion(user, tableName,null,whereSegment,pageNo,pageSize, findMax);
    }

    @Override
    public Result selectListByPageByVersion(String tableName, List<String> fieldList, String whereSegment, Integer pageNo, boolean findMax) {
        return selectListByPageByVersion(tableName,null,whereSegment,pageNo, null, findMax);
    public Result selectListByPageByVersion(TUser user, String tableName, List<String> fieldList, String whereSegment, Integer pageNo, boolean findMax) {
        return selectListByPageByVersion(user, tableName,null,whereSegment,pageNo, null, findMax);
    }

    @Override
    public Result selectListByPageByVersion(String tableName, List<String> fieldList, Integer pageNo, boolean findMax) {
        return selectListByPageByVersion(tableName,null,Constant.WHERE_DEFAULT,pageNo, findMax);
    public Result selectListByPageByVersion(TUser user, String tableName, List<String> fieldList, Integer pageNo, boolean findMax) {
        return selectListByPageByVersion(user, tableName,null,Constant.WHERE_DEFAULT,pageNo, findMax);
    }
    @Override
    public Result selectListByPageByVersion(String tableName, String whereSegment, Integer pageNo, String version, boolean findMax) {
        return selectListByPageByVersion(tableName, null,whereSegment, pageNo, null,version, findMax);
    public Result selectListByPageByVersion(TUser user, String tableName, String whereSegment, Integer pageNo, String version, boolean findMax) {
        return selectListByPageByVersion(user, tableName, null,whereSegment, pageNo, null,version, findMax);
    }

    @Override
    public List<Map<String, Object>> selectListByVersion(String tableName, List<String> fieldList, String whereSegment, String version, boolean findMax) {
    public List<Map<String, Object>> selectListByVersion(TUser user, String tableName, List<String> fieldList, String whereSegment, String version, boolean findMax) {
        Maintain maintainFromVersion = maintainService.getMaintainFromVersion(tableName, version);
        Maintain nowVersionMaintain = maintainService.getNowVersion(tableName);
        boolean isMax = maintainService.checkdMaxVersion(maintainFromVersion.getId());
@@ -379,12 +402,12 @@

        String tempHfields;
        if (fieldList == null || fieldList.size() == 0) {
            fields = getFields(tableName, maintainFromVersion);
            Hfields = getFields(tableName,Constant.H, maintainFromVersion);
            A1fields = getFields(tableName,Constant.A1, maintainFromVersion);
            A2fields = getFields(tableName,Constant.A2, maintainFromVersion);
            tempFields = getTempFields(tableName, maintainFromVersion);
            tempHfields = getTempFields(tableName, Constant.H, maintainFromVersion);
            fields = getFields(user, tableName, maintainFromVersion);
            Hfields = getFields(user, tableName,Constant.H, maintainFromVersion);
            A1fields = getFields(user, tableName,Constant.A1, maintainFromVersion);
            A2fields = getFields(user, tableName,Constant.A2, maintainFromVersion);
            tempFields = getTempFields(user, tableName, maintainFromVersion);
            tempHfields = getTempFields(user, tableName, Constant.H, maintainFromVersion);
        } else {
            fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA));
            Hfields = fieldList.stream().map(s -> MessageFormat.format(Constant.Alias,Constant.H, s)).collect(Collectors.joining(Constant.COMMA));
@@ -423,8 +446,7 @@
        return result;
    }
    @Override
    public Result selectListByPageByVersion(String tableName, List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize, String version, boolean findMax) {

    public Result selectListByPageByVersion(TUser user, String tableName, List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize, String version, boolean findMax) {
        Maintain maintainFromVersion = maintainService.getMaintainFromVersion(tableName, version);
        Maintain nowVersionMaintain = maintainService.getNowVersion(tableName);
        boolean isMax = maintainService.checkdMaxVersion(maintainFromVersion.getId());
@@ -448,11 +470,13 @@
           if (isFirst && nowVersionMaintain == null) {
               nowVersionOrderNo = nowVersionOrderNo - 1;
           }
            count = getCountByMaxVersion(maintainFromVersion.getId(), tableName, tableTempName, fromVersionOrderNo, nowVersionOrderNo,  whereSegment);
            count = getCountByMaxVersion(user, maintainFromVersion.getId(), tableName, tableTempName, fromVersionOrderNo, nowVersionOrderNo,  whereSegment);
        }else {
            count = getCountByVersion(maintainFromVersion.getId(), tableName, tableTempName, nowVersionOrderNo, fromVersionOrderNo, whereSegment);
            count = getCountByVersion(user, maintainFromVersion.getId(), tableName, tableTempName, nowVersionOrderNo, fromVersionOrderNo, whereSegment);
        }

        if (count == 0) {
            return Result.success(null);
        }
        //mapper.selectByPageByVersion(tableName, tableTempName, fieldList, whereSegment,);
        Page page = new Page(count);
        if (pageSize != null && pageSize.compareTo(1) != -1) {
@@ -473,12 +497,12 @@

        String tempHfields;
        if (fieldList == null || fieldList.size() == 0) {
            fields = getFields(tableName, maintainFromVersion);
            Hfields = getFields(tableName,Constant.H, maintainFromVersion);
            A1fields = getFields(tableName,Constant.A1, maintainFromVersion);
            A2fields = getFields(tableName,Constant.A2, maintainFromVersion);
            tempFields = getTempFields(tableName, maintainFromVersion);
            tempHfields = getTempFields(tableName, Constant.H, maintainFromVersion);
            fields = getFields(user, tableName, maintainFromVersion);
            Hfields = getFields(user, tableName,Constant.H, maintainFromVersion);
            A1fields = getFields(user, tableName,Constant.A1, maintainFromVersion);
            A2fields = getFields(user, tableName,Constant.A2, maintainFromVersion);
            tempFields = getTempFields(user, tableName, maintainFromVersion);
            tempHfields = getTempFields(user, tableName, Constant.H, maintainFromVersion);
        } else {
            fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA));
            Hfields = fieldList.stream().map(s -> MessageFormat.format(Constant.Alias,Constant.H, s)).collect(Collectors.joining(Constant.COMMA));
@@ -539,7 +563,6 @@

    @Override
    public Maintain uploadedData(String tableName, SysAssembleUpdateType uploadType, String userId) {

        MenuMapping menuMapping = menuMappingService.selectOne(new EntityWrapper<MenuMapping>().eq("table_name",tableName));
        SysOperateLog operateLog = new SysOperateLog();

@@ -701,8 +724,8 @@
    }

    @Override
    public Result selectListByPageByVersion(String tableName,List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize, boolean findMax) {
       return  selectListByPageByVersion(tableName, fieldList, whereSegment,pageNo,pageSize,String.valueOf(maintainService.getNowVersion(tableName).getVersion()), findMax);
    public Result selectListByPageByVersion(TUser user, String tableName,List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize, boolean findMax) {
       return  selectListByPageByVersion(user, tableName, fieldList, whereSegment,pageNo,pageSize,String.valueOf(maintainService.getNowVersion(tableName).getVersion()), findMax);
    }

    @Override
@@ -1038,7 +1061,9 @@
        ArrayList<String> fieldList = new ArrayList<>();
        fieldList.add(field);
        fieldList.add(Constant.ID);
        List<Map<String, Object>> maps = selectListByVersion(tableName, fieldList, Constant.WHERE_DEFAULT, max.getVersion(), false);
        // where

        List<Map<String, Object>> maps = selectListByVersion(null, tableName, fieldList, Constant.WHERE_DEFAULT, max.getVersion(), false);
        String tempTableName = tableName + Constant.RECORD;
        List<Map<String, Object>> tempVals = mapper.getOneTempFieldDataByMaintainExtent(DbUtils.quotedStr(tableName), tempTableName, field, min.getOrderNo(), max.getOrderNo());
        maps.addAll(tempVals);

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

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

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
@@ -15,10 +16,7 @@
import com.highdatas.mdm.mapper.TableInfoMapper;
import com.highdatas.mdm.pojo.CodeMsg;
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.service.ActivitiService;
import com.highdatas.mdm.service.IMaintainService;
import com.highdatas.mdm.service.IMenuMappingService;
import com.highdatas.mdm.service.ISysMenuService;
import com.highdatas.mdm.service.*;
import com.highdatas.mdm.util.Constant;
import com.highdatas.mdm.util.DbUtils;
import com.highdatas.mdm.util.WorkflowUtils;
@@ -54,6 +52,10 @@

    @Autowired
    ISysMenuService menuService;
    @Autowired
    IMaintainFieldService maintainFieldService;
    @Autowired
    IMasterAuthorService masterAuthorService;

    public static final String key = "process";

@@ -185,7 +187,9 @@
        }

        String tableName = menuMapping.getTableName();
        Maintain resultMaintain = maintainService.getNowVersion(tableName);
        TUser user = (TUser) session.getAttribute(Constant.USER);

        Maintain resultMaintain = masterAuthorService.getMaxVersionMaintain(user.getUserId(), tableName);

        if (resultMaintain != null) {
            mapping.put("version", resultMaintain.getVersion());

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

@@ -83,7 +83,7 @@
        }

        MaintainField maintainField = getMaintainFieldByMaintain(maintainId);
        if (maintainField == null && Constant.Default.equalsIgnoreCase(maintainField.getId())) {
        if (maintainField == null || Constant.Default.equalsIgnoreCase(maintainField.getId())) {

            fieldList = this.selectList(new EntityWrapper<SysField>().eq("table_name", maintain.getTableName()).isNull("maintain_field_id").orderBy("order_no"));
            return fieldList;
@@ -116,7 +116,7 @@

    @Override
    public MaintainField getMaintainFieldByMaintain(String maintainId) {
        MaintainField maintainField;
        MaintainField maintainField = null;
        List<SysField> fieldList = null;

        if (StringUtils.isEmpty(maintainId)) {
@@ -126,8 +126,18 @@
        if (maintain == null) {
            return null;
        }
        List<MaintainField> subList = maintainFieldService.selectList(new EntityWrapper<MaintainField>().eq("maintain_id", maintainId).orderBy("order_no desc, create_time desc"));
        subList.sort(new Comparator<MaintainField>() {
            @Override
            public int compare(MaintainField o1, MaintainField o2) {

        maintainField = maintainFieldService.selectOne(new EntityWrapper<MaintainField>().eq("maintain_id", maintainId).orderBy("order_no desc, create_time desc"));
                return o2.getOrderNo().compareTo(o1.getOrderNo());
            }
        });
        if (!subList.isEmpty()) {
            maintainField = subList.get(0);
        }

        if (maintainField == null) {
            //对应版本找不到 往前找
            String maintainFieldId = maintainFieldMapper.getMappedMatintainId(DbUtils.quotedStr(maintain.getTableName()), maintain.getOrderNo());

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

@@ -47,7 +47,7 @@

        String[] split = field.split(Constant.COMMA_TRIM);
        List<String> collect = Arrays.stream(split).collect(Collectors.toList());
        Result result = masterDataService.selectList(tableName, collect);
        Result result = masterDataService.selectList(null, tableName, collect);
        JSONObject object = (JSONObject)result.getData();
        List<Map<String, Object>> datas = (List<Map<String, Object>>) object.get("grid");
        String codeContent = tQualityRule.getCodeContent();

 src/main/java/com/highdatas/mdm/util/Constant.java

@@ -53,6 +53,7 @@
    String A1 = "a1";
    String A2 = "a2";
    String All = "all";
    String All_UPCASE = "All";
    String DataMenu = "DataMenu";
    String AND = " and ";
    String MD = "md_";

 src/main/java/com/highdatas/mdm/util/DbUtils.java

@@ -343,9 +343,10 @@
        return (TUser) request.getSession().getAttribute(Constant.USER);
    }

    public static ArrayList<String> getRoleByUser(String userId) {
        ArrayList<String> roleIds = new ArrayList<>();
        roleIds.add("ROO1");
    public static Set<String> getRoleByUser(String userId) {
        Set<String> roleIds = new HashSet<>();
        roleIds.add("R001");
        roleIds.add("R002");
        return roleIds;
    }
}

 src/main/resources/application.yml

@@ -1,7 +1,7 @@
spring:
  profiles:
    active:
      prod
      dev

  main:
    allow-bean-definition-overriding: true