Merge branch 'mdc_hyjs_master'

zhangherong

2025-06-25 23855599412c4d61b38d78f0f3abd3430a48b5b1

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/DevicePermissionServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,280 @@
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);
            }
        });
        // æŒ‰åˆ›å»ºæ—¶é—´å‡åºæŽ’序（空值排在最后）
        filteredProductions.sort(
                Comparator.comparing(
                        MdcProduction::getCreateTime,
                        Comparator.nullsLast(Comparator.naturalOrder()) // è‡ªç„¶é¡ºåºå³å‡åº
                )
        );
        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表示产线节点
    }

}