From c8aee7b9bfd79cfd741d7e5692520f4f51a31a86 Mon Sep 17 00:00:00 2001
From: kimi <kimi42345@gmail.com>
Date: 星期一, 18 五月 2020 18:30:01 +0800
Subject: [PATCH] bak 修改 获取版本数据前
---
src/main/java/com/highdatas/mdm/service/impl/MasterAuthorServiceImpl.java | 658 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 files changed, 645 insertions(+), 13 deletions(-)
diff --git a/src/main/java/com/highdatas/mdm/service/impl/MasterAuthorServiceImpl.java b/src/main/java/com/highdatas/mdm/service/impl/MasterAuthorServiceImpl.java
index 6367289..5b11f14 100644
--- a/src/main/java/com/highdatas/mdm/service/impl/MasterAuthorServiceImpl.java
+++ b/src/main/java/com/highdatas/mdm/service/impl/MasterAuthorServiceImpl.java
@@ -1,21 +1,29 @@
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.entity.MasterAuthor;
-import com.highdatas.mdm.entity.MasterAuthorDetail;
-import com.highdatas.mdm.entity.SysField;
-import com.highdatas.mdm.entity.SysMenu;
+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.Result;
-import com.highdatas.mdm.service.IMasterAuthorDetailService;
-import com.highdatas.mdm.service.IMasterAuthorService;
+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;
@@ -28,14 +36,90 @@
* @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 Result merageRoleAuthor(List<String> roleIds) {
- List<MasterAuthor> masterAuthors = selectList(new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(this.characterId, roleIds));
+ 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) {
@@ -52,19 +136,567 @@
resultMap.put(key, preMerageMasterAuthor);
}
}
- return Result.success(resultMap.values());
+ return resultMap;
}
@Override
- public List<SysMenu> getMenu(String userId) {
+ 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 List<SysField> getField(String userId) {
- return null;
+ 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();
--
Gitblit v1.8.0