package org.jeecg.modules.dnc.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.shiro.SecurityUtils;
|
import org.jeecg.common.constant.CommonConstant;
|
import org.jeecg.common.system.vo.LoginUser;
|
import org.jeecg.modules.dnc.entity.DevicePermission;
|
import org.jeecg.modules.dnc.mapper.DevicePermissionMapper;
|
import org.jeecg.modules.dnc.service.IDevicePermissionService;
|
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
|
import org.jeecg.modules.dnc.utils.ValidateUtil;
|
import org.jeecg.modules.mdc.entity.MdcEquipment;
|
import org.jeecg.modules.mdc.mapper.MdcEquipmentMapper;
|
import org.jeecg.modules.mdc.model.MdcEquipmentTree;
|
import org.jeecg.modules.mdc.util.FindsEquipmentProductionUtil;
|
import org.jeecg.modules.system.entity.MdcProduction;
|
import org.jeecg.modules.system.entity.SysUser;
|
import org.jeecg.modules.system.service.IMdcProductionService;
|
import org.jeecg.modules.system.service.IMdcUserProductionService;
|
import org.jeecg.modules.system.service.ISysUserService;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
import java.util.stream.Stream;
|
|
@Service
|
public class DevicePermissionServiceImpl extends ServiceImpl<DevicePermissionMapper, DevicePermission> implements IDevicePermissionService {
|
@Resource
|
private IMdcProductionService mdcProductionService;
|
@Resource
|
private IMdcUserProductionService mdcUserProductionService;
|
@Resource
|
private MdcEquipmentMapper mdcEquipmentMapper;
|
@Resource
|
private ISysUserService sysUserService;
|
|
@Override
|
public DevicePermission getByUserIdAndDeviceId(String userId, String deviceId) {
|
if(!ValidateUtil.validateString(userId) || !ValidateUtil.validateString(deviceId))
|
return null;
|
List<DevicePermission> list = super.lambdaQuery().eq(DevicePermission::getDeviceId, deviceId).eq(DevicePermission::getUserId, userId).list();
|
if(list == null || list.isEmpty())
|
return null;
|
return list.get(0);
|
}
|
|
@Override
|
public List<UserDepartExt> getUserPermsByDeviceId(String deviceId) {
|
return super.getBaseMapper().getUserPermsByDeviceId(deviceId);
|
}
|
|
@Override
|
public List<SysUser> getUserNonPermsByDeviceId(String deviceId) {
|
return super.getBaseMapper().getUserNonPermsByDeviceId(deviceId);
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean removeByCollection(List<DevicePermission> devicePermissions) {
|
if(devicePermissions == null || devicePermissions.isEmpty())
|
return false;
|
if(devicePermissions.size() == 1)
|
return super.removeById(devicePermissions.get(0).getDevicePermId());
|
List<String> ids = new ArrayList<>();
|
devicePermissions.forEach(item -> {
|
ids.add(item.getDevicePermId());
|
});
|
return super.removeByIds(ids);
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean deleteByDeviceId(String deviceId) {
|
LambdaQueryWrapper<DevicePermission> lambdaQueryWrapper = Wrappers.lambdaQuery();
|
lambdaQueryWrapper.eq(DevicePermission::getDeviceId, deviceId);
|
return super.remove(lambdaQueryWrapper);
|
}
|
|
@Override
|
public List<DevicePermission> getByDeviceId(String deviceId) {
|
List<DevicePermission> list = super.lambdaQuery().eq(DevicePermission::getDeviceId, deviceId).list();
|
if(list == null)
|
list = Collections.emptyList();
|
return list;
|
}
|
|
|
/**
|
* * 加载产线设备树
|
*/
|
@Override
|
public List<MdcEquipmentTree> DncLoadTreeListByProduction() {
|
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
|
// 获取所有有效产线并建立快速查询映射
|
Map<String, MdcProduction> productionMap = getValidProductions();
|
|
// 获取用户权限相关的所有产线ID（包含层级祖先）
|
Set<String> authorizedProductionIds = getAuthorizedProductionIds(user.getId(), productionMap);
|
|
// 构建产线树结构
|
List<MdcEquipmentTree> treeList = buildProductionTree(new ArrayList<>(authorizedProductionIds), productionMap);
|
|
// 批量填充设备数据
|
fillEquipmentData(treeList, user);
|
|
return treeList;
|
}
|
|
/**
|
* 获取所有有效产线并建立ID映射
|
*/
|
private Map<String, MdcProduction> getValidProductions() {
|
List<MdcProduction> productions = mdcProductionService.list(
|
new LambdaQueryWrapper<MdcProduction>()
|
.eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0)
|
.orderByAsc(MdcProduction::getProductionOrder)
|
);
|
return productions.stream().collect(Collectors.toMap(MdcProduction::getId, Function.identity()));
|
}
|
|
/**
|
* 获取用户权限相关的所有产线ID（包含层级祖先）
|
*/
|
private Set<String> getAuthorizedProductionIds(String userId, Map<String, MdcProduction> productionMap) {
|
Set<String> result = new HashSet<>();
|
|
// 获取直接关联的产线ID
|
List<String> directProductionIds = Optional.ofNullable(mdcUserProductionService.queryProductionIdsByUserId(userId))
|
.orElse(Collections.emptyList());
|
|
// 递归收集所有层级ID
|
directProductionIds.forEach(id -> collectHierarchyIds(id, productionMap, result));
|
|
return result;
|
}
|
|
/**
|
* 递归收集层级ID（包含自身及所有祖先）
|
*/
|
private void collectHierarchyIds(String productionId, Map<String, MdcProduction> productionMap, Set<String> collector) {
|
if (collector.contains(productionId)) return;
|
|
MdcProduction current = productionMap.get(productionId);
|
if (current == null) return;
|
|
collector.add(productionId);
|
if (StringUtils.isNotBlank(current.getParentId())) {
|
collectHierarchyIds(current.getParentId(), productionMap, collector);
|
}
|
}
|
|
/**
|
构建产线树结构
|
*/
|
private List<MdcEquipmentTree> buildProductionTree(List<String> productionIds, Map<String, MdcProduction> productionMap) {
|
|
List<MdcProduction> filteredProductions = new ArrayList<>();
|
productionIds.forEach(id -> {
|
MdcProduction production = productionMap.get(id);
|
if (production != null) {
|
filteredProductions.add(production);
|
}
|
});
|
return FindsEquipmentProductionUtil.wrapEquipmentProductionTreeList(filteredProductions);
|
}
|
/**
|
* 批量填充设备数据
|
*/
|
private void fillEquipmentData(List<MdcEquipmentTree> treeList, LoginUser user) {
|
// 获取用户设备权限
|
Set<String> deviceIds = getAuthorizedDeviceIds(user.getId());
|
if (deviceIds.isEmpty()) return;
|
|
// 批量获取所有相关设备
|
Map<String, List<MdcEquipment>> equipmentMap = getEquipmentMap(user, deviceIds);
|
|
// 批量获取用户信息
|
Map<String, String> userRealNameMap = getUserRealNameMapping(equipmentMap.values());
|
|
// 填充设备数据到树节点
|
populateEquipmentNodes(treeList, equipmentMap, userRealNameMap);
|
}
|
|
/**
|
* 获取授权设备ID集合
|
*/
|
private Set<String> getAuthorizedDeviceIds(String userId) {
|
return super.list(new QueryWrapper<DevicePermission>().select("device_id").eq("user_id", userId))
|
.stream()
|
.map(DevicePermission::getDeviceId)
|
.collect(Collectors.toSet());
|
}
|
|
/**
|
* 批量获取设备数据并按产线分组
|
*/
|
private Map<String, List<MdcEquipment>> getEquipmentMap(LoginUser user, Set<String> deviceIds) {
|
List<String> productionIds=Arrays.asList(user.getProductionIds().split(","));
|
return mdcEquipmentMapper.queryByDepartIdsAndType(productionIds, new ArrayList<>(deviceIds))
|
.stream()
|
.collect(Collectors.groupingBy(MdcEquipment::getProductionId));
|
}
|
|
|
/*** 批量获取用户真实姓名映射
|
*/
|
private Map<String, String> getUserRealNameMapping(Collection<List<MdcEquipment>> equipmentLists) {
|
Set<String> userNames = equipmentLists.stream()
|
.flatMap(List::stream)
|
.flatMap(e -> Stream.of(e.getCreateBy(), e.getUpdateBy()))
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.toSet());
|
|
return sysUserService.getUserRealNamesByUserNames(new ArrayList<>(userNames));
|
}
|
|
/**
|
* 填充设备节点数据
|
*/
|
private void populateEquipmentNodes(List<MdcEquipmentTree> nodes,
|
Map<String, List<MdcEquipment>> equipmentMap,
|
Map<String, String> userRealNameMap) {
|
for (MdcEquipmentTree node : nodes) {
|
if (!isProductionNode(node)) continue;
|
|
List<MdcEquipment> equipments = equipmentMap.getOrDefault(node.getKey(), Collections.emptyList());
|
List<MdcEquipmentTree> equipmentNodes = convertToEquipmentNodes(equipments, userRealNameMap, node.getKey());
|
|
node.getChildren().addAll(equipmentNodes);
|
node.setLeaf(equipmentNodes.isEmpty());
|
|
// 递归处理子节点
|
populateEquipmentNodes(node.getChildren(), equipmentMap, userRealNameMap);
|
}
|
}
|
|
/**
|
* 转换设备数据为树节点
|
*/
|
private List<MdcEquipmentTree> convertToEquipmentNodes(List<MdcEquipment> equipments,
|
Map<String, String> userRealNameMap,
|
String parentId) {
|
return equipments.stream().map(e -> {
|
// 更新用户显示名称
|
Optional.ofNullable(e.getCreateBy()).ifPresent(name ->
|
e.setCreateBy(userRealNameMap.getOrDefault(name, name)));
|
Optional.ofNullable(e.getUpdateBy()).ifPresent(name ->
|
e.setUpdateBy(userRealNameMap.getOrDefault(name, name)));
|
|
MdcEquipmentTree node = new MdcEquipmentTree().convert(e);
|
node.setParentId(parentId);
|
node.setEntity(e);
|
node.setType(2); // 设备节点类型
|
return node;
|
}).collect(Collectors.toList());
|
}
|
|
/**
|
* 判断是否为产线节点（根据业务逻辑定义）
|
*/
|
private boolean isProductionNode(MdcEquipmentTree node) {
|
return node.getType() == 1; // 假设类型1表示产线节点
|
}
|
|
}
|
