no message

kimi42345

2020-03-28 f7af6b99c11bf876c0faef82d42caacf5475de93

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

@@ -11,17 +11,14 @@
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 org.apache.commons.lang3.StringUtils;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.text.MessageFormat;
import java.util.*;
import java.util.stream.Collectors;
@@ -46,7 +43,10 @@
    IMaintainDetailService maintainDetailService;
    @Autowired
    IFlowsService flowsService;

    @Autowired
    RedisClient redisClient;
    @Autowired
    IMaintainFieldService maintainFieldService;
    @Resource
    protected DataSource dataSource;

@@ -355,6 +355,74 @@
    }

    @Override
    public List<Map<String, Object>> selectListByVersion(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());
        boolean isNow = maintainService.checkNowVersion(maintainFromVersion.getId());
        boolean isFirst = maintainService.checkFirstVersion(maintainFromVersion.getId());

        Integer fromVersionOrderNo = maintainFromVersion.getOrderNo();
        Integer nowVersionOrderNo = 0;
        if (nowVersionMaintain != null) {
            nowVersionOrderNo = nowVersionMaintain.getOrderNo();
        }

        String tableTempName = tableName + Constant.RECORD;
        List<Map<String, Object>> result = null;

        String fields;
        String tempFields;
        String Hfields;
        String A1fields;
        String A2fields;

        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);
        } 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));
            A1fields = fieldList.stream().map(s -> MessageFormat.format(Constant.Alias,Constant.A1, s)).collect(Collectors.joining(Constant.COMMA));
            A2fields = fieldList.stream().map(s -> MessageFormat.format(Constant.Alias,Constant.A2, s)).collect(Collectors.joining(Constant.COMMA));
            tempFields = fieldList.stream()
                    .map(s ->
                            s.equalsIgnoreCase(Constant.ID) ? MessageFormat.format("{0} as id",Constant.STD_ID): s)
                    .collect(Collectors.joining(Constant.COMMA));

            tempHfields =  fieldList.stream()
                    .map(s ->
                            s.equalsIgnoreCase(Constant.ID) ? MessageFormat.format("{0} as id",Constant.STD_ID): s)
                    .map(s -> MessageFormat.format(Constant.Alias,Constant.H,s))
                    .collect(Collectors.joining(Constant.COMMA));

        }
        if (isNow && !findMax){
            result = mapper.selectByPage(tableName, fields, whereSegment, null);
        }
        else if (isMax && findMax) {
            ContentBuilder builder = new ContentBuilder(Constant.COMMA);
            if (nowVersionMaintain == null) {
                builder.append(DbUtils.quotedStr(maintainFromVersion.getId()));
            }else {
                List<String> maintainIds = maintainService.getCompareVersionMaintains(nowVersionMaintain, maintainFromVersion);
                long con = maintainIds.stream().map(s -> builder.append(DbUtils.quotedStr(s))).count();
            }

            result = mapper.selectByPageByMaxVersion(tableName,tableTempName,fields,tempFields, Hfields, A1fields, A2fields, tempHfields, fromVersionOrderNo, nowVersionOrderNo, DbUtils.quotedStr(maintainFromVersion.getId()),  whereSegment, null);

        }else {
            result = mapper.selectByPageByVersion(tableName,tableTempName,fields,tempFields, Hfields, A1fields, A2fields, tempHfields, nowVersionOrderNo, fromVersionOrderNo, DbUtils.quotedStr(maintainFromVersion.getId()), whereSegment,  null);
        }

        return result;
    }
    @Override
    public Result selectListByPageByVersion(String tableName, List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize, String version, boolean findMax) {

        Maintain maintainFromVersion = maintainService.getMaintainFromVersion(tableName, version);
@@ -558,6 +626,8 @@

        return maintain;
    }



    //bak
    public Result selectListByPage(String tableName, List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize, String version) {
@@ -909,5 +979,79 @@
        }
    }

    @Override
    public Set<String> getFieldValByTable(String tableName, String field) {
        //查缓存
        String key = DbUtils.getFieldRedisKey(tableName,field);
        String redisVal = redisClient.getRedisVal(key);
        if (!StringUtils.isEmpty(redisVal)) {
            List<String> valList = DbUtils.split(redisVal);
            if (valList != null)  {
                return new HashSet<String>(valList);
            }
        }
        // 读数据库
        String tempTableName = tableName + Constant.RECORD;
        List<Map<String, Object>> maps = mapper.selectByPage(tableName, MessageFormat.format(Constant.DISTINCT, field), Constant.WHERE_DEFAULT, null);

        List<Map<String, Object>> tempMaps = mapper.selectByPage(tempTableName, MessageFormat.format(Constant.DISTINCT, field), Constant.WHERE_DEFAULT, null);
        maps.addAll(tempMaps);
        if (maps.size() == 0) {
            return null;
        }
        Set<String> result = maps.stream()
                .filter(one -> one != null)
                .map(one -> one.get(field))
                .filter(o -> o != null)
                .map(o -> o.toString()).collect(Collectors.toSet());
        return result;
    }

    @Override
    public Set<String> getFieldValByMaintainField(String maintainFieldId, String field, String tableName) {
        //查缓存
        MaintainField maintainField = maintainFieldService.selectById(maintainFieldId);

        String key = DbUtils.getFieldRedisKey(tableName, field);
        String redisVal = redisClient.getRedisVal(key);
        if (!StringUtils.isEmpty(redisVal)) {
            List<String> valList = DbUtils.split(redisVal);
            if (valList != null)  {
                HashSet<String> strings = new HashSet<>(valList);
                return strings;
            }
        }
        // 读数据库
        List<Maintain> list = maintainFieldService.getMaintainByMaintainField(maintainFieldId, tableName);
        Maintain max = list.stream().max(new Comparator<Maintain>() {
            @Override
            public int compare(Maintain o1, Maintain o2) {
                return o1.getOrderNo() - o2.getOrderNo();
            }
        }).get();
        Maintain min = list.stream().min(new Comparator<Maintain>() {
            @Override
            public int compare(Maintain o1, Maintain o2) {
                return o1.getOrderNo() - o2.getOrderNo();
            }
        }).get();
        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);
        String tempTableName = tableName + Constant.RECORD;
        List<Map<String, Object>> tempVals = mapper.getOneTempFieldDataByMaintainExtent(DbUtils.quotedStr(tableName), tempTableName, field, min.getOrderNo(), max.getOrderNo());
        maps.addAll(tempVals);
        if (maps.size() == 0) {
            return null;
        }
        Set<String> result = maps.stream()
                .filter(one -> one != null)
                .map(one -> one.get(field))
                .filter(o -> o != null)
                .map(o -> o.toString()).collect(Collectors.toSet());
        String val = result.stream().collect(Collectors.joining(Constant.SEMICOLON));
        redisClient.putRedisVal(key, val);
        return result;
    }
}