package com.highdatas.mdm.service.impl;
|
|
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.controller.MasterAuthorController;
|
import com.highdatas.mdm.entity.Character;
|
import com.highdatas.mdm.entity.*;
|
import com.highdatas.mdm.mapper.MasterAuthorMapper;
|
import com.highdatas.mdm.mapper.TableInfoMapper;
|
import com.highdatas.mdm.pojo.ActivitiStatus;
|
import com.highdatas.mdm.pojo.MasterAuthorType;
|
import com.highdatas.mdm.pojo.Page;
|
import com.highdatas.mdm.pojo.kettle.UnBigDataDataSourceInfo;
|
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 lombok.extern.slf4j.Slf4j;
|
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-23
|
*/
|
@Service
|
@Slf4j
|
public class MasterAuthorServiceImpl extends ServiceImpl<MasterAuthorMapper, MasterAuthor> implements IMasterAuthorService {
|
public static final String characterId = "characterId";
|
@Autowired
|
IMasterAuthorDetailService authorDetailService;
|
@Autowired
|
ITUserRoleService userRoleService;
|
@Autowired
|
ISysMenuService menuService;
|
@Autowired
|
ISysFieldService fieldService;
|
@Autowired
|
IMaintainFieldService maintainFieldService;
|
@Autowired
|
IMaintainService maintainService;
|
@Autowired
|
IFlowsService flowsService;
|
@Autowired
|
UnBigDataDataSourceInfo unBigDataDataSourceInfo;
|
@Autowired
|
IMenuMappingService menuMappingService;
|
@Autowired
|
IMaintainDetailService maintainDetailService;
|
@Autowired
|
MasterDataService masterDataService;
|
@Autowired
|
TableInfoMapper tableInfoMapper;
|
@Autowired
|
RedisClient redisClient;
|
|
@Override
|
public Page getInitPageInfo(MasterAuthor masterAuthor, Maintain maintain, TUser user, boolean getIncrement) {
|
String realRedisKey = RedisClient.getRealRedisKey(user.getUserId() + "-" + maintain.getId() + "-" + getIncrement);
|
Object redisValObj = redisClient.getRedisValObj(realRedisKey);
|
if (redisValObj != null) {
|
JSONObject object = (JSONObject) redisValObj;
|
Page page = JSONObject.parseObject(object.toJSONString(), Page.class);
|
return page;
|
}
|
Page page = new Page(0);
|
List<TableSchemaResult> tableField = tableInfoMapper.getTableField(masterAuthor.getTableName());
|
|
List<SysField> fieldByMaintain = fieldService.getFieldByMaintain(maintain.getId());
|
List<String> authorFieldList = fieldByMaintain.stream().map(sysField -> sysField.getField()).collect(Collectors.toList());
|
int totalLength = 0;
|
for (TableSchemaResult tableSchemaResult : tableField) {
|
String fieldName = tableSchemaResult.getFieldName();
|
if (!authorFieldList.contains(fieldName)) {
|
continue;
|
}
|
int length = tableSchemaResult.getLength();
|
totalLength += length;
|
}
|
|
int pageSize = Constant.MaxDispenseSize / totalLength;
|
page.setPageSize(pageSize);
|
long totalCnt;
|
if (getIncrement) {
|
totalCnt = maintainDetailService.selectCount(new EntityWrapper<MaintainDetail>().eq(Constant.PARENT_ID, maintain.getId()));
|
}else {
|
String filter = getFilter(user, maintain.getId());
|
totalCnt = masterDataService.getCountByVersion(user, maintain.getTableName(), filter, maintain.getVersion(), false);
|
}
|
page.setRecordCount(Long.valueOf(totalCnt).intValue());
|
if (totalCnt == 0) {
|
page.setRecordCount(0);
|
redisClient.putRedisValObj(realRedisKey, page);
|
return page;
|
}
|
int pages;
|
if (totalCnt % pageSize == 0) {
|
pages = Long.valueOf(totalCnt/pageSize).intValue();
|
}else {
|
pages = (Long.valueOf(totalCnt/pageSize).intValue()) + 1;
|
}
|
page.setPages(pages);
|
|
redisClient.putRedisValObj(realRedisKey, page);
|
return page;
|
}
|
|
@Override
|
public HashMap<String, MasterAuthor> merageRoleAuthor(Set<String> roleIds) {
|
List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleIds));
|
HashMap<String, MasterAuthor> resultMap = new HashMap<>();
|
|
for (MasterAuthor masterAuthor : masterAuthors) {
|
List<MasterAuthorDetail> masterAuthorDetails = authorDetailService.selectList(new EntityWrapper<MasterAuthorDetail>().eq(Constant.PARENT_ID, masterAuthor.getId()));
|
masterAuthor.setFields(masterAuthorDetails);
|
|
String key = DbUtils.getFieldRedisKey(masterAuthor.getTableName(), masterAuthor.getMaintainFieldId());
|
MasterAuthor preMerageMasterAuthor = resultMap.get(key);
|
if (preMerageMasterAuthor == null) {
|
resultMap.put(key, masterAuthor);
|
}
|
else {
|
preMerageMasterAuthor = merage(preMerageMasterAuthor, masterAuthor);
|
resultMap.put(key, preMerageMasterAuthor);
|
}
|
}
|
return resultMap;
|
}
|
|
@Override
|
public List<SysMenu> getMenu(Character character) {
|
return getMenu(character, false);
|
}
|
|
@Override
|
public List<SysMenu> getMenuUnParent(Character character) {
|
return getMenuUnParent(character, false);
|
}
|
|
@Override
|
public List<SysMenu> getMenuUnParent(Character character, boolean isTableMenu) {
|
String key = DbUtils.StrJoinLink(Constant.UnderLine,character.getId(),"menuUnParent", String.valueOf(isTableMenu));
|
List<Object> redisList = redisClient.getRedisList(key);
|
if (redisList != null) {
|
List<SysMenu> result = new ArrayList<>();
|
for (Object o : redisList) {
|
JSONObject object = (JSONObject) o;
|
SysMenu menu = JSONObject.parseObject(object.toJSONString(), SysMenu.class);
|
result.add(menu);
|
}
|
return result;
|
}
|
MasterAuthorType type = character.getType();
|
List<MasterAuthor> masterAuthors = null;
|
switch (type){
|
case role:
|
masterAuthors = getRoleAuthors(character.getId(), null);
|
break;
|
case groupInfo:
|
masterAuthors = getOneGroupAuthors(character.getId(), null);
|
break;
|
case user:
|
masterAuthors = getUserAuthor(character.getId(), null);
|
}
|
if (masterAuthors == null || masterAuthors.isEmpty()) {
|
return null;
|
}
|
List<String> menuIds = masterAuthors.stream().map(masterAuthor -> masterAuthor.getMenuId()).collect(Collectors.toList());
|
|
if (isTableMenu) {
|
List<String> tempList = new ArrayList<>();
|
for (String menuId : menuIds) {
|
String tableNameByMenu = menuMappingService.getTableNameByMenu(menuId);
|
boolean exists = unBigDataDataSourceInfo.checkTableExists(tableNameByMenu);
|
if (exists) {
|
tempList.add(menuId);
|
}
|
}
|
menuIds = tempList;
|
}
|
List<SysMenu> sysMenus = menuService.selectBatchIds(menuIds);
|
redisClient.putRedisList(key, (sysMenus));
|
return sysMenus;
|
}
|
|
@Override
|
public List<SysMenu> getMenu(Character character, boolean isTableMenu) {
|
|
String key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(),"menu", String.valueOf(isTableMenu));
|
List<Object> redisList = redisClient.getRedisList(key);
|
if (redisList != null) {
|
List<SysMenu> result = new ArrayList<>();
|
for (Object o : redisList) {
|
JSONObject object = (JSONObject) o;
|
SysMenu menu = JSONObject.parseObject(object.toJSONString(), SysMenu.class);
|
result.add(menu);
|
}
|
return result;
|
}
|
|
MasterAuthorType type = character.getType();
|
List<MasterAuthor> masterAuthors = null;
|
switch (type){
|
case role:
|
masterAuthors = getRoleAuthors(character.getId(), null);
|
break;
|
case groupInfo:
|
masterAuthors = getOneGroupAuthors(character.getId(), null);
|
break;
|
case user:
|
masterAuthors = getUserAuthor(character.getId(), null);
|
}
|
if (masterAuthors == null || masterAuthors.isEmpty()) {
|
return null;
|
}
|
List<String> menuIds = masterAuthors.stream().map(masterAuthor -> masterAuthor.getMenuId()).collect(Collectors.toList());
|
|
if (isTableMenu) {
|
List<String> tempList = new ArrayList<>();
|
for (String menuId : menuIds) {
|
String tableNameByMenu = menuMappingService.getTableNameByMenu(menuId);
|
boolean exists = unBigDataDataSourceInfo.checkTableExists(tableNameByMenu);
|
if (exists) {
|
tempList.add(menuId);
|
}
|
}
|
menuIds = tempList;
|
}
|
|
LinkedHashSet<String> strings = new LinkedHashSet<>(menuIds);
|
List<SysMenu> sysMenus = menuService.getMenuByParentId(strings);
|
if (sysMenus == null) {
|
return null;
|
}
|
redisClient.putRedisList(key, (sysMenus));
|
return sysMenus;
|
}
|
@Override
|
public List<MasterAuthor> getUserAuthor(String characterId, MaintainField maintainField) {
|
return getUserAuthor(characterId, maintainField, null);
|
}
|
@Override
|
public List<MasterAuthor> getUserAuthor(String characterId, MaintainField maintainField, String uuid) {
|
Date startDate = new Date();
|
Wrapper<MasterAuthor> userWrapper = new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, characterId);
|
int i = selectCount(userWrapper);
|
boolean isUser;
|
if (i == 0) {
|
isUser = false;
|
}else {
|
isUser = true;
|
}
|
if (maintainField != null) {
|
if (maintainField.getId() != null) {
|
userWrapper.eq("maintain_field_id", maintainField.getId());
|
}
|
if (maintainField.getTableName() != null) {
|
userWrapper.eq("table_name",maintainField.getTableName());
|
}
|
}
|
List<MasterAuthor> masterAuthors = selectList(userWrapper);
|
Date endDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} select user author:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));
|
|
if (masterAuthors.isEmpty() && !isUser) {
|
//user 获取role
|
Set<String> roleIdSet = DbUtils.getRoleByUser(characterId, uuid);
|
if (roleIdSet.isEmpty()) {
|
return new ArrayList<>();
|
}else {
|
Wrapper<MasterAuthor> roleWrapper = new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleIdSet);
|
if (maintainField != null) {
|
if (!StringUtils.isEmpty(maintainField.getId())) {
|
roleWrapper.eq("maintain_field_id", maintainField.getId());
|
}
|
if (!StringUtils.isEmpty(maintainField.getTableName())) {
|
roleWrapper.eq("table_name",maintainField.getTableName());
|
}
|
}
|
masterAuthors = selectList(roleWrapper);
|
}
|
|
startDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} select role author by user:{1} ms",uuid, (startDate.getTime() - endDate.getTime())));
|
|
}
|
List<MasterAuthor> groupAuthors = getUserGroupAuthor(characterId, null, uuid);
|
|
|
endDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} merage group author:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));
|
|
masterAuthors.addAll(groupAuthors);
|
return masterAuthors;
|
}
|
|
private List<MasterAuthor> getRoleAuthors(String characterId, MaintainField maintainField) {
|
Wrapper<MasterAuthor> roleWrapper = new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).eq(MasterAuthorController.character_id, characterId);
|
if (maintainField != null) {
|
if (maintainField.getId() != null) {
|
roleWrapper.eq("maintain_field_id", maintainField.getId());
|
}
|
if (maintainField.getTableName() != null) {
|
roleWrapper.eq("table_name",maintainField.getTableName());
|
}
|
|
}
|
|
return selectList(roleWrapper);
|
}
|
|
private List<MasterAuthor> getUserGroupAuthor(String userId, MaintainField maintainField) {
|
return getUserGroupAuthor(userId, maintainField, null);
|
}
|
|
private List<MasterAuthor> getUserGroupAuthor(String userId, MaintainField maintainField, String uuid) {
|
Set<String> groupIdList = DbUtils.getGroupByUser(userId, uuid);
|
List<MasterAuthor> result = new ArrayList<>();
|
if (groupIdList == null) {
|
return result;
|
}
|
|
for (String groupId : groupIdList) {
|
List<MasterAuthor> oneGroupAuthors = getOneGroupAuthors(groupId, maintainField, uuid);
|
if (oneGroupAuthors == null || oneGroupAuthors.isEmpty()) {
|
continue;
|
}
|
result.addAll(oneGroupAuthors);
|
}
|
|
return result;
|
}
|
@Override
|
public List<MasterAuthor> getOneGroupAuthors(String groupId, MaintainField maintainField) {
|
return getOneGroupAuthors(groupId, maintainField, null);
|
}
|
@Override
|
public List<MasterAuthor> getOneGroupAuthors(String groupId, MaintainField maintainField, String uuid) {
|
Date startDate = new Date();
|
Wrapper<MasterAuthor> userWrapper = new EntityWrapper<MasterAuthor>().eq("user_group", true).eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, groupId);
|
Wrapper<MasterAuthor> roleWrapper = new EntityWrapper<MasterAuthor>().eq("user_group", true).eq(Constant.TYPE, MasterAuthorType.role).eq(MasterAuthorController.character_id, groupId);
|
int i = selectCount(userWrapper);
|
boolean isUser;
|
if (i == 0) {
|
isUser = false;
|
}else {
|
isUser = true;
|
}
|
if (maintainField != null) {
|
if (maintainField.getId() != null) {
|
userWrapper.eq("maintain_field_id", maintainField.getId());
|
roleWrapper.eq("maintain_field_id", maintainField.getId());
|
}
|
if (maintainField.getTableName() != null) {
|
userWrapper.eq("table_name",maintainField.getTableName());
|
roleWrapper.eq("table_name",maintainField.getTableName());
|
}
|
|
}
|
List<MasterAuthor> groupAuthors = selectList(userWrapper);
|
Date endDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} select group author:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));
|
|
if (groupAuthors.isEmpty() && !isUser) {
|
Set<String> roleByGroup = DbUtils.getRoleByGroup(groupId, uuid);
|
if(roleByGroup.isEmpty()) {
|
groupAuthors = new ArrayList<>();
|
}else {
|
groupAuthors = selectList(roleWrapper);
|
}
|
|
startDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} select role author by group :{1} ms",uuid, (startDate.getTime() - endDate.getTime())));
|
|
}
|
return groupAuthors;
|
}
|
@Override
|
public List<SysField> getField(Character character, String maintainId) {
|
return getField(character, maintainId, null);
|
}
|
@Override
|
public List<SysField> getField(Character character, String maintainId, String uuid) {
|
String key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(),"field", maintainId);
|
List<Object> redisList = redisClient.getRedisList(key);
|
if (redisList != null) {
|
List<SysField> result = new ArrayList<>();
|
for (Object o : redisList) {
|
JSONObject object = (JSONObject) o;
|
SysField sysField = JSONObject.parseObject(object.toJSONString(), SysField.class);
|
result.add(sysField);
|
}
|
return result;
|
}
|
Maintain maintain = maintainService.selectById(maintainId);
|
if (maintain == null){
|
return new ArrayList<>();
|
}
|
Date startDate = new Date();
|
boolean isAll = checkUnFilterAuthor(character, maintain.getTableName(), uuid);
|
Date endDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} field check isAll:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));
|
|
if (isAll) {
|
List<SysField> total = fieldService.getFieldByMaintain(maintainId);
|
redisClient.putRedisList(key, (total));
|
return total;
|
}
|
|
MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
|
if (maintainField == null){
|
return new ArrayList<>();
|
}
|
String maintainFieldId = maintainField.getId();
|
|
MasterAuthorType type = character.getType();
|
List<MasterAuthor> masterAuthors = null;
|
switch (type){
|
case role:
|
masterAuthors = getRoleAuthors(character.getId(), maintainField);
|
break;
|
case groupInfo:
|
masterAuthors = getOneGroupAuthors(character.getId(), maintainField, uuid);
|
break;
|
case user:
|
masterAuthors = getUserAuthor(character.getId(), maintainField, uuid);
|
}
|
startDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} field get author:{1} ms",uuid, (startDate.getTime() - endDate.getTime())));
|
|
if (masterAuthors == null || masterAuthors.isEmpty()) {
|
return null;
|
}
|
|
List<String> authorIds = masterAuthors.stream().map(masterAuthor -> masterAuthor.getId()).collect(Collectors.toList());
|
List<MasterAuthorDetail> masterAuthorDetails = authorDetailService.selectList(new EntityWrapper<MasterAuthorDetail>().in(Constant.PARENT_ID, authorIds));
|
Set<String> codes = masterAuthorDetails.stream().map(masterAuthorDetail -> masterAuthorDetail.getField()).collect(Collectors.toSet());
|
if (codes.isEmpty()) {
|
return new ArrayList<>();
|
}
|
Wrapper<SysField> wrapper = new EntityWrapper<SysField>().in(Constant.FIELD, codes).eq("table_name", maintain.getTableName());
|
|
if (!maintainFieldId.equalsIgnoreCase(Constant.Default)) {
|
wrapper.eq("maintain_field_id", maintainFieldId);
|
}else {
|
wrapper.isNull("maintain_field_id");
|
}
|
wrapper.orderBy("order_no");
|
|
List<SysField> fieldList = fieldService.selectList(wrapper);
|
endDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} field get field:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));
|
|
redisClient.putRedisList(key, ((fieldList)));
|
return fieldList;
|
}
|
|
private boolean checkUnFilterAuthor(Character character, String tableName, String uuid) {
|
String key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(),"checkUnFilterAuthor", tableName);
|
String redisVal = redisClient.getRedisVal(key);
|
if (!StringUtils.isEmpty(redisVal)) {
|
return Boolean.valueOf(redisVal);
|
}
|
MasterAuthorType type = character.getType();
|
List<MasterAuthor> masterAuthors = null;
|
MaintainField maintainField = new MaintainField().setTableName(tableName);
|
switch (type){
|
case role:
|
masterAuthors = getRoleAuthors(character.getId(), maintainField);
|
break;
|
case groupInfo:
|
masterAuthors = getOneGroupAuthors(character.getId(), maintainField, uuid);
|
break;
|
case user:
|
masterAuthors = getUserAuthor(character.getId(), maintainField, uuid);
|
}
|
if (masterAuthors.isEmpty()) {
|
return false;
|
}
|
long isAll = masterAuthors.stream()
|
.filter(masterAuthor -> !StringUtils.isEmpty(masterAuthor.getMaintainFieldId()))
|
.filter(masterAuthor -> masterAuthor.getMaintainFieldId().equalsIgnoreCase(Constant.All)).count();
|
if (isAll > 0) {
|
redisClient.putRedisVal(key, "true");
|
return true;
|
}else {
|
redisClient.putRedisVal(key, "false");
|
return false;
|
}
|
|
}
|
|
@Override
|
public boolean checkMaintainAuthor(Character character, String maintainId) {
|
return checkMaintainAuthor(character, maintainId, null);
|
}
|
@Override
|
public boolean checkMaintainAuthor(Character character, String maintainId, String uuid) {
|
String key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(), "checkMaintainAuthor", maintainId);
|
String redisVal = redisClient.getRedisVal(key);
|
if (!StringUtils.isEmpty(redisVal)) {
|
return Boolean.valueOf(redisVal);
|
}
|
Maintain maintain = maintainService.selectById(maintainId);
|
if (maintain == null) {
|
return false;
|
}
|
int checked = 0;
|
boolean isAll = checkUnFilterAuthor(character, maintain.getTableName(), uuid);
|
if (isAll){
|
return true;
|
}
|
MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
|
if (maintainField == null) {
|
return false;
|
}
|
MasterAuthorType type = character.getType();
|
List<MasterAuthor> masterAuthors = null;
|
switch (type){
|
case role:
|
masterAuthors = getRoleAuthors(character.getId(), maintainField);
|
break;
|
case groupInfo:
|
masterAuthors = getOneGroupAuthors(character.getId(), maintainField, uuid);
|
break;
|
case user:
|
masterAuthors = getUserAuthor(character.getId(), maintainField, uuid);
|
}
|
if (masterAuthors.isEmpty()) {
|
redisClient.putRedisVal(key, "false");
|
return false;
|
}else {
|
redisClient.putRedisVal(key, "true");
|
return true;
|
}
|
}
|
|
@Override
|
public String getFilter(Character character, String maintainId) {
|
return getFilter(character, maintainId, null);
|
}
|
@Override
|
public String getFilter(Character character, String maintainId, String uuid) {
|
String key = DbUtils.StrJoinLink(Constant.UnderLine, character.getId(),"filter",maintainId);
|
String redisVal = redisClient.getRedisVal(key);
|
if (!StringUtils.isEmpty(redisVal)) {
|
return redisVal;
|
}
|
Maintain maintain = maintainService.selectById(maintainId);
|
if (maintain == null){
|
return Constant.WHERE_DEFAULTUN;
|
}
|
Date startDate = new Date();
|
|
boolean isAll = checkUnFilterAuthor(character, maintain.getTableName(), uuid);
|
Date endDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} filter check isAll:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));
|
|
if (isAll) {
|
redisClient.putRedisVal(key, Constant.WHERE_DEFAULT);
|
return Constant.WHERE_DEFAULT;
|
}
|
MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
|
MasterAuthorType type = character.getType();
|
List<MasterAuthor> masterAuthors = null;
|
switch (type){
|
case role:
|
masterAuthors = getRoleAuthors(character.getId(), maintainField);
|
break;
|
case groupInfo:
|
masterAuthors = getOneGroupAuthors(character.getId(), maintainField, uuid);
|
break;
|
case user:
|
masterAuthors = getUserAuthor(character.getId(), maintainField, uuid);
|
}
|
startDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} filter get author:{1} ms",uuid, (startDate.getTime() - endDate.getTime())));
|
|
if (masterAuthors.isEmpty()) {
|
redisClient.putRedisVal(key, Constant.WHERE_DEFAULTUN);
|
return Constant.WHERE_DEFAULTUN;
|
}
|
|
List<String> authorIds = masterAuthors.stream().map(masterAuthor -> masterAuthor.getId()).collect(Collectors.toList());
|
List<MasterAuthorDetail> masterAuthorDetails = authorDetailService.selectList(new EntityWrapper<MasterAuthorDetail>().in(Constant.PARENT_ID, authorIds));
|
if (masterAuthorDetails.isEmpty()) {
|
redisClient.putRedisVal(key, Constant.WHERE_DEFAULTUN);
|
return Constant.WHERE_DEFAULTUN;
|
}
|
HashMap<String, List<String>> segmentMap = new HashMap<>();
|
HashMap<String, Boolean> segmentAllMap = new HashMap<>();
|
|
for (MasterAuthorDetail detail : masterAuthorDetails) {
|
String field = detail.getField();
|
Boolean all = detail.getAll();
|
if (!(segmentAllMap.containsKey(field) && segmentAllMap.get(field))) {
|
segmentAllMap.put(field, all);
|
}
|
|
Boolean preAll = segmentAllMap.get(field);
|
if (preAll) {
|
if (segmentMap.containsKey(field)) {
|
segmentMap.remove(field);
|
}
|
continue;
|
}
|
|
String val = detail.getVal();
|
List<String> split = DbUtils.split(val);
|
segmentMap.put(field,split);
|
}
|
ContentBuilder builder = new ContentBuilder(Constant.AND);
|
Set<String> keySet = segmentMap.keySet();
|
for (String code : keySet) {
|
List<String> vals = segmentMap.get(code);
|
String val = vals.stream()
|
.filter(s -> !StringUtils.isEmpty(s))
|
.map(s -> DbUtils.quotedStr(s)).collect(Collectors.joining(Constant.COMMA));
|
String format = MessageFormat.format(Constant.InSql, code, val);
|
builder.append(format);
|
}
|
String filter = builder.toString();
|
endDate = new Date();
|
log.info(MessageFormat.format("master tag:{0} filter merage filter:{1} ms",uuid, (endDate.getTime() - startDate.getTime())));
|
|
if (StringUtils.isEmpty(filter)) {
|
redisClient.putRedisVal(key, Constant.WHERE_DEFAULT);
|
return Constant.WHERE_DEFAULT;
|
}
|
|
redisClient.putRedisVal(key, filter);
|
return filter;
|
}
|
|
@Override
|
public Maintain getMaxVersionMaintain(Character character, String tableName) {
|
List<Maintain> maintainList = maintainService.selectList(new EntityWrapper<Maintain>().eq("table_name", tableName).orderBy("order_no desc"));
|
for (Maintain maintain : maintainList) {
|
ActivitiStatus status = flowsService.getStatusByBusinessId(maintain.getId());
|
if (!ActivitiStatus.open.equals(status)) {
|
continue;
|
}
|
boolean b = checkMaintainAuthor(character, maintain.getId());
|
if (b) {
|
return maintain;
|
}
|
}
|
return null;
|
}
|
|
@Override
|
public LinkedHashSet<Maintain> getMaintainSet(String tableName, TUser user) {
|
List<MasterAuthor> userAuthor = this.getUserAuthor(user.getUserId(), null);
|
LinkedHashSet<Maintain> maintainSet = new LinkedHashSet<>();
|
Collections.reverse(userAuthor);
|
|
for (MasterAuthor masterAuthor : userAuthor) {
|
String tabName = masterAuthor.getTableName();
|
String maintainFieldId = masterAuthor.getMaintainFieldId();
|
if (StringUtils.isEmpty(tabName) || !tableName.equalsIgnoreCase(tableName) || StringUtils.isEmpty(maintainFieldId)) {
|
continue;
|
}
|
List<Maintain> maintainByMaintainField = maintainFieldService.getMaintainByMaintainField(maintainFieldId, tableName);
|
if (maintainByMaintainField != null) {
|
maintainSet.addAll(maintainByMaintainField);
|
}
|
|
}
|
return maintainSet;
|
}
|
|
public void dealFlow(String maintainId, ActivitiStatus status) {
|
Maintain maintain = maintainService.selectById(maintainId);
|
MaintainField maintainFieldByMaintain = fieldService.getMaintainFieldByMaintain(maintainId);
|
SysMenu menuByTableName = menuMappingService.getMenuByTableName(maintain.getTableName());
|
|
List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>()
|
.eq("maintain_field_id", maintainFieldByMaintain.getId())
|
.eq("table_name", maintain.getTableName())
|
.eq("menu_id", menuByTableName.getId())
|
.eq("maintain_auto", true));
|
for (MasterAuthor masterAuthor : masterAuthors) {
|
|
}
|
}
|
|
|
private MasterAuthor merage(MasterAuthor preMerageMasterAuthor, MasterAuthor masterAuthor) {
|
// table name masterField 一样 只有字段不同了
|
List<MasterAuthorDetail> preFields = preMerageMasterAuthor.getFields();
|
Map<String, MasterAuthorDetail> fieldMap = masterAuthor.getFields().stream().collect(Collectors.toMap(MasterAuthorDetail::getField, masterAuthorDetail -> masterAuthorDetail));
|
|
HashSet<String> valSet = new HashSet<>();
|
for (MasterAuthorDetail preField : preFields) {
|
valSet.clear();
|
String fieldId = preField.getField();
|
String val = preField.getVal();
|
if (val.equalsIgnoreCase(Constant.All)) {
|
continue;
|
}
|
MasterAuthorDetail detail = fieldMap.get(fieldId);
|
if (detail == null) {
|
continue;
|
}
|
String preAddVal = detail.getVal();
|
if (preAddVal.equalsIgnoreCase(Constant.All)) {
|
preField.setVal(preAddVal);
|
continue;
|
}
|
|
valSet.addAll(DbUtils.split(val));
|
valSet.addAll(DbUtils.split(preAddVal));
|
|
String resultVal = valSet.stream().collect(Collectors.joining(Constant.SEMICOLON));
|
preField.setVal(resultVal);
|
}
|
return preMerageMasterAuthor;
|
}
|
}
|
