package com.highdatas.mdm.controller;
|
|
import com.alibaba.fastjson.JSON;
|
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.CodeMsg;
|
import com.highdatas.mdm.pojo.Operate;
|
import com.highdatas.mdm.pojo.Result;
|
import com.highdatas.mdm.pojo.SysAssembleUpdateType;
|
import com.highdatas.mdm.service.IMaintainDetailService;
|
import com.highdatas.mdm.service.IMaintainService;
|
import com.highdatas.mdm.service.IMenuMappingService;
|
import com.highdatas.mdm.service.MasterDataService;
|
import com.highdatas.mdm.util.Constant;
|
import com.highdatas.mdm.util.DbUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.*;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.io.UnsupportedEncodingException;
|
import java.net.URLDecoder;
|
import java.text.MessageFormat;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author kimi
|
* @description
|
* @date 2019-12-17 12:02
|
*/
|
|
@RestController
|
@RequestMapping("/master")
|
public class MasterDataController {
|
@Autowired
|
MasterDataService masterDataService;
|
|
@Autowired
|
IMaintainService maintainService;
|
@Autowired
|
IMaintainDetailService maintainDetailService;
|
|
@Autowired
|
IMenuMappingService menuMappingService;
|
|
@Autowired
|
TableInfoMapper tableInfoMapper;
|
|
@RequestMapping(value = "{tableName}/uploaded", method = RequestMethod.GET)
|
public Result get(@PathVariable String tableName, HttpServletRequest request) {
|
String uploadTypeStr = request.getParameter("uploadType");
|
SysAssembleUpdateType uploadType;
|
if (StringUtils.isEmpty(uploadTypeStr)) {
|
uploadType = SysAssembleUpdateType.Increment;
|
}
|
uploadType = SysAssembleUpdateType.valueOf(uploadTypeStr);
|
TUser user = (TUser) request.getSession().getAttribute(Constant.USER);
|
Maintain maintain = masterDataService.uploadedData(tableName, uploadType, user.getUserId());
|
JSONObject object = new JSONObject();
|
object.fluentPut("maintainId",maintain.getId());
|
object.fluentPut("version",maintain.getVersion());
|
return Result.success(object);
|
}
|
|
|
@RequestMapping(value = "{tableName}/get/{id}", method = RequestMethod.GET)
|
public Result get(@PathVariable String tableName, @PathVariable String id) {
|
return masterDataService.selectById(tableName,id);
|
}
|
|
@RequestMapping(value = "{tableName}/all/{pageNo}", method = RequestMethod.GET)
|
public Result getByPage(@PathVariable String tableName, @PathVariable Integer pageNo, HttpServletRequest request) throws UnsupportedEncodingException {
|
String pageSizeStr = request.getParameter("pageSize");
|
String whereSegment = request.getParameter(Constant.WHERE_SEGMENT);
|
String fields = request.getParameter(Constant.FIELDS);
|
if (StringUtils.isEmpty(whereSegment)) {
|
whereSegment = Constant.WHERE_DEFAULT;
|
}else {
|
whereSegment = URLDecoder.decode(whereSegment, "UTF-8");
|
}
|
String version = request.getParameter(Constant.VERSION);
|
String tableByName = tableInfoMapper.selectTableByName(tableName);
|
if (StringUtils.isEmpty(tableByName)) {
|
return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
|
}
|
|
boolean findMax = false;
|
if (StringUtils.isEmpty(version)) {
|
Maintain nowVersion = maintainService.getNowVersion(tableName);
|
if(nowVersion == null) {
|
return Result.error(new CodeMsg(100001,"无当前版本"));
|
}
|
version = String.valueOf(nowVersion.getVersion());
|
}else if(version.equalsIgnoreCase(Constant.MAX)){
|
findMax = true;
|
version = String.valueOf(maintainService.getMaxVersion(tableName).getVersion());
|
}
|
|
if (StringUtils.isEmpty(fields)) {
|
if (StringUtils.isEmpty(pageSizeStr)) {
|
return masterDataService.selectListByPageByVersion(tableName, whereSegment,pageNo,version, findMax);
|
}
|
return masterDataService.selectListByPageByVersion(tableName, null, whereSegment,pageNo, Integer.valueOf(pageSizeStr),version,findMax);
|
}else {
|
String[] split = fields.split(Constant.COMMA_TRIM);
|
List<String> fieldList = Arrays.stream(split).collect(Collectors.toList());
|
if (StringUtils.isEmpty(pageSizeStr)) {
|
return masterDataService.selectListByPageByVersion(tableName, fieldList, whereSegment,pageNo, null,version, findMax);
|
}
|
return masterDataService.selectListByPageByVersion(tableName, fieldList, whereSegment,pageNo, Integer.valueOf(pageSizeStr), findMax);
|
|
}
|
}
|
@RequestMapping(value = "{tableName}/all", method = RequestMethod.GET)
|
public Result<MenuMapping> getAll(@PathVariable String tableName,HttpServletRequest request) {
|
String whereSegment = request.getParameter(Constant.WHERE_SEGMENT);
|
String version = request.getParameter(Constant.VERSION);
|
if (StringUtils.isEmpty(version)) {
|
version = String.valueOf(maintainService.getNowVersion(tableName).getVersion());
|
}
|
if (StringUtils.isEmpty(whereSegment)) {
|
return masterDataService.selectList(tableName);
|
}
|
return masterDataService.selectList(tableName,whereSegment);
|
}
|
|
@RequestMapping(value = "{maintainId}/modify/{operateStr}", method = RequestMethod.POST)
|
public Result modify(@RequestParam String datas, @PathVariable String maintainId, @PathVariable String operateStr, HttpServletRequest request) throws UnsupportedEncodingException {
|
Result result = null;
|
Operate operate = Operate.parse(operateStr);
|
Maintain maintain = maintainService.selectById(maintainId);
|
switch (operate) {
|
case delete:
|
//datas is id;
|
Integer deleteCount = tableInfoMapper.deleteRecordByMaintainId(maintain.getTableName() + Constant.RECORD, DbUtils.quotedStr(datas), DbUtils.quotedStr(maintainId));
|
result = Result.success(deleteCount);
|
|
|
break;
|
case update:
|
JSONObject jsonObject = JSONObject.parseObject(datas);
|
String id = (String) jsonObject.get("id");
|
jsonObject.remove(Constant.ID);
|
datas = jsonObject.toJSONString();
|
String updateSegment = masterDataService.getUpdateSegment(maintain.getTableName(), maintain.getTableName() + Constant.RECORD, datas);
|
|
Integer updateCount = tableInfoMapper.updateRecordByMaintainId(maintain.getTableName() + Constant.RECORD, updateSegment, DbUtils.quotedStr(maintainId));
|
result = Result.success(updateCount);
|
break;
|
case create:
|
JSONObject createObject = JSONObject.parseObject(datas);
|
String recordId = DbUtils.getUUID();
|
createObject.fluentPut(Constant.ID, recordId);
|
createObject.fluentPut(Constant.STD_ID, DbUtils.getUUID());
|
datas = createObject.toJSONString();
|
|
MaintainDetail maintainDetail = new MaintainDetail();
|
maintainDetail.setParentId(maintainId);
|
maintainDetail.setId(DbUtils.getUUID());
|
maintainDetail.setPreMergeId(recordId);
|
maintainDetail.setCreateTime(new Date());
|
maintainDetail.setOperate(Operate.create);
|
|
result = masterDataService.insert(maintain.getTableName() + Constant.RECORD, datas);
|
if (result.getSuccess()) {
|
maintainDetail.insert();
|
}
|
break;
|
default:
|
result = Result.error(CodeMsg.OPERATR_ERROR);
|
break;
|
}
|
|
return result;
|
}
|
|
|
@RequestMapping(value = "{tableName}/{operateStr}", method = RequestMethod.POST)
|
public Result insert(@PathVariable String tableName,@PathVariable String operateStr, @RequestParam String datas, @RequestParam String modify, HttpServletRequest request) {
|
String fields = request.getParameter("fields");
|
Operate operate = Operate.parse(operateStr);
|
TUser user = (TUser) request.getSession().getAttribute("user");
|
String userId = user.getUserId();
|
Maintain maintain = maintainService.getMaxVersion(tableName);
|
Maintain nowMaintain = maintainService.getNextMaintain(tableName, userId);
|
|
|
Result result;
|
if (operate.equals(Operate.delete)) {
|
String nowMaintainId = nowMaintain.getId();
|
String tempId = tableInfoMapper.getTempIdByStdId(tableName + Constant.RECORD,DbUtils.quotedStr(datas), DbUtils.quotedStr(nowMaintainId));
|
if (!StringUtils.isEmpty(tempId)){
|
maintainDetailService.delete(new EntityWrapper<MaintainDetail>().eq("parent_id", maintain.getId()).eq("pre_merge_id",tempId));
|
result = masterDataService.deleteById(tableName + Constant.RECORD, tempId);
|
return result;
|
}else {
|
result = masterDataService.selectById(tableName, datas);
|
Object data = result.getData();
|
datas = JSON.toJSONString(data);
|
JSONObject object = JSON.parseObject(datas);
|
Object grid = object.get("grid");
|
datas = JSON.toJSONString(grid);
|
}
|
} else if (operate.equals(Operate.update)) {
|
JSONObject jsonObject = JSONObject.parseObject(datas);
|
Object id = jsonObject.get("id");
|
String nowMaintainId = nowMaintain.getId();
|
String tempId = tableInfoMapper.getTempIdByStdId(tableName + Constant.RECORD,DbUtils.quotedStr(id.toString()), DbUtils.quotedStr(nowMaintainId));
|
if (StringUtils.isEmpty(tempId)) {
|
result = masterDataService.selectById(tableName, id.toString());
|
} else {
|
jsonObject.put(Constant.STD_ID, id);
|
jsonObject.put(Constant.ID, tempId);
|
return masterDataService.updateById(tableName + Constant.RECORD, JSON.toJSONString(jsonObject), tempId,false);
|
}
|
}
|
|
//merge 2 temp
|
String tableTempName = tableName + Constant.RECORD;
|
|
JSONObject object = JSON.parseObject(datas);
|
Object dataId = object.get(Constant.ID);
|
if (dataId == null) {
|
dataId = DbUtils.getUUID();
|
}
|
object.put(Constant.STD_ID, dataId);
|
object.put(Constant.ID, DbUtils.getUUID());
|
datas = JSON.toJSONString(object);
|
if (StringUtils.isEmpty(fields)) {
|
result = masterDataService.insert(tableTempName, datas);
|
} else {
|
result = masterDataService.insert(tableTempName, fields, datas);
|
}
|
|
List<String> ids = (List<String>) result.getData();
|
|
nowMaintain.insertOrUpdate();
|
for (String id : ids) {
|
MaintainDetail maintainDetail = new MaintainDetail();
|
maintainDetail.setId(DbUtils.getUUID());
|
maintainDetail.setParentId(nowMaintain.getId());
|
maintainDetail.setPreMergeId(id);
|
maintainDetail.setOperate(operate);
|
maintainDetail.setCreateTime(new Date());
|
maintainDetail.insert();
|
}
|
|
result.setData(nowMaintain.getId());
|
|
Maintain firstVersionMaintain = maintainService.getMaintainFromVersion(tableName, Constant.VERSION_Default);
|
|
MenuMapping menuMapping = menuMappingService.selectOne(new EntityWrapper<MenuMapping>().eq("table_name", firstVersionMaintain.getTableName()));
|
|
SysOperateLog operateLog = new SysOperateLog();
|
operateLog.setChargeId(user.getUserId()).setId(DbUtils.getUUID())
|
.setMaintainId(nowMaintain.getId())
|
.setDesp(MessageFormat.format(operate.getLogMessage(), ids.size()))
|
.setOperate("更新主题")
|
.setCreateTime(new Date())
|
.setMenumappingId(menuMapping.getId());
|
operateLog.insert();
|
|
return result;
|
|
}
|
@RequestMapping(value = "update/{id}", method = RequestMethod.POST)
|
public Result updateById(@PathVariable String tableName,@RequestParam String datas, @PathVariable String id, HttpServletRequest request) {
|
String totalStr = request.getParameter(Constant.TOTAL);
|
boolean total = false;
|
if (!StringUtils.isEmpty(totalStr)) {
|
total = true;
|
}
|
return masterDataService.updateById(tableName, datas, id, total);
|
}
|
|
@RequestMapping(value = "update", method = RequestMethod.POST)
|
public Result update(@PathVariable String tableName, @RequestParam String datas, HttpServletRequest request) {
|
String whereSegment = request.getParameter(Constant.WHERE_SEGMENT);
|
String totalStr = request.getParameter(Constant.TOTAL);
|
boolean total = false;
|
if (!StringUtils.isEmpty(totalStr)) {
|
total = true;
|
}
|
if (StringUtils.isEmpty(whereSegment)) {
|
return masterDataService.update(tableName, datas,total);
|
} else {
|
return masterDataService.update(tableName, datas, whereSegment, total);
|
}
|
|
}
|
|
@RequestMapping(value = "delete/{id}", method = RequestMethod.GET)
|
public Result deleteById(@PathVariable String tableName, @PathVariable String id) {
|
return masterDataService.deleteById(tableName,id);
|
}
|
|
@RequestMapping(value = "delete", method = RequestMethod.GET)
|
public Result delete(@PathVariable String tableName, HttpServletRequest request) {
|
String whereSegment = request.getParameter(Constant.WHERE_SEGMENT);
|
if (StringUtils.isEmpty(whereSegment)) {
|
return masterDataService.delete(tableName);
|
} else {
|
return masterDataService.delete(tableName, whereSegment);
|
}
|
}
|
}
|
