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.*;
|
import com.highdatas.mdm.mapper.TableInfoMapper;
|
import com.highdatas.mdm.pojo.*;
|
import com.highdatas.mdm.service.*;
|
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.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import javax.sql.DataSource;
|
import java.sql.Connection;
|
import java.text.MessageFormat;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author kimi
|
* @description
|
* @date 2019-12-17 12:09
|
*/
|
|
@Service
|
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;
|
|
@Resource
|
protected DataSource dataSource;
|
|
@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<Map<String, Object>> 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(TUser user, String tableName) {
|
return selectList(user, tableName, null,null, (maintainService.getNowVersion(tableName).getVersion()));
|
}
|
|
|
@Override
|
public Result selectList(TUser user, String tableName, String whereSegment) {
|
return selectList(user,tableName, whereSegment, (maintainService.getNowVersion(tableName).getVersion()));
|
}
|
|
@Override
|
public Result selectList(TUser user,String tableName, String whereSegment, String version) {
|
return selectList(user, tableName, null, whereSegment, version);
|
}
|
|
@Override
|
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(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(user, tableName, maintainFromVersion);
|
} else {
|
fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA));
|
}
|
//std
|
List<Map<String, Object>> select = mapper.select(tableName, fields, whereSegment);
|
|
List<Map<String, Object>> 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(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) {
|
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 (TUser user, String maintainId, String tableName,String tableTempName,Integer fromOrderNo, Integer toOrderNo, String whereSegment) {
|
try{
|
Maintain maintain = maintainService.selectById(maintainId);
|
|
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;
|
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) {
|
e.printStackTrace();
|
return null;
|
}
|
}
|
|
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(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.getCountByMaxVersion(tableName, tableTempName, fields, tempFields, Hfields, A1fields,A2fields,tempHFields, fromOrderNo, toOrderNo, DbUtils.quotedStr(maintainId), 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(TUser user, String tableName, Maintain maintain) {
|
|
return getFields(user, tableName, null, maintain);
|
}
|
|
private String getCaseWhenFields(String tableName) {
|
List<TableSchemaResult> 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<TableSchemaResult> 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(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));
|
}
|
|
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(TUser user, String tableName, Maintain maintain) {
|
return getTempFields(user, tableName, null, maintain);
|
}
|
|
@Override
|
public String getTempFields(TUser user, String tableName) {
|
return getTempFields(user, tableName, Constant.EMPTY_Str);
|
}
|
@Override
|
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();
|
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(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));
|
}
|
|
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 {
|
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 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(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(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(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(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(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(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(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(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());
|
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(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));
|
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(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());
|
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(user, maintainFromVersion.getId(), tableName, tableTempName, fromVersionOrderNo, nowVersionOrderNo, whereSegment);
|
}else {
|
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) {
|
page.setPageSize(pageSize);
|
}
|
List<Map<String, Object>> result = null;
|
if (page.getPageCount() < pageNo) {
|
return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
|
}
|
page.setPageNo(pageNo);
|
|
String limitSQL = page.getLimitSQL();
|
String fields;
|
String tempFields;
|
String Hfields;
|
String A1fields;
|
String A2fields;
|
|
String tempHfields;
|
if (fieldList == null || fieldList.size() == 0) {
|
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));
|
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("{} as id",Constant.STD_ID): s)
|
.collect(Collectors.joining(Constant.COMMA));
|
|
tempHfields = fieldList.stream()
|
.map(s ->
|
s.equalsIgnoreCase(Constant.ID) ? MessageFormat.format("{} 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, page.getLimitSQL());
|
}
|
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, limitSQL);
|
|
}else {
|
result = mapper.selectByPageByVersion(tableName,tableTempName,fields,tempFields, Hfields, A1fields, A2fields, tempHfields, nowVersionOrderNo, fromVersionOrderNo, DbUtils.quotedStr(maintainFromVersion.getId()), whereSegment, limitSQL);
|
}
|
|
EntityWrapper<SysField> sysFieldEntityWrapper = new EntityWrapper<>();
|
sysFieldEntityWrapper.eq("table_name", tableName);
|
List<SysField> sysFields = fieldService.getFieldByMaintain(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();
|
|
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());
|
return Result.success(resultobject);
|
}
|
|
@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();
|
|
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<MaintainDetail>().eq("parent_id", maxVersion.getId()));
|
|
maxVersion.deleteById();
|
}else {
|
biggerVersion = DbUtils.versionAddBig(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;
|
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<TableSchemaResult> tableField = mapper.getTableField(tableName);
|
List<String> 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();
|
|
}
|
|
return maintain;
|
}
|
|
|
|
//bak
|
public Result selectListByPage(String tableName, List<String> 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<Map<String, Object>> 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<Map<String, Object>> 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(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
|
public Result insert(String tableName, String fields, String values) {
|
try {
|
String[] split = fields.split(Constant.SEMICOLON);
|
List<String> 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<String> 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 {
|
List<SysField> fieldByTable = fieldService.getFieldByTable(tableName);
|
|
List<String> fieldNameList = fieldByTable.stream().map(sysField -> sysField.getField()).collect(Collectors.toList());
|
String fields = fieldByTable.stream().map(sysField -> sysField.getField()).collect(Collectors.joining(Constant.COMMA));
|
|
ContentBuilder builder = new ContentBuilder(Constant.COMMA);
|
Object parse = JSON.parse(json);
|
List<String> 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<String> 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<TableSchemaResult> 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<TableSchemaResult> 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<TableSchemaResult> 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<String> fieldSet = jsonObject.keySet();
|
for (String fieldName : fieldSet) {
|
List<TableSchemaResult> 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<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);
|
// 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);
|
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;
|
}
|
}
|
