优化分配权限代码 默认新增添加管理员权限

lyh

2025-02-20 0eb2de47356408212a2641801ac7fd1aed7f5c33

优化分配权限代码
默认新增添加管理员权限

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/controller/ProductInfoController.java

@@ -173,7 +173,7 @@
    @ApiOperation(value = "产品表-指派产品树节点的用户权限", notes = "产品表-指派产品树节点的用户权限")
    @PostMapping("/assign/add/user/{nodeType}/{paramId}/{relativeFlag}")
    public ResponseResult assignAddUser(@PathVariable("nodeType") Integer nodeType, @PathVariable("paramId") String paramId, @PathVariable("relativeFlag") Integer relativeFlag, @RequestBody String[] userIds) {
        boolean b = productInfoService.assignAddUser(nodeType, paramId, relativeFlag, userIds);
        boolean b = productInfoService.assignAddUserAll(nodeType, paramId, relativeFlag, userIds);
        if(b) {
            return new ResponseResult(CommonCode.SUCCESS);
        }
@@ -192,7 +192,7 @@
    @ApiOperation(value = "产品表-移除产品树节点的用户权限", notes = "产品表-移除产品树节点的用户权限")
    @PostMapping("/assign/remove/user/{nodeType}/{paramId}/{relativeFlag}")
    public ResponseResult assignRemoveUser(@PathVariable("nodeType") Integer nodeType, @PathVariable("paramId") String paramId, @PathVariable("relativeFlag") Integer relativeFlag, @RequestBody String[] userIds) {
        boolean b = productInfoService.assignRemoveUser(nodeType, paramId, relativeFlag, userIds);
        boolean b = productInfoService.assignRemoveUserAll(nodeType, paramId, relativeFlag, userIds);
        if(b) {
            return new ResponseResult(CommonCode.SUCCESS);
        }
@@ -211,7 +211,7 @@
    @ApiOperation(value = "产品表-指派产品树节点的部门权限", notes = "产品表-指派产品树节点的部门权限")
    @PostMapping("/assign/add/department/{nodeType}/{paramId}/{relativeFlag}")
    public ResponseResult assignAddDepartment(@PathVariable("nodeType") Integer nodeType, @PathVariable("paramId") String paramId, @PathVariable("relativeFlag") Integer relativeFlag, @RequestBody String[] departmentIds) {
        boolean b = productInfoService.assignAddDepartment(nodeType, paramId, relativeFlag, departmentIds);
        boolean b = productInfoService.assignAddDepartmentAll(nodeType, paramId, relativeFlag, departmentIds);
        if(b) {
            return new ResponseResult(CommonCode.SUCCESS);
        }
@@ -230,7 +230,7 @@
    @ApiOperation(value = "产品表-移除产品树节点的部门权限", notes = "产品表-移除产品树节点的部门权限")
    @PostMapping("/assign/remove/department/{nodeType}/{paramId}/{relativeFlag}")
    public ResponseResult assignRemoveDepartment(@PathVariable("nodeType") Integer nodeType, @PathVariable("paramId") String paramId, @PathVariable("relativeFlag") Integer relativeFlag, @RequestBody String[] departmentIds) {
        boolean b = productInfoService.assignRemoveDepartment(nodeType, paramId, relativeFlag, departmentIds);
        boolean b = productInfoService.assignRemoveDepartmentAll(nodeType, paramId, relativeFlag, departmentIds);
        if(b) {
            return new ResponseResult(CommonCode.SUCCESS);
        }

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/entity/ComponentPermission.java

@@ -14,8 +14,8 @@
@NoArgsConstructor
@TableName(value = "nc_component_permission")
public class ComponentPermission {
    @TableId(value = "component_perm_id")
    private String componentPermId;
    @TableId(value = "id")
    private String id;
    @TableField(value = "component_id")
    private String componentId;
    @TableField(value = "user_id")

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/entity/PartsPermission.java

@@ -13,8 +13,8 @@
@NoArgsConstructor
@TableName(value = "nc_parts_permission")
public class PartsPermission {
    @TableId(value = "parts_perm_id")
    private String partsPermId;
    @TableId(value = "id")
    private String id;
    @TableField(value = "parts_id")
    private String partsId;
    @TableField(value = "user_id")

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/entity/ProcessionPermission.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,35 @@
package org.jeecg.modules.dnc.entity;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@TableName(value = "nc_process_stream_permission")
public class ProcessionPermission {
    @TableId(value = "id")
    private String id;
    @TableField(value = "process_id")
    private String processId;
    @TableField(value = "user_id")
    private String userId;
    @JsonIgnore
    @TableField(value = "create_time", select = false, fill = FieldFill.INSERT)
    private Date createTime;
    @JsonIgnore
    @TableField(value = "create_by", select = false, fill = FieldFill.INSERT)
    private String createBy;

    public ProcessionPermission(String processId, String userId){
        this.processId = processId;
        this.userId = userId;
    }

}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/entity/ProductPermission.java

@@ -14,8 +14,8 @@
@NoArgsConstructor
@TableName(value = "nc_product_permission")
public class ProductPermission {
    @TableId(value = "product_perm_id")
    private String productPermId;
    @TableId(value = "id")
    private String id;
    @TableField(value = "product_id")
    private String productId;
    @TableField(value = "user_id")

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/entity/WorkStepPermission.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,35 @@
package org.jeecg.modules.dnc.entity;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@TableName(value = "nc_work_step_permission")
public class WorkStepPermission {
    @TableId(value = "id")
    private String id;
    @TableField(value = "step_id")
    private String stepId;
    @TableField(value = "user_id")
    private String userId;
    @JsonIgnore
    @TableField(value = "create_time", select = false, fill = FieldFill.INSERT)
    private Date createTime;
    @JsonIgnore
    @TableField(value = "create_by", select = false, fill = FieldFill.INSERT)
    private String createBy;

    public WorkStepPermission(String stepId, String userId){
        this.stepId = stepId;
        this.userId = userId;
    }

}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/mapper/ProcessStreamPermissionMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,25 @@
package org.jeecg.modules.dnc.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.dnc.entity.ProcessionPermission;
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
import org.jeecg.modules.system.entity.SysUser;

import java.util.List;
public interface ProcessStreamPermissionMapper extends BaseMapper<ProcessionPermission> {

    /**
     * èŽ·å–已分配的用户
     * @param processId
     * @return
     */
    List<UserDepartExt> getUserPermsByProcessId(@Param("processId") String processId);

    /**
     * èŽ·å–未分配的用户
     * @param processId
     * @return
     */
    List<SysUser> getUserNonPermsByProcessId(@Param("processId") String processId);
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/mapper/WorkStepPermissionMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,26 @@
package org.jeecg.modules.dnc.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.dnc.entity.WorkStepPermission;
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
import org.jeecg.modules.system.entity.SysUser;

import java.util.List;

public interface WorkStepPermissionMapper extends BaseMapper<WorkStepPermission> {

    /**
     * èŽ·å–已分配的用户
     * @param stepId
     * @return
     */
    List<UserDepartExt> getUserPermsByStepId(@Param("stepId") String stepId);

    /**
     * èŽ·å–未分配的用户
     * @param stepId
     * @return
     */
    List<SysUser> getUserNonPermsByStepId(@Param("stepId") String stepId);
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/mapper/xml/ProcessStreamPermissionMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="org.jeecg.modules.dnc.mapper.ProcessStreamPermissionMapper">
    <select id="getUserPermsByProcessId"  parameterType="String" resultType="org.jeecg.modules.dnc.ucenter.UserDepartExt">
        select u.id
        , u.username
        , u.realname
        , u.avatar
        , u.phone
        , u.email
        from sys_user u
        inner join
        (select user_id from nc_process_stream_permission where process_id=#{processId}) p
        on u.id=p.user_id
    </select>

    <select id="getUserNonPermsByProcessId" resultType="org.jeecg.modules.system.entity.SysUser" parameterType="String">
        select u.id
        , u.username
        , u.realname
        , u.avatar
        , u.phone
        , u.email
        from sys_user u
        where u.id not in (select user_id from nc_process_stream_permission where process_id=#{processId})
    </select>
</mapper>

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/mapper/xml/WorkStepPermissionMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="org.jeecg.modules.dnc.mapper.WorkStepPermissionMapper">
    <select id="getUserPermsByStepId"  parameterType="String" resultType="org.jeecg.modules.dnc.ucenter.UserDepartExt">
        select u.id
        , u.username
        , u.realname
        , u.avatar
        , u.phone
        , u.email
        from sys_user u
        inner join
        (select user_id from nc_work_step_permission where step_id=#{stepId}) p
        on u.id=p.user_id
    </select>

    <select id="getUserNonPermsByStepId" resultType="org.jeecg.modules.system.entity.SysUser" parameterType="String">
        select u.id
        , u.username
        , u.realname
        , u.avatar
        , u.phone
        , u.email
        from sys_user u
        where u.id not in (select user_id from nc_work_step_permission where step_id=#{stepId})
    </select>
</mapper>

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,63 @@
package org.jeecg.modules.dnc.service;

import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.dnc.entity.ProcessionPermission;
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
import org.jeecg.modules.system.entity.SysUser;

import java.util.List;

public interface IProcessStreamPermissionService extends IService<ProcessionPermission> {

    /**
     * æ ¹æ®å·¥åºid å’ŒuserId æŸ¥æ‰¾æƒé™
     * @param processId
     * @param userId
     * @return
     */
    ProcessionPermission getByProcessIdAndUserId(String processId, String userId);

    /**
     * æ ¹æ®å·¥åºid删除用户权限
     * @param processId
     * @return
     */
    boolean deleteByProcessId(String processId);


    /**
     * èŽ·å–已分配的用户
     * @param processId
     * @return
     */
    List<UserDepartExt> getUserPermsByProductId(String processId);

    /**
     * èŽ·å–未分配的用户
     * @param processId
     * @return
     */
    List<SysUser> getUserNonPermsByProductId(String processId);

    /**
     * ç§»é™¤ç”¨æˆ·æƒé™
     * @param permissionList
     * @return
     */
    boolean removeByCollection(List<ProcessionPermission> permissionList);

    /**
     * èŽ·å–当前工序的所有用户权限
     * @param processId
     * @return
     */
    List<ProcessionPermission> getByProcessId(String processId);

    /**
     * æŸ¥è¯¢ä¸€ç»„权限
     * @param processIds
     * @param ids
     * @return
     */
    List<ProcessionPermission> getByProcessIdsAndUserIds(List<String> processIds, List<String> ids);
}

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

@@ -7,6 +7,7 @@
import org.jeecg.modules.dnc.request.ProcessStreamRequest;
import org.jeecg.modules.dnc.ucenter.Department;
import org.jeecg.modules.system.entity.MdcProduction;
import org.jeecg.modules.system.entity.SysUser;

import java.util.Collection;
import java.util.List;
@@ -125,4 +126,21 @@
     * @return
     */
    boolean assignRemoveDepart(ProcessStream processStream, Collection<MdcProduction> departmentList);


    /**
     * åˆ†é…ç”¨æˆ·æƒé™
     * @param processStream
     * @param userList
     * @return
     */
    boolean assignAddUser(ProcessStream processStream, Collection<SysUser> userList);

    /**
     * ç§»é™¤ç”¨æˆ·æƒé™
     * @param processStream
     * @param userList
     * @return
     */
    boolean assignRemoveUser(ProcessStream processStream, Collection<SysUser> userList);
}

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

@@ -103,7 +103,7 @@
     * @param relativeFlag 1 æ˜¯ 2 å¦
     * @return
     */
    boolean assignAddUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds);
    boolean assignAddUserAll(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds);

    /**
     * ç§»é™¤äº§å“æ ‘节点的用户权限
@@ -113,7 +113,7 @@
     * @param relativeFlag 1 æ˜¯ 2 å¦
     * @return
     */
    boolean assignRemoveUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds);
    boolean assignRemoveUserAll(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds);

    /**
     * æŒ‡æ´¾äº§å“æ ‘节点的部门权限
@@ -123,7 +123,7 @@
     * @param relativeFlag 1 æ˜¯ 2 å¦
     * @return
     */
    boolean assignAddDepartment(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds);
    boolean assignAddDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds);

    /**
     * ç§»é™¤äº§å“æ ‘节点的部门权限
@@ -133,7 +133,7 @@
     * @param relativeFlag 1 æ˜¯ 2 å¦
     * @return
     */
    boolean assignRemoveDepartment(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds);
    boolean assignRemoveDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds);


    /**

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,65 @@
package org.jeecg.modules.dnc.service;

import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.dnc.entity.PartsPermission;
import org.jeecg.modules.dnc.entity.WorkStepPermission;
import org.jeecg.modules.dnc.entity.WorkStepPermission;
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
import org.jeecg.modules.system.entity.SysUser;

import java.util.List;

public interface IWorkStepPermissionService extends IService<WorkStepPermission> {

    /**
     * æ ¹æ®å·¥åºid å’ŒuserId æŸ¥æ‰¾æƒé™
     * @param stepId
     * @param userId
     * @return
     */
    WorkStepPermission getByStepIdAndUserId(String stepId, String userId);

    /**
     * æ ¹æ®å·¥åºid删除用户权限
     * @param stepId
     * @return
     */
    boolean deleteByStepId(String stepId);


    /**
     * èŽ·å–已分配的用户
     * @param stepId
     * @return
     */
    List<UserDepartExt> getUserPermsByProductId(String stepId);

    /**
     * èŽ·å–未分配的用户
     * @param stepId
     * @return
     */
    List<SysUser> getUserNonPermsByProductId(String stepId);

    /**
     * ç§»é™¤ç”¨æˆ·æƒé™
     * @param permissionList
     * @return
     */
    boolean removeByCollection(List<WorkStepPermission> permissionList);

    /**
     * èŽ·å–当前工序的所有用户权限
     * @param stepId
     * @return
     */
    List<WorkStepPermission> getByStepId(String stepId);

    /**
     * æŸ¥è¯¢ä¸€ç»„权限
     * @param stepIds
     * @param ids
     * @return
     */
    List<WorkStepPermission> getByStepIdsAndUserIds(List<String> stepIds, List<String> ids);
}

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

@@ -4,6 +4,7 @@
import org.jeecg.modules.dnc.entity.*;
import org.jeecg.modules.dnc.ucenter.Department;
import org.jeecg.modules.system.entity.MdcProduction;
import org.jeecg.modules.system.entity.SysUser;

import java.util.Collection;
import java.util.List;
@@ -82,4 +83,20 @@
     * @return
     */
    boolean deleteWorkStep(String id);

    /**
     * åˆ†é…ç”¨æˆ·æƒé™
     * @param workStep
     * @param userList
     * @return
     */
    boolean assignAddUser(WorkStep workStep, Collection<SysUser> userList);

    /**
     * ç§»é™¤ç”¨æˆ·æƒé™
     * @param workStep
     * @param userList
     * @return
     */
    boolean assignRemoveUser(WorkStep workStep, Collection<SysUser> userList);
}

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

@@ -55,10 +55,10 @@
        if(permissionList == null || permissionList.isEmpty())
            return false;
        if(permissionList.size() == 1)
            return super.removeById(permissionList.get(0).getComponentPermId());
            return super.removeById(permissionList.get(0).getId());
        List<String> ids = new ArrayList<>();
        permissionList.forEach(item -> {
            ids.add(item.getComponentPermId());
            ids.add(item.getId());
        });
        return super.removeByIds(ids);
    }

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

@@ -55,10 +55,10 @@
        if(permissionList == null || permissionList.isEmpty())
            return false;
        if(permissionList.size() == 1)
            return super.removeById(permissionList.get(0).getPartsPermId());
            return super.removeById(permissionList.get(0).getId());
        List<String> ids = new ArrayList<>();
        permissionList.forEach(item -> {
            ids.add(item.getPartsPermId());
            ids.add(item.getId());
        });
        if(ids.size() > 1000){
            List<List<String>> idsArr = ListUtils.partition(ids, 1000);

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,112 @@
package org.jeecg.modules.dnc.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections4.ListUtils;
import org.jeecg.modules.dnc.entity.ProcessionPermission;
import org.jeecg.modules.dnc.mapper.ProcessStreamPermissionMapper;
import org.jeecg.modules.dnc.service.IProcessStreamPermissionService;
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.system.entity.SysUser;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

@Service
public class ProcessStreamPermissionServiceImpl extends ServiceImpl<ProcessStreamPermissionMapper, ProcessionPermission> implements IProcessStreamPermissionService {
    @Override
    public ProcessionPermission getByProcessIdAndUserId(String partsId, String userId) {
        if(!ValidateUtil.validateString(partsId) || !ValidateUtil.validateString(userId))
            return null;
        List<ProcessionPermission> permissions = super.lambdaQuery().eq(ProcessionPermission::getProcessId, partsId).eq(ProcessionPermission::getUserId, userId).list();
        if(permissions == null || permissions.isEmpty())
            return null;
        return permissions.get(0);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteByProcessId(String partsId) {
        if(!ValidateUtil.validateString(partsId))
            return false;
        LambdaQueryWrapper<ProcessionPermission> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(ProcessionPermission::getProcessId, partsId);
        return super.remove(lambdaQueryWrapper);
    }

    @Override
    public List<UserDepartExt> getUserPermsByProductId(String partsId) {
        return super.getBaseMapper().getUserPermsByProcessId(partsId);
    }

    @Override
    public List<SysUser> getUserNonPermsByProductId(String partsId) {
        return super.getBaseMapper().getUserNonPermsByProcessId(partsId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean removeByCollection(List<ProcessionPermission> permissionList) {
        if(permissionList == null || permissionList.isEmpty())
            return false;
        if(permissionList.size() == 1)
            return super.removeById(permissionList.get(0).getId());
        List<String> ids = new ArrayList<>();
        permissionList.forEach(item -> {
            ids.add(item.getId());
        });
        if(ids.size() > 1000){
            List<List<String>> idsArr = ListUtils.partition(ids, 1000);
            for(List<String> arr : idsArr){
                super.removeByIds(arr);
            }
            return true;
        }else {
            return super.removeByIds(ids);
        }
    }

    @Override
    public List<ProcessionPermission> getByProcessId(String partsId) {
        List<ProcessionPermission> list = super.lambdaQuery().eq(ProcessionPermission::getProcessId, partsId).list();
        if(list == null)
            list = Collections.emptyList();
        return list;
    }

    @Override
    public List<ProcessionPermission> getByProcessIdsAndUserIds(List<String> partsIds, List<String> userIds) {
        if(partsIds == null || partsIds.isEmpty() || userIds == null || userIds.isEmpty())
            return null;
        List<ProcessionPermission> total = new ArrayList<>();
        List<List<String>> partsListArr;
        List<List<String>> userListArr;
        if(partsIds.size() > 1000){
            partsListArr = ListUtils.partition(partsIds, 100);
        }else {
            partsListArr = ListUtils.partition(partsIds, 1000);
        }
        if(userIds.size() > 1000){
            userListArr = ListUtils.partition(userIds, 100);
        }else {
            userListArr = ListUtils.partition(userIds, 1000);
        }
        for(List<String> compList : partsListArr) {
            for(List<String> userList : userListArr){
                LambdaQueryWrapper<ProcessionPermission> queryWrapper = Wrappers.lambdaQuery();
                queryWrapper.in(ProcessionPermission::getProcessId, compList);
                queryWrapper.in(ProcessionPermission::getUserId, userList);
                List<ProcessionPermission> list = super.list(queryWrapper);
                if(list != null && !list.isEmpty()){
                    total.addAll(list);
                }
            }
        }
        return total;
    }
}

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

@@ -15,13 +15,13 @@
import org.jeecg.modules.dnc.response.*;

import org.jeecg.modules.dnc.service.*;
import org.jeecg.modules.dnc.ucenter.Department;
import org.jeecg.modules.dnc.utils.ValidateUtil;


import org.jeecg.modules.dnc.request.ProcessStreamRequest;
import org.jeecg.modules.dnc.entity.*;
import org.jeecg.modules.system.entity.MdcProduction;
import org.jeecg.modules.system.entity.SysUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
@@ -56,6 +56,8 @@
    private IWorkStepService workStepService;
    @Autowired
    private IDocRelativeService iDocRelativeService;
    @Autowired
    private IProcessStreamPermissionService processStreamPermissionService;

    @Override
    @Transactional(rollbackFor = {Exception.class})
@@ -359,4 +361,78 @@
        return true;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddUser(ProcessStream processStream, Collection<SysUser> userList) {
        if(processStream == null || userList == null || userList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<ProcessionPermission> permissionList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        userList.forEach(item -> {
            ProcessionPermission en = processStreamPermissionService.getByProcessIdAndUserId(processStream.getProcessId(), item.getId());
            if(en == null) {
                en = new ProcessionPermission();
                en.setUserId(item.getId());
                en.setProcessId(processStream.getProcessId());
                permissionList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByProcessIdAndUserId(processStream.getProductId(), processStream.getComponentId(), processStream.getPartsId(),processStream.getProcessId(), item.getId());
            if(stream == null) {
                stream = new PermissionStream();
                stream.setUserId(item.getId());
                stream.setProductId(processStream.getProductId());
                stream.setComponentId(processStream.getComponentId());
                stream.setPartsId(processStream.getPartsId());
                stream.setProcessId(processStream.getProcessId());
                permissionStreamList.add(stream);
            }
        });
        if(!permissionList.isEmpty()) {
            boolean b = processStreamPermissionService.saveBatch(permissionList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.saveBatch(permissionStreamList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveUser(ProcessStream processStream, Collection<SysUser> userList) {
        if(processStream == null || userList == null || userList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<ProcessionPermission> permissionList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        userList.forEach(item -> {
            ProcessionPermission en = processStreamPermissionService.getByProcessIdAndUserId(processStream.getProcessId(), item.getId());
            if(en != null) {
                permissionList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByProcessIdAndUserId(processStream.getProductId(), processStream.getComponentId(), processStream.getPartsId(),processStream.getProcessId(), item.getId());
            if(stream != null) {
                permissionStreamList.add(stream);
            }
        });
        //清空用户权限校验
        if(!permissionList.isEmpty()) {
            boolean b = processStreamPermissionService.removeByCollection(permissionList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.removeByCollection(permissionStreamList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        return true;
    }

}

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

@@ -9,30 +9,25 @@
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.dnc.dto.ComponentExt;

import org.jeecg.modules.dnc.exception.ExceptionCast;
import org.jeecg.modules.dnc.mapper.ProductInfoMapper;

import org.jeecg.modules.dnc.response.*;
import org.jeecg.modules.dnc.service.*;
import org.jeecg.modules.dnc.service.support.ProductTreeWrapper;
import org.jeecg.modules.dnc.ucenter.Department;
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
import org.jeecg.modules.dnc.utils.ValidateUtil;

import org.jeecg.modules.dnc.entity.*;
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.ISysUserService;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

@Service
@Slf4j
@@ -58,16 +53,12 @@
    @Autowired
    private IPartsPermissionService partsPermissionService;
    @Autowired
    private IDepartmentService departmentService;
    @Autowired
    private ISysUserService userService;
    @Autowired
    @Lazy
    private IProcessStreamService processStreamService;
    @Autowired
    private IWorkStepService workStepService;
    @Autowired
    private IDocInfoService docInfoService;
    @Autowired
    private INcLogInfoService iNcLogInfoService;
    @Autowired
@@ -78,43 +69,38 @@
    private IMdcProductionService mdcProductionService;
    @Autowired
    private IDocRelativeService iDocRelativeService;
    @Autowired
    private IProcessStreamPermissionService iProcessStreamPermissionService;
    @Autowired
    private IWorkStepPermissionService iWorkStepPermissionService;

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addProductInfo(ProductInfo productInfo) {
        if(productInfo == null)
        if (productInfo == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(!ValidateUtil.validateString(productInfo.getProductName()))
        if (!ValidateUtil.validateString(productInfo.getProductName()))
            ExceptionCast.cast(ProductInfoCode.PRODUCT_NAME_NONE);
        if(!ValidateUtil.validateString(productInfo.getProductNo())) {
        if (!ValidateUtil.validateString(productInfo.getProductNo())) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_NO_NONE);
        }
        ProductInfo en = getByProductNo(productInfo.getProductNo());
        if(en != null)
        if (en != null)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_IS_EXIST);
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if(!ValidateUtil.validateString(userId))
        if (!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        productInfo.setProductStatus(1);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("产品结构树");
        //类型
        ncLogInfo.setOperateType(2);
        //日志内容
        ncLogInfo.setLogContent("产品名称："+productInfo.getProductName()+"，产品编号："+productInfo.getProductNo());
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        boolean b = super.save(productInfo);
        if(!b) {
        if (!b) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
        }
        ProductPermission permission = new ProductPermission();
        permission.setProductId(productInfo.getProductId());
        permission.setUserId(userId);
        b = productPermissionService.save(permission);
        if(!b) {
        if (!b) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
        }
        PermissionStream stream = new PermissionStream();
@@ -125,43 +111,33 @@

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean editProductInfo(String id ,ProductInfo productInfo) {
        if(!ValidateUtil.validateString(id) || productInfo == null)
    public boolean editProductInfo(String id, ProductInfo productInfo) {
        if (!ValidateUtil.validateString(id) || productInfo == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if(!ValidateUtil.validateString(userId))
        if (!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        ProductInfo en = super.getById(id);
        if(en == null)
        if (en == null)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
        productInfo.setProductId(id);
        productInfo.setProductStatus(null);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("产品结构树");
        //类型
        ncLogInfo.setOperateType(3);
        //日志内容
        ncLogInfo.setLogContent("产品名称："+productInfo.getProductName());
        ncLogInfo.setRemark(JSONObject.toJSONString(en));
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        boolean b = super.updateById(productInfo);
        if(!b)
        if (!b)
            return false;
        ProductPermission permission = productPermissionService.getByProductIdAndUserId(id, userId);
        if(permission == null) {
        if (permission == null) {
            permission = new ProductPermission();
            permission.setProductId(id);
            permission.setUserId(userId);
            b = productPermissionService.save(permission);
            if(!b) {
            if (!b) {
                return false;
            }
        }
        PermissionStream stream = permissionStreamService.getByProductIdAndUserId(id, userId);
        if(stream == null) {
        if (stream == null) {
            stream = new PermissionStream();
            stream.setProductId(id);
            stream.setUserId(userId);
@@ -174,41 +150,41 @@
    public List<CommonGenericTree> loadProductTree(String userId) {
        //产品
        List<ProductInfo> productInfoList = getByUserPerms(userId);
        if(productInfoList == null || productInfoList.isEmpty())
        if (productInfoList == null || productInfoList.isEmpty())
            return Collections.emptyList();
        //部件
        List<ComponentExt> componentInfoList = componentInfoService.getByUserPermsAs(userId);
        if(componentInfoList == null)
        if (componentInfoList == null)
            componentInfoList = Collections.emptyList();
        //零件
        List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId);
        if(partsInfos == null)
        if (partsInfos == null)
            partsInfos = Collections.emptyList();
        //工序
        List<ProcessStream> processStreams=processStreamService.getByuserPerms(userId);
        if(processStreams==null)
        List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId);
        if (processStreams == null)
            processStreams = Collections.emptyList();
        //工步
        List<WorkStep> workStepList=workStepService.getByUserPerms(userId);
        if(workStepList==null)
        List<WorkStep> workStepList = workStepService.getByUserPerms(userId);
        if (workStepList == null)
            workStepList = Collections.emptyList();
        return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos,processStreams,workStepList);
        return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos, processStreams, workStepList);
    }

    @Override
    public List<ProductInfo> getByUserPerms(String userId) {
        if(!ValidateUtil.validateString(userId))
        if (!ValidateUtil.validateString(userId))
            return Collections.emptyList();
        return super.getBaseMapper().getByUserPerms(userId);
    }

    @Override
    public List<ProductInfo> getByUserPerms(String userId, String queryParam) {
        if(!ValidateUtil.validateString(userId))
        if (!ValidateUtil.validateString(userId))
            return Collections.emptyList();
        //去除权限  TODO
        LambdaQueryWrapper<ProductInfo> queryWrapper = Wrappers.lambdaQuery();
        if(ValidateUtil.validateString(queryParam)) {
        if (ValidateUtil.validateString(queryParam)) {
            queryWrapper.and(wrapper -> wrapper.like(ProductInfo::getProductNo, queryParam)
                    .or()
                    .like(ProductInfo::getProductName, queryParam));
@@ -219,83 +195,83 @@
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteProductInfo(String id) {
        if(!ValidateUtil.validateString(id))
        if (!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        ProductInfo productInfo = super.getById(id);
        if(productInfo == null)
        if (productInfo == null)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
        //验证产品下是否有部件
        List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
        if(componentInfoList != null && !componentInfoList.isEmpty()) {
        if (componentInfoList != null && !componentInfoList.isEmpty()) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_COMPONENT_EXIST);
        }
        //验证产品下是否有零件
        List<PartsInfo> partsInfoList = partsInfoService.getByProductId(productInfo.getProductId());
        if(partsInfoList != null && !partsInfoList.isEmpty()) {
        if (partsInfoList != null && !partsInfoList.isEmpty()) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_PARTS_EXIST);
        }
        List<ProcessStream> processStreams = processStreamService.findByProductId(id);
        if(processStreams != null && !processStreams.isEmpty())
        if (processStreams != null && !processStreams.isEmpty())
            ExceptionCast.cast(ProductInfoCode.PRODUCT_PROCESS_EXIST);
        boolean b = productPermissionService.deleteByProductId(id);
        //验证是否存在文档
        List<DocRelative> docRelativeList=iDocRelativeService.list(new QueryWrapper<DocRelative>().eq("attribution_type","1").eq("attribution_id",id));
        if (!docRelativeList.isEmpty()){
        List<DocRelative> docRelativeList = iDocRelativeService.list(new QueryWrapper<DocRelative>().eq("attribution_type", "1").eq("attribution_id", id));
        if (!docRelativeList.isEmpty()) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_DOC_EXIST);
        }
        if(!b)
        if (!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = productDepartmentService.deleteByProductId(id);
        if(!b)
        if (!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = permissionStreamService.deleteUserPermsByProductId(id);
        if(!b)
        if (!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = permissionStreamService.deleteDepartPermsByProductId(id);
        if(!b)
        if (!b)
            ExceptionCast.cast(CommonCode.FAIL);
        return super.removeById(id);
    }

    @Override
    public boolean checkProductPerm(Integer nodeType, String paramId) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
        if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if(!ValidateUtil.validateString(userId))
        if (!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        if(nodeType == 1) {
        if (nodeType == 1) {
            ProductInfo productInfo = super.getById(paramId);
            if(productInfo == null)
            if (productInfo == null)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            PermissionStream permission = permissionStreamService.getByProductIdAndUserId(paramId, userId);
            return permission != null;
        }else if(nodeType == 2) {
        } else if (nodeType == 2) {
            ComponentInfo componentInfo = componentInfoService.getById(paramId);
            if(componentInfo == null)
            if (componentInfo == null)
                ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            PermissionStream permission = permissionStreamService.getByComponentIdAndUserId(componentInfo.getProductId(), paramId, userId);
            return permission != null;
        }else if(nodeType == 3) {
        } else if (nodeType == 3) {
            PartsInfo partsInfo = partsInfoService.getById(paramId);
            if(partsInfo == null)
            if (partsInfo == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            PermissionStream permission = permissionStreamService.getByPartsIdAndUserId(partsInfo.getProductId(), partsInfo.getComponentId(), paramId, userId);
            return permission != null;
        }else if (nodeType == 5) {
            ProcessStream processStream=processStreamService.getById(paramId);
            if(processStream == null)
        } else if (nodeType == 5) {
            ProcessStream processStream = processStreamService.getById(paramId);
            if (processStream == null)
                ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
            PermissionStream permission = permissionStreamService.getByProcessIdAndUserId(processStream.getProductId(),processStream.getComponentId()
                        ,processStream.getPartsId(),processStream.getProcessId(),userId);
            PermissionStream permission = permissionStreamService.getByProcessIdAndUserId(processStream.getProductId(), processStream.getComponentId()
                    , processStream.getPartsId(), processStream.getProcessId(), userId);
            return permission != null;
        }else if (nodeType == 6){
            WorkStep workStep=workStepService.getById(paramId);
            if(workStep == null)
        } else if (nodeType == 6) {
            WorkStep workStep = workStepService.getById(paramId);
            if (workStep == null)
                ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
            PermissionStream permission = permissionStreamService.getByStepIdAndUserId(workStep.getProductId(),workStep.getComponentId()
                    ,workStep.getPartsId(),workStep.getProcessId(),workStep.getId(),userId);
            PermissionStream permission = permissionStreamService.getByStepIdAndUserId(workStep.getProductId(), workStep.getComponentId()
                    , workStep.getPartsId(), workStep.getProcessId(), workStep.getId(), userId);
            return permission != null;
        }
        return false;
@@ -303,47 +279,55 @@

    @Override
    public List<UserDepartExt> getUserPermsList(Integer nodeType, String paramId) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
        if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
            return null;
        if(nodeType == 1) {
        if (nodeType == 1) {
            return productPermissionService.getUserPermsByProductId(paramId);
        }else if(nodeType == 2) {
        } else if (nodeType == 2) {
            return componentPermissionService.getUserPermsByComponentId(paramId);
        }else if(nodeType == 3) {
        } else if (nodeType == 3) {
            return partsPermissionService.getUserPermsByProductId(paramId);
        }else {
        } else if (nodeType == 5) {
            return iProcessStreamPermissionService.getUserPermsByProductId(paramId);
        } else if (nodeType == 6) {
            return iWorkStepPermissionService.getUserPermsByProductId(paramId);
        } else {
            return null;
        }
    }

    @Override
    public List<SysUser> getUserNonPermsList(Integer nodeType, String paramId) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
        if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
            return null;
        if(nodeType == 1) {
        if (nodeType == 1) {
            return productPermissionService.getUserNonPermsByProductId(paramId);
        }else if(nodeType == 2) {
        } else if (nodeType == 2) {
            return componentPermissionService.getUserNonPermsByComponentId(paramId);
        }else if(nodeType == 3) {
        } else if (nodeType == 3) {
            return partsPermissionService.getUserNonPermsByProductId(paramId);
        }else {
        } else if (nodeType == 5) {
            return iProcessStreamPermissionService.getUserNonPermsByProductId(paramId);
        } else if (nodeType == 6) {
            return iWorkStepPermissionService.getUserNonPermsByProductId(paramId);
        } else {
            return null;
        }
    }

    @Override
    public List<MdcProduction> getDepartPermsList(Integer nodeType, String paramId) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
        if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
            return null;
        if(nodeType == 1) {
        if (nodeType == 1) {
            return productDepartmentService.getDepartPermsByProductId(paramId);
        }else if(nodeType == 2) {
        } else if (nodeType == 2) {
            return componentDepartmentService.getDepartPermsByComponentId(paramId);
        }else if(nodeType == 3) {
        } else if (nodeType == 3) {
            return partsDepartmentService.getDepartPermsByPartsId(paramId);
        }else if(nodeType == 5) {
        } else if (nodeType == 5) {
            return processionDepartmentService.getDepartPermsByProcessId(paramId);
        }else if(nodeType == 6) {
        } else if (nodeType == 6) {
            return workStepDepartmentService.getDepartPermsByStepId(paramId);
        }
        //todo å°è£…树状结构
@@ -354,1199 +338,180 @@

    @Override
    public List<MdcProduction> getDepartNonPermsList(Integer nodeType, String paramId) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
        if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
            return null;
        if(nodeType == 1) {
        if (nodeType == 1) {
            return productDepartmentService.getDepartNonPermsByProductId(paramId);
        }else if(nodeType == 2) {
        } else if (nodeType == 2) {
            return componentDepartmentService.getDepartNonPermsByComponentId(paramId);
        }else if(nodeType == 3) {
        } else if (nodeType == 3) {
            return partsDepartmentService.getDepartNonPermsByProductId(paramId);
        }else if(nodeType == 5) {
        } else if (nodeType == 5) {
            return processionDepartmentService.getDepartNonPermsByProcessId(paramId);
        }else if(nodeType == 6) {
        } else if (nodeType == 6) {
            return workStepDepartmentService.getDepartNonPermsByStepId(paramId);
        }
        //todo å°è£…树状结构
        else {
        } else {
            return null;
        }
    }

    /**
     * 1、循环插入优化
     * 2、查询优化
     * 3、封装优化 TODO
     * @param nodeType 1 äº§å“ 2 éƒ¨ä»¶ 3 é›¶ä»¶
     * @param paramId  äº§å“æ ‘节点id
     * @param nodeType     1 äº§å“ 2 éƒ¨ä»¶ 3 é›¶ä»¶
     * @param paramId      äº§å“æ ‘节点id
     * @param relativeFlag 1 æ˜¯ 2 å¦
     * @param userIds æ·»åŠ ç”¨æˆ·ids
     * @param userIds      æ·»åŠ ç”¨æˆ·ids
     * @return
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
        //参数校验
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
                !ValidateUtil.validateInteger(relativeFlag))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(userIds == null || userIds.length < 1)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
    public boolean assignAddUserAll(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
        // å‚数校验
        validateInputParameters(nodeType, paramId, relativeFlag, "1", userIds);
        List<String> ids = new ArrayList<>(userIds.length);
        Collections.addAll(ids, userIds);
        Collection<SysUser> userList = userService.listByIds(ids);
        if(userList == null || userList.isEmpty() || userList.size() != userIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        //节点类型判定
        if(nodeType == 3) {
            //处理零件
            PartsInfo partsInfo = partsInfoService.getById(paramId);
            if(partsInfo == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(3, partsInfo.getPartsId());
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return partsInfoService.assignAddUser(partsInfo, userList);
        }else if(nodeType == 1) {
            //处理产品
            ProductInfo productInfo = super.getById(paramId);
            if(productInfo == null)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            boolean b1 = checkProductPerm(1, productInfo.getProductId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = this.assignAddUser(productInfo, userList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {

                List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
                if(componentInfoList == null || componentInfoList.isEmpty()){
                    //没有可添加的零部件权限
                    return true;
                }

                //最终保存权限数据初始化
                List<ComponentPermission> componentPermissionList = new ArrayList<>();
                List<PartsPermission> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                //处理子部件
                List<String> componentIds = new ArrayList<>();
                PermissionStream s;

                Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
                Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

                //初始化全体数据
                String key;
                ComponentPermission cp;
                ComponentInfo cpInfo;
                for(ComponentInfo c : componentInfoList){
                    componentIds.add(c.getComponentId());
                    componentInfoMap.put(c.getComponentId(), c);
                    for(SysUser u : userList){
                        key = c.getComponentId() + "," + u.getId();
                        cp = new ComponentPermission(c.getComponentId(), u.getId());
                        componentPermissionMap.put(key, cp);
                    }
                }
                //查询已存在的权限数据
                List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
                if(existList != null && !existList.isEmpty()){
                    //踢出权限数据
                    for(ComponentPermission permission : existList){
                        key = permission.getComponentId() + "," + permission.getUserId();
                        if(componentPermissionMap.containsKey(key)){
                            componentPermissionMap.remove(key);
                        }
                    }
                }
                for(Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()){
                    cp = entry.getValue();
                    componentPermissionList.add(cp);
                    cpInfo = componentInfoMap.get(cp.getComponentId());
                    s = new PermissionStream();
                    s.setProductId(cpInfo.getProductId());
                    s.setComponentId(cpInfo.getComponentId());
                    s.setUserId(cp.getUserId());
                    permissionStreamList.add(s);
                }

                //处理子零件
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
                    Map<String, PartsInfo> partsInfoMap = new HashMap<>();
                    List<String> partsIds = new ArrayList<>();
                    PartsPermission pp;
                    PartsInfo ptInfo;
                    for(PartsInfo p : partsInfoList){
                        partsIds.add(p.getPartsId());
                        partsInfoMap.put(p.getPartsId(), p);
                        for(SysUser u : userList){
                            key = p.getPartsId() + "," + u.getId();
                            pp = new PartsPermission(p.getPartsId(), u.getId());
                            partsPermissionHashMap.put(key, pp);
                        }
                    }

                    //查询已存在的权限数据
                    List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
                    if(existPartsList != null && !existPartsList.isEmpty()){
                        //踢出权限数据
                        for(PartsPermission permission : existPartsList){
                            key = permission.getPartsId() + "," + permission.getUserId();
                            if(partsPermissionHashMap.containsKey(key)){
                                partsPermissionHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()){
                        pp = entry.getValue();
                        partsPermissionList.add(pp);
                        ptInfo = partsInfoMap.get(pp.getPartsId());
                        s = new PermissionStream();
                        s.setProductId(ptInfo.getProductId());
                        s.setComponentId(ptInfo.getComponentId());
                        s.setPartsId(ptInfo.getPartsId());
                        s.setUserId(pp.getUserId());
                        permissionStreamList.add(s);
                    }
                }

                if(!componentPermissionList.isEmpty()){
                    componentPermissionService.saveBatch(componentPermissionList);
                }
                if(!partsPermissionList.isEmpty()){
                    partsPermissionService.saveBatch(partsPermissionList);
                }
                if(!permissionStreamList.isEmpty()){
                    permissionStreamService.saveBatch(permissionStreamList);
                }
            }
            return true;
        }else if(nodeType == 2) {
            //处理部件
            ComponentInfo componentInfo = componentInfoService.getById(paramId);
            if(componentInfo == null)
                ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
            if(!b1){
                //没有当前部件的权限
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            b1 = componentInfoService.assignAddUser(componentInfo, userList);
            if(!b1){
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if(relativeFlag == 1) {
                //最终保存权限数据初始化
                List<ComponentPermission> componentPermissionList = new ArrayList<>();
                List<PartsPermission> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();

                List<String> componentIds = new ArrayList<>();
                PermissionStream s;
                String key;
                //处理子部件
                List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
                if(childrenList != null && !childrenList.isEmpty()) {
                    Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
                    Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

                    //初始化全体数据
                    ComponentPermission cp;
                    ComponentInfo cpInfo;
                    for(ComponentInfo c : childrenList){
                        componentIds.add(c.getComponentId());
                        componentInfoMap.put(c.getComponentId(), c);
                        for(SysUser u : userList){
                            key = c.getComponentId() + "," + u.getId();
                            cp = new ComponentPermission(c.getComponentId(), u.getId());
                            componentPermissionMap.put(key, cp);
                        }
                    }
                    //查询已存在的权限数据
                    List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
                    if(existList != null && !existList.isEmpty()){
                        //踢出权限数据
                        for(ComponentPermission permission : existList){
                            key = permission.getComponentId() + "," + permission.getUserId();
                            if(componentPermissionMap.containsKey(key)){
                                componentPermissionMap.remove(key);
                            }
                        }
                    }
                    for(Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()){
                        cp = entry.getValue();
                        componentPermissionList.add(cp);
                        cpInfo = componentInfoMap.get(cp.getComponentId());
                        s = new PermissionStream();
                        s.setProductId(cpInfo.getProductId());
                        s.setComponentId(cpInfo.getComponentId());
                        s.setUserId(cp.getUserId());
                        permissionStreamList.add(s);
                    }
                }
                //处理零件
                componentIds.add(componentInfo.getComponentId());
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIds);
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
                    Map<String, PartsInfo> partsInfoMap = new HashMap<>();
                    List<String> partsIds = new ArrayList<>();
                    PartsPermission pp;
                    PartsInfo ptInfo;
                    for(PartsInfo p : partsInfoList){
                        partsIds.add(p.getPartsId());
                        partsInfoMap.put(p.getPartsId(), p);
                        for(SysUser u : userList){
                            key = p.getPartsId() + "," + u.getId();
                            pp = new PartsPermission(p.getPartsId(), u.getId());
                            partsPermissionHashMap.put(key, pp);
                        }
                    }

                    //查询已存在的权限数据
                    List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
                    if(existPartsList != null && !existPartsList.isEmpty()){
                        //踢出权限数据
                        for(PartsPermission permission : existPartsList){
                            key = permission.getPartsId() + "," + permission.getUserId();
                            if(partsPermissionHashMap.containsKey(key)){
                                partsPermissionHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()){
                        pp = entry.getValue();
                        partsPermissionList.add(pp);
                        ptInfo = partsInfoMap.get(pp.getPartsId());
                        s = new PermissionStream();
                        s.setProductId(ptInfo.getProductId());
                        s.setComponentId(ptInfo.getComponentId());
                        s.setPartsId(ptInfo.getPartsId());
                        s.setUserId(pp.getUserId());
                        permissionStreamList.add(s);
                    }
                }
                if(!componentPermissionList.isEmpty()){
                    componentPermissionService.saveBatch(componentPermissionList);
                }
                if(!partsPermissionList.isEmpty()){
                    partsPermissionService.saveBatch(partsPermissionList);
                }
                if(!permissionStreamList.isEmpty()){
                    permissionStreamService.saveBatch(permissionStreamList);
                }
            }
            return true;
        validateSysUserList(userList, ids);
        switch (nodeType) {
            case 6:
                return handleWorkStep(paramId, null,userList);
            case 5:
                return handleProcessStream(paramId, relativeFlag, null,userList);
            case 3:
                return handlePartsInfo(paramId, relativeFlag, null,userList);
            case 1:
                return handleProductInfo(paramId, relativeFlag, null,userList);
            case 2:
                return handleComponentInfo(paramId, relativeFlag, null,userList);
            default:
                return false;
        }
        return false;
    }

    /**
     * å¾…优化 TODO
     * @param nodeType 1 äº§å“ 2 éƒ¨ä»¶ 3 é›¶ä»¶
     * @param paramId  äº§å“æ ‘节点id
     * @param relativeFlag 1 æ˜¯ 2 å¦
     * @param userIds ç§»é™¤ç”¨æˆ·ids
     * @return
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
                !ValidateUtil.validateInteger(relativeFlag))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(userIds == null || userIds.length < 1)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
        List<String> ids = new ArrayList<>(userIds.length);
        Collections.addAll(ids, userIds);
        Collection<SysUser> userList = userService.listByIds(ids);
        if(userList == null || userList.isEmpty() || userList.size() != userIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(nodeType == 3) {
            //处理零件
            PartsInfo partsInfo = partsInfoService.getById(paramId);
            if(partsInfo == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(3, partsInfo.getPartsId());
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return partsInfoService.assignRemoveUser(partsInfo, userList);
        }else if(nodeType == 1) {
            //处理产品
            ProductInfo productInfo = super.getById(paramId);
            if(productInfo == null)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            boolean b1 = checkProductPerm(1, productInfo.getProductId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = this.assignRemoveUser(productInfo, userList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                //处理产品 ä¸‹çš„部件
                List<String> componentIds = new ArrayList<>();
                //总计需要删除的数据信息
                List<ComponentPermission> componentPermissionList = new ArrayList<>();
                List<PartsPermission> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
                if(componentInfoList != null && !componentInfoList.isEmpty()) {
                    for(ComponentInfo componentInfo : componentInfoList){
                        componentIds.add(componentInfo.getComponentId());
                    }
                    componentPermissionList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndUserIds(componentIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                //处理产品 ä¸‹çš„零件
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
                List<String> partsIds = new ArrayList<>();
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    for(PartsInfo partsInfo : partsInfoList){
                        partsIds.add(partsInfo.getPartsId());
                    }
                    partsPermissionList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndUserIds(partsIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                if(componentPermissionList != null && !componentPermissionList.isEmpty()){
                    componentPermissionService.removeByCollection(componentPermissionList);
                }
                if(partsPermissionList != null && !partsPermissionList.isEmpty()){
                    partsPermissionService.removeByCollection(partsPermissionList);
                }
                if(permissionStreamList != null && !permissionStreamList.isEmpty()){
                    permissionStreamService.removeByCollection(permissionStreamList);
                }
            }
            return true;
        }else if(nodeType == 2) {
            ComponentInfo componentInfo = componentInfoService.getById(paramId);
            if(componentInfo == null)
                ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = componentInfoService.assignRemoveUser(componentInfo, userList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                List<String> componentIdList = new ArrayList<>();
                //最终需要删除的数据
                List<ComponentPermission> componentPermissionList = new ArrayList<>();
                List<PartsPermission> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
                if(childrenList != null && !childrenList.isEmpty()) {
                    for(ComponentInfo component : childrenList){
                        componentIdList.add(component.getComponentId());
                    }
                    componentPermissionList = componentPermissionService.getByComponentIdsAndUserIds(componentIdList, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndUserIds(componentIdList, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                componentIdList.add(componentInfo.getComponentId());
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
                List<String> partsIds = new ArrayList<>();
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    for(PartsInfo partsInfo : partsInfoList){
                        partsIds.add(partsInfo.getPartsId());
                    }
                    partsPermissionList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndUserIds(partsIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }
                if(componentPermissionList != null && !componentPermissionList.isEmpty()){
                    componentPermissionService.removeByCollection(componentPermissionList);
                }
                if(partsPermissionList != null && !partsPermissionList.isEmpty()){
                    partsPermissionService.removeByCollection(partsPermissionList);
                }
                if(permissionStreamList != null && !permissionStreamList.isEmpty()){
                    permissionStreamService.removeByCollection(permissionStreamList);
                }
            }
            return true;
        }
        return false;
    }

    /**
     * å¾…优化 TODO
     * @param nodeType 1 äº§å“ 2 éƒ¨ä»¶ 3 é›¶ä»¶ 5 å·¥åº 6 å·¥æ­¥
     * @param paramId äº§å“æ ‘节点id
     * @param relativeFlag 1 æ˜¯ 2 å¦
     * @param nodeType      1 äº§å“ 2 éƒ¨ä»¶ 3 é›¶ä»¶ 5 å·¥åº 6 å·¥æ­¥
     * @param paramId       äº§å“æ ‘节点id
     * @param relativeFlag  1 æ˜¯ 2 å¦
     * @param departmentIds æ·»åŠ éƒ¨é—¨ids
     * @return
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddDepartment(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
                !ValidateUtil.validateInteger(relativeFlag))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(departmentIds == null || departmentIds.length < 1)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
    public boolean assignAddDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
        validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds);
        List<String> ids = new ArrayList<>(departmentIds.length);
        Collections.addAll(ids, departmentIds);
        Collection<MdcProduction> mdcProductionList=mdcProductionService.listByIds(ids);
        if(mdcProductionList == null || mdcProductionList.isEmpty() || mdcProductionList.size() != departmentIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(nodeType == 6) {
            //处理工步
            WorkStep workStep=workStepService.getById(paramId);
            if (workStep == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(6, workStep.getId());
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return workStepService.assignAddDepart(workStep, mdcProductionList);
        }else if(nodeType == 5) {
            //处理工序
            ProcessStream processStream = processStreamService.getById(paramId);
            if (processStream == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(5, processStream.getProcessId());
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return processStreamService.assignAddDepart(processStream, mdcProductionList);
        }else if(nodeType == 3) {
            //处理零件
            PartsInfo partsInfo = partsInfoService.getById(paramId);
            if(partsInfo == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(3, partsInfo.getPartsId());
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
        }else if(nodeType == 1) {
            //处理产品
            ProductInfo productInfo = super.getById(paramId);
            if(productInfo == null)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            boolean b1 = checkProductPerm(1, productInfo.getProductId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = this.assignAddDepartment(productInfo, mdcProductionList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                //处理产品 ä¸‹çš„部件
                List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
                //最终保存权限数据初始化
                List<ComponentDepartment> componentPermissionList = new ArrayList<>();
                List<PartsDepartment> partsPermissionList = new ArrayList<>();
                List<ProcessionDepartment> processionPermissionList = new ArrayList<>();
                List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                //处理子部件
                List<String> componentIds = new ArrayList<>();
                List<String> partsIds= new ArrayList<>();
                List<String> ProcessionIds= new ArrayList<>();
                List<String> workStepIds= new ArrayList<>();
                PermissionStream s;

                Map<String, ComponentDepartment> componentPermissionMap = new HashMap<>();
                Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

                //初始化全体数据
                String key;
                ComponentDepartment cp;
                ComponentInfo cpInfo;
                for(ComponentInfo c : componentInfoList){
                    componentIds.add(c.getComponentId());
                    componentInfoMap.put(c.getComponentId(), c);
                    for(MdcProduction mdcProduction : mdcProductionList){
                        key = c.getComponentId() + "," + mdcProduction.getId();
                        cp = new ComponentDepartment(c.getComponentId(), mdcProduction.getId());
                        componentPermissionMap.put(key, cp);
                    }
                }
                //查询已存在的权限数据
                List<ComponentDepartment> existList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, ids);
                if(existList != null && !existList.isEmpty()){
                    //踢出权限数据
                    for(ComponentDepartment permission : existList){
                        key = permission.getComponentId() + "," + permission.getDepartId();
                        if(componentPermissionMap.containsKey(key)){
                            componentPermissionMap.remove(key);
                        }
                    }
                }
                for(Map.Entry<String, ComponentDepartment> entry : componentPermissionMap.entrySet()){
                    cp = entry.getValue();
                    componentPermissionList.add(cp);
                    cpInfo = componentInfoMap.get(cp.getComponentId());
                    s = new PermissionStream();
                    s.setProductId(cpInfo.getProductId());
                    s.setComponentId(cpInfo.getComponentId());
                    s.setDepartId(cp.getDepartId());
                    permissionStreamList.add(s);
                }

                //处理子零件
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    Map<String, PartsDepartment> partsPermissionHashMap = new HashMap<>();
                    Map<String, PartsInfo> partsInfoMap = new HashMap<>();
                    partsIds = new ArrayList<>();
                    PartsDepartment pp;
                    PartsInfo ptInfo;
                    for(PartsInfo p : partsInfoList){
                        partsIds.add(p.getPartsId());
                        partsInfoMap.put(p.getPartsId(), p);
                        for(MdcProduction mdcProduction : mdcProductionList){
                            key = p.getPartsId() + "," + mdcProduction.getId();
                            pp = new PartsDepartment(p.getPartsId(), mdcProduction.getId());
                            partsPermissionHashMap.put(key, pp);
                        }
                    }

                    //查询已存在的权限数据
                    List<PartsDepartment> existPartsList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
                    if(existPartsList != null && !existPartsList.isEmpty()){
                        //踢出权限数据
                        for(PartsDepartment permission : existPartsList){
                            key = permission.getPartsId() + "," + permission.getDepartId();
                            if(partsPermissionHashMap.containsKey(key)){
                                partsPermissionHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, PartsDepartment> entry : partsPermissionHashMap.entrySet()){
                        pp = entry.getValue();
                        partsPermissionList.add(pp);
                        ptInfo = partsInfoMap.get(pp.getPartsId());
                        s = new PermissionStream();
                        s.setProductId(ptInfo.getProductId());
                        s.setComponentId(ptInfo.getComponentId());
                        s.setPartsId(ptInfo.getPartsId());
                        s.setDepartId(pp.getDepartId());
                        permissionStreamList.add(s);
                    }
                }

                //查询工序已存在的权限数据
                List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(productInfo.getProductId(),componentIds,partsIds);
                if(processStreamList != null && !processStreamList.isEmpty()) {
                    Map<String, ProcessionDepartment> processionDepartmentHashMap = new HashMap<>();
                    Map<String, ProcessStream> processStreamMap = new HashMap<>();
                    ProcessionIds = new ArrayList<>();
                    ProcessionDepartment pp;
                    ProcessStream processStream;
                    for(ProcessStream p : processStreamList){
                        ProcessionIds.add(p.getProcessId());
                        processStreamMap.put(p.getProcessId(), p);
                        for(MdcProduction mdcProduction : mdcProductionList){
                            key = p.getPartsId() + "," + mdcProduction.getId();
                            pp = new ProcessionDepartment(p.getProcessId(), mdcProduction.getId());
                            processionDepartmentHashMap.put(key, pp);
                        }
                    }

                    //查询已存在的权限数据
                    List<ProcessionDepartment> processionDepartmentList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
                    if(processionDepartmentList != null && !processionDepartmentList.isEmpty()){
                        //踢出权限数据
                        for(ProcessionDepartment processionDepartment : processionDepartmentList){
                            key = processionDepartment.getProcessId() + "," + processionDepartment.getDepartId();
                            if(processionDepartmentHashMap.containsKey(key)){
                                processionDepartmentHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, ProcessionDepartment> entry : processionDepartmentHashMap.entrySet()){
                        pp = entry.getValue();
                        processionPermissionList.add(pp);
                        processStream = processStreamMap.get(pp.getProcessId());
                        s = new PermissionStream();
                        s.setProductId(processStream.getProductId());
                        s.setComponentId(processStream.getComponentId());
                        s.setPartsId(processStream.getPartsId());
                        s.setProcessId(processStream.getProcessId());
                        s.setDepartId(pp.getDepartId());
                        permissionStreamList.add(s);
                    }
                }
                //查询工步已存在的权限数据
                List<WorkStep> workStepList = workStepService.getByProcessIds(productInfo.getProductId(),ProcessionIds);
                if(workStepList != null && !workStepList.isEmpty()) {
                    Map<String, WorkStepDepartment> workStepDepartmentHashMap = new HashMap<>();
                    Map<String, WorkStep> workStepHashMap = new HashMap<>();
                    workStepIds = new ArrayList<>();
                    WorkStepDepartment ws;
                    WorkStep workStep;
                    for(WorkStep w : workStepList){
                        workStepIds.add(w.getId());
                        workStepHashMap.put(w.getId(), w);
                        for(MdcProduction mdcProduction : mdcProductionList){
                            key = w.getId() + "," + mdcProduction.getId();
                            ws = new WorkStepDepartment(w.getId(), mdcProduction.getId());
                            workStepDepartmentHashMap.put(key, ws);
                        }
                    }

                    //查询已存在的权限数据
                    List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
                    if(workStepDepartments != null && !workStepDepartments.isEmpty()){
                        //踢出权限数据
                        for(WorkStepDepartment workStepDepartment : workStepDepartments){
                            key = workStepDepartment.getStepId() + "," + workStepDepartment.getDepartId();
                            if(workStepDepartmentHashMap.containsKey(key)){
                                workStepDepartmentHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, WorkStepDepartment> entry : workStepDepartmentHashMap.entrySet()){
                        ws = entry.getValue();
                        workStepDepartmentList.add(ws);
                        workStep = workStepHashMap.get(ws.getStepId());
                        s = new PermissionStream();
                        s.setProductId(workStep.getProductId());
                        s.setComponentId(workStep.getComponentId());
                        s.setPartsId(workStep.getPartsId());
                        s.setProcessId(workStep.getProcessId());
                        s.setStepId(workStep.getId());
                        s.setDepartId(ws.getDepartId());
                        permissionStreamList.add(s);
                    }
                }

                if(!componentPermissionList.isEmpty()){
                    componentDepartmentService.saveBatch(componentPermissionList);
                }
                if(!partsPermissionList.isEmpty()){
                    partsDepartmentService.saveBatch(partsPermissionList);
                }
                if(!processionPermissionList.isEmpty()){
                    processionDepartmentService.saveBatch(processionPermissionList);
                }
                if (!workStepDepartmentList.isEmpty()) {
                    workStepDepartmentService.saveBatch(workStepDepartmentList);
                }
                if(!permissionStreamList.isEmpty()){
                    permissionStreamService.saveBatch(permissionStreamList);
                }
            }
            return true;
        }else if(nodeType == 2) {
            ComponentInfo componentInfo = componentInfoService.getById(paramId);
            if(componentInfo == null)
                ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = componentInfoService.assignAddDepart(componentInfo, mdcProductionList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                List<String> componentIdList = new ArrayList<>();
                List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());

                //最终保存权限数据初始化
                List<ComponentDepartment> componentPermissionList = new ArrayList<>();
                List<PartsDepartment> partsPermissionList = new ArrayList<>();
                List<ProcessionDepartment> processionPermissionList = new ArrayList<>();
                List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                //处理子部件
                PermissionStream s;
                List<String> componentIds = new ArrayList<>();
                List<String> partsIds= new ArrayList<>();
                List<String> ProcessionIds= new ArrayList<>();
                List<String> workStepIds= new ArrayList<>();
                Map<String, ComponentDepartment> componentPermissionMap = new HashMap<>();
                Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

                //初始化全体数据
                String key;
                ComponentDepartment cp;
                ComponentInfo cpInfo;
                if(childrenList != null && !childrenList.isEmpty()) {
                    for (ComponentInfo c : childrenList) {
                        componentIdList.add(c.getComponentId());
                        componentInfoMap.put(c.getComponentId(), c);
                        for (MdcProduction mdcProduction : mdcProductionList) {
                            key = c.getComponentId() + "," + mdcProduction.getId();
                            cp = new ComponentDepartment(c.getComponentId(), mdcProduction.getId());
                            componentPermissionMap.put(key, cp);
                        }
                    }
                    //查询已存在的权限数据
                    List<ComponentDepartment> existList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIdList, ids);
                    if (existList != null && !existList.isEmpty()) {
                        //踢出权限数据
                        for (ComponentDepartment permission : existList) {
                            key = permission.getComponentId() + "," + permission.getDepartId();
                            if (componentPermissionMap.containsKey(key)) {
                                componentPermissionMap.remove(key);
                            }
                        }
                    }
                    for (Map.Entry<String, ComponentDepartment> entry : componentPermissionMap.entrySet()) {
                        cp = entry.getValue();
                        componentPermissionList.add(cp);
                        cpInfo = componentInfoMap.get(cp.getComponentId());
                        s = new PermissionStream();
                        s.setProductId(cpInfo.getProductId());
                        s.setComponentId(cpInfo.getComponentId());
                        s.setDepartId(cp.getDepartId());
                        permissionStreamList.add(s);
                    }
                }

                //处理子零件
                componentIdList.add(componentInfo.getComponentId());
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    Map<String, PartsDepartment> partsPermissionHashMap = new HashMap<>();
                    Map<String, PartsInfo> partsInfoMap = new HashMap<>();
                    partsIds = new ArrayList<>();
                    PartsDepartment pp;
                    PartsInfo ptInfo;
                    for(PartsInfo p : partsInfoList){
                        partsIds.add(p.getPartsId());
                        partsInfoMap.put(p.getPartsId(), p);
                        for(MdcProduction mdcProduction : mdcProductionList){
                            key = p.getPartsId() + "," + mdcProduction.getId();
                            pp = new PartsDepartment(p.getPartsId(), mdcProduction.getId());
                            partsPermissionHashMap.put(key, pp);
                        }
                    }

                    //查询已存在的权限数据
                    List<PartsDepartment> existPartsList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
                    if(existPartsList != null && !existPartsList.isEmpty()){
                        //踢出权限数据
                        for(PartsDepartment permission : existPartsList){
                            key = permission.getPartsId() + "," + permission.getDepartId();
                            if(partsPermissionHashMap.containsKey(key)){
                                partsPermissionHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, PartsDepartment> entry : partsPermissionHashMap.entrySet()){
                        pp = entry.getValue();
                        partsPermissionList.add(pp);
                        ptInfo = partsInfoMap.get(pp.getPartsId());
                        s = new PermissionStream();
                        s.setProductId(ptInfo.getProductId());
                        s.setComponentId(ptInfo.getComponentId());
                        s.setPartsId(ptInfo.getPartsId());
                        s.setDepartId(pp.getDepartId());
                        permissionStreamList.add(s);
                    }
                }

                //查询工序已存在的权限数据
                List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(componentInfo.getProductId(),componentIds,partsIds);
                if(processStreamList != null && !processStreamList.isEmpty()) {
                    Map<String, ProcessionDepartment> processionDepartmentHashMap = new HashMap<>();
                    Map<String, ProcessStream> processStreamMap = new HashMap<>();
                    ProcessionIds = new ArrayList<>();
                    ProcessionDepartment pp;
                    ProcessStream processStream;
                    for(ProcessStream p : processStreamList){
                        ProcessionIds.add(p.getProcessId());
                        processStreamMap.put(p.getProcessId(), p);
                        for(MdcProduction mdcProduction : mdcProductionList){
                            key = p.getPartsId() + "," + mdcProduction.getId();
                            pp = new ProcessionDepartment(p.getProcessId(), mdcProduction.getId());
                            processionDepartmentHashMap.put(key, pp);
                        }
                    }

                    //查询已存在的权限数据
                    List<ProcessionDepartment> processionDepartmentList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
                    if(processionDepartmentList != null && !processionDepartmentList.isEmpty()){
                        //踢出权限数据
                        for(ProcessionDepartment processionDepartment : processionDepartmentList){
                            key = processionDepartment.getProcessId() + "," + processionDepartment.getDepartId();
                            if(processionDepartmentHashMap.containsKey(key)){
                                processionDepartmentHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, ProcessionDepartment> entry : processionDepartmentHashMap.entrySet()){
                        pp = entry.getValue();
                        processionPermissionList.add(pp);
                        processStream = processStreamMap.get(pp.getProcessId());
                        s = new PermissionStream();
                        s.setProductId(processStream.getProductId());
                        s.setComponentId(processStream.getComponentId());
                        s.setPartsId(processStream.getPartsId());
                        s.setProcessId(processStream.getProcessId());
                        s.setDepartId(pp.getDepartId());
                        permissionStreamList.add(s);
                    }
                }
                //查询工步已存在的权限数据
                List<WorkStep> workStepList = workStepService.getByProcessIds(componentInfo.getProductId(),ProcessionIds);
                if(workStepList != null && !workStepList.isEmpty()) {
                    Map<String, WorkStepDepartment> workStepDepartmentHashMap = new HashMap<>();
                    Map<String, WorkStep> workStepHashMap = new HashMap<>();
                    workStepIds = new ArrayList<>();
                    WorkStepDepartment ws;
                    WorkStep workStep;
                    for(WorkStep w : workStepList){
                        workStepIds.add(w.getId());
                        workStepHashMap.put(w.getId(), w);
                        for(MdcProduction mdcProduction : mdcProductionList){
                            key = w.getId() + "," + mdcProduction.getId();
                            ws = new WorkStepDepartment(w.getId(), mdcProduction.getId());
                            workStepDepartmentHashMap.put(key, ws);
                        }
                    }

                    //查询已存在的权限数据
                    List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
                    if(workStepDepartments != null && !workStepDepartments.isEmpty()){
                        //踢出权限数据
                        for(WorkStepDepartment workStepDepartment : workStepDepartments){
                            key = workStepDepartment.getStepId() + "," + workStepDepartment.getDepartId();
                            if(workStepDepartmentHashMap.containsKey(key)){
                                workStepDepartmentHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, WorkStepDepartment> entry : workStepDepartmentHashMap.entrySet()){
                        ws = entry.getValue();
                        workStepDepartmentList.add(ws);
                        workStep = workStepHashMap.get(ws.getStepId());
                        s = new PermissionStream();
                        s.setProductId(workStep.getProductId());
                        s.setComponentId(workStep.getComponentId());
                        s.setPartsId(workStep.getPartsId());
                        s.setProcessId(workStep.getProcessId());
                        s.setStepId(workStep.getId());
                        s.setDepartId(ws.getDepartId());
                        permissionStreamList.add(s);
                    }
                }

                if(!componentPermissionList.isEmpty()){
                    componentDepartmentService.saveBatch(componentPermissionList);
                }
                if(!partsPermissionList.isEmpty()){
                    partsDepartmentService.saveBatch(partsPermissionList);
                }
                if(!processionPermissionList.isEmpty()){
                    processionDepartmentService.saveBatch(processionPermissionList);
                }
                if (!workStepDepartmentList.isEmpty()) {
                    workStepDepartmentService.saveBatch(workStepDepartmentList);
                }
                if(!permissionStreamList.isEmpty()){
                    permissionStreamService.saveBatch(permissionStreamList);
                }
            }
            return true;
        Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(ids);
        validateMdcProductionList(mdcProductionList, ids);
        switch (nodeType) {
            case 6:
                return handleWorkStep(paramId, mdcProductionList,null);
            case 5:
                return handleProcessStream(paramId, relativeFlag, mdcProductionList,null);
            case 3:
                return handlePartsInfo(paramId, relativeFlag, mdcProductionList,null);
            case 1:
                return handleProductInfo(paramId, relativeFlag, mdcProductionList,null);
            case 2:
                return handleComponentInfo(paramId, relativeFlag, mdcProductionList,null);
            default:
                return false;
        }
        return false;
    }

    /**
     * å¾…优化 TODO
     * @param nodeType 1 äº§å“ 2 éƒ¨ä»¶ 3 é›¶ä»¶ 5 å·¥åº 6 å·¥æ­¥
     * @param paramId äº§å“æ ‘节点id
     * @param nodeType     1 äº§å“ 2 éƒ¨ä»¶ 3 é›¶ä»¶
     * @param paramId      äº§å“æ ‘节点id
     * @param relativeFlag 1 æ˜¯ 2 å¦
     * @param userIds      ç§»é™¤ç”¨æˆ·ids
     * @return
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveUserAll(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
        validateInputParameters(nodeType, paramId, relativeFlag, "1", userIds);
        List<String> userIdsList = Arrays.asList(userIds);
        Collection<SysUser> userList = userService.listByIds(userIdsList);
        validateSysUserList(userList, userIdsList);
        switch (nodeType) {
            case 6:
                return handleWorkStepRemoval(paramId, userList,null);
            case 5:
                return handleProcessStreamRemoval(paramId, relativeFlag, userList,null);
            case 3:
                return handlePartsInfoRemoval(paramId, relativeFlag, userList,null);
            case 1:
                return handleProductInfoRemoval(paramId, relativeFlag, userList,null);
            case 2:
                return handleComponentInfoRemoval(paramId, relativeFlag, userList,null);
            default:
                return false;
        }
    }


    /**
     *
     * @param nodeType      1 äº§å“ 2 éƒ¨ä»¶ 3 é›¶ä»¶ 5 å·¥åº 6 å·¥æ­¥
     * @param paramId       äº§å“æ ‘节点id
     * @param relativeFlag  1 æ˜¯ 2 å¦
     * @param departmentIds ç§»é™¤éƒ¨é—¨ids
     * @return
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveDepartment(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
                !ValidateUtil.validateInteger(relativeFlag))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(departmentIds == null || departmentIds.length < 1)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
        List<String> ids = new ArrayList<>(departmentIds.length);
        Collections.addAll(ids, departmentIds);
        Collection<MdcProduction> mdcProductionList=mdcProductionService.listByIds(ids);
        if(mdcProductionList == null || mdcProductionList.isEmpty() || mdcProductionList.size() != departmentIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(nodeType == 6) {
            //处理工步
            WorkStep workStep=workStepService.getById(paramId);
            if (workStep == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(6, workStep.getId());
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return workStepService.assignRemoveDepart(workStep, mdcProductionList);
        }else if(nodeType == 5) {
            //处理工序
            ProcessStream processStream = processStreamService.getById(paramId);
            if (processStream == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(5, processStream.getProcessId());
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return processStreamService.assignRemoveDepart(processStream, mdcProductionList);
        }else if(nodeType == 3) {
            //处理零件
            PartsInfo partsInfo = partsInfoService.getById(paramId);
            if(partsInfo == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(3, partsInfo.getPartsId());
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return partsInfoService.assignRemoveDepart(partsInfo, mdcProductionList);
        }else if(nodeType == 1) {
            //处理产品
            ProductInfo productInfo = super.getById(paramId);
            if(productInfo == null)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            boolean b1 = checkProductPerm(1, productInfo.getProductId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = this.assignRemoveDepartment(productInfo, mdcProductionList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                //处理产品 ä¸‹çš„部件
                List<String> componentIds = new ArrayList<>();
                //总计需要删除的数据信息
                List<ComponentDepartment> componentPermissionList = new ArrayList<>();
                List<PartsDepartment> partsPermissionList = new ArrayList<>();
                List<ProcessionDepartment> processionPermissionList = new ArrayList<>();
                List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
                List<String> partsIds= new ArrayList<>();
                List<String> ProcessionIds= new ArrayList<>();
                List<String> workStepIds= new ArrayList<>();
                if(componentInfoList != null && !componentInfoList.isEmpty()) {
                    for(ComponentInfo componentInfo : componentInfoList){
                        componentIds.add(componentInfo.getComponentId());
                    }
                    componentPermissionList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndDepartIds(componentIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                //处理产品 ä¸‹çš„零件
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
                partsIds = new ArrayList<>();
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    for(PartsInfo partsInfo : partsInfoList){
                        partsIds.add(partsInfo.getPartsId());
                    }
                    partsPermissionList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(partsIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                //处理工序
                List<ProcessStream> processStreamList=processStreamService.getByComponentIdList(productInfo.getProductId(), componentIds,partsIds);
                ProcessionIds = new ArrayList<>();
                if(processStreamList != null && !processStreamList.isEmpty()) {
                    for(ProcessStream processStream : processStreamList){
                        ProcessionIds.add(processStream.getProcessId());
                    }
                    processionPermissionList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                //处理工步
                List<WorkStep> workStepList=workStepService.getByProcessIds(productInfo.getProductId(), ProcessionIds);
                workStepIds = new ArrayList<>();
                if(workStepList != null && !workStepList.isEmpty()) {
                    for(WorkStep workStep : workStepList){
                        workStepIds.add(workStep.getId());
                    }
                    workStepDepartmentList = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                if(componentPermissionList != null && !componentPermissionList.isEmpty()){
                    componentDepartmentService.removeByCollection(componentPermissionList);
                }
                if(partsPermissionList != null && !partsPermissionList.isEmpty()){
                    partsDepartmentService.removeByCollection(partsPermissionList);
                }
                if(processionPermissionList != null && !processionPermissionList.isEmpty()){
                    processionDepartmentService.removeByCollection(processionPermissionList);
                }
                if(workStepDepartmentList != null && !workStepDepartmentList.isEmpty()){
                    workStepDepartmentService.removeByCollection(workStepDepartmentList);
                }
                if(permissionStreamList != null && !permissionStreamList.isEmpty()){
                    permissionStreamService.removeByCollection(permissionStreamList);
                }
            }
            return true;
        }else if(nodeType == 2) {
            ComponentInfo componentInfo = componentInfoService.getById(paramId);
            if(componentInfo == null)
                ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = componentInfoService.assignRemoveDepart(componentInfo, mdcProductionList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                List<String> componentIdList = new ArrayList<>();
                //总计需要删除的数据信息
                List<ComponentDepartment> componentPermissionList = new ArrayList<>();
                List<PartsDepartment> partsPermissionList = new ArrayList<>();
                List<ProcessionDepartment> processionPermissionList = new ArrayList<>();
                List<WorkStepDepartment> workStepDepartmentList=new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                List<String> partsIds= new ArrayList<>();
                List<String> ProcessionIds= new ArrayList<>();
                List<String> workStepIds= new ArrayList<>();
                List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
                if(childrenList != null && !childrenList.isEmpty()) {
                    for(ComponentInfo cpn : childrenList){
                        componentIdList.add(cpn.getComponentId());
                    }
                    componentPermissionList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIdList, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndDepartIds(componentIdList, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                //处理产品 ä¸‹çš„零件
                componentIdList.add(componentInfo.getComponentId());
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
                partsIds = new ArrayList<>();
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    for(PartsInfo partsInfo : partsInfoList){
                        partsIds.add(partsInfo.getPartsId());
                    }
                    partsPermissionList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(partsIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                //处理工序
                List<ProcessStream> processStreamList=processStreamService.getByComponentIdList(componentInfo.getProductId(), componentIdList,partsIds);
                ProcessionIds = new ArrayList<>();
                if(processStreamList != null && !processStreamList.isEmpty()) {
                    for(ProcessStream processStream : processStreamList){
                        ProcessionIds.add(processStream.getProcessId());
                    }
                    processionPermissionList = processionDepartmentService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(ProcessionIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                //处理工步
                List<WorkStep> workStepList=workStepService.getByProcessIds(componentInfo.getProductId(), ProcessionIds);
                workStepIds = new ArrayList<>();
                if(workStepList != null && !workStepList.isEmpty()) {
                    for(WorkStep workStep : workStepList){
                        workStepIds.add(workStep.getId());
                    }
                    workStepDepartmentList = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                if(componentPermissionList != null && !componentPermissionList.isEmpty()){
                    componentDepartmentService.removeByCollection(componentPermissionList);
                }
                if(partsPermissionList != null && !partsPermissionList.isEmpty()){
                    partsDepartmentService.removeByCollection(partsPermissionList);
                }
                if(processionPermissionList != null && !processionPermissionList.isEmpty()){
                    processionDepartmentService.removeByCollection(processionPermissionList);
                }
                if(workStepDepartmentList != null && !workStepDepartmentList.isEmpty()){
                    workStepDepartmentService.removeByCollection(workStepDepartmentList);
                }
                if(permissionStreamList != null && !permissionStreamList.isEmpty()){
                    permissionStreamService.removeByCollection(permissionStreamList);
                }
            }
            return true;
    public boolean assignRemoveDepartmentAll(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
        validateInputParameters(nodeType, paramId, relativeFlag, "2", departmentIds);
        List<String> departmentIdList = Arrays.asList(departmentIds);
        Collection<MdcProduction> mdcProductionList = mdcProductionService.listByIds(departmentIdList);
        validateMdcProductionList(mdcProductionList, departmentIdList);
        switch (nodeType) {
            case 6:
                return handleWorkStepRemoval(paramId,null,mdcProductionList);
            case 5:
                return handleProcessStreamRemoval(paramId, relativeFlag, null,mdcProductionList);
            case 3:
                return handlePartsInfoRemoval(paramId, relativeFlag,null, mdcProductionList);
            case 1:
                return handleProductInfoRemoval(paramId, relativeFlag,null, mdcProductionList);
            case 2:
                return handleComponentInfoRemoval(paramId, relativeFlag, null,mdcProductionList);
            default:
                return false;
        }
        return false;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddUser(ProductInfo productInfo, Collection<SysUser> userList) {
        if(productInfo == null || userList == null || userList.isEmpty())
        if (productInfo == null || userList == null || userList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<ProductPermission> permissionList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        userList.forEach(item -> {
            ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
            if(en == null) {
            if (en == null) {
                en = new ProductPermission();
                en.setUserId(item.getId());
                en.setProductId(productInfo.getProductId());
                permissionList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
            if(stream == null) {
            if (stream == null) {
                stream = new PermissionStream();
                stream.setUserId(item.getId());
                stream.setProductId(productInfo.getProductId());
                permissionStreamList.add(stream);
            }
        });
        if(!permissionList.isEmpty()) {
        if (!permissionList.isEmpty()) {
            boolean b = productPermissionService.saveBatch(permissionList);
            if(!b) {
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
        if (!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.saveBatch(permissionStreamList);
            if(!b) {
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
@@ -1556,33 +521,33 @@
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveUser(ProductInfo productInfo, Collection<SysUser> userList) {
        if(productInfo == null || userList == null || userList.isEmpty())
        if (productInfo == null || userList == null || userList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<ProductPermission> permissionList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        userList.forEach(item -> {
            ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
            if(en != null) {
            if (en != null) {
                permissionList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
            if(stream != null) {
            if (stream != null) {
                permissionStreamList.add(stream);
            }
        });
        //移除用户权限清空校验
        List<ProductPermission> existList = productPermissionService.getByProductId(productInfo.getProductId());
        if(existList.size() <= permissionList.size())
        if (existList.size() <= permissionList.size())
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_NONE);
        if(!permissionList.isEmpty()) {
        if (!permissionList.isEmpty()) {
            boolean b = productPermissionService.removeByCollection(permissionList);
            if(!b) {
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
        if (!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.removeByCollection(permissionStreamList);
            if(!b) {
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
@@ -1592,35 +557,35 @@
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddDepartment(ProductInfo productInfo, Collection<MdcProduction> departmentList) {
        if(productInfo == null || departmentList == null || departmentList.isEmpty())
        if (productInfo == null || departmentList == null || departmentList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<ProductDepartment> productDepartmentList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        departmentList.forEach(item -> {
            ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
            if(en == null) {
            if (en == null) {
                en = new ProductDepartment();
                en.setDepartId(item.getId());
                en.setProductId(productInfo.getProductId());
                productDepartmentList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
            if(stream == null) {
            if (stream == null) {
                stream = new PermissionStream();
                stream.setDepartId(item.getId());
                stream.setProductId(productInfo.getProductId());
                permissionStreamList.add(stream);
            }
        });
        if(!productDepartmentList.isEmpty()) {
        if (!productDepartmentList.isEmpty()) {
            boolean b = productDepartmentService.saveBatch(productDepartmentList);
            if(!b) {
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
        if (!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.saveBatch(permissionStreamList);
            if(!b) {
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
@@ -1630,29 +595,29 @@
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveDepartment(ProductInfo productInfo, Collection<MdcProduction> departmentList) {
        if(productInfo == null || departmentList == null || departmentList.isEmpty())
        if (productInfo == null || departmentList == null || departmentList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<ProductDepartment> productDepartmentList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        departmentList.forEach(item -> {
            ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
            if(en != null) {
            if (en != null) {
                productDepartmentList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getId());
            if(stream != null) {
            if (stream != null) {
                permissionStreamList.add(stream);
            }
        });
        if(!productDepartmentList.isEmpty()) {
        if (!productDepartmentList.isEmpty()) {
            boolean b = productDepartmentService.removeByCollection(productDepartmentList);
            if(!b) {
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
        if (!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.removeByCollection(permissionStreamList);
            if(!b) {
            if (!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
@@ -1663,37 +628,37 @@
    public List<String> getDepartIdsByParams(Integer nodeType, String paramId) {
        List<String> departIds = new ArrayList<>();
        //5-工序
        if(nodeType == 5) {
            ProcessStream processStream= processStreamService.getById(paramId);
            if(processStream == null)
        if (nodeType == 5) {
            ProcessStream processStream = processStreamService.getById(paramId);
            if (processStream == null)
                return null;
            List<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>()
                    .eq(StrUtil.isNotEmpty(processStream.getProductId()),"product_id", processStream.getProductId())
                    .eq(StrUtil.isNotEmpty(processStream.getComponentId()),"component_id",processStream.getComponentId())
                    .eq(StrUtil.isNotEmpty(processStream.getPartsId()),"parts_id", processStream.getPartsId())
                    .eq(StrUtil.isNotEmpty(processStream.getProcessId()),"process_id",processStream.getProcessId()));
            if(permissionStreamList == null || permissionStreamList.isEmpty())
                    .eq(StrUtil.isNotEmpty(processStream.getProductId()), "product_id", processStream.getProductId())
                    .eq(StrUtil.isNotEmpty(processStream.getComponentId()), "component_id", processStream.getComponentId())
                    .eq(StrUtil.isNotEmpty(processStream.getPartsId()), "parts_id", processStream.getPartsId())
                    .eq(StrUtil.isNotEmpty(processStream.getProcessId()), "process_id", processStream.getProcessId()));
            if (permissionStreamList == null || permissionStreamList.isEmpty())
                return null;
            permissionStreamList.forEach(item -> {
                departIds.add(item.getDepartId());
            });
            //6-工步
        }else if(nodeType == 6) {
        } else if (nodeType == 6) {
            WorkStep workStep = workStepService.getById(paramId);
            if(workStep == null)
            if (workStep == null)
                return null;
            List<PermissionStream> permissionStreamList = permissionStreamService.list(new QueryWrapper<PermissionStream>()
                    .eq(StrUtil.isNotEmpty(workStep.getProductId()),"product_id", workStep.getProductId())
                    .eq(StrUtil.isNotEmpty(workStep.getComponentId()),"component_id",workStep.getComponentId())
                    .eq(StrUtil.isNotEmpty(workStep.getPartsId()),"parts_id", workStep.getPartsId())
                    .eq(StrUtil.isNotEmpty(workStep.getProcessId()),"process_id",workStep.getProcessId())
                    .eq(StrUtil.isNotEmpty(workStep.getId()),"step_id", workStep.getId()));
            if(permissionStreamList == null || permissionStreamList.isEmpty())
                    .eq(StrUtil.isNotEmpty(workStep.getProductId()), "product_id", workStep.getProductId())
                    .eq(StrUtil.isNotEmpty(workStep.getComponentId()), "component_id", workStep.getComponentId())
                    .eq(StrUtil.isNotEmpty(workStep.getPartsId()), "parts_id", workStep.getPartsId())
                    .eq(StrUtil.isNotEmpty(workStep.getProcessId()), "process_id", workStep.getProcessId())
                    .eq(StrUtil.isNotEmpty(workStep.getId()), "step_id", workStep.getId()));
            if (permissionStreamList == null || permissionStreamList.isEmpty())
                return null;
            permissionStreamList.forEach(item -> {
                departIds.add(item.getDepartId());
            });
        }else {
        } else {
            return null;
        }
        //去重
@@ -1705,9 +670,9 @@

    @Override
    public ProductInfo getByProductNo(String productNo) {
        if(ValidateUtil.validateString(productNo)) {
        if (ValidateUtil.validateString(productNo)) {
            List<ProductInfo> list = super.lambdaQuery().eq(ProductInfo::getProductNo, productNo).list();
            if(list == null || list.isEmpty())
            if (list == null || list.isEmpty())
                return null;
            return list.get(0);
        }
@@ -1717,7 +682,7 @@
    @Override
    public List<CommonGenericTree> loadBaseTree(String userId) {
        List<ProductInfo> productInfoList = getByUserPerms(userId);
        if(productInfoList == null || productInfoList.isEmpty())
        if (productInfoList == null || productInfoList.isEmpty())
            return Collections.emptyList();
//        List<ComponentExt> componentInfoList = componentInfoService.getByUserPermsAs(userId);
//        if(componentInfoList == null)
@@ -1727,13 +692,13 @@

    @Override
    public List<CommonGenericTree> loadTree(String userId, Integer nodeType, String paramId) {
        if(nodeType == 1) {
        if (nodeType == 1) {
            List<ComponentInfo> componentInfoList = componentInfoService.getByProductIdAndUserId(paramId, userId);
            if(componentInfoList == null || componentInfoList.isEmpty())
            if (componentInfoList == null || componentInfoList.isEmpty())
                return Collections.emptyList();
            List<CommonGenericTree> list = new ArrayList<>();
            CommonGenericTree<ComponentInfo> node;
            for(ComponentInfo c : componentInfoList) {
            for (ComponentInfo c : componentInfoList) {
                node = new CommonGenericTree();
                node.setId(c.getComponentId());
//                node.setLabel("[" + c.getComponentCode()+ "]" +  c.getComponentName());
@@ -1746,12 +711,12 @@
                list.add(node);
            }
            return list;
        }else if(nodeType == 2) {
        } else if (nodeType == 2) {
            List<ComponentInfo> componentInfoList = componentInfoService.getByParentIdAndUserId(paramId, userId);
            List<CommonGenericTree> list = new ArrayList<>();
            CommonGenericTree<ComponentInfo> componentNode;
            if(componentInfoList != null && !componentInfoList.isEmpty()) {
                for(ComponentInfo c : componentInfoList) {
            if (componentInfoList != null && !componentInfoList.isEmpty()) {
                for (ComponentInfo c : componentInfoList) {
                    componentNode = new CommonGenericTree();
                    componentNode.setId(c.getComponentId());
//                    componentNode.setLabel("[" + c.getComponentCode()+ "]" + c.getComponentName());
@@ -1765,10 +730,10 @@
                }
            }
            List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, paramId, null);
            if(partsInfos == null || partsInfos.isEmpty())
            if (partsInfos == null || partsInfos.isEmpty())
                return list;
            CommonGenericTree<PartsInfo> partNode;
            for(PartsInfo part : partsInfos) {
            for (PartsInfo part : partsInfos) {
                partNode = new CommonGenericTree();
                partNode.setId(part.getPartsId());
//                partNode.setLabel("[" + part.getPartsCode()+ "]" + part.getPartsName());
@@ -1782,7 +747,7 @@
                list.add(partNode);
            }
            return list;
        }else {
        } else {
            return Collections.emptyList();
        }
    }
@@ -1792,8 +757,8 @@
        List<ProductInfo> productInfos = this.getByUserPerms(userId, queryParam);
        List<ComponentInfo> componentInfos = componentInfoService.getByUserPerms(userId, queryParam);
        List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, null, queryParam);
        List<ProcessStream> processStreams=processStreamService.getByuserPerms(userId, queryParam);
        List<WorkStep> workSteps=workStepService.getByUserPerms(userId, queryParam);
        List<ProcessStream> processStreams = processStreamService.getByuserPerms(userId, queryParam);
        List<WorkStep> workSteps = workStepService.getByUserPerms(userId, queryParam);
        List<ComponentInfo> componentInfoList = new ArrayList<>();
        List<ProductInfo> productInfoList = new ArrayList<>();

@@ -1803,32 +768,32 @@
        ProductInfo product;
        ComponentInfo component;

        if(productInfos != null && !productInfos.isEmpty()){
            for(ProductInfo p : productInfos){
        if (productInfos != null && !productInfos.isEmpty()) {
            for (ProductInfo p : productInfos) {
                productInfoList.add(p);
                productInfoMap.put(p.getProductId(), p);
            }
        }

        if(componentInfos != null && !componentInfos.isEmpty()){
            for(ComponentInfo c : componentInfos){
        if (componentInfos != null && !componentInfos.isEmpty()) {
            for (ComponentInfo c : componentInfos) {
                componentInfoList.add(c);
                componentInfoMap.put(c.getComponentId(), c);
            }
        }

        for(PartsInfo p : partsInfos) {
            if(!productInfoMap.containsKey(p.getProductId())) {
                product  = super.getById(p.getProductId());
                if(product != null) {
        for (PartsInfo p : partsInfos) {
            if (!productInfoMap.containsKey(p.getProductId())) {
                product = super.getById(p.getProductId());
                if (product != null) {
                    productInfoMap.put(product.getProductId(), product);
                    productInfoList.add(product);
                }
            }

            if(!componentInfoMap.containsKey(p.getComponentId())) {
            if (!componentInfoMap.containsKey(p.getComponentId())) {
                component = componentInfoService.getById(p.getComponentId());
                if(component != null) {
                if (component != null) {
                    componentInfoMap.put(component.getComponentId(), component);
                    componentInfoList.add(component);
                }
@@ -1838,16 +803,16 @@

        for (ProcessStream processStream : processStreams) {
            if (!productInfoMap.containsKey(processStream.getProductId())) {
                product  = super.getById(processStream.getProductId());
                if(product != null) {
                product = super.getById(processStream.getProductId());
                if (product != null) {
                    productInfoMap.put(product.getProductId(), product);
                    productInfoList.add(product);
                }
            }

            if(!componentInfoMap.containsKey(processStream.getComponentId())) {
            if (!componentInfoMap.containsKey(processStream.getComponentId())) {
                component = componentInfoService.getById(processStream.getComponentId());
                if(component != null) {
                if (component != null) {
                    componentInfoMap.put(component.getComponentId(), component);
                    componentInfoList.add(component);
                }
@@ -1855,18 +820,18 @@
            }
        }

        for (WorkStep workStep :workSteps){
        for (WorkStep workStep : workSteps) {
            if (!productInfoMap.containsKey(workStep.getProductId())) {
                product  = super.getById(workStep.getProductId());
                if(product != null) {
                product = super.getById(workStep.getProductId());
                if (product != null) {
                    productInfoMap.put(product.getProductId(), product);
                    productInfoList.add(product);
                }
            }

            if(!componentInfoMap.containsKey(workStep.getComponentId())) {
            if (!componentInfoMap.containsKey(workStep.getComponentId())) {
                component = componentInfoService.getById(workStep.getComponentId());
                if(component != null) {
                if (component != null) {
                    componentInfoMap.put(component.getComponentId(), component);
                    componentInfoList.add(component);
                }
@@ -1879,30 +844,30 @@
        long start = System.currentTimeMillis();
        log.info("开始循环执行时间={}", start);
        String pid;
        for(ComponentInfo c : componentInfoList){
        for (ComponentInfo c : componentInfoList) {
            int rankLevel = c.getRankLevel();
            component = c;
            if(!productInfoMap.containsKey(c.getProductId())) {
                product  = super.getById(c.getProductId());
                if(product != null) {
            if (!productInfoMap.containsKey(c.getProductId())) {
                product = super.getById(c.getProductId());
                if (product != null) {
                    productInfoMap.put(product.getProductId(), product);
                    productInfoList.add(product);
                }
            }
            while((rankLevel - 1) > 0) {
            while ((rankLevel - 1) > 0) {
                pid = component.getParentId();
                if(componentInfoMap.containsKey(pid)) {
                if (componentInfoMap.containsKey(pid)) {
                    component = componentInfoMap.get(pid);
                    rankLevel = component.getRankLevel();
                    continue;
                }
                component = componentInfoService.getById(pid);
                if(component != null) {
                if (component != null) {
                    log.info("addList添加了新的部件id={}", component.getComponentId());
                    componentInfoMap.put(component.getComponentId(), component);
                    addList.add(component);
                    rankLevel = component.getRankLevel();
                }else {
                } else {
                    log.info("查询不到部件id={}", pid);
                    break;
                }
@@ -1912,18 +877,18 @@
        long end = System.currentTimeMillis();
        log.info("循环执行总耗时={}", (end - start));

        if(!addList.isEmpty()){
        if (!addList.isEmpty()) {
            componentInfoList.addAll(addList);
        }

        //转换数据
        List<ComponentExt> componentExtList = ComponentExt.convertToExtList(componentInfoList);

        return ProductTreeWrapper.loadTree(productInfoList, componentExtList, partsInfos,processStreams,workSteps);
        return ProductTreeWrapper.loadTree(productInfoList, componentExtList, partsInfos, processStreams, workSteps);
    }

    @Override
    public boolean deleteProductTree(String id, Integer type){
    public boolean deleteProductTree(String id, Integer type) {
        switch (type) {
            //产品
            case 1:
@@ -1944,4 +909,1022 @@
        }
        return false;
    }

    /**
     * éªŒè¯è¾“入参数
     */
    private void validateInputParameters(Integer nodeType, String paramId, Integer relativeFlag, String type, String[] paramIds) {
        if (!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
                !ValidateUtil.validateInteger(relativeFlag)) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        if (paramIds == null || paramIds.length < 1) {
            if (("1").equals(type)) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
            } else {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_DEPART_PERM_NONE);
            }
        }
    }

    /**
     * éªŒè¯ SysUser åˆ—表
     */
    private void validateSysUserList(Collection<SysUser> sysUserList, List<String> userIds) {
        if (sysUserList == null || sysUserList.isEmpty() || sysUserList.size() != userIds.size()) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
    }

    /**
     * éªŒè¯ MdcProduction åˆ—表
     */
    private void validateMdcProductionList(Collection<MdcProduction> mdcProductionList, List<String> departmentIds) {
        if (mdcProductionList == null || mdcProductionList.isEmpty() || mdcProductionList.size() != departmentIds.size()) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
    }

    private void handleRelativePermissions(String productId, List<String> componentIds, String processId, String partsId, Collection<SysUser> userList) {
        List<ComponentPermission> componentPermissionList = new ArrayList<>();
        List<PartsPermission> partsPermissionList = new ArrayList<>();
        List<ProcessionPermission> processionPermissionList = new ArrayList<>();
        List<WorkStepPermission> workStepPermissionList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();

        // å¤„理部件权限
        if (componentIds != null && !componentIds.isEmpty()) {
            handleComponentPermissions(componentIds, userList, componentPermissionList, permissionStreamList);
            List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
            if (partsInfoList != null && !partsInfoList.isEmpty()) {
                List<String> partsIds = partsInfoList.stream()
                        .map(PartsInfo::getPartsId)
                        .collect(Collectors.toList());
                handlePartsPermissions(partsIds, userList, partsPermissionList, permissionStreamList);
                List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(productId, componentIds, partsIds);
                processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
            }
        }

        // å¤„理工序权限
        if (processId != null) {
            List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq("process_id", processId));
            if (workStepList != null && !workStepList.isEmpty()) {
                List<String> workStepIds = workStepList.stream()
                        .map(WorkStep::getId)
                        .collect(Collectors.toList());
                handleWorkStepPermissions(workStepIds, userList, workStepPermissionList, permissionStreamList);
            }
        }

        // å¤„理零件权限
        if (partsId != null) {
            List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsId));
            processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
        }

        if (!componentPermissionList.isEmpty()) {
            componentPermissionService.saveBatch(componentPermissionList);
        }
        if (!partsPermissionList.isEmpty()) {
            partsPermissionService.saveBatch(partsPermissionList);
        }
        if (!processionPermissionList.isEmpty()) {
            iProcessStreamPermissionService.saveBatch(processionPermissionList);
        }
        if (!workStepPermissionList.isEmpty()) {
            iWorkStepPermissionService.saveBatch(workStepPermissionList);
        }
        if (!permissionStreamList.isEmpty()) {
            permissionStreamService.saveBatch(permissionStreamList);
        }
    }

    private void processStreamApi(String productId, Collection<SysUser> userList, List<ProcessionPermission> processionPermissionList, List<WorkStepPermission> workStepPermissionList, List<PermissionStream> permissionStreamList, List<ProcessStream> processStreamList) {
        if (processStreamList != null && !processStreamList.isEmpty()) {
            List<String> processIds = processStreamList.stream()
                    .map(ProcessStream::getProcessId)
                    .collect(Collectors.toList());
            handleProcessPermissions(processIds, userList, processionPermissionList, permissionStreamList);
            List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
            if (workStepList != null && !workStepList.isEmpty()) {
                List<String> workStepIds = workStepList.stream()
                        .map(WorkStep::getId)
                        .collect(Collectors.toList());
                handleWorkStepPermissions(workStepIds, userList, workStepPermissionList, permissionStreamList);
            }
        }
    }

    private void handleComponentPermissions(List<String> componentIds, Collection<SysUser> userList,
                                            List<ComponentPermission> componentPermissionList, List<PermissionStream> permissionStreamList) {
        Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
        Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
        String key;
        for (ComponentInfo c : componentInfoService.listByIds(componentIds)) {
            componentInfoMap.put(c.getComponentId(), c);
            for (SysUser u : userList) {
                key = c.getComponentId() + "," + u.getId();
                componentPermissionMap.put(key, new ComponentPermission(c.getComponentId(), u.getId()));
            }
        }
        List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
        if (existList != null && !existList.isEmpty()) {
            for (ComponentPermission permission : existList) {
                key = permission.getComponentId() + "," + permission.getUserId();
                componentPermissionMap.remove(key);
            }
        }
        for (Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()) {
            ComponentPermission cp = entry.getValue();
            componentPermissionList.add(cp);
            ComponentInfo cpInfo = componentInfoMap.get(cp.getComponentId());
            PermissionStream s = new PermissionStream();
            s.setProductId(cpInfo.getProductId());
            s.setComponentId(cpInfo.getComponentId());
            s.setUserId(cp.getUserId());
            permissionStreamList.add(s);
        }
    }

    private void handlePartsPermissions(List<String> partsIds, Collection<SysUser> userList,
                                        List<PartsPermission> partsPermissionList, List<PermissionStream> permissionStreamList) {
        Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
        Map<String, PartsInfo> partsInfoMap = new HashMap<>();
        String key;
        for (PartsInfo p : partsInfoService.listByIds(partsIds)) {
            partsInfoMap.put(p.getPartsId(), p);
            for (SysUser u : userList) {
                key = p.getPartsId() + "," + u.getId();
                partsPermissionHashMap.put(key, new PartsPermission(p.getPartsId(), u.getId()));
            }
        }
        List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
        if (existPartsList != null && !existPartsList.isEmpty()) {
            for (PartsPermission permission : existPartsList) {
                key = permission.getPartsId() + "," + permission.getUserId();
                partsPermissionHashMap.remove(key);
            }
        }
        for (Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()) {
            PartsPermission pp = entry.getValue();
            partsPermissionList.add(pp);
            PartsInfo ptInfo = partsInfoMap.get(pp.getPartsId());
            PermissionStream s = new PermissionStream();
            s.setProductId(ptInfo.getProductId());
            s.setComponentId(ptInfo.getComponentId());
            s.setPartsId(ptInfo.getPartsId());
            s.setUserId(pp.getUserId());
            permissionStreamList.add(s);
        }
    }

    private void handleProcessPermissions(List<String> processIds, Collection<SysUser> userList,
                                          List<ProcessionPermission> processionPermissionList, List<PermissionStream> permissionStreamList) {
        Map<String, ProcessionPermission> processionPermissionHashMap = new HashMap<>();
        Map<String, ProcessStream> processStreamMap = new HashMap<>();
        String key;
        for (ProcessStream p : processStreamService.listByIds(processIds)) {
            processStreamMap.put(p.getProcessId(), p);
            for (SysUser u : userList) {
                key = p.getProcessId() + "," + u.getId();
                processionPermissionHashMap.put(key, new ProcessionPermission(p.getProcessId(), u.getId()));
            }
        }
        List<ProcessionPermission> processionDepartmentList = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
        if (processionDepartmentList != null && !processionDepartmentList.isEmpty()) {
            for (ProcessionPermission processionPermission : processionDepartmentList) {
                key = processionPermission.getProcessId() + "," + processionPermission.getUserId();
                processionPermissionHashMap.remove(key);
            }
        }
        for (Map.Entry<String, ProcessionPermission> entry : processionPermissionHashMap.entrySet()) {
            ProcessionPermission pp = entry.getValue();
            processionPermissionList.add(pp);
            ProcessStream processStream = processStreamMap.get(pp.getProcessId());
            PermissionStream s = new PermissionStream();
            s.setProductId(processStream.getProductId());
            s.setComponentId(processStream.getComponentId());
            s.setPartsId(processStream.getPartsId());
            s.setProcessId(processStream.getProcessId());
            s.setUserId(pp.getUserId());
            permissionStreamList.add(s);
        }
    }

    private void handleWorkStepPermissions(List<String> workStepIds, Collection<SysUser> userList,
                                           List<WorkStepPermission> workStepPermissionList, List<PermissionStream> permissionStreamList) {
        Map<String, WorkStepPermission> workStepPermissionHashMap = new HashMap<>();
        Map<String, WorkStep> workStepHashMap = new HashMap<>();
        String key;
        for (WorkStep w : workStepService.listByIds(workStepIds)) {
            workStepHashMap.put(w.getId(), w);
            for (SysUser u : userList) {
                key = w.getId() + "," + u.getId();
                workStepPermissionHashMap.put(key, new WorkStepPermission(w.getId(), u.getId()));
            }
        }
        List<WorkStepPermission> workStepPermissions = iWorkStepPermissionService.getByStepIdsAndUserIds(workStepIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
        if (workStepPermissions != null && !workStepPermissions.isEmpty()) {
            for (WorkStepPermission workStepPermission : workStepPermissions) {
                key = workStepPermission.getStepId() + "," + workStepPermission.getUserId();
                workStepPermissionHashMap.remove(key);
            }
        }
        for (Map.Entry<String, WorkStepPermission> entry : workStepPermissionHashMap.entrySet()) {
            WorkStepPermission ws = entry.getValue();
            workStepPermissionList.add(ws);
            WorkStep workStep = workStepHashMap.get(ws.getStepId());
            PermissionStream s = new PermissionStream();
            s.setProductId(workStep.getProductId());
            s.setComponentId(workStep.getComponentId());
            s.setPartsId(workStep.getPartsId());
            s.setProcessId(workStep.getProcessId());
            s.setStepId(workStep.getId());
            s.setUserId(ws.getUserId());
            permissionStreamList.add(s);
        }
    }

    /**
     * æ·»åŠ æƒé™
     */

    private boolean handleWorkStep(String paramId, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        WorkStep workStep = workStepService.getById(paramId);
        if (workStep == null) {
            ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
        }
        boolean hasPerm = checkProductPerm(6, workStep.getId());
        if (!hasPerm) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
        }
        if (userList!=null){
            return workStepService.assignAddUser(workStep, userList);
        }else {
            return workStepService.assignAddDepart(workStep, mdcProductionList);
        }
    }

    private boolean handleProcessStream(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        ProcessStream processStream = processStreamService.getById(paramId);
        if (processStream == null) {
            ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
        }
        boolean hasPerm = checkProductPerm(5, processStream.getProcessId());
        if (!hasPerm) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
        }
        boolean result;
        if (userList!=null){
            boolean processResult = processStreamService.assignAddUser(processStream, userList);
            if (!processResult) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelativePermissions(processStream.getProductId(), null, processStream.getProcessId(), null, userList);
            }
        }else {
            result = processStreamService.assignAddDepart(processStream, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelatedPermissions(processStream, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService);
            }
        }
        return true;
    }

    private boolean handlePartsInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        PartsInfo partsInfo = partsInfoService.getById(paramId);
        if (partsInfo == null) {
            ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
        }
        boolean hasPerm = checkProductPerm(3, partsInfo.getPartsId());
        if (!hasPerm) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
        }
        boolean result;
        if (userList!=null){
            result = partsInfoService.assignAddUser(partsInfo, userList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelativePermissions(partsInfo.getProductId(), null, null, partsInfo.getPartsId(), userList);
            }
        }else {
            result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
            }
        }
        return true;
    }

    private boolean handleProductInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        ProductInfo productInfo = super.getById(paramId);
        if (productInfo == null) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
        }
        boolean hasPerm = checkProductPerm(1, productInfo.getProductId());
        if (!hasPerm) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
        }
        boolean result;
        if (userList!=null){
            result = this.assignAddUser(productInfo, userList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
                if (componentInfoList != null && !componentInfoList.isEmpty()) {
                    List<String> componentIds = componentInfoList.stream()
                            .map(ComponentInfo::getComponentId)
                            .collect(Collectors.toList());
                    handleRelativePermissions(productInfo.getProductId(), componentIds, null, null, userList);
                }
            }
        }else {
            result = this.assignAddDepartment(productInfo, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelatedPermissionsForProduct(productInfo, mdcProductionList);
            }
        }
        return true;
    }

    private boolean handleComponentInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        ComponentInfo componentInfo = componentInfoService.getById(paramId);
        if (componentInfo == null) {
            ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
        }
        boolean hasPerm = checkProductPerm(2, componentInfo.getComponentId());
        if (!hasPerm) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
        }
        boolean result;
        if (userList!=null){
            result = componentInfoService.assignAddUser(componentInfo, userList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
                List<String> componentIds = new ArrayList<>();
                if (childrenList != null && !childrenList.isEmpty()) {
                    componentIds = childrenList.stream()
                            .map(ComponentInfo::getComponentId)
                            .collect(Collectors.toList());
                }
                componentIds.add(componentInfo.getComponentId());
                handleRelativePermissions(componentInfo.getProductId(), componentIds, null, null, userList);
            }
        }else {
            result = componentInfoService.assignAddDepart(componentInfo, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelatedPermissionsForComponent(componentInfo, mdcProductionList);
            }
        }
        return true;
    }

    private void handleRelatedPermissions(Object parentEntity, Collection<MdcProduction> mdcProductionList, IWorkStepService workStepService, IWorkStepDepartmentService workStepDepartmentService, IPermissionStreamService permissionStreamService) {
        String parentId = getParentId(parentEntity);
        List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq("process_id", parentId));
        if (workStepList == null || workStepList.isEmpty()) {
            return;
        }
        Map<String, WorkStepDepartment> allPermissions = new HashMap<>();
        Map<String, WorkStep> workStepMap = new HashMap<>();
        for (WorkStep workStep : workStepList) {
            workStepMap.put(workStep.getId(), workStep);
            for (MdcProduction mdcProduction : mdcProductionList) {
                String key = workStep.getId() + "," + mdcProduction.getId();
                WorkStepDepartment wsDep = new WorkStepDepartment(workStep.getId(), mdcProduction.getId());
                allPermissions.put(key, wsDep);
            }
        }

        List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
        List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
        List<WorkStepDepartment> existingPermissions = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, departmentIds);
        if (existingPermissions != null && !existingPermissions.isEmpty()) {
            for (WorkStepDepartment existing : existingPermissions) {
                String key = existing.getStepId() + "," + existing.getDepartId();
                allPermissions.remove(key);
            }
        }

        List<WorkStepDepartment> newWorkStepDepartments = new ArrayList<>();
        List<PermissionStream> newPermissionStreams = new ArrayList<>();
        for (Map.Entry<String, WorkStepDepartment> entry : allPermissions.entrySet()) {
            WorkStepDepartment wsDep = entry.getValue();
            newWorkStepDepartments.add(wsDep);
            WorkStep workStep = workStepMap.get(wsDep.getStepId());
            PermissionStream permStream = new PermissionStream();
            permStream.setProductId(workStep.getProductId());
            permStream.setComponentId(workStep.getComponentId());
            permStream.setPartsId(workStep.getPartsId());
            permStream.setProcessId(workStep.getProcessId());
            permStream.setStepId(workStep.getId());
            permStream.setDepartId(wsDep.getDepartId());
            newPermissionStreams.add(permStream);
        }

        if (!newWorkStepDepartments.isEmpty()) {
            workStepDepartmentService.saveBatch(newWorkStepDepartments);
        }
        if (!newPermissionStreams.isEmpty()) {
            permissionStreamService.saveBatch(newPermissionStreams);
        }
    }

    private void handleRelatedPermissionsForParts(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
        // å¤„理工序权限
        handleProcessPermissions(partsInfo,null, mdcProductionList);
        // å¤„理工步权限
        handleWorkStepPermissions(partsInfo, mdcProductionList);
    }

    private void handleProcessPermissions(PartsInfo partsInfo,ComponentInfo componentInfo,Collection<MdcProduction> mdcProductionList) {
        List<ProcessStream> processStreamList=new ArrayList<>();
        if (componentInfo != null) {
            processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()));
        }else {
            processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
        }
        if (processStreamList == null || processStreamList.isEmpty()) {
            return;
        }
        processStreamList.forEach(item->{
            handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService);
        });
        Map<String, ProcessionDepartment> allProcessPermissions = new HashMap<>();
        Map<String, ProcessStream> processStreamMap = new HashMap<>();
        for (ProcessStream processStream : processStreamList) {
            processStreamMap.put(processStream.getProcessId(), processStream);
            for (MdcProduction mdcProduction : mdcProductionList) {
                String key = processStream.getProcessId() + "," + mdcProduction.getId();
                ProcessionDepartment procDep = new ProcessionDepartment(processStream.getProcessId(), mdcProduction.getId());
                allProcessPermissions.put(key, procDep);
            }
        }

        List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
        List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
        List<ProcessionDepartment> existingProcessPermissions = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIds);
        if (existingProcessPermissions != null && !existingProcessPermissions.isEmpty()) {
            for (ProcessionDepartment existing : existingProcessPermissions) {
                String key = existing.getProcessId() + "," + existing.getDepartId();
                allProcessPermissions.remove(key);
            }
        }

        List<ProcessionDepartment> newProcessPermissions = new ArrayList<>();
        List<PermissionStream> newPermissionStreams = new ArrayList<>();
        for (Map.Entry<String, ProcessionDepartment> entry : allProcessPermissions.entrySet()) {
            ProcessionDepartment procDep = entry.getValue();
            newProcessPermissions.add(procDep);
            ProcessStream processStream = processStreamMap.get(procDep.getProcessId());
            PermissionStream permStream = new PermissionStream();
            permStream.setProductId(processStream.getProductId());
            permStream.setComponentId(processStream.getComponentId());
            permStream.setPartsId(processStream.getPartsId());
            permStream.setProcessId(processStream.getProcessId());
            permStream.setDepartId(procDep.getDepartId());
            newPermissionStreams.add(permStream);
        }

        if (!newProcessPermissions.isEmpty()) {
            processionDepartmentService.saveBatch(newProcessPermissions);
        }
        if (!newPermissionStreams.isEmpty()) {
            permissionStreamService.saveBatch(newPermissionStreams);
        }
    }

    private void handleWorkStepPermissions(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
        List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
        if (processStreamList == null || processStreamList.isEmpty()) {
            return;
        }
        List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
        List<WorkStep> workStepList = workStepService.getByProcessIds(partsInfo.getProductId(), processIds);
        if (workStepList == null || workStepList.isEmpty()) {
            return;
        }
        workStepList.forEach(item->{
            handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService);
        });
    }

    private void handleRelatedPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
        // å¤„理组件权限
        handleComponentPermissionsForProduct(productInfo, mdcProductionList);
        // å¤„理零件权限
        handlePartsPermissionsForProduct(productInfo, mdcProductionList);
        List<ComponentInfo> componentInfoList=componentInfoService.list(new QueryWrapper<ComponentInfo>().eq("product_id", productInfo.getProductId()));
        componentInfoList.forEach(item->{
            handleProcessPermissions(null,item, mdcProductionList);
        });
    }

    private void handleComponentPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
        List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
        if (componentInfoList == null || componentInfoList.isEmpty()) {
            return;
        }
        Map<String, ComponentDepartment> allComponentPermissions = new HashMap<>();
        Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
        for (ComponentInfo componentInfo : componentInfoList) {
            componentInfoMap.put(componentInfo.getComponentId(), componentInfo);
            for (MdcProduction mdcProduction : mdcProductionList) {
                String key = componentInfo.getComponentId() + "," + mdcProduction.getId();
                ComponentDepartment compDep = new ComponentDepartment(componentInfo.getComponentId(), mdcProduction.getId());
                allComponentPermissions.put(key, compDep);
            }
        }

        List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
        List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
        List<ComponentDepartment> existingComponentPermissions = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIds);
        if (existingComponentPermissions != null && !existingComponentPermissions.isEmpty()) {
            for (ComponentDepartment existing : existingComponentPermissions) {
                String key = existing.getComponentId() + "," + existing.getDepartId();
                allComponentPermissions.remove(key);
            }
        }

        List<ComponentDepartment> newComponentPermissions = new ArrayList<>();
        List<PermissionStream> newPermissionStreams = new ArrayList<>();
        for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
            ComponentDepartment compDep = entry.getValue();
            newComponentPermissions.add(compDep);
            ComponentInfo componentInfo = componentInfoMap.get(compDep.getComponentId());
            PermissionStream permStream = new PermissionStream();
            permStream.setProductId(componentInfo.getProductId());
            permStream.setComponentId(componentInfo.getComponentId());
            permStream.setDepartId(compDep.getDepartId());
            newPermissionStreams.add(permStream);
        }

        if (!newComponentPermissions.isEmpty()) {
            componentDepartmentService.saveBatch(newComponentPermissions);
        }
        if (!newPermissionStreams.isEmpty()) {
            permissionStreamService.saveBatch(newPermissionStreams);
        }
    }

    private void handlePartsPermissionsForProduct(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
        List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
        if (componentInfoList == null || componentInfoList.isEmpty()) {
            return;
        }
        List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
        List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
        if (partsInfoList == null || partsInfoList.isEmpty()) {
            return;
        }
        for (PartsInfo partsInfo : partsInfoList) {
            boolean result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
        }
    }

    private void handleRelatedPermissionsForComponent(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
        // å¤„理子组件权限
        handleChildComponentPermissions(componentInfo, mdcProductionList);
        // å¤„理零件权限
        handlePartsPermissionsForComponent(componentInfo, mdcProductionList);
        // å¤„理工序权限
        handleProcessPermissions(null,componentInfo, mdcProductionList);
    }

    private void handleChildComponentPermissions(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
        List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
        if (childrenList == null || childrenList.isEmpty()) {
            return;
        }
        Map<String, ComponentDepartment> allComponentPermissions = new HashMap<>();
        Map<String, ComponentInfo> componentInfoMap = new HashMap<>();
        for (ComponentInfo childComponent : childrenList) {
            componentInfoMap.put(childComponent.getComponentId(), childComponent);
            for (MdcProduction mdcProduction : mdcProductionList) {
                String key = childComponent.getComponentId() + "," + mdcProduction.getId();
                ComponentDepartment compDep = new ComponentDepartment(childComponent.getComponentId(), mdcProduction.getId());
                allComponentPermissions.put(key, compDep);
            }

            List<String> componentIds = childrenList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
            List<String> departmentIds = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
            List<ComponentDepartment> existingComponentPermissions = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIds);
            if (existingComponentPermissions != null && !existingComponentPermissions.isEmpty()) {
                for (ComponentDepartment existing : existingComponentPermissions) {
                    String key = existing.getComponentId() + "," + existing.getDepartId();
                    allComponentPermissions.remove(key);
                }
            }

            List<ComponentDepartment> newComponentPermissions = new ArrayList<>();
            List<PermissionStream> newPermissionStreams = new ArrayList<>();
            for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
                ComponentDepartment compDep = entry.getValue();
                newComponentPermissions.add(compDep);
                childComponent = componentInfoMap.get(compDep.getComponentId());
                PermissionStream permStream = new PermissionStream();
                permStream.setProductId(childComponent.getProductId());
                permStream.setComponentId(childComponent.getComponentId());
                permStream.setDepartId(compDep.getDepartId());
                newPermissionStreams.add(permStream);
            }

            if (!newComponentPermissions.isEmpty()) {
                componentDepartmentService.saveBatch(newComponentPermissions);
            }
            if (!newPermissionStreams.isEmpty()) {
                permissionStreamService.saveBatch(newPermissionStreams);
            }
        }
    }

    private void handlePartsPermissionsForComponent(ComponentInfo componentInfo, Collection<MdcProduction> mdcProductionList) {
        List<PartsInfo> partsInfoList = partsInfoService.getByComponentId(componentInfo.getProductId(),componentInfo.getComponentId());
        if (partsInfoList == null || partsInfoList.isEmpty()) {
            return;
        }
        for (PartsInfo partsInfo : partsInfoList) {
            handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
        }
    }

    private String getParentId(Object parentEntity) {
        if (parentEntity instanceof ProcessStream) {
            return ((ProcessStream) parentEntity).getProcessId();
        } else if (parentEntity instanceof WorkStep) {
            return ((WorkStep) parentEntity).getProcessId();
        }
        return null;
    }


    /**移除权限*/

    private boolean handleWorkStepRemoval(String paramId, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        WorkStep workStep = workStepService.getById(paramId);
        if (workStep == null) {
            ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
        }
        checkProductPerm(6, workStep.getId());
        if (userList!=null){
            return workStepService.assignRemoveUser(workStep, userList);
        }else {
            return workStepService.assignRemoveDepart(workStep, mdcProductionList);
        }
    }

    private boolean handleProcessStreamRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        ProcessStream processStream = processStreamService.getById(paramId);
        if (processStream == null) {
            ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
        }
        checkProductPerm(5, processStream.getProcessId());
        boolean result;
        if (userList!=null){
            result = processStreamService.assignRemoveUser(processStream, userList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelatedRemovals(processStream.getProcessId(), userList,
                        workStepService, iWorkStepPermissionService, permissionStreamService,
                        "process_id");
            }
        }else {
            result = processStreamService.assignRemoveDepart(processStream, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelatedDepartmentRemovals(processStream.getProcessId(), mdcProductionList,
                        workStepService, workStepDepartmentService, permissionStreamService,
                        "process_id");
            }
        }
        return true;
    }

    private boolean handlePartsInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        PartsInfo partsInfo = partsInfoService.getById(paramId);
        if (partsInfo == null) {
            ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
        }
        checkProductPerm(3, partsInfo.getPartsId());
        boolean result;
        if (userList!=null){
            result = partsInfoService.assignRemoveUser(partsInfo, userList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handlePartsRelatedRemovals(null,partsInfo, userList);
            }
        }else {
            result = partsInfoService.assignRemoveDepart(partsInfo, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handlePartsRelatedDepartmentRemovals(null,partsInfo, mdcProductionList);
            }
        }
        return true;
    }

    private boolean handleProductInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        ProductInfo productInfo = super.getById(paramId);
        if (productInfo == null) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
        }
        checkProductPerm(1, productInfo.getProductId());
        boolean result;
        if (userList!=null){
            result =this.assignRemoveUser(productInfo, userList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleProductRelatedRemovals(productInfo, userList);
            }
        }else {
            result = this.assignRemoveDepartment(productInfo, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleProductRelatedDepartmentRemovals(productInfo, mdcProductionList);
            }
        }
        return true;
    }

    private boolean handleComponentInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        ComponentInfo componentInfo = componentInfoService.getById(paramId);
        if (componentInfo == null) {
            ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
        }
        checkProductPerm(2, componentInfo.getComponentId());
        boolean result;
        if (userList!=null){
            result =componentInfoService.assignRemoveUser(componentInfo, userList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleComponentRelatedRemovals(componentInfo, userList,null);
            }
        }else {
            result = componentInfoService.assignRemoveDepart(componentInfo, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleComponentRelatedRemovals(componentInfo,null,mdcProductionList);
            }
        }
        return true;
    }

    private void handleRelatedRemovals(String parentId, Collection<SysUser> userList,
                                       IWorkStepService workStepService,
                                       IWorkStepPermissionService workStepPermissionService,
                                       IPermissionStreamService permissionStreamService,
                                       String queryField) {
        List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId));
        if (workStepList.isEmpty()) {
            return;
        }
        List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
        List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
        List<WorkStepPermission> workStepPermissions = workStepPermissionService.getByStepIdsAndUserIds(workStepIds, userIdList);
        List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, userIdList);

        if (!workStepPermissions.isEmpty()) {
            workStepPermissionService.removeByCollection(workStepPermissions);
        }
        if (!permissionStreams.isEmpty()) {
            permissionStreamService.removeByCollection(permissionStreams);
        }
    }

    private void handleRelatedDepartmentRemovals(String parentId, Collection<MdcProduction> mdcProductionList,
                                                 IWorkStepService workStepService,
                                                 IWorkStepDepartmentService workStepDepartmentService,
                                                 IPermissionStreamService permissionStreamService,
                                                 String queryField) {
        List<WorkStep> workStepList = workStepService.list(new QueryWrapper<WorkStep>().eq(queryField, parentId));
        if (workStepList.isEmpty()) {
            return;
        }
        List<String> workStepIds = workStepList.stream().map(WorkStep::getId).collect(Collectors.toList());
        List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
        List<WorkStepDepartment> workStepDepartments = workStepDepartmentService.getByPartsIdsAndDepartIds(workStepIds, departmentIdList);
        List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(workStepIds, departmentIdList);

        if (!workStepDepartments.isEmpty()) {
            workStepDepartmentService.removeByCollection(workStepDepartments);
        }
        if (!permissionStreams.isEmpty()) {
            permissionStreamService.removeByCollection(permissionStreams);
        }
    }

    private void handlePartsRelatedRemovals(ComponentInfo componentInfo,PartsInfo partsInfo,Collection<SysUser> userList) {
        List<ProcessStream> processStreamList =new ArrayList<>();
        String productId="";
        if (partsInfo!=null){
            processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
            productId=partsInfo.getProductId();
        }else {
            processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()).isNull("parts_id"));
            productId=componentInfo.getProductId();
        }
        List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
        handleProcessRemovals(processIds, userList);
        handleWorkStepRemovals(productId, processIds, userList);
    }

    private void handleProcessRemovals(List<String> processIds, Collection<SysUser> userList) {
        if (processIds.isEmpty()) {
            return;
        }
        List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
        List<ProcessionPermission> processionPermissions = iProcessStreamPermissionService.getByProcessIdsAndUserIds(processIds, userIdList);
        List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndUserIds(processIds, userIdList);

        if (!processionPermissions.isEmpty()) {
            iProcessStreamPermissionService.removeByCollection(processionPermissions);
        }
        if (!permissionStreams.isEmpty()) {
            permissionStreamService.removeByCollection(permissionStreams);
        }
    }

    private void handleProcessDepartmentRemovals(List<String> processIds, Collection<MdcProduction> mdcProductionList) {
        if (processIds.isEmpty()) {
            return;
        }
        List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
        List<ProcessionDepartment> processionDepartments = processionDepartmentService.getByPartsIdsAndDepartIds(processIds, departmentIdList);
        List<PermissionStream> permissionStreams = permissionStreamService.getByPartsIdsAndDepartIds(processIds, departmentIdList);

        if (!processionDepartments.isEmpty()) {
            processionDepartmentService.removeByCollection(processionDepartments);
        }
        if (!permissionStreams.isEmpty()) {
            permissionStreamService.removeByCollection(permissionStreams);
        }
    }

    private void handleWorkStepRemovals(String productId, List<String> processIds, Collection<SysUser> userList) {
        List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
        if (workStepList!=null){
            workStepList.forEach(item->{
                handleRelatedRemovals(item.getProcessId(), userList, workStepService, iWorkStepPermissionService, permissionStreamService, "process_id");
            });
        }
    }

    private void handleWorkStepDepartmentRemovals(String productId, List<String> processIds, Collection<MdcProduction> mdcProductionList) {
        List<WorkStep> workStepList = workStepService.getByProcessIds(productId, processIds);
        if (workStepList!=null){
            workStepList.forEach(item->{
                handleRelatedDepartmentRemovals(item.getProcessId(), mdcProductionList, workStepService, workStepDepartmentService, permissionStreamService, "process_id");
            });
        }
    }

    private void handleProductRelatedRemovals(ProductInfo productInfo, Collection<SysUser> userList) {
        List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
        List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
        handleComponentRemovals(componentIds, userList);
        handlePartsRemovals(productInfo.getProductId(), componentIds, userList);
        componentInfoList.forEach(item->{
            handlePartsRelatedRemovals(item,null, userList);
        });
    }

    private void handleProductRelatedDepartmentRemovals(ProductInfo productInfo, Collection<MdcProduction> mdcProductionList) {
        List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
        List<String> componentIds = componentInfoList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
        handleComponentDepartmentRemovals(componentIds, mdcProductionList);
        handlePartsDepartmentRemovals(productInfo.getProductId(), componentIds, mdcProductionList);
        componentInfoList.forEach(item->{
            handlePartsRelatedDepartmentRemovals(item,null, mdcProductionList);
        });
    }

    private void handleComponentRemovals(List<String> componentIds, Collection<SysUser> userList) {
        if (componentIds.isEmpty()) {
            return;
        }
        List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
        List<ComponentPermission> componentPermissions = componentPermissionService.getByComponentIdsAndUserIds(componentIds, userIdList);
        List<PermissionStream> permissionStreams = permissionStreamService.getByComponentIdsAndUserIds(componentIds, userIdList);

        if (!componentPermissions.isEmpty()) {
            componentPermissionService.removeByCollection(componentPermissions);
        }
        if (!permissionStreams.isEmpty()) {
            permissionStreamService.removeByCollection(permissionStreams);
        }
    }

    private void handleComponentDepartmentRemovals(List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
        if (componentIds.isEmpty()) {
            return;
        }
        List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
        List<ComponentDepartment> componentDepartments = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, departmentIdList);
        List<PermissionStream> permissionStreams = permissionStreamService.getByComponentIdsAndDepartIds(componentIds, departmentIdList);

        if (!componentDepartments.isEmpty()) {
            componentDepartmentService.removeByCollection(componentDepartments);
        }
        if (!permissionStreams.isEmpty()) {
            permissionStreamService.removeByCollection(permissionStreams);
        }
    }

    private void handlePartsRemovals(String productId, List<String> componentIds, Collection<SysUser> userList) {
        List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
        partsInfoList.forEach(item->{
            partsInfoService.assignRemoveUser(item,userList);
            handlePartsRelatedRemovals(null,item, userList);
        });
    }
    private void handlePartsDepartmentRemovals(String productId, List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
        List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
        partsInfoList.forEach(item->{
            partsInfoService.assignRemoveDepart(item,mdcProductionList);
            handlePartsRelatedDepartmentRemovals(null,item, mdcProductionList);
        });
    }

    private void handleComponentRelatedRemovals(ComponentInfo componentInfo, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
        List<String> componentIds = new ArrayList<>();
        if (childrenList != null) {
            componentIds = childrenList.stream().map(ComponentInfo::getComponentId).collect(Collectors.toList());
        }
        componentIds.add(componentInfo.getComponentId());
        if (mdcProductionList!=null){
            handleComponentDepartmentRemovals(componentIds, mdcProductionList);
            handlePartsDepartmentRemovals(componentInfo.getProductId(), componentIds, mdcProductionList);
            if (childrenList != null) {
                childrenList.forEach(item->{
                    handlePartsRelatedDepartmentRemovals(item,null, mdcProductionList);
                });
            }
        }else {
            handleComponentRemovals(componentIds, userList);
            handlePartsRemovals(componentInfo.getProductId(), componentIds, userList);
            if (childrenList != null) {
                childrenList.forEach(item->{
                    handlePartsRelatedRemovals(item,null, userList);
                });
            }
        }
    }

    private void handlePartsRelatedDepartmentRemovals(ComponentInfo componentInfo,PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
        List<ProcessStream> processStreamList=new ArrayList<>();
        String productId="";
        if (componentInfo!=null){
            processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("component_id", componentInfo.getComponentId()));
            productId=componentInfo.getProductId();
        }else {
            processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("parts_id", partsInfo.getPartsId()));
            productId=partsInfo.getProductId();
        }
        List<String> processIds = processStreamList.stream().map(ProcessStream::getProcessId).collect(Collectors.toList());
        handleProcessDepartmentRemovals(processIds, mdcProductionList);
        handleWorkStepDepartmentRemovals(productId, processIds, mdcProductionList);
    }

}

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

@@ -53,11 +53,11 @@
        if(permissionList == null || permissionList.isEmpty())
            return false;
        if(permissionList.size() == 1) {
            return super.removeById(permissionList.get(0).getProductPermId());
            return super.removeById(permissionList.get(0).getId());
        }
        List<String> ids = new ArrayList<>();
        permissionList.forEach(item -> {
            ids.add(item.getProductPermId());
            ids.add(item.getId());
        });
        return super.removeByIds(ids);
    }

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,112 @@
package org.jeecg.modules.dnc.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections4.ListUtils;
import org.jeecg.modules.dnc.entity.WorkStepPermission;
import org.jeecg.modules.dnc.mapper.WorkStepPermissionMapper;
import org.jeecg.modules.dnc.service.IWorkStepPermissionService;
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.system.entity.SysUser;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

@Service
public class WorkStepPermissionServiceImpl extends ServiceImpl<WorkStepPermissionMapper, WorkStepPermission> implements IWorkStepPermissionService {
    @Override
    public WorkStepPermission getByStepIdAndUserId(String partsId, String userId) {
        if(!ValidateUtil.validateString(partsId) || !ValidateUtil.validateString(userId))
            return null;
        List<WorkStepPermission> permissions = super.lambdaQuery().eq(WorkStepPermission::getStepId, partsId).eq(WorkStepPermission::getUserId, userId).list();
        if(permissions == null || permissions.isEmpty())
            return null;
        return permissions.get(0);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteByStepId(String partsId) {
        if(!ValidateUtil.validateString(partsId))
            return false;
        LambdaQueryWrapper<WorkStepPermission> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(WorkStepPermission::getStepId, partsId);
        return super.remove(lambdaQueryWrapper);
    }

    @Override
    public List<UserDepartExt> getUserPermsByProductId(String partsId) {
        return super.getBaseMapper().getUserPermsByStepId(partsId);
    }

    @Override
    public List<SysUser> getUserNonPermsByProductId(String partsId) {
        return super.getBaseMapper().getUserNonPermsByStepId(partsId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean removeByCollection(List<WorkStepPermission> permissionList) {
        if(permissionList == null || permissionList.isEmpty())
            return false;
        if(permissionList.size() == 1)
            return super.removeById(permissionList.get(0).getId());
        List<String> ids = new ArrayList<>();
        permissionList.forEach(item -> {
            ids.add(item.getId());
        });
        if(ids.size() > 1000){
            List<List<String>> idsArr = ListUtils.partition(ids, 1000);
            for(List<String> arr : idsArr){
                super.removeByIds(arr);
            }
            return true;
        }else {
            return super.removeByIds(ids);
        }
    }

    @Override
    public List<WorkStepPermission> getByStepId(String partsId) {
        List<WorkStepPermission> list = super.lambdaQuery().eq(WorkStepPermission::getStepId, partsId).list();
        if(list == null)
            list = Collections.emptyList();
        return list;
    }

    @Override
    public List<WorkStepPermission> getByStepIdsAndUserIds(List<String> partsIds, List<String> userIds) {
        if(partsIds == null || partsIds.isEmpty() || userIds == null || userIds.isEmpty())
            return null;
        List<WorkStepPermission> total = new ArrayList<>();
        List<List<String>> partsListArr;
        List<List<String>> userListArr;
        if(partsIds.size() > 1000){
            partsListArr = ListUtils.partition(partsIds, 100);
        }else {
            partsListArr = ListUtils.partition(partsIds, 1000);
        }
        if(userIds.size() > 1000){
            userListArr = ListUtils.partition(userIds, 100);
        }else {
            userListArr = ListUtils.partition(userIds, 1000);
        }
        for(List<String> compList : partsListArr) {
            for(List<String> userList : userListArr){
                LambdaQueryWrapper<WorkStepPermission> queryWrapper = Wrappers.lambdaQuery();
                queryWrapper.in(WorkStepPermission::getStepId, compList);
                queryWrapper.in(WorkStepPermission::getUserId, userList);
                List<WorkStepPermission> list = super.list(queryWrapper);
                if(list != null && !list.isEmpty()){
                    total.addAll(list);
                }
            }
        }
        return total;
    }
}

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

@@ -20,6 +20,7 @@
import org.jeecg.modules.dnc.service.*;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.system.entity.MdcProduction;
import org.jeecg.modules.system.entity.SysUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -46,7 +47,7 @@
    private IWorkStepDepartmentService workStepDepartmentService;

    @Autowired
    private IDocInfoService docInfoService;
    private IWorkStepPermissionService workStepPermissionService;

    @Autowired
    private IDocRelativeService iDocRelativeService;
@@ -279,4 +280,81 @@
        return super.removeById(id);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddUser(WorkStep workStep, Collection<SysUser> userList) {
        if(workStep == null || userList == null || userList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<WorkStepPermission> permissionList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        userList.forEach(item -> {
            WorkStepPermission en = workStepPermissionService.getByStepIdAndUserId(workStep.getId(), item.getId());
            if(en == null) {
                en = new WorkStepPermission();
                en.setUserId(item.getId());
                en.setStepId(workStep.getId());
                permissionList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByStepIdAndUserId(workStep.getProductId(), workStep.getComponentId(), workStep.getPartsId()
                    ,workStep.getProcessId(),workStep.getId(), item.getId());
            if(stream == null) {
                stream = new PermissionStream();
                stream.setUserId(item.getId());
                stream.setProductId(workStep.getProductId());
                stream.setComponentId(workStep.getComponentId());
                stream.setPartsId(workStep.getPartsId());
                stream.setProcessId(workStep.getProcessId());
                stream.setStepId(workStep.getId());
                permissionStreamList.add(stream);
            }
        });
        if(!permissionList.isEmpty()) {
            boolean b = workStepPermissionService.saveBatch(permissionList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.saveBatch(permissionStreamList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveUser(WorkStep workStep, Collection<SysUser> userList) {
        if(workStep == null || userList == null || userList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<WorkStepPermission> permissionList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        userList.forEach(item -> {
            WorkStepPermission en = workStepPermissionService.getByStepIdAndUserId(workStep.getId(), item.getId());
            if(en != null) {
                permissionList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByStepIdAndUserId(workStep.getProductId(), workStep.getComponentId(),
                    workStep.getPartsId(),workStep.getProcessId(), workStep.getId(),item.getId());
            if(stream != null) {
                permissionStreamList.add(stream);
            }
        });
        //清空用户权限校验
        if(!permissionList.isEmpty()) {
            boolean b = workStepPermissionService.removeByCollection(permissionList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.removeByCollection(permissionStreamList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        return true;
    }

}

 lxzn-module-mdc/src/main/java/org/jeecg/modules/mdc/service/impl/MdcEquipmentServiceImpl.java

@@ -104,7 +104,7 @@
    private ISysParamsService ISysParamsService;

    @Resource
    private DncDevicePermissionMapper dncDevicePermissionMapper;
    private IDncDevicePermissionService iDncDevicePermissionService;

    @Value("${fileNCPath}")
    private String fileNCPath;
@@ -158,11 +158,7 @@
        this.save(mdcEquipment);
        //DNC添加设备权限
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        DncDevicePermission dncDevicePermission=new DncDevicePermission();
        dncDevicePermission.setDeviceId(mdcEquipment.getId());
        dncDevicePermission.setUserId(userId);
        dncDevicePermissionMapper.insert(dncDevicePermission);
        iDncDevicePermissionService.addDevicePermission(mdcEquipment.getId(), user.getId());
        //step.2 ä¿å­˜æ‰€å±žéƒ¨é—¨
        if (oConvertUtils.isNotEmpty(selectedDeparts)) {
            String[] arr = selectedDeparts.split(",");
@@ -228,7 +224,7 @@
            }
        }
        //删除所有设备权限
        dncDevicePermissionMapper.delete(new QueryWrapper<DncDevicePermission>().lambda().eq(DncDevicePermission::getDeviceId, mdcEquipment.getId()));
        iDncDevicePermissionService.remove(new QueryWrapper<DncDevicePermission>().lambda().eq(DncDevicePermission::getDeviceId, mdcEquipment.getId()));
        //step.3 ä¿®æ”¹äº§çº¿
        String productions = mdcEquipment.getSelectedProduction();
        String[] array = {};
@@ -253,14 +249,10 @@
        addDevicePermission(mdcEquipment);
        //step.4 ä¿®æ”¹è®¾å¤‡æƒé™
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        List<DncDevicePermission> dncDevicePermissions=dncDevicePermissionMapper.selectList(new LambdaQueryWrapper<DncDevicePermission>()
                .eq(DncDevicePermission::getDeviceId, mdcEquipment.getId()).eq(DncDevicePermission ::getUserId, userId));
        List<DncDevicePermission> dncDevicePermissions=iDncDevicePermissionService.list(new LambdaQueryWrapper<DncDevicePermission>()
                .eq(DncDevicePermission::getDeviceId, mdcEquipment.getId()).eq(DncDevicePermission ::getUserId, user.getId()));
        if (CollectionUtils.isEmpty(dncDevicePermissions)){
            DncDevicePermission dncDevicePermission=new DncDevicePermission();
            dncDevicePermission.setDeviceId(mdcEquipment.getId());
            dncDevicePermission.setUserId(userId);
            dncDevicePermissionMapper.insert(dncDevicePermission);
            iDncDevicePermissionService.addDevicePermission(mdcEquipment.getId(), user.getId());
        }
    }

@@ -270,10 +262,7 @@
                .stream().map(MdcProductionEquipment::getProductionId).collect(Collectors.toList());
        List<MdcUserProduction> mdcUserProductionList=mdcUserProductionService.queryByProductionIds(productionIds);
        mdcUserProductionList.forEach(item->{
            DncDevicePermission devicePermission=new DncDevicePermission();
            devicePermission.setDeviceId(mdcEquipment.getId());
            devicePermission.setUserId(item.getUserId());
            dncDevicePermissionMapper.insert(devicePermission);
            iDncDevicePermissionService.addDevicePermission(mdcEquipment.getId(), item.getUserId());
        });
    }

@@ -288,7 +277,7 @@
        // 3. åˆ é™¤è®¾å¤‡äº§çº¿å…³ç³»
        line += mdcProductionEquipmentMapper.delete(new LambdaQueryWrapper<MdcProductionEquipment>().eq(MdcProductionEquipment::getEquipmentId, id));
        // 4. åˆ é™¤è®¾å¤‡æƒé™
        line += dncDevicePermissionMapper.delete(new LambdaQueryWrapper<DncDevicePermission>().eq(DncDevicePermission::getDeviceId, id));
        line += iDncDevicePermissionService.remove(new LambdaQueryWrapper<DncDevicePermission>().eq(DncDevicePermission::getDeviceId, id))? 1 : 0;
        return line != 0;
    }

@@ -330,7 +319,7 @@
    public void removeEquipmentForProduction(String productionId, String equipmentId) {
        mdcProductionEquipmentMapper.delete(new LambdaQueryWrapper<MdcProductionEquipment>().eq(MdcProductionEquipment::getProductionId, productionId).eq(MdcProductionEquipment::getEquipmentId, equipmentId));
        //移除设备权限
        dncDevicePermissionMapper.delete(new LambdaQueryWrapper<DncDevicePermission>().eq(DncDevicePermission::getDeviceId, equipmentId));
        iDncDevicePermissionService.remove(new LambdaQueryWrapper<DncDevicePermission>().eq(DncDevicePermission::getDeviceId, equipmentId));
    }

    @Override

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/system/entity/DncDevicePermission.java

@@ -14,6 +14,11 @@
@NoArgsConstructor
@TableName(value = "nc_device_permission")
public class DncDevicePermission {
    public DncDevicePermission(String userId, String deviceId) {
        this.userId = userId;
        this.deviceId = deviceId;
    }

    @TableId(value = "device_perm_id")
    private String devicePermId;
    @TableField(value = "device_id")
@@ -26,4 +31,5 @@
    @JsonIgnore
    @TableField(value = "create_by", select = false, fill = FieldFill.INSERT)
    private String createBy;

}

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/system/service/IDncDevicePermissionService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,15 @@
package org.jeecg.modules.system.service;

import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.DncDevicePermission;

public interface IDncDevicePermissionService extends IService<DncDevicePermission> {

    /**
     * æ–°å¢žè®¾å¤‡æƒé™
     * @param EquipmentId è®¾å¤‡ID
     * @param userId ç”¨æˆ·ID
     */
    public void addDevicePermission(String EquipmentId, String userId);

}

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/system/service/impl/DncDevicePermissionServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,38 @@
package org.jeecg.modules.system.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.modules.system.entity.DncDevicePermission;
import org.jeecg.modules.system.entity.MdcProduction;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.mapper.DncDevicePermissionMapper;
import org.jeecg.modules.system.service.IDncDevicePermissionService;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class DncDevicePermissionServiceImpl extends ServiceImpl<DncDevicePermissionMapper, DncDevicePermission> implements IDncDevicePermissionService {
    @Autowired
    private ISysUserService sysUserService;

    @Override
    public void addDevicePermission(String EquipmentId, String userId) {
        DncDevicePermission dncDevicePermission=new DncDevicePermission(EquipmentId,userId);
        SysUser sysUser=sysUserService.getUserByName("admin");
        if (userId.equals(sysUser.getId())) {
            // ç®¡ç†å‘˜æ–°å¢ž
            super.save(dncDevicePermission);
        }else {
            // éžç®¡ç†å‘˜æ–°å¢žï¼Œé»˜è®¤æ·»åŠ ç®¡ç†å‘˜æƒé™
            List<DncDevicePermission> dncDevicePermissions=new ArrayList<>();
            dncDevicePermissions.add(dncDevicePermission);
            dncDevicePermissions.add(new DncDevicePermission(EquipmentId,sysUser.getId()));
            super.saveBatch(dncDevicePermissions);
        }

    }
}