package com.highdatas.mdm.service.impl;
|
|
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.*;
|
import com.highdatas.mdm.mapper.MasterAuthorMapper;
|
import com.highdatas.mdm.pojo.ActivitiStatus;
|
import com.highdatas.mdm.pojo.MasterAuthorType;
|
import com.highdatas.mdm.service.*;
|
import com.highdatas.mdm.util.Constant;
|
import com.highdatas.mdm.util.ContentBuilder;
|
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-23
|
*/
|
@Service
|
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;
|
|
@Override
|
public HashMap<String, MasterAuthor> merageRoleAuthor(List<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(String userId) {
|
List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, userId));
|
if (masterAuthors.size() == 0) {
|
//user 获取role
|
List<TUserRole> roles = userRoleService.selectList(new EntityWrapper<TUserRole>().eq("user_id", userId));
|
List<String> roleIds = roles.stream().map(tUserRole -> tUserRole.getRoleId()).collect(Collectors.toList());
|
masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleIds));
|
}
|
List<String> menuIds = masterAuthors.stream().map(masterAuthor -> masterAuthor.getMenuId()).collect(Collectors.toList());
|
LinkedHashSet<String> strings = new LinkedHashSet<>(menuIds);
|
LinkedHashSet<String> byParentId = menuService.getByParentId(strings);
|
List<SysMenu> sysMenus = menuService.selectBatchIds(byParentId);
|
return sysMenus;
|
}
|
|
@Override
|
public List<SysField> getField(String userId, String maintainId) {
|
Maintain maintain = maintainService.selectById(maintainId);
|
if (maintain == null){
|
return new ArrayList<>();
|
}
|
boolean isAll = checkUnFilterAuthor(userId, maintain.getTableName());
|
if (isAll) {
|
List<SysField> total = fieldService.getFieldByMaintain(maintainId);
|
return total;
|
}
|
|
MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
|
if (maintainField == null){
|
return new ArrayList<>();
|
}
|
String maintainFieldId = maintainField.getId();
|
|
List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, userId).eq("maintain_field_id", maintainFieldId));
|
if (masterAuthors.size() == 0) {
|
//user 获取role
|
List<TUserRole> roles = userRoleService.selectList(new EntityWrapper<TUserRole>().eq("user_id", userId));
|
List<String> roleIds = roles.stream().map(tUserRole -> tUserRole.getRoleId()).collect(Collectors.toList());
|
masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleIds).eq("maintain_field_id", maintainFieldId));
|
}
|
if (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 null;
|
}
|
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);
|
return fieldList;
|
}
|
|
private boolean checkUnFilterAuthor(String userId, String tableName) {
|
List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, userId).eq("table_name", tableName));
|
long isAll = masterAuthors.stream().filter(masterAuthor -> masterAuthor.getMaintainFieldId().equalsIgnoreCase(Constant.All)).count();
|
if (isAll > 0) {
|
return true;
|
}
|
if (!masterAuthors.isEmpty()) {
|
return false;
|
}
|
Set<String> roleByUser = DbUtils.getRoleByUser(userId);
|
isAll = selectCount(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleByUser).eq("table_name", tableName).eq("maintain_field_id", Constant.All_UPCASE));
|
if (isAll > 0) {
|
return true;
|
}
|
|
return false;
|
}
|
|
@Override
|
public boolean checkMaintainAuthor(String userId, String maintainId) {
|
Maintain maintain = maintainService.selectById(maintainId);
|
if (maintain == null) {
|
return false;
|
}
|
int checked = 0;
|
boolean isAll = checkUnFilterAuthor(userId, maintain.getTableName());
|
if (isAll){
|
return true;
|
|
}
|
MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
|
if (maintainField == null) {
|
return false;
|
}
|
//get user author
|
checked = selectCount(new EntityWrapper<MasterAuthor>()
|
.eq(Constant.TYPE, MasterAuthorType.user)
|
.eq(MasterAuthorController.character_id, userId)
|
.eq("table_name", maintain.getTableName())
|
.eq("maintain_field_id", maintainField.getId()));
|
if (checked > 0) {
|
return true;
|
}
|
List<TUserRole> roles = userRoleService.selectList(new EntityWrapper<TUserRole>().eq("user_id", userId));
|
Set<String> collect = roles.stream().map(tUserRole -> tUserRole.getRoleId()).collect(Collectors.toSet());
|
checked = selectCount(new EntityWrapper<MasterAuthor>()
|
.eq(Constant.TYPE, MasterAuthorType.role)
|
.in(MasterAuthorController.character_id, collect)
|
.eq("table_name", maintain.getTableName())
|
.eq("maintain_field_id", maintainField.getId()));
|
if (checked > 0) {
|
return true;
|
}
|
return false;
|
}
|
|
@Override
|
public String getFilter(String userId, String maintainId) {
|
Maintain maintain = maintainService.selectById(maintainId);
|
if (maintain == null){
|
return Constant.WHERE_DEFAULTUN;
|
}
|
boolean isAll = checkUnFilterAuthor(userId, maintain.getTableName());
|
if (isAll) {
|
return Constant.WHERE_DEFAULT;
|
}
|
MaintainField maintainField = fieldService.getMaintainFieldByMaintain(maintainId);
|
String maintainFieldId = maintainField.getId();
|
|
List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>()
|
.eq("table_name", maintain.getTableName())
|
.eq(Constant.TYPE, MasterAuthorType.user).eq(MasterAuthorController.character_id, userId).eq("maintain_field_id", maintainFieldId));
|
if (masterAuthors.size() == 0) {
|
//user 获取role
|
List<TUserRole> roles = userRoleService.selectList(new EntityWrapper<TUserRole>().eq("user_id", userId));
|
List<String> roleIds = roles.stream().map(tUserRole -> tUserRole.getRoleId()).collect(Collectors.toList());
|
masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq("table_name", maintain.getTableName()).eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleIds).eq("maintain_field_id", maintainFieldId));
|
}
|
if (masterAuthors.isEmpty()){
|
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()) {
|
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();
|
return filter;
|
}
|
|
@Override
|
public Maintain getMaxVersionMaintain(String userId, 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 (!status.equals(ActivitiStatus.open)) {
|
continue;
|
}
|
boolean b = checkMaintainAuthor(userId, maintain.getId());
|
if (b) {
|
return maintain;
|
}
|
}
|
return null;
|
}
|
|
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;
|
}
|
}
|
