package com.highdatas.mdm.service.impl;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.baomidou.mybatisplus.mapper.Wrapper;
|
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
|
import com.highdatas.mdm.entity.*;
|
import com.highdatas.mdm.mapper.MaintainFieldMapper;
|
import com.highdatas.mdm.pojo.ActivitiStatus;
|
import com.highdatas.mdm.pojo.Operate;
|
import com.highdatas.mdm.service.*;
|
import com.highdatas.mdm.util.Constant;
|
import com.highdatas.mdm.util.DbUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.text.MessageFormat;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 服务实现类
|
* </p>
|
*
|
* @author kimi
|
* @since 2020-03-06
|
*/
|
@Service
|
public class MaintainFieldServiceImpl extends ServiceImpl<MaintainFieldMapper, MaintainField> implements IMaintainFieldService {
|
@Autowired
|
IMaintainService maintainService;
|
@Autowired
|
IFlowsService flowsService;
|
@Autowired
|
ISysFieldService fieldService;
|
@Autowired
|
MaintainFieldMapper maintainFieldMapper;
|
@Autowired
|
IMasterAuthorService masterAuthorService;
|
@Autowired
|
IMasterAuthorDetailService masterAuthorDetailService;
|
@Override
|
public MaintainField getNextMaintain(String tableName, String userId) {
|
MaintainField maintain = this.getMaxVersion(tableName);
|
Maintain nowVersion = maintainService.getNowVersion(tableName);
|
if (nowVersion == null) {
|
return null;
|
}
|
if (maintain == null){
|
MaintainField maintainField = new MaintainField().setId(DbUtils.getUUID()).setVersion(Constant.VERSION_Default).setCreateTime(new Date()).setChargeId(userId).setOrderNo(0).setTableName(tableName);
|
maintainField.setMaintainId(nowVersion.getId());
|
return maintainField;
|
}
|
MaintainField unFlowMaxVersion = this.getUnFlowMaxVersion(tableName);
|
if (unFlowMaxVersion == null) {
|
unFlowMaxVersion = new MaintainField();
|
if (maintain != null) {
|
unFlowMaxVersion.setVersion(DbUtils.versionAddSub(maintain.getVersion()));
|
int orderNo = maintain.getOrderNo();
|
orderNo++;
|
unFlowMaxVersion.setOrderNo(orderNo);
|
} else {
|
unFlowMaxVersion.setVersion(Constant.VERSION_Default);
|
unFlowMaxVersion.setOrderNo(0);
|
}
|
|
unFlowMaxVersion.setId(DbUtils.getUUID());
|
unFlowMaxVersion.setChargeId(userId);
|
unFlowMaxVersion.setCreateTime(new Date());
|
unFlowMaxVersion.setTableName(tableName);
|
}
|
|
MaintainField nowMaintain = unFlowMaxVersion;
|
if (DbUtils.compareVersion(maintain, unFlowMaxVersion) != 0) {
|
nowMaintain = new MaintainField();
|
String maintanId = DbUtils.getUUID();
|
nowMaintain.setId(maintanId);
|
nowMaintain.setCreateTime(new Date());
|
int orderNo = maintain.getOrderNo();
|
orderNo++;
|
nowMaintain.setVersion(DbUtils.versionAddSub(maintain.getVersion()));
|
nowMaintain.setOrderNo(orderNo);
|
nowMaintain.setTableName(tableName);
|
}
|
|
if (nowVersion!= null){
|
nowMaintain.setMaintainId(nowVersion.getId());
|
}
|
|
nowMaintain.setChargeId(userId);
|
String maintainId = nowMaintain.getId();
|
if(StringUtils.isEmpty(maintainId)) {
|
nowMaintain.setId(DbUtils.getUUID());
|
}
|
return nowMaintain;
|
}
|
|
@Override
|
public List<Maintain> getMaintainByMaintainField(String maintainFieldId, String tableName) {
|
HashMap<String, List<Maintain>> resultMap = getMaintainFieldMapByTable(tableName);
|
if (resultMap == null) {
|
return null;
|
}
|
if (maintainFieldId.equalsIgnoreCase(Constant.All)) {
|
Collection<List<Maintain>> values = resultMap.values();
|
HashSet<Maintain> maintains = new HashSet<>();
|
for (List<Maintain> value : values) {
|
maintains.addAll(value);
|
}
|
|
return new ArrayList<>(maintains);
|
}
|
return resultMap.get(maintainFieldId);
|
}
|
|
@Override
|
public boolean checkNowVersion(String maintainFieldId) {
|
MaintainField maintain = selectById(maintainFieldId);
|
MaintainField maxVersion = getNowVersion(maintain.getTableName());
|
Integer compared = DbUtils.compareVersion(maxVersion, maintain);
|
if (compared != null && compared == 0) {
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
@Override
|
public boolean checkFirstVersion(String id) {
|
MaintainField maintain = selectById(id);
|
MaintainField order_no = selectOne(new EntityWrapper<MaintainField>().eq("table_name", maintain.getTableName()).orderBy("order_no"));
|
if (maintain.getId().equalsIgnoreCase(order_no.getId())) {
|
return true;
|
}
|
return false;
|
}
|
|
@Override
|
public boolean checkdMaxVersion(String maintainFieldId) {
|
MaintainField maintain = selectById(maintainFieldId);
|
MaintainField maxVersion = getMaxVersion(maintain.getTableName());
|
Integer compared = DbUtils.compareVersion(maxVersion, maintain);
|
if (compared == 0) {
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
@Override
|
public MaintainField getMaxVersion(String tableName) {
|
Wrapper<MaintainField> versionWrapper = new EntityWrapper<MaintainField>().eq("table_name", tableName).orderBy("order_no desc");
|
|
MaintainField maxVersion = this.selectOne(versionWrapper);
|
return maxVersion;
|
}
|
|
@Override
|
public MaintainField getUnFlowMaxVersion(String tableName) {
|
Wrapper<MaintainField> versionWrapper = new EntityWrapper<MaintainField>().isNull("flow_id").eq("table_name", tableName).orderBy("order_no desc");
|
|
MaintainField maxVersion = selectOne(versionWrapper);
|
return maxVersion;
|
}
|
|
@Override
|
public MaintainField getNowVersion(String tableName) {
|
Wrapper<MaintainField> versionWrapper = new EntityWrapper<MaintainField>().eq("table_name", tableName).isNotNull("flow_id").orderBy("order_no desc");
|
|
List<MaintainField> maintains = selectList(versionWrapper);
|
for (MaintainField maintain : maintains) {
|
Flows flows = flowsService.selectById(maintain.getFlowId());
|
if (flows == null){
|
continue;
|
}
|
ActivitiStatus status = flows.getStatus();
|
if (status.equals(ActivitiStatus.open)) {
|
return maintain;
|
}
|
}
|
return null;
|
}
|
|
@Override
|
public MaintainField getMaintainFromVersion(String tableName, String verison) {
|
Wrapper<MaintainField> versionWrapper = new EntityWrapper<MaintainField>().eq("version", verison).eq("table_name", tableName);
|
MaintainField maxVersion = selectOne(versionWrapper);
|
return maxVersion;
|
}
|
|
@Override
|
public void dealFlow(String maintainId, ActivitiStatus status) {
|
MaintainField maintainField = selectById(maintainId);
|
if (status.equals(ActivitiStatus.close)) {
|
//delete maintain
|
fieldService.delete(new EntityWrapper<SysField>().eq("maintain_field_id", maintainField.getId()));
|
maintainField.deleteById();
|
}
|
else if (status.equals(ActivitiStatus.open)) {
|
|
Integer orderNo = maintainField.getOrderNo();
|
int preNo = orderNo - 1;
|
MaintainField preMaintainField;
|
if (preNo < 0 ) {
|
preMaintainField = new MaintainField().setId(Constant.Default);
|
}else {
|
preMaintainField = selectOne(new EntityWrapper<MaintainField>()
|
.eq("table_name", maintainField.getTableName())
|
.eq("order_no", preNo));
|
}
|
|
if (preMaintainField == null){
|
return;
|
}
|
List<MasterAuthor> masterAuthors = masterAuthorService.selectList(
|
new EntityWrapper<MasterAuthor>()
|
.eq("maintain_auto", true)
|
.eq("table_name", maintainField.getTableName())
|
.eq("maintain_field_id", preMaintainField.getId()));
|
if (masterAuthors.isEmpty()) {
|
return;
|
}
|
List<SysField> fieldList = fieldService.selectList(new EntityWrapper<SysField>().eq("maintain_field_id", maintainField.getId()));
|
|
List<SysField> deleteList = fieldList.stream().filter(sysField -> Operate.delete.equals(sysField.getOperate())).collect(Collectors.toList());
|
List<SysField> updateList = fieldList.stream().filter(sysField -> (Operate.update.equals(sysField.getOperate()))).collect(Collectors.toList());
|
List<SysField> createList = fieldList.stream().filter(sysField -> (Operate.create.equals(sysField.getOperate()))).collect(Collectors.toList());
|
|
List<String> createFieldList = createList.stream().map(sysField -> sysField.getField()).collect(Collectors.toList());
|
|
|
for (MasterAuthor masterAuthor : masterAuthors) {
|
Boolean fieldAuto = masterAuthor.getFieldAuto();
|
|
List<MasterAuthorDetail> masterAuthorDetails = masterAuthorDetailService.selectList(new EntityWrapper<MasterAuthorDetail>().eq(Constant.PARENT_ID, masterAuthor.getId()));
|
|
masterAuthor.setMaintainFieldId(maintainField.getId())
|
.setCreateTime(new Date())
|
.setUpdateTime(null)
|
.setId(DbUtils.getUUID())
|
.insert();
|
|
for (MasterAuthorDetail masterAuthorDetail : masterAuthorDetails) {
|
long count = deleteList.stream().filter(sysField -> sysField.getField().equalsIgnoreCase(masterAuthorDetail.getField())).count();
|
if (count > 0) {
|
continue;
|
}
|
masterAuthorDetail.setParentId(masterAuthor.getId()).setId(DbUtils.getUUID()).insert();
|
}
|
|
if (fieldAuto) {
|
for (String s : createFieldList) {
|
new MasterAuthorDetail().setField(s).setVal(Constant.z_AllVal).setAll(true).setParentId(masterAuthor.getId()).setId(DbUtils.getUUID()).insert();
|
}
|
}
|
}
|
//
|
|
|
//delete
|
for (SysField field : deleteList) {
|
field.deleteById();
|
}
|
//update
|
for (SysField field : updateList) {
|
field.setOperate(null).updateById();
|
}
|
for (SysField field : createList) {
|
String fieldType = field.getFieldType();
|
if (StringUtils.isEmpty(fieldType)) {
|
fieldType = Constant.varchar;
|
}
|
String fieldTypeStr;
|
if (fieldType.equalsIgnoreCase(Constant.varchar)) {
|
fieldTypeStr = DbUtils.StrJoin(fieldType, Constant.varcharSize);
|
}else {
|
fieldTypeStr = fieldType;
|
}
|
String tableName = field.getTableName();
|
String tempTableName = Constant.Temp + tableName;
|
String recordTableName = tableName + Constant.RECORD;
|
|
|
maintainFieldMapper.addCloumn(tempTableName, field.getField(), fieldTypeStr);
|
maintainFieldMapper.addCloumn(recordTableName, field.getField(), fieldTypeStr);
|
maintainFieldMapper.addCloumn(tableName, field.getField(), fieldTypeStr);
|
|
field.setOperate(null).updateById();
|
}
|
|
|
|
}
|
}
|
|
|
|
|
|
@Override
|
public int getUnFlowCount(String tableName, String userId) {
|
List<MaintainField> maintainFields = selectList(new EntityWrapper<MaintainField>().eq("table_name", tableName));
|
List<String> flowIdList = maintainFields.stream().filter(maintainField -> maintainField.getFlowId() != null).map(MaintainField::getFlowId).collect(Collectors.toList());
|
if (flowIdList.size() == 0) {
|
return 0;
|
}
|
List<Flows> flowsList = flowsService.selectBatchIds(flowIdList);
|
List<Flows> unFlowedList = flowsList.stream().filter(flows -> flows.getStatus().equals(ActivitiStatus.working) || flows.getStatus().equals(ActivitiStatus.refuse)).collect(Collectors.toList());
|
int cnt = 0;
|
for (Flows flows : unFlowedList) {
|
boolean nextAudit = flowsService.isNextAudit(flows, userId);
|
if (nextAudit) {
|
|
cnt++;
|
}
|
}
|
return cnt;
|
}
|
|
@Override
|
public JSONArray getMaintainListByTable(String tableName) {
|
HashMap<String, List<Maintain>> resultMap = getMaintainFieldMapByTable(tableName);
|
|
Set<String> keySet = resultMap.keySet();
|
ArrayList<String> keys = new ArrayList<>(keySet);
|
Collections.sort(keys, new Comparator<String>() {
|
@Override
|
public int compare(String maintianFieldId1, String maintianFieldId2) {
|
MaintainField maintainField1 = selectById(maintianFieldId1);
|
MaintainField maintainField2 = selectById(maintianFieldId2);
|
if (maintainField1 == null) {
|
return 1;
|
}
|
if (maintainField2 == null){
|
return -1;
|
}
|
|
return maintainField1.getOrderNo().compareTo(maintainField2.getOrderNo());
|
}
|
});
|
|
JSONArray array = new JSONArray();
|
for (String s : keys) {
|
List<Maintain> list = resultMap.get(s);
|
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();
|
JSONObject object = new JSONObject();
|
object.fluentPut("maintainFieldId", s);
|
object.fluentPut("version", MessageFormat.format(Constant.extent, min.getVersion(), max.getVersion()));
|
object.fluentPut("list", list);
|
|
array.add(object);
|
}
|
return array;
|
}
|
|
@Override
|
public List<Maintain> getMaintainListByMaintainField(String id, String tableName) {
|
MaintainField maintainField = selectById(id);
|
if (maintainField == null) {
|
if (!id.equalsIgnoreCase(Constant.Default) && !id.equalsIgnoreCase(Constant.All)){
|
return null;
|
}else {
|
maintainField = new MaintainField().setId(id).setTableName(tableName);
|
}
|
|
}
|
|
return getMaintainByMaintainField(maintainField.getId(), maintainField.getTableName());
|
}
|
|
private HashMap<String, List<Maintain>> getMaintainFieldMapByTable(String tableName) {
|
List<Maintain> maintainList = maintainService.selectList(new EntityWrapper<Maintain>().eq("table_name", tableName).isNotNull("flow_id").orderBy("order_no desc"));
|
HashMap<String, List<Maintain>> resultMap = new HashMap<>();
|
for (Maintain maintain : maintainList) {
|
ActivitiStatus status = flowsService.getStatusByBusinessId(maintain.getId());
|
if (!status.equals(ActivitiStatus.open)) {
|
continue;
|
}
|
MaintainField maintainFieldByMaintain = fieldService.getMaintainFieldByMaintain(maintain.getId());
|
List<Maintain> list = resultMap.get(maintainFieldByMaintain.getId());
|
if (list == null) {
|
list = new ArrayList<>();
|
}
|
list.add(maintain);
|
resultMap.put(maintainFieldByMaintain.getId(), list);
|
}
|
return resultMap;
|
}
|
}
|
