package com.product.admin.service;
|
|
import cn.hutool.core.util.IdUtil;
|
import com.beust.jcommander.internal.Lists;
|
import com.google.common.collect.Maps;
|
import com.google.common.collect.Sets;
|
import com.product.admin.config.CmnConst;
|
import com.product.admin.config.SystemCode;
|
import com.product.admin.service.idel.IRolesService;
|
import com.product.core.cache.DataPoolCacheImpl;
|
import com.product.core.dao.BaseDao;
|
import com.product.core.entity.DataTableEntity;
|
import com.product.core.entity.FieldSetEntity;
|
import com.product.core.exception.BaseException;
|
import com.product.core.permission.PermissionService;
|
import com.product.core.service.support.AbstractBaseService;
|
import com.product.core.service.support.QueryFilterService;
|
import com.product.core.spring.context.SpringMVCContextHolder;
|
import com.product.core.transfer.Transactional;
|
import com.product.module.sys.entity.SystemUser;
|
import com.product.util.BaseUtil;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.util.*;
|
|
|
/**
|
* Copyright LX-BASE
|
*
|
* @Title: RolesService
|
* @Project: LX-BASE-SERVER
|
* @Date: 2020年6月3日 下午4:40:01
|
* @Author: 郑盟
|
* @Description: 创建角色权限
|
*/
|
@Component
|
public class RolesService extends AbstractBaseService implements IRolesService {
|
@Autowired
|
private BaseDao baseDao;
|
|
@Autowired
|
PermissionService permissionService;
|
@Autowired
|
public QueryFilterService queryFilterService;
|
|
@Autowired
|
private UpdateLoginUserInfoService updateLoginUserInfoService;
|
|
@Autowired
|
public SystemMenusService systemMenusService;
|
|
/**
|
* 创建权限如果要添加功能许可请将product_sys_function_permission作为FieldSetEntity 子表
|
*/
|
@Transactional
|
public String addRole(FieldSetEntity fs) throws BaseException {
|
DataTableEntity subDataTable = fs.getSubDataTable(CmnConst.PRODUCT_SYS_FUNCTION_PERMISSION);
|
fs.setValue(CmnConst.CREATED_BY, SpringMVCContextHolder.getCurrentUser().getUser_id());
|
fs.setValue(CmnConst.CREATED_UTC_DATETIME, new Date());
|
fs.setValue(CmnConst.ORG_LEVEL_UUID, SpringMVCContextHolder.getCurrentUser().getOrg_level_uuid());
|
String effective_start_date = fs.getString("effective_start_date");
|
/*
|
* //罗鑫2021年3月1日 开始时间不能大于结束时间 if(BaseUtil.strIsNull(effective_start_date)){
|
* throw new BaseException(SystemCode.SYSTEM_VALID_TIME_WE_FAIL.getValue(),
|
* SystemCode.SYSTEM_VALID_TIME_WE_FAIL.getText(),this.getClass()
|
* ,"public String addRole(FieldSetEntity fs) throws BaseException"); }
|
*/
|
String effective_end_date = fs.getString("effective_end_date");
|
if (!BaseUtil.strIsNull(effective_end_date)) {
|
if (BaseUtil.temporalComparison(effective_start_date, effective_end_date)) {
|
throw new BaseException(SystemCode.SYSTEM_VALID_TIME_FAIL.getValue(), SystemCode.SYSTEM_VALID_TIME_FAIL.getText(), this.getClass(), "public String addRole(FieldSetEntity fs) throws BaseException");
|
}
|
}
|
String roleUUID = baseDao.add(fs, false);
|
if (roleUUID != null && subDataTable != null) {
|
for (int i = 0; i < subDataTable.getRows(); i++) {
|
subDataTable.setFieldValue(i, CmnConst.ROLE_UUID, roleUUID);
|
subDataTable.setFieldValue(i, CmnConst.CREATED_BY,
|
SpringMVCContextHolder.getCurrentUser().getUser_id());
|
subDataTable.setFieldValue(i, CmnConst.CREATED_UTC_DATETIME, new Date());
|
}
|
boolean add = baseDao.add(subDataTable);
|
}
|
return roleUUID;
|
}
|
|
/**
|
* 系统管理员详情
|
*/
|
public FieldSetEntity findRole(FieldSetEntity fs) throws BaseException {
|
String uuid = fs.getString("uuid");
|
// 郑盟 2020年12月17日 下午14:05
|
if (StringUtils.isEmpty(uuid))
|
return null;
|
FieldSetEntity roleFs = baseDao.getFieldSetEntity("product_sys_role", uuid, true);
|
baseDao.listInternationDataTable(roleFs, null);
|
DataTableEntity listTable = baseDao.listTable("product_sys_staffs", "role_uuids like '%" + uuid + "%'");
|
roleFs.setValue("userNum", listTable.getRows());
|
return roleFs;
|
}
|
|
/**
|
* 系统管理员列表
|
*/
|
public DataTableEntity listRole(FieldSetEntity fse) throws BaseException {
|
String queryFilter = "";
|
if (!BaseUtil.dataTableIsEmpty(fse.getSubDataTable("systemSeniorQueryString"))) {
|
queryFilter = queryFilterService.getQueryFilter(fse);
|
}
|
String dataFilter = permissionService.getDataFilter("c." + CmnConst.ORG_LEVEL_UUID);
|
if (!StringUtils.isEmpty(dataFilter)) {
|
if (!StringUtils.isEmpty(queryFilter)) {
|
queryFilter = " and " + queryFilter;
|
}
|
dataFilter = " WHERE " + dataFilter + queryFilter;
|
} else {
|
dataFilter = "";
|
String manager_type = returnManagerType();
|
if ("1".equals(manager_type)) {
|
dataFilter = " WHERE c.org_level_uuid='00000000-0000-0000-0000-000000000000'";
|
if (!StringUtils.isEmpty(queryFilter)) {
|
queryFilter = " and " + queryFilter;
|
}
|
} else {
|
if (!StringUtils.isEmpty(queryFilter)) {
|
queryFilter = " where " + queryFilter;
|
}
|
}
|
}
|
return roleDt(dataFilter, queryFilter, fse);
|
}
|
|
private String returnManagerType() {
|
SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
|
String manager_type = null;
|
if (currentUser != null && currentUser.getCurrentManager() != null) {
|
manager_type = currentUser.getCurrentManager().getString(CmnConst.MANAGER_TYPE);
|
}
|
return manager_type;
|
}
|
|
private DataTableEntity roleDt(String dataFilter, String queryFilter, FieldSetEntity fse) {
|
StringBuilder sql = new StringBuilder();
|
sql.append(" SELECT ");
|
sql.append(" c.*, ");
|
sql.append(" ( ");
|
sql.append(" (select count(*) num ");
|
sql.append(" from product_sys_staffs f ");
|
sql.append(" where concat(',',role_uuids,',') like concat('%,',c.uuid,',%')) ");
|
sql.append(" + ");
|
sql.append(" (select count(*) num ");
|
sql.append(" from product_sys_org_manager ");
|
sql.append(" where concat(',',role_uuids,',') like concat('%,',c.uuid,',%')) ");
|
sql.append(" )userNum ");
|
sql.append(" FROM product_sys_role c ");
|
sql.append(dataFilter).append(queryFilter);
|
// 只有超级管理员才能看到 管理员所有的角色 cheng 2021年12月22日17:11:59
|
if (1 == SpringMVCContextHolder.getCurrentUser().getUserType()) {
|
sql.append(" and uuid in ");
|
} else {
|
sql.append(" and uuid not in ");
|
}
|
sql.append("('175b7de5-0d13-45f9-ba10-eaec67b73f90-notchange','a8e2a6ac-a507-47da-851b-9ac61541cd5a-notchange','bb3d5d27-8c05-49c1-bdb2-c743a53863e0-notchange','eabb00f3-2118-4165-967b-a7d88f472f67-notchange')");
|
sql.append(" ORDER BY c.sequence ASC ");
|
DataTableEntity roleDt = baseDao.listInternationDataTable(
|
baseDao.listTable(sql.toString(), new Object[]{}, fse.getInteger("pagesize"), fse.getInteger("cpage")),
|
null);
|
baseDao.loadPromptData(roleDt);
|
return roleDt;
|
}
|
|
@Autowired
|
RouterService routerService;
|
|
public void updateRoleCache() {
|
DataPoolCacheImpl.getInstance().cacheDataByTable("product_sys_page_button_v");
|
DataPoolCacheImpl.getInstance().cacheDataByTable("product_sys_function_buttons");
|
routerService.refreshRouter();
|
}
|
|
|
/**
|
* 更新角色权限
|
*/
|
@Transactional
|
public boolean updateRole(FieldSetEntity fs) throws BaseException {
|
DataTableEntity subDataTable = fs.getSubDataTable("product_sys_function_permission");
|
Map<String, DataTableEntity> subData = fs.getSubData();
|
subData.remove("product_sys_function_permission");
|
fs.setSubData(subData);
|
fs.setValue(CmnConst.UPDATED_BY, SpringMVCContextHolder.getCurrentUser().getUser_id());
|
fs.setValue(CmnConst.UPDATED_UTC_DATETIME, new Date());
|
String effective_start_date = fs.getString("effective_start_date");
|
//罗鑫2021年3月1日 开始时间不能大于结束时间
|
if (BaseUtil.strIsNull(effective_start_date)) {
|
throw new BaseException(SystemCode.SYSTEM_VALID_TIME_WE_FAIL.getValue(), SystemCode.SYSTEM_VALID_TIME_WE_FAIL.getText(), this.getClass(), "public boolean updateRole(FieldSetEntity fs) throws BaseException");
|
}
|
if (StringUtils.isEmpty(fs.getString("effective_end_date"))) {
|
fs.remove("effective_end_date");
|
} else {
|
String effective_end_date = fs.getString("effective_end_date");
|
if (BaseUtil.temporalComparison(effective_start_date, effective_end_date)) {
|
throw new BaseException(SystemCode.SYSTEM_VALID_TIME_FAIL.getValue(), SystemCode.SYSTEM_VALID_TIME_FAIL.getText(), this.getClass(), "public boolean updateRole(FieldSetEntity fs) throws BaseException");
|
}
|
}
|
if (StringUtils.isEmpty(fs.getString("effective_start_date"))) {
|
fs.remove("effective_start_date");
|
}
|
boolean update = baseDao.update(fs);
|
if (update && subDataTable != null) {
|
for (int i = 0; i < subDataTable.getRows(); i++) {
|
subDataTable.setFieldValue(i, CmnConst.ROLE_UUID, fs.getString("uuid"));
|
subDataTable.setFieldValue(i, CmnConst.CREATED_BY,
|
SpringMVCContextHolder.getCurrentUser().getUser_id());
|
subDataTable.setFieldValue(i, CmnConst.CREATED_UTC_DATETIME, new Date());
|
// 杜洪波 updatetime 2020年12月8日15时23分 移除uuid,防止新增变修改
|
subDataTable.getFieldSetEntity(i).remove(CmnConst.UUID);
|
}
|
boolean updatePermission = updatePermission(subDataTable);
|
// xupengcheng updateTime 2020年11月28日14:10:13 更新使用该角色菜单
|
updateLoginUserInfoService.updateUserInfoByUpdateRole(new String[]{fs.getUUID()}, false);
|
return updatePermission;
|
} else if (subDataTable == null) {
|
baseDao.delete("product_sys_function_permission", "role_uuid=?", new String[]{fs.getString("uuid")});
|
return update;
|
} else {
|
return update;
|
}
|
}
|
|
/**
|
* 更新关联role 的功能许可
|
*/
|
public boolean updatePermission(DataTableEntity dt) throws BaseException {
|
// 郑盟 2020年12月17日 下午14:05
|
if (!StringUtils.isEmpty(dt.getString(0, CmnConst.ROLE_UUID))) {
|
boolean delete = baseDao.delete("product_sys_function_permission", "role_uuid=?",
|
new String[]{dt.getString(0, CmnConst.ROLE_UUID)});
|
if (!delete)
|
return false;
|
return baseDao.add(dt);
|
}
|
return false;
|
}
|
|
/**
|
* 更新关联role 的功能许可
|
*/
|
@Transactional
|
public boolean delectRole(String uuid) throws BaseException {
|
boolean delete = baseDao.delete(CmnConst.PRODUCT_SYS_ROLE, "uuid=?", new String[]{uuid});
|
// xupengcheng updateTime 2020年11月28日14:10:13 更新使用该角色菜单
|
updateLoginUserInfoService.updateUserInfoByUpdateRole(new String[]{uuid}, true);
|
return delete;
|
}
|
|
/**
|
* 超级管理员创建 角色 || 超级管理员创建客户 根据需求封装 产品、模块、功能、按钮 子父级关系 type 0 产品、模块、功能、按钮 1
|
* 产品、模块、功能 2 产品、模块
|
* <p>
|
* funtype 1、业务功能 2、系统功能 3、所有功能
|
*/
|
public DataTableEntity listFunctionRoleForClients(int type, String role_uuids) throws BaseException {
|
SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
|
String manager_type = null;
|
if (currentUser != null && currentUser.getCurrentManager() != null) {
|
manager_type = currentUser.getCurrentManager().getString("manager_type");
|
}
|
String roles = returnRoles(role_uuids);
|
String[] roles_arr = roles.split(",");
|
//不是超级管理员 并且 不是系统管理员则 开启 权限获取数据 否则获取 所有 数据
|
boolean accessControl = !"1".equals(manager_type) && !"4".equals(manager_type);
|
if (type == 2) {
|
//产品、模块
|
DataTableEntity data = getData(2);
|
return treeProduct(data);
|
} else if (type == 1) {
|
//产品、模块、功能
|
DataTableEntity data = getFunctionPermissionByRole(roles_arr, null, false, accessControl);
|
return getTree(treeModule(data), 2);
|
} else if (type == 0) {
|
DataTableEntity data = getFunctionPermissionByRole(roles_arr, null, true, accessControl);
|
return getTree(treeModule(data), 2);
|
}
|
return new DataTableEntity();
|
}
|
|
/**
|
* 单位管理员或隐藏管理员创建 角色 根据需求封装 产品、模块、功能、按钮 子父级关系 type 0 产品、模块、功能、按钮 1 产品、模块、功能 2
|
* 产品、模块
|
* <p>
|
* funtype 1、业务功能 2、系统功能 3、所有功能
|
*/
|
public DataTableEntity listFunctionRole(int type, String role_uuids, int funtype) throws BaseException {
|
SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
|
String manager_type = null;
|
if (currentUser != null && currentUser.getCurrentManager() != null) {
|
manager_type = currentUser.getCurrentManager().getString("manager_type");
|
}
|
String roles = returnRoles(role_uuids);
|
boolean accessControl = !"1".equals(manager_type) && !"4".equals(manager_type);
|
if (type == 2) {
|
//产品、模块
|
DataTableEntity data = getData(2);
|
return treeProduct(data);
|
} else if (type == 1) {
|
//产品、模块、功能
|
DataTableEntity data = getFunctionPermissionByRole(roles.split(","), !accessControl ? String.valueOf(funtype) : "", false, accessControl);
|
return getTree(treeModule(data), 2);
|
} else if (type == 0) {
|
DataTableEntity data = getFunctionPermissionByRole(roles.split(","), !accessControl ? String.valueOf(funtype) : "", true, accessControl);
|
return getTree(treeModule(data), 2);
|
}
|
|
return null;
|
}
|
|
|
/**
|
* 33 根据角色查找功能
|
*
|
* @return 返回 function_uuid , button_uuid, role_uuid ,org_level_uuid ,uuid
|
* @throws BaseException
|
*/
|
public DataTableEntity functionsByRoleUuid(String role_uuids) throws BaseException {
|
String[] role_uuids_arr = role_uuids.split(",");
|
String sql = "select function_uuid , button_uuid, role_uuid,uuid from product_sys_function_permission where "
|
+ BaseUtil.buildQuestionMarkFilter("role_uuid", role_uuids_arr.length, true) + "";
|
return baseDao.listTable(sql, role_uuids_arr);
|
}
|
|
/**
|
* 根据用户uuid 查询角色功能
|
*
|
* @param user
|
* @return 返回 function_uuid , button_uuid, role_uuid ,org_level_uuid ,uuid
|
* @throws BaseException
|
*/
|
public DataTableEntity functionsByUser(SystemUser user) throws BaseException {
|
if (user.getCurrentStaff() != null) {
|
return functionsByRoleUuid(user.getCurrentStaff().getString("role_uuids"));
|
} else if (user.getCurrentManager() != null) {
|
String role_uuid = user.getCurrentManager().getString("role_uuids");
|
return functionsByRoleUuid(role_uuid);
|
} else {
|
return null;
|
}
|
}
|
|
|
private String returnRoles(String role_uuids) {
|
SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
|
String roles = null;
|
if (StringUtils.isEmpty(role_uuids)) {
|
if (currentUser != null && currentUser.getCurrentManager() != null) {
|
roles = currentUser.getCurrentManager().getString("role_uuids");
|
} else {
|
throw new BaseException(SystemCode.SYSTEM_NOTOBTAINEDROLE_FAIL.getValue(),
|
SystemCode.SYSTEM_NOTOBTAINEDROLE_FAIL.getText(), this.getClass(), "listFunctionRole");
|
}
|
} else {
|
roles = role_uuids;
|
}
|
return roles;
|
}
|
|
|
/**
|
* 系统管理员创建客户 || 单位管理员或隐藏管理员创建单位角色时的功能权限过滤 客户 单位管理员 或 隐藏管理员才会有 ，系统管理员为空
|
*/
|
public DataTableEntity listFunctionRoleForClients(String role_uuid, String client_role_uuid, boolean isButton)
|
throws BaseException {
|
String functionType = getFunctionType(role_uuid, client_role_uuid);
|
if (StringUtils.isEmpty(role_uuid) && StringUtils.isEmpty(client_role_uuid) && !SpringMVCContextHolder.getCurrentUser().isManager()) {
|
return new DataTableEntity();
|
}
|
//luoxin 去掉客户限制
|
else {
|
if (!StringUtils.isEmpty(client_role_uuid)) {
|
// 超级管理员所在客户的 角色（虚拟）角色表中没有此条数据
|
if (1 == SpringMVCContextHolder.getCurrentUser().getUserType()) {
|
role_uuid = "";
|
} else {
|
// 去除客户权限设定 cheng 2022年3月1日10:43:53
|
// role_uuid = client_role_uuid;
|
}
|
}
|
}
|
if (role_uuid == null) {
|
role_uuid = "";
|
}
|
|
DataTableEntity functionPermissionByRole = getFunctionPermissionByRole(role_uuid.split(","), functionType, isButton, !StringUtils.isEmpty(role_uuid));
|
DataTableEntity tree = getTree(getTree(functionPermissionByRole, 1), 2);
|
return tree;
|
}
|
|
/**
|
* 获取对应角色的功能类型
|
*
|
* @param role_uuid
|
* @param client_role_uuid
|
* @return
|
*/
|
private String getFunctionType(String role_uuid, String client_role_uuid) {
|
SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
|
if (currentUser.getCurrentManager() != null) {
|
if (currentUser.getCurrentManager().getString("manager_type") != null
|
&& currentUser.getCurrentManager().getInteger("manager_type") == 2 // 单位管理员
|
|| currentUser.getCurrentManager().getInteger("manager_type") == 3)// 隐藏管理员
|
{
|
return "1,5";
|
} else if (currentUser.getCurrentManager().getInteger("manager_type") == 4) {
|
// 系统管理员,创建客户时，只显示
|
// 业务功能和业务后台功能
|
return "1,5";
|
} else {
|
if (!StringUtils.isEmpty(role_uuid)) {
|
// 超级管理员，修改管理员角色，加载管理功能 2=系统管理功能、3=系统功能、4=客户后台功能
|
String functon_type = "2,3,4";
|
if (StringUtils.equalsAny(role_uuid, "bb3d5d27-8c05-49c1-bdb2-c743a53863e0-notchange", "eabb00f3-2118-4165-967b-a7d88f472f67-notchange", "a8e2a6ac-a507-47da-851b-9ac61541cd5a-notchange")) {
|
functon_type += ",5";
|
}
|
return functon_type;
|
} else if (!StringUtils.isEmpty(client_role_uuid)) {
|
// 查看客户的功能权限，只显示业务功能
|
return "1,5";
|
} else {
|
// 超级管理员，查看全部功能模块
|
return "";
|
}
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 系统管理员创建客户 || 单位管理员或隐藏管理员创建单位角色时的功能权限过滤 客户 单位管理员 或 隐藏管理员才会有 ，系统管理员为空
|
*/
|
public DataTableEntity listFunctionRoleForClients() throws BaseException {
|
return listFunctionRoleForClients(null, null, true);
|
}
|
|
|
/**
|
* 获取数据
|
*
|
* @param type 1 = 产品 2 = 模块 3 = 功能
|
* @return
|
*/
|
private DataTableEntity getData(int type) {
|
if (1 == type) {
|
return baseDao.listTable(CmnConst.PRODUCT_SYS_PRODUCTS);
|
} else if (2 == type) {
|
DataTableEntity dt = DataPoolCacheImpl.getInstance().getCacheData("所有模块按编码分组");
|
if (!BaseUtil.dataTableIsEmpty(dt)) {
|
return dt.clones();
|
}
|
} else if (3 == type) {
|
DataTableEntity dt = DataPoolCacheImpl.getInstance().getCacheData("所有功能");
|
if (!BaseUtil.dataTableIsEmpty(dt)) {
|
|
return dt.clones();
|
}
|
}
|
return null;
|
}
|
|
|
private DataTableEntity getFunctionPermissionByRole(String[] roleUuids, String functionType, boolean isButton, boolean accessControl) {
|
//返回的功能结果集
|
DataTableEntity functionResult = new DataTableEntity();
|
DataPoolCacheImpl dataPoolCache = DataPoolCacheImpl.getInstance();
|
Map<String, Set<String>> permissionMap = Maps.newHashMap();
|
List<FieldSetEntity> functionList = Lists.newArrayList();
|
if (accessControl) {
|
if (roleUuids == null) {
|
return functionResult;
|
}
|
for (int i = 0; i < roleUuids.length; i++) {
|
String roleUuid = roleUuids[i];
|
//根据角色获取对应权限
|
DataTableEntity dt = dataPoolCache.getCacheData("功能权限按角色分组", new String[]{roleUuid});
|
if (!BaseUtil.dataTableIsEmpty(dt)) {
|
functionList.addAll(dt.getData());
|
}
|
}
|
for (int i = 0; i < functionList.size(); i++) {
|
FieldSetEntity fs = functionList.get(i);
|
if (fs == null) {
|
continue;
|
}
|
//功能uuid
|
String function_uuid = fs.getString(CmnConst.FUNCTION_UUID);
|
//按钮uuid
|
String button_uuid = fs.getString(CmnConst.BUTTON_UUID);
|
if (StringUtils.isEmpty(button_uuid)) {
|
continue;
|
}
|
Set<String> buttonUuids = permissionMap.get(function_uuid);
|
if (buttonUuids == null) {
|
buttonUuids = Sets.newHashSet();
|
permissionMap.put(function_uuid, buttonUuids);
|
}
|
if (isButton) {
|
//将按钮uuid放入集合中
|
buttonUuids.addAll(Arrays.asList(button_uuid.split(",")));
|
}
|
}
|
//遍历有权限的功能
|
permissionMap.forEach((k, v) -> {
|
//根据功能uuid获取功能详情
|
DataTableEntity functionDataTable = dataPoolCache.getCacheData("所有功能", new String[]{k});
|
if (!BaseUtil.dataTableIsEmpty(functionDataTable)) {
|
FieldSetEntity functionFieldSet = functionDataTable.getFieldSetEntity(0);
|
String function_type = functionFieldSet.getString("function_type_uuid");
|
if (!StringUtils.isEmpty(functionType) && ("," + functionType + ",").indexOf("," + function_type + ",") < 0) {
|
//功能类型过滤
|
return;
|
}
|
//根据功能uuid获取所有按钮
|
DataTableEntity buttonDataTable = dataPoolCache.getCacheData("所有按钮按功能分组", new String[]{k});
|
functionDataTable = functionDataTable.clones();
|
dataProcessing(functionDataTable, null);
|
List<FieldSetEntity> buttons = Lists.newArrayList();
|
|
if (!BaseUtil.dataTableIsEmpty(buttonDataTable)) {
|
if (accessControl) {
|
List<FieldSetEntity> finalButtons = buttons;
|
v.forEach(buttonUuid -> {
|
//遍历有权限的功能按钮集合 根据功能uuid取出功能详情
|
List<FieldSetEntity> fieldSetEntity = buttonDataTable.getFieldSetEntity(buttonUuid);
|
if (fieldSetEntity != null && fieldSetEntity.get(0) != null) {
|
finalButtons.add(fieldSetEntity.get(0).clones());
|
}
|
});
|
} else {
|
buttons.addAll(buttonDataTable.getData());
|
}
|
}
|
if (!buttons.isEmpty()) {
|
DataTableEntity templateData = new DataTableEntity();
|
templateData.setData(buttons);
|
|
dataProcessing(templateData, null);
|
//按钮排序
|
buttons.sort((a, b) -> {
|
if (a == null || b == null || StringUtils.isEmpty(a.getString(CmnConst.SEQUENCE)) || StringUtils.isEmpty(b.getString(CmnConst.SEQUENCE))) {
|
return -1;
|
}
|
|
return a.getString(CmnConst.SEQUENCE).compareTo(b.getString(CmnConst.SEQUENCE));
|
});
|
List<FieldSetEntity> fieldSetEntities = new ArrayList<>();
|
FieldSetEntity clientType = new FieldSetEntity();
|
clientType.setTableName("client_type");
|
clientType.setValue("names", "Web");
|
clientType.setValue("type", 5);
|
clientType.setValue("icon", "el-icon-monitor");
|
clientType.setValue("uuid", IdUtil.randomUUID() + "_Web");
|
fieldSetEntities.add(clientType);
|
clientType = clientType.clones();
|
clientType.setValue("uuid", IdUtil.randomUUID() + "_App");
|
clientType.setValue("icon", "el-icon-mobile");
|
clientType.setValue("names", "App");
|
fieldSetEntities.add(clientType);
|
buttons.forEach(f -> {
|
FieldSetEntity fieldSetEntity = fieldSetEntities.get(0);
|
DataTableEntity sub = fieldSetEntities.get("App".equals(f.getString("client_type_uuid")) ? 1 : 0).getSubDataTable(f.getTableName());
|
boolean isAdd = false;
|
if (sub == null) {
|
sub = new DataTableEntity();
|
isAdd = true;
|
}
|
sub.addFieldSetEntity(f);
|
if (isAdd) {
|
fieldSetEntity.addSubDataTable(sub);
|
}
|
});
|
buttons = fieldSetEntities;
|
}
|
|
//克隆功能缓存对象 避免脏数据
|
functionFieldSet = functionFieldSet.clones();
|
if (isButton) {
|
DataTableEntity buttonResult = new DataTableEntity();
|
buttonResult.setData(buttons);
|
Map<String, DataTableEntity> subData = functionFieldSet.getSubData();
|
if (subData == null) {
|
subData = new TreeMap<>();
|
functionFieldSet.setSubData(subData);
|
}
|
subData.put(this.childrenKey, buttonResult);
|
}
|
functionResult.addFieldSetEntity(functionFieldSet);
|
|
}
|
});
|
|
} else {
|
//所有功能
|
DataTableEntity data = getData(3);
|
if (!BaseUtil.dataTableIsEmpty(data)) {
|
dataProcessing(data, null);
|
for (int i = 0; i < data.getRows(); i++) {
|
FieldSetEntity fs = data.getFieldSetEntity(i);
|
String function_type = fs.getString("function_type_uuid");
|
if (!StringUtils.isEmpty(functionType) && ("," + functionType + ",").indexOf("," + function_type + ",") < 0) {
|
//功能类型过滤
|
data.removeFieldSetEntity(i);
|
i--;
|
continue;
|
}
|
DataTableEntity buttonDataTable = dataPoolCache.getCacheData("所有按钮按功能分组", new String[]{fs.getUUID()});
|
if (BaseUtil.dataTableIsEmpty(buttonDataTable)) {
|
// 没有找到功能按钮 防止功能下按钮为空时 空指针异常
|
data.removeFieldSetEntity(i);
|
i--;
|
continue;
|
}
|
buttonDataTable = buttonDataTable.clones();
|
dataProcessing(buttonDataTable, null);
|
List<FieldSetEntity> fieldSetEntities = new ArrayList<>();
|
FieldSetEntity clientType = new FieldSetEntity();
|
clientType.setTableName(this.childrenKey);
|
clientType.setValue("names", "Web");
|
clientType.setValue("type", 5);
|
clientType.setValue("uuid", IdUtil.randomUUID() + "_Web");
|
clientType.setValue("icon", "el-icon-monitor");
|
fieldSetEntities.add(clientType);
|
clientType = clientType.clones();
|
clientType.setValue("uuid", IdUtil.randomUUID() + "_App");
|
clientType.setValue("icon", "el-icon-mobile");
|
clientType.setValue("names", "App");
|
fieldSetEntities.add(clientType);
|
buttonDataTable.getData().forEach(f -> {
|
int index = "App".equals(f.getString("client_type_uuid")) ? 1 : 0;
|
FieldSetEntity fieldSetEntity = fieldSetEntities.get(index);
|
DataTableEntity sub = fieldSetEntity.getSubDataTable(this.childrenKey);
|
boolean isAdd = false;
|
if (sub == null) {
|
sub = new DataTableEntity();
|
isAdd = true;
|
}
|
sub.addFieldSetEntity(f);
|
if (isAdd) {
|
Map<String, DataTableEntity> subData = fieldSetEntity.getSubData();
|
if (subData == null) {
|
subData = new HashMap<>();
|
}
|
subData.put(this.childrenKey, sub);
|
fieldSetEntity.setSubData(subData);
|
}
|
});
|
Map<String, DataTableEntity> subData = fs.getSubData();
|
if (subData == null) {
|
subData = new TreeMap<>();
|
fs.setSubData(subData);
|
}
|
buttonDataTable = new DataTableEntity();
|
for (FieldSetEntity fieldSetEntity : fieldSetEntities) {
|
buttonDataTable.addFieldSetEntity(fieldSetEntity);
|
}
|
if (buttonDataTable.getRows() >= 1 && (buttonDataTable.getFieldSetEntity(0).getSubData() == null || buttonDataTable.getFieldSetEntity(0).getSubData().isEmpty())) {
|
buttonDataTable.removeFieldSetEntity(0);
|
}
|
if (buttonDataTable.getRows() >= 2 && (buttonDataTable.getFieldSetEntity(1).getSubData() == null || buttonDataTable.getFieldSetEntity(1).getSubData().isEmpty())) {
|
buttonDataTable.removeFieldSetEntity(1);
|
}
|
|
if (buttonDataTable != null && buttonDataTable.getRows() > 0) {
|
subData.put(this.childrenKey, buttonDataTable);
|
}
|
}
|
}
|
functionResult.setData(data.getData());
|
}
|
if (functionResult.getData() != null && !functionResult.getData().isEmpty()) {
|
//功能排序
|
functionResult.getData().sort((a, b) -> {
|
if (a == null || b == null) {
|
return -1;
|
}
|
return a.getString(CmnConst.TRICODE).compareTo(b.getString(CmnConst.TRICODE));
|
});
|
}
|
return functionResult;
|
}
|
|
public DataTableEntity getModuleFunctions() {
|
return getTree(getData(3), 1);
|
}
|
|
/**
|
* 获取树形数据
|
*
|
* @param data 数据
|
* @param type 0 = 按钮 1 = 功能 2=模块
|
* @return
|
*/
|
private DataTableEntity getTree(DataTableEntity data, int type) {
|
Map<String, FieldSetEntity> result = Maps.newHashMap();
|
if (2 == type) {
|
//模块找产品
|
return treeProduct(data);
|
} else if (1 == type) {
|
//功能找模块
|
return treeModule(data);
|
}
|
|
return null;
|
}
|
|
private final String childrenKey = "sub";
|
|
private DataTableEntity treeModule(DataTableEntity data) {
|
// getFunctionPermissionByRole(SpringMVCContextHolder.getCurrentUser().getRoles().split(","));
|
// data = 功能数据
|
DataTableEntity modules = getData(2);
|
|
//模块map 模块code作为key
|
Map<String, FieldSetEntity> codeModuleMap = Maps.newLinkedHashMap();
|
dataProcessing(modules, codeModuleMap);
|
|
//功能map 功能code作为key
|
Map<String, FieldSetEntity> codeFunctionMap = Maps.newLinkedHashMap();
|
dataProcessing(data, codeFunctionMap);
|
Map<String, FieldSetEntity> tempMap = Maps.newHashMap();
|
Set<String> codeSet = Sets.newHashSet();
|
codeFunctionMap.forEach((tricode, v) -> {
|
String parentCode = v.getString(CmnConst.TRICODE_PARENT);
|
FieldSetEntity value = v;
|
|
while (parentCode != null && parentCode.indexOf('-') > -1) {
|
//上级
|
FieldSetEntity parentFieldSet = codeModuleMap.get(parentCode);
|
if (parentFieldSet != null) {
|
Map<String, DataTableEntity> subData = parentFieldSet.getSubData();
|
if (subData == null) {
|
subData = new TreeMap<>();
|
parentFieldSet.setSubData(subData);
|
}
|
DataTableEntity subDataTable = parentFieldSet.getSubDataTable(this.childrenKey);
|
if (subDataTable == null) {
|
subDataTable = new DataTableEntity();
|
}
|
subDataTable.addFieldSetEntity(value);
|
subData.put(this.childrenKey, subDataTable);
|
parentCode = parentFieldSet.getString(CmnConst.TRICODE_PARENT);
|
if (codeSet.contains(parentFieldSet.getString(CmnConst.TRICODE))) {
|
break;
|
}
|
if (parentCode != null && parentCode.indexOf('-') > -1) {
|
codeSet.add(parentFieldSet.getString(CmnConst.TRICODE));
|
}
|
value = parentFieldSet;
|
|
} else {
|
FieldSetEntity fs = tempMap.get(parentCode);
|
if (fs != null) {
|
DataTableEntity subDataTable = fs.getSubDataTable(this.childrenKey);
|
subDataTable.addFieldSetEntity(fs);
|
}
|
parentCode = null;
|
}
|
}
|
});
|
DataTableEntity result = new DataTableEntity();
|
codeModuleMap.values().forEach(v -> {
|
String tricode = v.getString(CmnConst.TRICODE);
|
if (!codeSet.contains(tricode)) {
|
DataTableEntity subDataTable = v.getSubDataTable(this.childrenKey);
|
if (!BaseUtil.dataTableIsEmpty(subDataTable)) {
|
result.addFieldSetEntity(v);
|
}
|
}
|
|
});
|
return result;
|
}
|
|
/**
|
* 模块上级
|
*
|
* @param data
|
* @return
|
*/
|
private DataTableEntity treeProduct(DataTableEntity data) {
|
DataTableEntity product = getData(1);
|
//模块map 模块code作为key
|
Map<String, FieldSetEntity> codeModuleMap = Maps.newHashMap();
|
//模块map 模块上级code作为key
|
dataProcessing(data, codeModuleMap);
|
// 产品map 产品code作为key
|
Map<String, FieldSetEntity> codeProductMap = Maps.newHashMap();
|
dataProcessing(product, codeProductMap);
|
for (Map.Entry<String, FieldSetEntity> currentData : codeModuleMap.entrySet()) {
|
// v =模块数据 FieldSetEntity
|
FieldSetEntity v = currentData.getValue();
|
// k =模块编码
|
String k = currentData.getKey();
|
// 上级编码 可以是产品也可以是模块的编码
|
String parentCode = v.getString(CmnConst.TRICODE_PARENT);
|
//层级 如果层级大于1说明当前 v 的上级为模块
|
int level = k.split("-").length - 1;
|
if (level > 1) {
|
//获取上级模块 根据上级编码
|
FieldSetEntity parentFieldSet = codeModuleMap.get(parentCode);
|
if (parentFieldSet != null) {
|
//取出子级
|
Map<String, DataTableEntity> subData = parentFieldSet.getSubData();
|
if (subData == null) {
|
subData = new TreeMap<>();
|
parentFieldSet.setSubData(subData);
|
}
|
DataTableEntity subDataTable = parentFieldSet.getSubDataTable(this.childrenKey);
|
if (subDataTable == null) {
|
//子级为空 new 对象
|
subDataTable = new DataTableEntity();
|
}
|
subDataTable.addFieldSetEntity(v);
|
//将子级放入父级
|
// parentFieldSet.addSubDataTable(subDataTable);
|
subData.put(this.childrenKey, subDataTable);
|
continue;
|
|
}
|
} else {
|
//获取上级产品 根据上级编码
|
FieldSetEntity fieldSetEntity = codeProductMap.get(parentCode);
|
if (fieldSetEntity != null) {
|
Map<String, DataTableEntity> subData = fieldSetEntity.getSubData();
|
if (subData == null) {
|
subData = new TreeMap<>();
|
}
|
fieldSetEntity.setSubData(subData);
|
DataTableEntity subDataTable = fieldSetEntity.getSubDataTable(this.childrenKey);
|
if (subDataTable == null) {
|
subDataTable = new DataTableEntity();
|
}
|
subDataTable.addFieldSetEntity(v);
|
fieldSetEntity.addSubDataTable(subDataTable);
|
subData.put(this.childrenKey, subDataTable);
|
}
|
}
|
}
|
DataTableEntity result = new DataTableEntity();
|
codeProductMap.values().forEach(v -> {
|
DataTableEntity subDataTable = v.getSubDataTable(this.childrenKey);
|
if (!BaseUtil.dataTableIsEmpty(subDataTable)) {
|
result.addFieldSetEntity(v);
|
v.getSubData().remove(CmnConst.PRODUCT_SYS_FUNCTIONS);
|
}
|
});
|
return result;
|
}
|
|
/**
|
* 数据处理 根据表名
|
*
|
* @param dt
|
*/
|
private void dataProcessing(DataTableEntity dt, Map<String, FieldSetEntity> codeMap) {
|
if (!BaseUtil.dataTableIsEmpty(dt)) {
|
//表名
|
Object tableName = dt.getTableName();
|
if (tableName == null) {
|
return;
|
}
|
//name 字段名称
|
String field;
|
//数据类型 1=产品 2=模块 3=功能 4=按钮
|
Integer type = null;
|
//数据图标
|
String svg = null;
|
DataPoolCacheImpl dataPoolCache = null;
|
if (CmnConst.PRODUCT_SYS_PRODUCTS.equals(tableName)) {
|
field = CmnConst.PRODUCT_NAME;
|
type = 1;
|
svg = "product";
|
} else if (CmnConst.PRODUCT_SYS_FUNCTIONS.equals(tableName)) {
|
field = CmnConst.FUNCTION_NAME;
|
} else if (CmnConst.PRODUCT_SYS_FUNCTION_BUTTONS.equals(tableName)) {
|
field = CmnConst.BUTTON_TITLE;
|
type = 4;
|
svg = "btn";
|
dataPoolCache = DataPoolCacheImpl.getInstance();
|
} else {
|
return;
|
}
|
Map<String, String> functionCode = Maps.newHashMap();
|
for (int i = 0; i < dt.getRows(); i++) {
|
dt.setFieldValue(i, "names", dt.getString(i, field));
|
if (null == type) {
|
String data_type = dt.getString(i, "data_type");
|
// dt.setFieldValue(i,"uuid1",dt.getString(i,CmnConst.TRICODE_PARENT));
|
if ("1".equals(data_type)) {
|
type = 3;
|
svg = "fuc";
|
} else if ("2".equals(data_type)) {
|
type = 2;
|
svg = "module";
|
} else {
|
continue;
|
}
|
}
|
if (dataPoolCache != null) {
|
//将功能编码添加到按钮的父级字段中
|
String function_uuid = dt.getString(i, CmnConst.FUNCTION_UUID);
|
if (functionCode.get(function_uuid) == null) {
|
DataTableEntity d = dataPoolCache.getCacheData("所有功能", new String[]{function_uuid});
|
if (!BaseUtil.dataTableIsEmpty(dt)) {
|
String tricode = d.getString(0, "tricode");
|
functionCode.put(function_uuid, tricode);
|
}
|
}
|
String parentCode = functionCode.get(function_uuid);
|
if (!StringUtils.isEmpty(parentCode)) {
|
dt.setFieldValue(i, CmnConst.PARENT_CODE, parentCode);
|
}
|
}
|
dt.setFieldValue(i, "type", type);
|
dt.setFieldValue(i, "svg", svg);
|
if (!StringUtils.isEmpty(dt.getString(i, CmnConst.TRICODE)) && codeMap != null) {
|
codeMap.put(dt.getString(i, CmnConst.TRICODE), dt.getFieldSetEntity(i));
|
}
|
|
}
|
}
|
}
|
}
|
