package com.highdatas.mdm.service.impl; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.highdatas.mdm.entity.Character; import com.highdatas.mdm.entity.*; import com.highdatas.mdm.mapper.TableInfoMapper; import com.highdatas.mdm.pojo.*; import com.highdatas.mdm.service.*; import com.highdatas.mdm.util.*; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang3.StringUtils; import org.apache.ibatis.session.SqlSessionFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; 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; /** * @author kimi * @description * @date 2019-12-17 12:09 */ @Service @Slf4j public class MasterDataServiceImpl implements MasterDataService { @Autowired IMenuMappingService menuMappingService; @Autowired TableInfoMapper mapper; @Autowired ISysFieldService fieldService; @Autowired IMaintainService maintainService; @Autowired IMaintainDetailService maintainDetailService; @Autowired IFlowsService flowsService; @Autowired RedisClient redisClient; @Autowired IMaintainFieldService maintainFieldService; @Autowired IMasterAuthorService masterAuthorService; @Autowired SqlSessionFactory sqlSessionFactory; @Resource protected DataSource dataSource; @Autowired AntianaphylaxisClient antianaphylaxisClient; @Override public Result selectById(String tableName, String id) { try{ JSONObject object = new JSONObject(); String whereStr = DbUtils.combieOneSegment(Constant.ID, id); String fields = getFields(tableName); List> select = mapper.select(tableName, fields, whereStr); if (select == null || select.size() == 0) { return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND); } else if (select.size() == 1) { object.fluentPut("grid", select.get(0)); return Result.success(object); }else { object.fluentPut("grid", select); return Result.success(object); } } catch (Exception e) { return Result.error(CodeMsg.SELECT_ERROR); } } @Override public Result selectList(Character character, String tableName) { return selectList(character, tableName, null,null, (maintainService.getNowVersion(tableName).getVersion())); } @Override public Result selectList(Character character, String tableName, String whereSegment) { return selectList(character,tableName, whereSegment, (maintainService.getNowVersion(tableName).getVersion())); } @Override public Result selectList(Character character,String tableName, String whereSegment, String version) { return selectList(character, tableName, null, whereSegment, version); } @Override public Result selectList(Character character, String tableName, List fieldList, String whereSegment) { return selectList(character, tableName, fieldList, whereSegment, maintainService.getNowVersion(tableName).getVersion()); } @Override public Result selectList(Character character, String tableName,List 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(character, tableName, maintainFromVersion); } else { fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA)); } //std List> select = mapper.select(tableName, fields, whereSegment); List> maps = maintainService.selectVersionOperatorByType(tableName, maintainFromVersion.getId(), Operate.create); select.addAll(maps); object.fluentPut("grid", select); return Result.success(object); } catch (Exception e) { return Result.error(CodeMsg.SELECT_ERROR); } } @Override public Result selectList(Character character, String tableName, List fields) { return selectList(character, tableName,fields,Constant.WHERE_DEFAULT,(maintainService.getNowVersion(tableName).getVersion())); } public Long getCount(String tableName, String whereSegment) { try{ if (StringUtils.isEmpty(whereSegment)) { whereSegment = Constant.WHERE_DEFAULT; } Long count = mapper.getCount(tableName, whereSegment); return count; } catch (Exception e) { e.printStackTrace(); return null; } } @Override public Long getCountByVersion (Character character, String maintainId, String tableName,String tableTempName,Integer fromOrderNo, Integer toOrderNo, String whereSegment) { try{ Maintain maintain = maintainService.selectById(maintainId); String fields = getFields(character,tableName, maintain); String tempFields = getTempFields(character, tableName, Constant.A1, maintain); String A1fields = getFields(character, tableName, Constant.A1, maintain); if (StringUtils.isEmpty(whereSegment)) { whereSegment = Constant.WHERE_DEFAULT; } Long count; if (StringUtils.isEmpty(fields)) { return 0L; } count = mapper.getCountByVersion(tableName, tableTempName, fields, tempFields, A1fields,fromOrderNo, toOrderNo, whereSegment); return count; } catch (Exception e) { e.printStackTrace(); return null; } } public Long getCountByMaxVersion (Character character, String maintainId, String tableName,String tableTempName,Integer fromOrderNo, String whereSegment) { try{ Maintain maintain = maintainService.selectById(maintainId); String fields = getFields(character, tableName, maintain); String tempFields = getTempFields(character, tableName, Constant.A1, maintain); String A1fields = getFields(character, tableName, Constant.A1, maintain); if (StringUtils.isEmpty(whereSegment)) { whereSegment = Constant.WHERE_DEFAULT; } Long count = mapper.getCountByMaxVersion(tableName, tableTempName, fields, tempFields, A1fields, fromOrderNo, whereSegment); return count; } catch (Exception e) { e.printStackTrace(); return null; } } @Override public String getFields(String tableName) { return getFields(tableName, Constant.EMPTY_Str); } @Override public String getFields(Character character, String tableName, Maintain maintain) { return getFields(character, tableName, null, maintain); } @Override public String getFields(Character character, String tableName, Maintain maintain, String uuid) { return getFields(character, tableName, null, maintain, uuid); } private String getCaseWhenFields(String tableName) { List tableField = mapper.getTableField(tableName); ContentBuilder contentBuilder = new ContentBuilder(Constant.COMMA); for (TableSchemaResult tableSchemaResult : tableField) { String fieldName = tableSchemaResult.getFieldName(); if (fieldName.equalsIgnoreCase(Constant.DEAL)) { //DEAL 不给看 continue; } contentBuilder.append(MessageFormat.format(Constant.caseWhen, fieldName)); } return contentBuilder.toString(); } @Override public String getFields(String tableName, String alias) { List tableField = mapper.getTableField(tableName); ContentBuilder contentBuilder = new ContentBuilder(Constant.COMMA); for (TableSchemaResult tableSchemaResult : tableField) { String fieldName = tableSchemaResult.getFieldName(); if (fieldName.equalsIgnoreCase(Constant.DEAL)) { //DEAL 不给看 continue; } if (StringUtils.isEmpty(alias)) { contentBuilder.append(fieldName); } else { contentBuilder.append(MessageFormat.format(Constant.Alias,alias,fieldName)); } } return contentBuilder.toString(); } @Override public String getFields(Character character, String tableName, String alias, Maintain maintain) { return getFields(character, tableName, alias, maintain, null); } @Override public String getFields(Character character, String tableName, String alias, Maintain maintain, String uuid) { List fields; if (character == null) { fields = fieldService.getFieldByMaintain(maintain.getId()); }else { fields = masterAuthorService.getField(character, maintain.getId(), uuid); } 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)); } for (SysField field : fields) { String fieldName = field.getField(); if (fieldName.equalsIgnoreCase(Constant.DEAL)) { //DEAL 不给看 continue; } if (StringUtils.isEmpty(alias)) { contentBuilder.append(fieldName); } else { contentBuilder.append(MessageFormat.format(Constant.Alias,alias,fieldName)); } } return contentBuilder.toString(); } @Override public String getTempFields(Character character, String tableName, Maintain maintain) { return getTempFields(character, tableName, null, maintain); } @Override public String getTempFields(Character character, String tableName) { return getTempFields(character, tableName, Constant.EMPTY_Str); } @Override public String getTempFields(Character character, String tableName, String alias) { List tableField = mapper.getTableField(tableName); ContentBuilder contentBuilder = new ContentBuilder(Constant.COMMA); for (TableSchemaResult tableSchemaResult : tableField) { String fieldName = tableSchemaResult.getFieldName(); if (fieldName.equalsIgnoreCase(Constant.ID)) { if (StringUtils.isEmpty(alias)) { contentBuilder.append(MessageFormat.format("{0} as id", Constant.STD_ID)); } else { contentBuilder.append(MessageFormat.format("{0}.{1} as id", alias, Constant.STD_ID)); } continue; } if (StringUtils.isEmpty(alias)) { contentBuilder.append(fieldName); } else { contentBuilder.append(MessageFormat.format(Constant.Alias,alias,fieldName)); } } return contentBuilder.toString(); } @Override public String getTempFields(Character character, String tableName, String alias, Maintain maintain) { List fields; if (character == null) { fields = fieldService.getFieldByMaintain(maintain.getId()); }else { fields = masterAuthorService.getField(character, 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)); } List joinFieldList = getJoinFieldList(); for (SysField field : fields) { String fieldName = field.getField(); if (fieldName.equalsIgnoreCase(Constant.ID)) { if (StringUtils.isEmpty(alias)) { contentBuilder.append(MessageFormat.format("{0} as id", Constant.STD_ID)); } else { if (joinFieldList.contains(fieldName)) { contentBuilder.append(MessageFormat.format("{0}.{1} as id", alias, Constant.STD_ID)); } else { contentBuilder.append(MessageFormat.format("{0} as id", Constant.STD_ID)); } } continue; } if (StringUtils.isEmpty(alias)) { contentBuilder.append(fieldName); } else { if (joinFieldList.contains(fieldName)) { contentBuilder.append(MessageFormat.format(Constant.Alias,alias,fieldName)); } else { contentBuilder.append(fieldName); } } } return contentBuilder.toString(); } private List getJoinFieldList() { List fieldList = new ArrayList<>(); List maintainList = mapper.getTableField("maintain"); if (maintainList != null) { fieldList.addAll(maintainList); } List flows = mapper.getTableField("flows"); if (flows != null) { fieldList.addAll(flows); } List maintain_detail = mapper.getTableField("maintain_detail"); if (maintain_detail != null) { fieldList.addAll(maintain_detail); } return fieldList.stream().map(tableSchemaResult -> tableSchemaResult.getFieldName()).collect(Collectors.toList()); } @Override public Result selectListByPageByVersion(Character character, String tableName, Integer pageNo, Integer pageSize, boolean findMax) { return selectListByPageByVersion(character, tableName,Constant.WHERE_DEFAULT,pageNo,pageSize, findMax); } @Override public Result selectListByPageByVersion(Character character, String tableName, String whereSegment, Integer pageNo, boolean findMax) { return selectListByPageByVersion(character, tableName,null, whereSegment,pageNo, null, String.valueOf(maintainService.getNowVersion(tableName).getVersion()), findMax); } @Override public Result selectListByPageByVersion(Character character, String tableName, Integer pageNo, String version, boolean findMax) { return selectListByPageByVersion(character, tableName,null,Constant.WHERE_DEFAULT,pageNo, null, version, findMax); } @Override public Result selectListByPageByVersion(Character character, String tableName, Integer pageNo, boolean findMax) { return selectListByPageByVersion(character, tableName,null,Constant.WHERE_DEFAULT,pageNo, null, String.valueOf(maintainService.getNowVersion(tableName).getVersion()), findMax); } @Override public Result selectListByPageByVersion(Character character, String tableName, String whereSegment, Integer pageNo, Integer pageSize, boolean findMax) { return selectListByPageByVersion(character, tableName,null,whereSegment,pageNo,pageSize, findMax); } @Override public Result selectListByPageByVersion(Character character, String tableName, List fieldList, String whereSegment, Integer pageNo, boolean findMax) { return selectListByPageByVersion(character, tableName,null,whereSegment,pageNo, null, findMax); } @Override public Result selectListByPageByVersion(Character character, String tableName, List fieldList, Integer pageNo, boolean findMax) { return selectListByPageByVersion(character, tableName,null,Constant.WHERE_DEFAULT,pageNo, findMax); } @Override public Result selectListByPageByVersion(Character character, String tableName, String whereSegment, Integer pageNo, String version, boolean findMax) { return selectListByPageByVersion(character, tableName, null,whereSegment, pageNo, null,version, findMax); } @Override public Result selectListByPageByVersion(Character character, String tableName, String whereSegment, Integer pageNo, String version, boolean findMax, String uuid) { return selectListByPageByVersion(character, tableName, null,whereSegment, pageNo, null,version, findMax, uuid); } @Override public List> selectListByVersion(Character character, String tableName, List 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> result = null; String fields; String tempFields; String A1Fields; if (fieldList == null || fieldList.size() == 0) { fields = getFields(character, tableName, maintainFromVersion); A1Fields = getFields(character, tableName, Constant.A1, maintainFromVersion); tempFields = getTempFields(character, tableName, Constant.A1, maintainFromVersion); } else { fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA)); A1Fields = fieldList.stream() .map(s -> MessageFormat.format(Constant.Alias,Constant.A1, s)) .collect(Collectors.joining(Constant.COMMA)); tempFields = fieldList.stream() .map(s -> s.equalsIgnoreCase(Constant.ID) ? MessageFormat.format("{0} as id",Constant.STD_ID): s) .map(s -> MessageFormat.format(Constant.Alias,Constant.A1, 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 maintainIds = maintainService.getCompareVersionMaintains(nowVersionMaintain, maintainFromVersion); long con = maintainIds.stream().map(s -> builder.append(DbUtils.quotedStr(s))).count(); } result = mapper.selectByPageByMaxVersion(tableName,tableTempName,fields, A1Fields, tempFields, nowVersionOrderNo, whereSegment, null); }else { result = mapper.selectByPageByVersion(tableName,tableTempName,fields, A1Fields, tempFields, nowVersionOrderNo, fromVersionOrderNo, whereSegment, null); } return result; } @Override public String selectByVersionSql(Character character, String tableName, List 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; String result = null; String fields; String tempFields; String Hfields; String A1fields; String A2fields; String tempHfields; if (fieldList == null || fieldList.size() == 0) { fields = getFields(null, tableName, maintainFromVersion); Hfields = getFields(null, tableName,Constant.H, maintainFromVersion); A1fields = getFields(null, tableName,Constant.A1, maintainFromVersion); A2fields = getFields(null, tableName,Constant.A2, maintainFromVersion); tempFields = getTempFields(null, tableName, maintainFromVersion); tempHfields = getTempFields(null, 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)); } MyBatisSql ibatisSql = new MyBatisSql(); Map parameterMap = new HashMap<>(); if (isNow && !findMax){ parameterMap.put("tableName", tableName); parameterMap.put("fields", fields); parameterMap.put("where", whereSegment); parameterMap.put("limit", null); result = DbUtils.getMyBatisSql("selectByPage", parameterMap, sqlSessionFactory).getSql(); } else if (isMax && findMax) { ContentBuilder builder = new ContentBuilder(Constant.COMMA); if (nowVersionMaintain == null) { builder.append(DbUtils.quotedStr(maintainFromVersion.getId())); }else { List maintainIds = maintainService.getCompareVersionMaintains(nowVersionMaintain, maintainFromVersion); long con = maintainIds.stream().map(s -> builder.append(DbUtils.quotedStr(s))).count(); } parameterMap.put("tableName", tableName); parameterMap.put("tableTempName", tableTempName); parameterMap.put("fields", fields); parameterMap.put("tempFields", tempFields); parameterMap.put("Hfields", Hfields); parameterMap.put("A1fields", A1fields); parameterMap.put("A2fields", A2fields); parameterMap.put("tempHFields", tempHfields); parameterMap.put("fromOrderNo", fromVersionOrderNo); parameterMap.put("toOrderNo", nowVersionOrderNo); parameterMap.put("maintainId", DbUtils.quotedStr(maintainFromVersion.getId())); parameterMap.put("where", whereSegment); parameterMap.put("limit", null); result = DbUtils.getMyBatisSql("selectByPageByMaxVersion", parameterMap, sqlSessionFactory).getSql(); }else { parameterMap.put("tableName", tableName); parameterMap.put("tableTempName", tableTempName); parameterMap.put("fields", fields); parameterMap.put("tempFields", tempFields); parameterMap.put("Hfields", Hfields); parameterMap.put("A1fields", A1fields); parameterMap.put("A2fields", A2fields); parameterMap.put("tempHFields", tempHfields); parameterMap.put("fromOrderNo", fromVersionOrderNo); parameterMap.put("toOrderNo", nowVersionOrderNo); parameterMap.put("maintainId", DbUtils.quotedStr(maintainFromVersion.getId())); parameterMap.put("where", whereSegment); parameterMap.put("limit", null); result = DbUtils.getMyBatisSql("selectByPageByVersion", parameterMap, sqlSessionFactory).getSql(); } return result; } @Override public Long getCountByVersion(Character character, String tableName, 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; Long count; if (isNow && !findMax){ count = getCount(tableName, whereSegment); } else if (isMax && findMax) { if (isFirst && nowVersionMaintain == null) { nowVersionOrderNo = nowVersionOrderNo - 1; } count = getCountByMaxVersion(character, maintainFromVersion.getId(), tableName, tableTempName, nowVersionOrderNo, whereSegment); }else { count = getCountByVersion(character, maintainFromVersion.getId(), tableName, tableTempName, nowVersionOrderNo, fromVersionOrderNo, whereSegment); } return count; } @Override public Result selectListByPageByVersion(Character character, String tableName, List fieldList, String whereSegment, Integer pageNo, Integer pageSize, String version, boolean findMax) { return selectListByPageByVersion(character, tableName, fieldList, whereSegment, pageNo, pageSize, version, findMax, null); } @Override public Result selectListByPageByVersion(Character character, String tableName, List fieldList, String whereSegment, Integer pageNo, Integer pageSize, String version, boolean findMax, String uuid) { return selectListByPageByVersion(character, tableName, fieldList, whereSegment, pageNo, pageSize, version, findMax, uuid, null); } @Override public Result selectListByPageByVersion(Character character, String tableName, List fieldList, String whereSegment, Integer pageNo, Integer pageSize, String version, boolean findMax, String uuid, Page page) { String fieldStr = ""; if (fieldList == null || fieldList.isEmpty()) { fieldStr = ""; } else { fieldList.stream().collect(Collectors.joining(Constant.UnderLine)); } String key; if (page == null) { key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(), tableName, whereSegment, String.valueOf(pageNo), String.valueOf(pageSize), version, String.valueOf(findMax)); } else { key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(), tableName, whereSegment, String.valueOf(pageNo), String.valueOf(pageSize), version, String.valueOf(findMax), page.getLimitSQL()); } if (!findMax) { Object redisValObj = redisClient.getRedisValObj(key); if (redisValObj != null) { JSONObject object = (JSONObject) redisValObj; Result result = JSONObject.parseObject(object.toJSONString(), Result.class); return result; } } 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; Long count; Date startDate = new Date(); if (isNow && !findMax){ count = getCount(tableName, whereSegment); } else if (isMax && findMax) { if (isFirst && nowVersionMaintain == null) { nowVersionOrderNo = nowVersionOrderNo - 1; } count = getCountByMaxVersion(character, maintainFromVersion.getId(), tableName, tableTempName, nowVersionOrderNo, whereSegment); }else { count = getCountByVersion(character, maintainFromVersion.getId(), tableName, tableTempName, nowVersionOrderNo, fromVersionOrderNo, whereSegment); } Date endDate = new Date(); log.info(MessageFormat.format("master tag:{0} MASTER-- select count:{1} ms",uuid, (endDate.getTime() - startDate.getTime()))); if (page != null && count != null) { page.setRecordCount(count.intValue()); } if (count == null || count == 0) { return Result.success(null); } //mapper.selectByPageByVersion(tableName, tableTempName, fieldList, whereSegment,); List> result = null; if (page == null) { page = new Page(count); if (pageSize != null && pageSize.compareTo(1) != -1) { page.setPageSize(pageSize); } if (page.getPageCount() < pageNo) { return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND); } page.setPageNo(pageNo); } String limitSQL = page.getLimitSQL(); String fields; String tempFields; String A1Fields; if (fieldList == null || fieldList.size() == 0) { fields = getFields(character, tableName, maintainFromVersion, uuid); A1Fields = getFields(character, tableName, Constant.A1, maintainFromVersion, uuid); List fieldStrList = DbUtils.split(fields, Constant.COMMA); tempFields = fieldStrList.stream() .map(s -> s.equalsIgnoreCase(Constant.ID) ? MessageFormat.format("{0} as id",Constant.STD_ID): s) .map(s -> MessageFormat.format(Constant.Alias,Constant.A1, s)) .collect(Collectors.joining(Constant.COMMA)); } else { if (!fieldList.contains(Constant.ID)) { fieldList.add(Constant.ID); } fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA)); A1Fields = fieldList.stream() .map(s -> MessageFormat.format(Constant.Alias,Constant.A1, s)) .collect(Collectors.joining(Constant.COMMA)); tempFields = fieldList.stream() .map(s -> s.equalsIgnoreCase(Constant.ID) ? MessageFormat.format("{0} as id",Constant.STD_ID): s) .map(s -> MessageFormat.format(Constant.Alias,Constant.A1, s)) .collect(Collectors.joining(Constant.COMMA)); } startDate = new Date(); log.info(MessageFormat.format("master tag:{0} MASTER-- select field :{1} ms",uuid, (startDate.getTime() - endDate.getTime()))); if (isNow && !findMax){ result = mapper.selectByPage(tableName, fields, whereSegment, page.getLimitSQL()); } else if (isMax && findMax) { ContentBuilder builder = new ContentBuilder(Constant.COMMA); if (nowVersionMaintain == null) { builder.append(DbUtils.quotedStr(maintainFromVersion.getId())); }else { List maintainIds = maintainService.getCompareVersionMaintains(nowVersionMaintain, maintainFromVersion); long con = maintainIds.stream().map(s -> builder.append(DbUtils.quotedStr(s))).count(); } result = mapper.selectByPageByMaxVersion(tableName,tableTempName,fields, A1Fields, tempFields, nowVersionOrderNo, whereSegment, limitSQL); }else { result = mapper.selectByPageByVersion(tableName,tableTempName,fields, A1Fields, tempFields, nowVersionOrderNo, fromVersionOrderNo, whereSegment, limitSQL); } endDate = new Date(); log.info(MessageFormat.format("master tag:{0} MASTER-- select dataMap :{1} ms",uuid, (endDate.getTime() - startDate.getTime()))); EntityWrapper sysFieldEntityWrapper = new EntityWrapper<>(); sysFieldEntityWrapper.eq("table_name", tableName); List sysFields = masterAuthorService.getField(character, maintainFromVersion.getId()); if (isMax) { sysFields.add(new SysField().setAlias("数据状态").setField("operate").setVisible(true).setFormat("operate_")); sysFields.add(new SysField().setAlias("审批状态").setField("status").setVisible(true).setFormat("status_")); } JSONObject resultobject = new JSONObject(); JSONObject object = new JSONObject(); Map helpfulField = antianaphylaxisClient.getHelpfulField(fields, tableName); antianaphylaxisClient.fixMasterData(result,helpfulField); startDate = new Date(); log.info(MessageFormat.format("master tag:{0} MASTER-- antianaphy dataMap :{1} ms",uuid, (startDate.getTime() - endDate.getTime()))); object.fluentPut("total", page.getRecordCount()); object.fluentPut("size", page.getPageSize()); object.fluentPut("pages", page.getPageCount()); object.fluentPut("current", page.getPageNo()); object.fluentPut("record", result); resultobject.fluentPut("grid",object); resultobject.fluentPut("fields",sysFields); resultobject.fluentPut("maintainId", maintainFromVersion.getId()); redisClient.putRedisValObj(key, Result.success(resultobject)); return Result.success(resultobject); } @Override public Maintain uploadedData(String tableName, SysAssembleUpdateType uploadType, String userId) { return uploadedData(tableName, uploadType, userId, true); } @Override public Maintain uploadedData(String tableName, SysAssembleUpdateType uploadType, String userId, boolean bigVersion) { MenuMapping menuMapping = menuMappingService.selectOne(new EntityWrapper().eq("table_name",tableName)); SysOperateLog operateLog = new SysOperateLog(); Maintain maxVersion = maintainService.getMaxVersion(tableName); Maintain maintain = new Maintain(); String biggerVersion = null; if (maxVersion == null) { biggerVersion = Constant.VERSION_Default; maintain.setOrderNo(0); operateLog.setOperate("初始化主题数据"); } else { operateLog.setOperate("更新主题"); String flowId = maxVersion.getFlowId(); String mVersion = maxVersion.getVersion(); if (StringUtils.isEmpty(flowId)) { biggerVersion = mVersion; maintain.setOrderNo(maxVersion.getOrderNo()); String tempName = maxVersion.getTableName() + Constant.RECORD; mapper.deleteTempByMaintainId(tempName, DbUtils.quotedStr(maxVersion.getId())); maintainDetailService.delete(new EntityWrapper().eq("parent_id", maxVersion.getId())); maxVersion.deleteById(); }else { if (bigVersion) { biggerVersion = DbUtils.versionAddBig(mVersion); }else { biggerVersion = DbUtils.versionAddSub(mVersion); } maintain.setOrderNo(DbUtils.getOrderNoAdd(maxVersion.getOrderNo())); } } String uuid = DbUtils.getUUID(); maintain.setId(uuid); maintain.setVersion(biggerVersion); maintain.setChargeId(userId); maintain.setTableName(tableName); maintain.setCreateTime(new Date()); Connection connection = null; try { connection = dataSource.getConnection(); connection.setAutoCommit(false); mapper.insertMatintainDetailFromTemp(DbUtils.quotedStr(maintain.getId()), maintain.getTableName() + Constant.RECORD , DbUtils.quotedStr(Operate.create.toString())); mapper.updateStdId( maintain.getTableName() + Constant.RECORD); Integer aLong = mapper.tempDeal(maintain.getTableName() + Constant.RECORD, DbUtils.quotedStr(maintain.getId())); if (aLong == null) { maintain.setDesp("上传数据"); }else { maintain.setDesp(MessageFormat.format("上传数据{0}条", aLong)); } if (uploadType.equals(SysAssembleUpdateType.All)) { List tableField = mapper.getTableField(tableName); List tableFieldList = tableField.stream().map(tableSchemaResult -> tableSchemaResult.getFieldName()).collect(Collectors.toList()); tableFieldList.add(Constant.STD_ID); String collect = tableFieldList.stream().map(s -> s.equalsIgnoreCase(Constant.ID) ? MessageFormat.format(Constant.FieldAsAlias, Constant.MYSQL_UUID, Constant.ID) : s) .map(s -> s.equalsIgnoreCase(Constant.STD_ID) ? MessageFormat.format(Constant.FieldAsAlias, Constant.ID, Constant.STD_ID) : s).collect(Collectors.joining(Constant.COMMA)); mapper.insertRecordFromStandrad(maintain.getTableName(), maintain.getTableName() + Constant.RECORD, collect); mapper.insertMatintainDetailFromStandrad(DbUtils.quotedStr(maintain.getId()), maintain.getTableName() + Constant.RECORD); Integer standradCnt = mapper.tempDeal(maintain.getTableName() + Constant.RECORD, DbUtils.quotedStr(maintain.getId())); if (standradCnt != null) { maintain.setDesp(maintain.getDesp() + MessageFormat.format("删除原数据{0}条", standradCnt)); }else { maintain.setDesp(maintain.getDesp() + "删除原数据"); } } operateLog.setCreateTime(new Date()) .setMaintainId(maintain.getId()) .setId(DbUtils.getUUID()) .setMaintainId(menuMapping.getId()) .setOperate("open") .setDesp("批量上传数据"); maintain.insert(); connection.commit(); } catch (Exception e) { e.printStackTrace(); }finally { if (connection != null) { try { connection.close(); } catch (SQLException e) { e.printStackTrace(); } } } return maintain; } //bak public Result selectListByPage(String tableName, List fieldList, String whereSegment, Integer pageNo, Integer pageSize, String version) { Maintain maintainFromVersion = maintainService.getMaintainFromVersion(tableName, version); long changeCount = maintainService.countVersionOperatorByType(tableName + Constant.RECORD, whereSegment, maintainFromVersion.getId(), Operate.create); Long count = getCount(tableName, whereSegment); if (count == null) { //return Result.error(CodeMsg.SELECT_ERROR); } Page page = new Page(count + changeCount); if (pageSize != null && pageSize.compareTo(1) != -1) { page.setPageSize(pageSize); } List> result = null; if (page.getPageCount() < pageNo) { return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND); } page.setPageNo(pageNo); long recordNo = page.getRecordNo(); long preRecordNo = page.getPreRecordNo(); if (preRecordNo >= changeCount) { String limitSQL = page.getLimitSQL(); String fields; if (fieldList == null || fieldList.size() == 0) { fields = getFields(tableName); fieldList = Arrays.stream(fields.split(Constant.COMMA_TRIM)).collect(Collectors.toList()); } else { fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA)); } result = mapper.selectByPage(tableName, fields, whereSegment, limitSQL); } else if (changeCount > preRecordNo && recordNo > changeCount) { int fromchange = (int) (changeCount - preRecordNo); int fromStd = (int) (recordNo - changeCount); String limitSQL = page.getLimitSQL(); result = maintainService.selectVersionOperatorByTypeByPage(tableName + Constant.RECORD, maintainFromVersion.getId(), Operate.create, limitSQL); Page stdPage = new Page(changeCount + count); stdPage.setPageNo(1); stdPage.setPageSize(fromStd); limitSQL = stdPage.getLimitSQL(); String fields; if (fieldList == null || fieldList.size() == 0) { fields = getFields(tableName); fieldList = Arrays.stream(fields.split(Constant.COMMA_TRIM)).collect(Collectors.toList()); } else { fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA)); } List> maps = mapper.selectByPage(tableName, fields, whereSegment, limitSQL); result.addAll(maps); }else { String limitSQL = page.getLimitSQL(); result = maintainService.selectVersionOperatorByTypeByPage(tableName + Constant.RECORD, maintainFromVersion.getId(), Operate.create, limitSQL); } JSONObject resultobject = new JSONObject(); JSONObject object = new JSONObject(); object.fluentPut("total", page.getRecordCount()); object.fluentPut("size", page.getPageSize()); object.fluentPut("pages", page.getPageCount()); object.fluentPut("current", page.getPageNo()); object.fluentPut("record", result); resultobject.fluentPut("grid",object); resultobject.fluentPut("maintainId", maintainFromVersion.getId()); return Result.success(resultobject); } @Override public Result selectListByPageByVersion(Character character, String tableName,List fieldList, String whereSegment, Integer pageNo, Integer pageSize, boolean findMax, String uuid) { return selectListByPageByVersion(character, tableName, fieldList, whereSegment,pageNo,pageSize,String.valueOf(maintainService.getNowVersion(tableName).getVersion()), findMax, uuid); } @Override public Result selectListByPageByVersion(Character character, String tableName,List fieldList, String whereSegment, Integer pageNo, Integer pageSize, boolean findMax) { return selectListByPageByVersion(character, tableName, fieldList, whereSegment,pageNo,pageSize,String.valueOf(maintainService.getNowVersion(tableName).getVersion()), findMax); } @Override public Result insert(String tableName, String fields, String values) { try { String[] split = fields.split(Constant.SEMICOLON); List fieldNameList = Arrays.stream(split).map(s -> s.trim()).collect(Collectors.toList()); fields = fieldNameList.stream().collect(Collectors.joining(Constant.COMMA)); ContentBuilder builder = new ContentBuilder(Constant.COMMA); Object parse = JSON.parse(values); List ids = new ArrayList<>(); if (parse instanceof JSONObject){ JSONObject jsonObject = (JSONObject) parse; String id = appendOneValue(jsonObject, fieldNameList, builder); ids.add(id); String sqlValues = builder.toString(); mapper.insert(tableName, fields, sqlValues); return Result.success(ids); } else if (parse instanceof JSONArray) { JSONArray jsonArray = (JSONArray) parse; int size = jsonArray.size(); for (int i = 0; i < size; i++) { JSONObject jsonObject = jsonArray.getJSONObject(i); ids.add(appendOneValue(jsonObject, fieldNameList, builder)); } String sqlValues = builder.toString(); mapper.insert(tableName, fields, sqlValues); return Result.success(ids); } else { return Result.error(CodeMsg.INSERT_ERROR); } } catch (Exception e) { e.printStackTrace(); return Result.error(CodeMsg.INSERT_ERROR); } } public Result insert(String tableName, String json) { try { JSONObject dataObject = JSON.parseObject(json); Set keySet = dataObject.keySet(); List fieldNameList = new ArrayList<>(keySet); // List fieldByTable = fieldService.getFieldByTable(tableName); // List fieldNameList = fieldByTable.stream().map(sysField -> sysField.getField()).collect(Collectors.toList()); String fields = keySet.stream().collect(Collectors.joining(Constant.COMMA)); ContentBuilder builder = new ContentBuilder(Constant.COMMA); Object parse = JSON.parse(json); List ids = new ArrayList<>(); if (parse instanceof JSONObject){ JSONObject jsonObject = (JSONObject) parse; ids.add(appendOneValue(jsonObject, fieldNameList, builder)); String sqlValues = builder.toString(); mapper.insert(tableName, fields, sqlValues); return Result.success(ids); } else if (parse instanceof JSONArray) { JSONArray jsonArray = (JSONArray) parse; int size = jsonArray.size(); for (int i = 0; i < size; i++) { JSONObject jsonObject = jsonArray.getJSONObject(i); ids.add(appendOneValue(jsonObject, fieldNameList, builder)); } String sqlValues = builder.toString(); mapper.insert(tableName, fields, sqlValues); return Result.success(ids); } else { return Result.error(CodeMsg.INSERT_ERROR); } } catch (Exception e) { e.printStackTrace(); return Result.error(CodeMsg.INSERT_ERROR); } } private String appendOneValue(JSONObject jsonObject, List fieldNameList, ContentBuilder builder) { String id = null; builder.append("("); boolean first = true; for (int i = 0; i < fieldNameList.size(); i++) { String fieldName = fieldNameList.get(i); Object value = jsonObject.get(fieldName); if (fieldName.equalsIgnoreCase(Constant.ID)) { if (value == null) { id = DbUtils.getUUID(); value = id; }else { id = value.toString(); } } if (value == null && fieldName.equalsIgnoreCase(Constant.DEAL)) { //手动添加的默认deal=1 value = 1; } if (value instanceof String) { value = DbUtils.quotedStr(value); } if (first) { builder.appendOnly(String.valueOf(value)); first = false; } else { builder.append(value); } } builder.appendOnly(")"); return id; } @Override public Result updateById(String tableName, String fieldsSegment, String id, boolean total) { String whereStr = DbUtils.combieOneSegment(Constant.ID, id); return update(tableName, fieldsSegment,whereStr, total); } @Override public Result updateByStdId(String tableName, String fieldsSegment, String id, boolean total) { String whereStr = DbUtils.combieOneSegment(Constant.STD_ID, id); return update(tableName, fieldsSegment,whereStr, total); } @Override public Result update(String tableName, String fieldsSegment, boolean total) { String whereSegment = Constant.WHERE_DEFAULT; return update(tableName, fieldsSegment,whereSegment, total); } @Override public Result update(String tableName, String fieldsSegment, String whereSegment) { try { String updateSegment = getUpdateSegment(tableName, fieldsSegment); mapper.update(tableName, updateSegment, whereSegment); return Result.success(CodeMsg.UPDATE_SUCCESS); } catch (Exception e) { e.printStackTrace(); return Result.error(CodeMsg.UPDATE_ERROR); } } @Override public String getUpdateSegment(String tableName, String fieldsSegment) { ContentBuilder builder = new ContentBuilder(Constant.COMMA); JSONObject jsonObject = JSONObject.parseObject(fieldsSegment); List tableFieldResultList = mapper.getTableField(tableName); for (TableSchemaResult tableSchemaResult : tableFieldResultList) { String dbType = tableSchemaResult.getDbType(); String fieldName = tableSchemaResult.getFieldName(); Object o = jsonObject.get(fieldName); String javaTypeStr = DbUtils.toSqlToJava(dbType); Segment segment; if ("string".equalsIgnoreCase(javaTypeStr.trim())) { segment = new Segment(fieldName, String.valueOf(o)); } else { segment = new Segment(fieldName, o); } builder.append(segment.toString()); } return builder.toString(); } @Override public String getUpdateSegment(String tableName, String alias, String fieldsSegment) { ContentBuilder builder = new ContentBuilder(Constant.COMMA); JSONObject jsonObject = JSONObject.parseObject(fieldsSegment); List tableFieldResultList = mapper.getTableField(tableName); for (TableSchemaResult tableSchemaResult : tableFieldResultList) { String dbType = tableSchemaResult.getDbType(); String fieldName = tableSchemaResult.getFieldName(); Object o = jsonObject.get(fieldName); if (o == null) { continue; } String javaTypeStr = DbUtils.toSqlToJava(dbType); Segment segment; if ("string".equalsIgnoreCase(javaTypeStr.trim())) { segment = new Segment(MessageFormat.format(Constant.Alias, alias, fieldName), String.valueOf(o)); } else { segment = new Segment(MessageFormat.format(Constant.Alias, alias, fieldName), o); } builder.append(segment.toString()); } return builder.toString(); } @Override public Result update(String tableName, String fieldsSegment, String whereSegment, boolean total) { try { ContentBuilder builder = new ContentBuilder(Constant.COMMA); JSONObject jsonObject = JSONObject.parseObject(fieldsSegment); List tableFieldResultList = mapper.getTableField(tableName); if (total) { for (TableSchemaResult tableSchemaResult : tableFieldResultList) { String dbType = tableSchemaResult.getDbType(); String fieldName = tableSchemaResult.getFieldName(); Object o = jsonObject.get(fieldName); String javaTypeStr = DbUtils.toSqlToJava(dbType); Segment segment; if (o == null) { continue; } if ("string".equalsIgnoreCase(javaTypeStr.trim())) { segment = new Segment(fieldName, String.valueOf(o)); } else { if (fieldName.equalsIgnoreCase(Constant.DEAL)) { segment = new Segment(fieldName, 1); } else { segment = new Segment(fieldName, o); } } builder.append(segment.toString()); } } else { Set fieldSet = jsonObject.keySet(); for (String fieldName : fieldSet) { List collect = tableFieldResultList.stream().filter(tableSchemaResult -> tableSchemaResult.getFieldName().equalsIgnoreCase(fieldName)).collect(Collectors.toList()); if (collect.isEmpty()) { continue; } TableSchemaResult tableSchemaResult = collect.get(0); String dbType = tableSchemaResult.getDbType(); Object o = jsonObject.get(fieldName); String javaTypeStr = DbUtils.toSqlToJava(dbType); Segment segment; if ("string".equalsIgnoreCase(javaTypeStr.trim())) { segment = new Segment(fieldName, String.valueOf(o)); } else { if (fieldName.equalsIgnoreCase(Constant.DEAL)) { segment = new Segment(fieldName, 1); } else { segment = new Segment(fieldName, o); } } builder.append(segment.toString()); } } String updateSegment = builder.toString(); mapper.update(tableName, updateSegment, whereSegment); return Result.success(CodeMsg.UPDATE_SUCCESS); } catch (Exception e) { e.printStackTrace(); return Result.error(CodeMsg.UPDATE_ERROR); } } @Override public Result delete(String tableName) { return delete(tableName, Constant.WHERE_DEFAULT); } @Override public Result deleteById(String tableName, String id) { String whereStr = DbUtils.combieOneSegment(Constant.ID, id); return delete(tableName, whereStr); } @Override public Result deleteByStdId(String tableName, String id) { String whereStr = DbUtils.combieOneSegment(Constant.STD_ID, id); return delete(tableName, whereStr); } @Override public Result delete(String tableName, String whereSegment) { try { mapper.delete(tableName, whereSegment); return Result.success(CodeMsg.DELETE_SUCCESS); } catch (Exception e) { e.printStackTrace(); return Result.error(CodeMsg.DELETE_ERROR); } } @Override public Set getFieldValByTable(String tableName, String field) { //查缓存 String key = DbUtils.getFieldRedisKey(tableName,field); List redisList = redisClient.getRedisList(key); if (redisList != null) { HashSet strings = new HashSet<>(); for (Object o : redisList) { strings.add(o.toString()); } return strings; } // 读数据库 String tempTableName = tableName + Constant.RECORD; // List> maps = mapper.selectByPage(tableName, MessageFormat.format(Constant.DISTINCT, field), Constant.WHERE_DEFAULT, null); List> maps = mapper.selectDistinct(tempTableName, field, Constant.WHERE_DEFAULT); if (maps.size() == 0) { return null; } Set result = maps.stream() .filter(one -> one != null) .map(one -> one.get(field)) .filter(o -> o != null) .map(o -> o.toString()).collect(Collectors.toSet()); redisClient.putRedisList(key, new ArrayList(result)); return result; } @Override public Set getFieldValByMaintainField(String maintainFieldId, String field, String tableName) { //查缓存 MaintainField maintainField = maintainFieldService.selectById(maintainFieldId); // 读数据库 List list = maintainFieldService.getMaintainByMaintainField(maintainFieldId, tableName); Maintain max = list.stream().max(new Comparator() { @Override public int compare(Maintain o1, Maintain o2) { return o1.getOrderNo() - o2.getOrderNo(); } }).get(); Maintain min = list.stream().min(new Comparator() { @Override public int compare(Maintain o1, Maintain o2) { return o1.getOrderNo() - o2.getOrderNo(); } }).get(); ArrayList fieldList = new ArrayList<>(); fieldList.add(field); fieldList.add(Constant.ID); // where List> maps = selectListByVersion(null, tableName, fieldList, Constant.WHERE_DEFAULT, max.getVersion(), false); String tempTableName = tableName + Constant.RECORD; List> tempVals = mapper.getOneTempFieldDataByMaintainExtent(DbUtils.quotedStr(tableName), tempTableName, field, min.getOrderNo(), max.getOrderNo()); maps.addAll(tempVals); if (maps.size() == 0) { return null; } Set 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)); return result; } @Override public void createIdx(String recordTableName) { String idxName = MessageFormat.format(Constant.IDX_TEMPLATE, recordTableName, Constant.STD_ID); List> maps = mapper.selectIdxByTableName(DbUtils.quotedStr(recordTableName)); long existsIdx = maps.stream().filter(stringObjectMap -> stringObjectMap.get("index_name") != null) .map(stringObjectMap -> stringObjectMap.get("index_name").toString()) .filter(s -> idxName.equalsIgnoreCase(s)).count(); if (existsIdx == 0) { mapper.createIdx(recordTableName, idxName, Constant.STD_ID + Constant.COMMA + Constant.DEAL); } } }