Merge branch 'mdc_hyjs_master'

zhangherong

2025-06-25 2fb6c67b2c0c72195eef6fe5f7904d739b46e2c0

Merge branch 'mdc_hyjs_master'

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

@@ -1,5 +1,7 @@
package org.jeecg.modules.dnc.controller;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
@@ -13,6 +15,7 @@

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;

@Slf4j
@Api(tags = "刀具信息")
@@ -35,6 +38,25 @@
    }

    /**
     * 查询刀具List
     * @param cutter
     * @return
     */
    @AutoLog(value = "刀具信息-查询刀具List")
    @ApiOperation(value = "刀具信息-查询刀具List", notes = "刀具信息-查询刀具List")
    @GetMapping("/getList")
    public Result<?> getList( Cutter cutter){
        QueryWrapper<Cutter> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(StrUtil.isNotEmpty(cutter.getDocId()),"doc_id",cutter.getDocId());
        queryWrapper.like(StrUtil.isNotEmpty(cutter.getCutterName()),"cutter_name",cutter.getCutterName());
        queryWrapper.like(StrUtil.isNotEmpty(cutter.getCutterType()),"cutter_type",cutter.getCutterType());
        queryWrapper.like(StrUtil.isNotEmpty(cutter.getCutterSpacing()),"cutter_spacing",cutter.getCutterSpacing());
        queryWrapper.orderByDesc("create_time");
        List<Cutter> list = service.list(queryWrapper);
        return Result.OK(list);
    }

    /**
     * 新增刀具信息
     * @param cutter
     * @return

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

@@ -169,6 +169,10 @@
     * @return
     */
    Result<?> borrowComponent(String oldId, String newIds);

    boolean assignPermission(Object entity, Collection<SysUser> userList, boolean isAdd);

    boolean assignDepartPermission(Object entity, Collection<MdcProduction> departments, boolean isAdd);
}



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

@@ -123,4 +123,8 @@
     * @return
     */
    List<DocInfo> getByPartsInfo(TreeInfoRequest treeInfoRequest);

    boolean assignPermission(Object entity, Collection<SysUser> userList, boolean isAdd);

    boolean assignDepartPermission(Object entity, Collection<MdcProduction> departments, boolean isAdd);
}

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

@@ -118,4 +118,8 @@
     */
    List<DocInfo> getByProcessSpecVersion(TreeInfoRequest treeInfoRequest);


    boolean assignPermission(Object entity, Collection<SysUser> userList, boolean isAdd);

    boolean assignDepartPermission(Object entity, Collection<MdcProduction> departments, boolean isAdd);
}

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

@@ -157,4 +157,8 @@
     * @return
     */
    List<DocInfo> getByProcessStreamNCFile(TreeInfoRequest treeInfoRequest);

    boolean assignPermission(Object entity, Collection<SysUser> userList, boolean isAdd);

    boolean assignDepartPermission(Object entity, Collection<MdcProduction> departments, boolean isAdd);
}

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

@@ -118,4 +118,8 @@
     */
    List<DocInfo> getByWorkStepNCFile(TreeInfoRequest treeInfoRequest);


    boolean assignPermission(Object entity, Collection<SysUser> userList, boolean isAdd);

    boolean assignDepartPermission(Object entity, Collection<MdcProduction> departments, boolean isAdd);
}

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

@@ -703,4 +703,21 @@
        });
        return Result.ok("部件借用成功");
    }

    @Override
    public boolean assignPermission(Object entity, Collection<SysUser> userList, boolean isAdd){
        if (isAdd) {
            return assignAddUser((ComponentInfo) entity, userList);
        } else {
            return assignRemoveUser((ComponentInfo) entity, userList);
        }
    }
    @Override
    public boolean assignDepartPermission(Object entity, Collection<MdcProduction> departments, boolean isAdd) {
        if (isAdd) {
            return assignAddDepart((ComponentInfo) entity, departments);
        } else {
            return assignRemoveDepart((ComponentInfo) entity, departments);
        }
    }
}

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

@@ -133,7 +133,7 @@
        if (partsInfo!=null){
            guideCardBatch.setPartsCode(partsInfo.getPartsCode());
            guideCardBatch.setPartsName(partsInfo.getPartsName());
            guideCardBatch.setMaterielDesp(partsInfo.getMaterielDesp());
            guideCardBatch.setMaterielDesp(partsInfo.getStructureType());
        }
        guideCardBatch.setFlowStatus("0");
        guideCardBatch.setCompiler(user.getUsername());

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

@@ -497,4 +497,21 @@
        }
        return docInfos;
    }

    @Override
    public boolean assignPermission(Object entity, Collection<SysUser> userList, boolean isAdd){
        if (isAdd) {
            return assignAddUser((PartsInfo) entity, userList);
        } else {
            return assignRemoveUser((PartsInfo) entity, userList);
        }
    }
    @Override
    public boolean assignDepartPermission(Object entity, Collection<MdcProduction> departments, boolean isAdd) {
        if (isAdd) {
            return assignAddDepart((PartsInfo) entity, departments);
        } else {
            return assignRemoveDepart((PartsInfo) entity, departments);
        }
    }
}

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

@@ -525,4 +525,21 @@
        }
        return docInfos;
    }

    @Override
    public boolean assignPermission(Object entity, Collection<SysUser> userList, boolean isAdd){
        if (isAdd) {
            return assignAddUser((ProcessSpecVersion) entity, userList);
        } else {
            return assignRemoveUser((ProcessSpecVersion) entity, userList);
        }
    }
    @Override
    public boolean assignDepartPermission(Object entity, Collection<MdcProduction> departments, boolean isAdd) {
        if (isAdd) {
            return assignAddDepart((ProcessSpecVersion) entity, departments);
        } else {
            return assignRemoveDepart((ProcessSpecVersion) entity, departments);
        }
    }
}

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

@@ -564,4 +564,21 @@
        return null;
    }

    @Override
    public boolean assignPermission(Object entity, Collection<SysUser> userList, boolean isAdd){
        if (isAdd) {
            return assignAddUser((ProcessStream) entity, userList);
        } else {
            return assignRemoveUser((ProcessStream) entity, userList);
        }
    }
    @Override
    public boolean assignDepartPermission(Object entity, Collection<MdcProduction> departments, boolean isAdd) {
        if (isAdd) {
            return assignAddDepart((ProcessStream) entity, departments);
        } else {
            return assignRemoveDepart((ProcessStream) entity, departments);
        }
    }

}

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

@@ -1283,1154 +1283,276 @@
        }
    }

    private void handleRelativePermissions(String productId, List<String> componentIds, String processId, String partsId,String psvId ,Collection<SysUser> userList) {
        List<ComponentPermission> componentPermissionList = new ArrayList<>();
        List<PartsPermission> partsPermissionList = new ArrayList<>();
        List<ProcessSpecVersionPermission> processSpecVersionPermissionList = new ArrayList<>();
        List<ProcessionPermission> processionPermissionList = new ArrayList<>();
        List<WorkStepPermission> workStepPermissionList = new ArrayList<>();
        List<PermissionStreamNew> 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<ProcessSpecVersion> processSpecVersionList = processSpecVersionService.getByPartsIds(partsIds);
                if (processSpecVersionList!= null &&!processSpecVersionList.isEmpty()) {
                    List<String> psvIds = processSpecVersionList.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
                    handlePsvPermissions(psvIds, userList, processSpecVersionPermissionList, permissionStreamList);
                }
                List<ProcessStream> processStreamList = processStreamService.getByComponentIdList(productId, componentIds, partsIds);
                processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
            }
    /**
     * 添加权限
     */
    private boolean handleProductInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        return handlePermission(paramId, 1, relativeFlag, mdcProductionList, userList, true);
        }

        // 处理零件权限
        if (partsId != null) {
            List<ProcessSpecVersion> processStreamList = processSpecVersionService.list(new QueryWrapper<ProcessSpecVersion>().eq("id", psvId));
            if (processStreamList != null && !processStreamList.isEmpty()) {
                List<String> psvIds = processStreamList.stream()
                        .map(ProcessSpecVersion::getId)
                        .collect(Collectors.toList());
                handlePsvPermissions(psvIds,userList,processSpecVersionPermissionList,permissionStreamList);
            }
    private boolean handleComponentInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        return handlePermission(paramId, 2, relativeFlag, mdcProductionList, userList, true);
        }

        // 处理工艺规程版本权限
        if (psvId!= null) {
            List<ProcessStream> processStreamList = processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", psvId));
            processStreamApi(productId, userList, processionPermissionList, workStepPermissionList, permissionStreamList, processStreamList);
    private boolean handlePartsInfo(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        return handlePermission(paramId, 3, relativeFlag, mdcProductionList, userList, true);
        }

        // 处理工序权限
        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);
            }
    private boolean handleProcessSpecVersion(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        return handlePermission(paramId, 4, relativeFlag, mdcProductionList, userList, true);
        }

        if (!componentPermissionList.isEmpty()) {
            componentPermissionService.saveBatch(componentPermissionList);
        }
        if (!partsPermissionList.isEmpty()) {
            partsPermissionService.saveBatch(partsPermissionList);
        }
        if (!processSpecVersionPermissionList.isEmpty()) {
            processSpecVersionPermissionService.saveBatch(processSpecVersionPermissionList);
        }
        if (!processionPermissionList.isEmpty()) {
            iProcessStreamPermissionService.saveBatch(processionPermissionList);
        }
        if (!workStepPermissionList.isEmpty()) {
            iWorkStepPermissionService.saveBatch(workStepPermissionList);
        }
        if (!permissionStreamList.isEmpty()) {
            permissionStreamNewService.saveBatch(permissionStreamList);
        }
    private boolean handleProcessStream(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        return handlePermission(paramId, 5, relativeFlag, mdcProductionList, userList, true);
    }

    private void processStreamApi(String productId, Collection<SysUser> userList, List<ProcessionPermission> processionPermissionList,
                                  List<WorkStepPermission> workStepPermissionList, List<PermissionStreamNew> 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 boolean handleWorkStep(String paramId, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        return handlePermission(paramId, 6, null, mdcProductionList, userList, true);
    }

    private void handleComponentPermissions(List<String> componentIds, Collection<SysUser> userList,
                                            List<ComponentPermission> componentPermissionList, List<PermissionStreamNew> 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());
            PermissionStreamNew s = new PermissionStreamNew();
            s.setBusinessId(cpInfo.getComponentId());
            s.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
            s.setUserId(cp.getUserId());
            permissionStreamList.add(s);
        }

    /**
     * 移除权限
     */
    private boolean handleProductInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        return handlePermission(paramId, 1, relativeFlag, mdcProductionList, userList, false);
    }

    private void handlePartsPermissions(List<String> partsIds, Collection<SysUser> userList,
                                        List<PartsPermission> partsPermissionList, List<PermissionStreamNew> 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());
            PermissionStreamNew s = new PermissionStreamNew();
            s.setBusinessId(ptInfo.getPartsId());
            s.setBusinessType(DocAttributionTypeEnum.PARTS.getCode().toString());
            s.setUserId(pp.getUserId());
            permissionStreamList.add(s);
        }
    private boolean handleComponentInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        return handlePermission(paramId, 2, relativeFlag, mdcProductionList, userList, false);
    }

    private void handlePsvPermissions(List<String> psvIds, Collection<SysUser> userList,
                                        List<ProcessSpecVersionPermission> processSpecVersionPermissionList, List<PermissionStreamNew> permissionStreamList) {
        Map<String, ProcessSpecVersionPermission> processSpecVersionPermissionMap = new HashMap<>();
        Map<String, ProcessSpecVersion> processStreamMap = new HashMap<>();
        String key;
        for (ProcessSpecVersion p : processSpecVersionService.listByIds(psvIds)) {
            processStreamMap.put(p.getId(), p);
            for (SysUser u : userList) {
                key = p.getId() + "," + u.getId();
                processSpecVersionPermissionMap.put(key, new ProcessSpecVersionPermission(p.getId(), u.getId()));
            }
        }
        List<ProcessSpecVersionPermission> processSpecVersionPermissions = processSpecVersionPermissionService.getByPsvIdsAndUserIds(psvIds, userList.stream().map(SysUser::getId).collect(Collectors.toList()));
        if (processSpecVersionPermissions != null && !processSpecVersionPermissions.isEmpty()) {
            for (ProcessSpecVersionPermission processionPermission : processSpecVersionPermissions) {
                key = processionPermission.getPsvId() + "," + processionPermission.getUserId();
                processSpecVersionPermissionMap.remove(key);
            }
        }
        for (Map.Entry<String, ProcessSpecVersionPermission> entry : processSpecVersionPermissionMap.entrySet()) {
            ProcessSpecVersionPermission pp = entry.getValue();
            processSpecVersionPermissionList.add(pp);
            ProcessSpecVersion processSpecVersion = processStreamMap.get(pp.getPsvId());
            PermissionStreamNew s = new PermissionStreamNew();
            s.setBusinessId(processSpecVersion.getId());
            s.setBusinessType(DocAttributionTypeEnum.OPERATION.getCode().toString());
            s.setUserId(pp.getUserId());
            permissionStreamList.add(s);
        }
    private boolean handlePartsInfoRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        return handlePermission(paramId, 3, relativeFlag, mdcProductionList, userList, false);
    }

    private void handleProcessPermissions(List<String> processIds, Collection<SysUser> userList,
                                          List<ProcessionPermission> processionPermissionList, List<PermissionStreamNew> 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());
            PermissionStreamNew s = new PermissionStreamNew();
            s.setBusinessId(processStream.getProcessId());
            s.setBusinessType(DocAttributionTypeEnum.PROCESS.getCode().toString());
            s.setUserId(pp.getUserId());
            permissionStreamList.add(s);
        }
    private boolean handleProcessSpecVersionRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        return handlePermission(paramId, 4, relativeFlag, mdcProductionList, userList, false);
    }

    private void handleWorkStepPermissions(List<String> workStepIds, Collection<SysUser> userList,
                                           List<WorkStepPermission> workStepPermissionList, List<PermissionStreamNew> 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()));
    private boolean handleProcessStreamRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        return handlePermission(paramId, 5, relativeFlag, mdcProductionList, userList, false);
            }

    private boolean handleWorkStepRemoval(String paramId, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        return handlePermission(paramId, 6, null, mdcProductionList, userList, false);
        }
        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);

    /**
    * 通用权限处理方法
    */
    private boolean handlePermission(String paramId, int type, Integer relativeFlag,
                                     Collection<MdcProduction> mdcProductionList,
                                     Collection<SysUser> userList, boolean isAddOperation) {

        // 获取实体和进行存在性检查
        Object entity = getEntityById(type, paramId);
        if (entity == null) {
            throwExceptionForType(type);
            }

        // 权限检查
        String entityId = getEntityId(entity, type);
        if (!checkProductPerm(type, entityId)) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
        }
        for (Map.Entry<String, WorkStepPermission> entry : workStepPermissionHashMap.entrySet()) {
            WorkStepPermission ws = entry.getValue();
            workStepPermissionList.add(ws);
            WorkStep workStep = workStepHashMap.get(ws.getStepId());
            PermissionStreamNew s = new PermissionStreamNew();
            s.setBusinessId(workStep.getId());
            s.setBusinessType(DocAttributionTypeEnum.WORKSITE.getCode().toString());
            s.setUserId(ws.getUserId());
            permissionStreamList.add(s);

        // 获取子节点列表
        List<ProductMix> productMixList = productMixService.getChildrenList(entityId);
        boolean result;

        // 执行用户/部门的权限操作
        if (userList != null) {
            result = executeUserPermissionOperation(entity, type, userList, isAddOperation);
            handleChildrenPermission(productMixList, relativeFlag, userList, null, isAddOperation);
        } else {
            result = executeDepartmentPermissionOperation(entity, type, mdcProductionList, isAddOperation);
            handleChildrenPermission(productMixList, relativeFlag, null, mdcProductionList, isAddOperation);
        }

        if (!result) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
        }

        return true;
    }

    /**
     * 处理子节点权限
    */
    private void handleChildrenPermission(List<ProductMix> productMixList, Integer relativeFlag,
                                          Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList,
                                          boolean isAddOperation) {
        if (relativeFlag != 1) return;

        productMixList.forEach(productMix -> {
            int childType = productMix.getTreeType();
            executeChildPermissionOperation(String.valueOf(productMix.getId()), childType, userList, mdcProductionList, isAddOperation);
        });
    }

    /**
        * 根据类型执行子节点权限操作
    */
    private void executeChildPermissionOperation(String id, int type,
                                                 Collection<SysUser> userList,
                                                 Collection<MdcProduction> mdcProductionList,
                                                 boolean isAddOperation) {
        switch (type) {
            case 2: // 组件
                ComponentInfo componentInfo = componentInfoService.getById(id);
                if (userList != null) {
                    componentInfoService.assignPermission(componentInfo, userList, isAddOperation);
                } else {
                    componentInfoService.assignDepartPermission(componentInfo, mdcProductionList, isAddOperation);
                }
                break;
            case 3: // 零件
                PartsInfo partsInfo = partsInfoService.getById(id);
                if (userList != null) {
                    partsInfoService.assignPermission(partsInfo, userList, isAddOperation);
                } else {
                    partsInfoService.assignDepartPermission(partsInfo, mdcProductionList, isAddOperation);
                }
                break;
            case 4: // 工艺规范
                ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(id);
                if (userList != null) {
                    processSpecVersionService.assignPermission(processSpecVersion, userList, isAddOperation);
                } else {
                    processSpecVersionService.assignDepartPermission(processSpecVersion, mdcProductionList, isAddOperation);
                }
                break;
            case 5: // 工序
                ProcessStream processStream = processStreamService.getById(id);
                if (userList != null) {
                    processStreamService.assignPermission(processStream, userList, isAddOperation);
                } else {
                    processStreamService.assignDepartPermission(processStream, mdcProductionList, isAddOperation);
                }
                break;
            case 6: // 工步
                WorkStep workStep = workStepService.getById(id);
                if (userList != null) {
                    workStepService.assignPermission(workStep, userList, isAddOperation);
                } else {
                    workStepService.assignDepartPermission(workStep, mdcProductionList, isAddOperation);
                }
                break;
        }
    }

    /**
     * 添加权限
     * 根据类型获取实体
     */

    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 Object getEntityById(int type, String paramId) {
        switch (type) {
            case 1: return super.getById(paramId);  // 产品
            case 2: return componentInfoService.getById(paramId);  // 组件
            case 3: return partsInfoService.getById(paramId);  // 零件
            case 4: return processSpecVersionService.getById(paramId);  // 工艺规范
            case 5: return processStreamService.getById(paramId);  // 工序
            case 6: return workStepService.getById(paramId);  // 工步
            default: return null;
        }
    }

    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,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, permissionStreamNewService);
            }
    /**
     * 根据类型抛出异常
    */
    private void throwExceptionForType(int type) {
        switch (type) {
            case 1: ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            case 2: ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            case 3: ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            case 4: ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
            case 5: ExceptionCast.cast(ProcessInfoCode.PROCESS_NOT_EXIST);
            case 6: ExceptionCast.cast(ProcessInfoCode.WORKSTEP_NOT_EXIST);
        }
        return true;
    }

    private boolean handleProcessSpecVersion(String paramId, Integer relativeFlag, Collection<MdcProduction> mdcProductionList,Collection<SysUser> userList) {
        ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
        if (processSpecVersion == null) {
            ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
        }
        boolean hasPerm = checkProductPerm(4, processSpecVersion.getId());
        if (!hasPerm) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
        }
        boolean result;
        if (userList!=null){
            result = processSpecVersionService.assignAddUser(processSpecVersion, userList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelativePermissions(processSpecVersion.getProductId(), null, null,null, processSpecVersion.getId(), userList);
            }
        }else {
            result = processSpecVersionService.assignAddDepart(processSpecVersion, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelatedPermissionsForProcessSpecVersion(processSpecVersion, mdcProductionList);
            }
    /**
     * 获取实体ID
    */
    private String getEntityId(Object entity, int type) {
        switch (type) {
            case 1: return ((ProductInfo) entity).getProductId();
            case 2: return ((ComponentInfo) entity).getComponentId();
            case 3: return ((PartsInfo) entity).getPartsId();
            case 4: return ((ProcessSpecVersion) entity).getId();
            case 5: return ((ProcessStream) entity).getProcessId();
            case 6: return ((WorkStep) entity).getId();
            default: return null;
        }
        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(),null, userList);
            }
        }else {
            result = partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleRelatedPermissionsForParts(partsInfo, mdcProductionList);
            }
    /**
     * 执行用户权限操作
    */
    private boolean executeUserPermissionOperation(Object entity, int type,
                                                   Collection<SysUser> userList,
                                                   boolean isAddOperation) {
        switch (type) {
            case 1:
                return isAddOperation ?
                        assignAddUser((ProductInfo) entity, userList) :
                        assignRemoveUser((ProductInfo) entity, userList);
            case 2:
                return isAddOperation ?
                        componentInfoService.assignAddUser((ComponentInfo) entity, userList) :
                        componentInfoService.assignRemoveUser((ComponentInfo) entity, userList);
            case 3:
                return isAddOperation ?
                        partsInfoService.assignAddUser((PartsInfo) entity, userList) :
                        partsInfoService.assignRemoveUser((PartsInfo) entity, userList);
            case 4:
                return isAddOperation ?
                        processSpecVersionService.assignAddUser((ProcessSpecVersion) entity, userList) :
                        processSpecVersionService.assignRemoveUser((ProcessSpecVersion) entity, userList);
            case 5:
                return isAddOperation ?
                        processStreamService.assignAddUser((ProcessStream) entity, userList) :
                        processStreamService.assignRemoveUser((ProcessStream) entity, userList);
            case 6:
                return isAddOperation ?
                        workStepService.assignAddUser((WorkStep) entity, userList) :
                        workStepService.assignRemoveUser((WorkStep) entity, userList);
            default: return false;
        }
        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, 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,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, IPermissionStreamNewService permissionStreamNewService) {
        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<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
        for (Map.Entry<String, WorkStepDepartment> entry : allPermissions.entrySet()) {
            WorkStepDepartment wsDep = entry.getValue();
            newWorkStepDepartments.add(wsDep);
            WorkStep workStep = workStepMap.get(wsDep.getStepId());
            PermissionStreamNew permStream = new PermissionStreamNew();
            permStream.setBusinessId(workStep.getId());
            permStream.setBusinessType(DocAttributionTypeEnum.WORKSITE.getCode().toString());
            permStream.setDepartId(wsDep.getDepartId());
            newPermissionStreams.add(permStream);
        }
        if (!newWorkStepDepartments.isEmpty()) {
            workStepDepartmentService.saveBatch(newWorkStepDepartments);
        }
        if (!newPermissionStreams.isEmpty()) {
            permissionStreamNewService.saveBatch(newPermissionStreams);
        }
    }

    private void handleRelatedPermissionsForParts(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
        // 处理工艺规程版本
        List<ProcessSpecVersion> processSpecVersionList = processSpecVersionService.list(new QueryWrapper<ProcessSpecVersion>().eq("parts_id", partsInfo.getPartsId()));
        processSpecVersionList.forEach(item->{
            processSpecVersionService.assignAddDepart(item, mdcProductionList);
            handleRelatedPermissionsForProcessSpecVersion(item, mdcProductionList);
        });
    }

    private void handleRelatedPermissionsForProcessSpecVersion(ProcessSpecVersion processSpecVersion, Collection<MdcProduction> mdcProductionList) {
        // 处理工序权限
        handleProcessPermissions(processSpecVersion,null, mdcProductionList);
        // 处理工步权限
        handleWorkStepPermissions(processSpecVersion, mdcProductionList);

    }

    private void handleProcessPermissions(ProcessSpecVersion processSpecVersion,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("psv_id", processSpecVersion.getId()));
        }
        if (processStreamList == null || processStreamList.isEmpty()) {
            return;
        }
        processStreamList.forEach(item->{
            handleRelatedPermissions(item, mdcProductionList, workStepService, workStepDepartmentService, permissionStreamNewService);
        });
        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<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
        for (Map.Entry<String, ProcessionDepartment> entry : allProcessPermissions.entrySet()) {
            ProcessionDepartment procDep = entry.getValue();
            newProcessPermissions.add(procDep);
            ProcessStream processStream = processStreamMap.get(procDep.getProcessId());
            PermissionStreamNew permStream = new PermissionStreamNew();
            permStream.setBusinessId(processStream.getProcessId());
            permStream.setBusinessType(DocAttributionTypeEnum.PROCESS.getCode().toString());
            permStream.setDepartId(procDep.getDepartId());
            newPermissionStreams.add(permStream);
        }

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

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

    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<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
        for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
            ComponentDepartment compDep = entry.getValue();
            newComponentPermissions.add(compDep);
            ComponentInfo componentInfo = componentInfoMap.get(compDep.getComponentId());
            PermissionStreamNew permStream = new PermissionStreamNew();
            permStream.setBusinessId(componentInfo.getComponentId());
            permStream.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
            permStream.setDepartId(compDep.getDepartId());
            newPermissionStreams.add(permStream);
        }

        if (!newComponentPermissions.isEmpty()) {
            componentDepartmentService.saveBatch(newComponentPermissions);
        }
        if (!newPermissionStreams.isEmpty()) {
            permissionStreamNewService.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<PermissionStreamNew> newPermissionStreams = new ArrayList<>();
            for (Map.Entry<String, ComponentDepartment> entry : allComponentPermissions.entrySet()) {
                ComponentDepartment compDep = entry.getValue();
                newComponentPermissions.add(compDep);
                childComponent = componentInfoMap.get(compDep.getComponentId());
                PermissionStreamNew permStream = new PermissionStreamNew();
                permStream.setBusinessId(childComponent.getComponentId());
                permStream.setBusinessType(DocAttributionTypeEnum.COMPONENT.getCode().toString());
                permStream.setDepartId(compDep.getDepartId());
                newPermissionStreams.add(permStream);
            }

            if (!newComponentPermissions.isEmpty()) {
                componentDepartmentService.saveBatch(newComponentPermissions);
            }
            if (!newPermissionStreams.isEmpty()) {
                permissionStreamNewService.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) {
            partsInfoService.assignAddDepart(partsInfo, mdcProductionList);
            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 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 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) {
                handlePartRelatedRemovals(partsInfo, userList);
            }
        }else {
            result = partsInfoService.assignRemoveDepart(partsInfo, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handlePartRelatedDepartmentRemovals(partsInfo, mdcProductionList);
            }
        }
        return true;
    }

    private boolean handleProcessSpecVersionRemoval(String paramId, Integer relativeFlag, Collection<SysUser> userList, Collection<MdcProduction> mdcProductionList) {
        ProcessSpecVersion processSpecVersion = processSpecVersionService.getById(paramId);
        if (processSpecVersion == null) {
            ExceptionCast.cast(PartsInfoCode.PROCESSSPECVERSION_NOT_EXIST);
        }
        checkProductPerm(4, processSpecVersion.getPartsId());
        boolean result;
        if (userList!=null){
            result = processSpecVersionService.assignRemoveUser(processSpecVersion, userList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleProcessSpecVersionRelatedRemovals(null,processSpecVersion, userList);
            }
        }else {
            result = processSpecVersionService.assignRemoveDepart(processSpecVersion, mdcProductionList);
            if (!result) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if (relativeFlag == 1) {
                handleProcessSpecVersionRelatedDepartmentRemovals(null,processSpecVersion, mdcProductionList);
            }
        }
        return true;
    }

    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, permissionStreamNewService,
                        "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, permissionStreamNewService,
                        "process_id");
            }
        }
        return true;
    }

    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 void handleRelatedRemovals(String parentId, Collection<SysUser> userList,
                                       IWorkStepService workStepService,
                                       IWorkStepPermissionService workStepPermissionService,
                                       IPermissionStreamNewService permissionStreamNewService,
                                       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<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(workStepIds, userIdList,"6");

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

    private void handleRelatedDepartmentRemovals(String parentId, Collection<MdcProduction> mdcProductionList,
                                                 IWorkStepService workStepService,
                                                 IWorkStepDepartmentService workStepDepartmentService,
                                                 IPermissionStreamNewService permissionStreamNewService,
                                                 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<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(workStepIds, departmentIdList,"6");

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

    private void handleProcessSpecVersionRelatedRemovals(ComponentInfo componentInfo,ProcessSpecVersion processSpecVersion,Collection<SysUser> userList) {
        List<ProcessStream> processStreamList =new ArrayList<>();
        String productId="";
        if (processSpecVersion!=null){
            processStreamList= processStreamService.list(new QueryWrapper<ProcessStream>().eq("psv_id", processSpecVersion.getId()));
            productId=processSpecVersion.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<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(processIds, userIdList,"5");

        if (!processionPermissions.isEmpty()) {
            iProcessStreamPermissionService.removeByCollection(processionPermissions);
        }
        if (!permissionStreams.isEmpty()) {
            permissionStreamNewService.deletePermissionStreamNewByList(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<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(processIds, departmentIdList,"5");

        if (!processionDepartments.isEmpty()) {
            processionDepartmentService.removeByCollection(processionDepartments);
        }
        if (!permissionStreams.isEmpty()) {
            permissionStreamNewService.deletePermissionStreamNewByList(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, permissionStreamNewService, "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, permissionStreamNewService, "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->{
            handleProcessSpecVersionRelatedRemovals(item,null, userList);
        });
    }

    private void handlePartRelatedRemovals(PartsInfo partsInfo, Collection<SysUser> userList) {
        List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByPartsId(partsInfo.getPartsId());
        if (processSpecVersions!=null){
            List<String> psvIds = processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
            handleProcessSpecVersionRemovals(psvIds, userList);
            processSpecVersions.forEach(item->{
                handleProcessSpecVersionRelatedRemovals(null,item, userList);
            });
        }
    }

    private void handlePartRelatedDepartmentRemovals(PartsInfo partsInfo, Collection<MdcProduction> mdcProductionList) {
        List<ProcessSpecVersion> processSpecVersions = processSpecVersionService.getByPartsId(partsInfo.getPartsId());
        if (processSpecVersions!=null){
            List<String> psvIds = processSpecVersions.stream().map(ProcessSpecVersion::getId).collect(Collectors.toList());
            handleProcessSpecVersionDepartmentRemovals(psvIds, mdcProductionList);
            processSpecVersions.forEach(item->{
                handleProcessSpecVersionRelatedDepartmentRemovals(null,item, mdcProductionList);
            });
        }
    }

    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->{
            handleProcessSpecVersionRelatedDepartmentRemovals(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<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(componentIds, userIdList,"2");

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

    private void handleProcessSpecVersionRemovals(List<String> psvIds, Collection<SysUser> userList) {
        if (psvIds.isEmpty()) {
            return;
        }
        List<String> userIdList = userList.stream().map(SysUser::getId).collect(Collectors.toList());
        List<ProcessSpecVersionPermission> processSpecVersionPermissions = processSpecVersionPermissionService.getByPsvIdsAndUserIds(psvIds, userIdList);
        List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndUserIds(psvIds, userIdList,"4");
        if (!processSpecVersionPermissions.isEmpty()) {
            processSpecVersionPermissionService.removeByCollection(processSpecVersionPermissions);
        }
        if (!permissionStreams.isEmpty()) {
            permissionStreamNewService.deletePermissionStreamNewByList(permissionStreams);
        }
    }

    private void handleProcessSpecVersionDepartmentRemovals(List<String> psvIds, Collection<MdcProduction> mdcProductionList) {
        if (psvIds.isEmpty()) {
            return;
        }
        List<String> departmentIdList = mdcProductionList.stream().map(MdcProduction::getId).collect(Collectors.toList());
        List<ProcessSpecVersionDepartment> processSpecVersionDepartments =processSpecVersionDepartmentService.getByPsvIdsAndDepartIds(psvIds, departmentIdList);
        List<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(psvIds, departmentIdList,"4");
        if (!processSpecVersionDepartments.isEmpty()) {
            processSpecVersionDepartmentService.removeByCollection(processSpecVersionDepartments);
        }
        if (!permissionStreams.isEmpty()) {
            permissionStreamNewService.deletePermissionStreamNewByList(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<PermissionStreamNew> permissionStreams = permissionStreamNewService.loadPermissionStreamNewByBusinessIdsAndDepartIds(componentIds, departmentIdList,"2");

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

    private void handlePartsRemovals(String productId, List<String> componentIds,Collection<SysUser> userList) {
        List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
        if (partsInfoList!=null){
            partsInfoList.forEach(item->{
                partsInfoService.assignRemoveUser(item,userList);
                //删除
                handlePartRelatedRemovals(item, userList);
            });
        }
    }
    private void handlePartsDepartmentRemovals(String productId, List<String> componentIds, Collection<MdcProduction> mdcProductionList) {
        List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productId, componentIds);
        if (partsInfoList!=null) {
            partsInfoList.forEach(item->{
                partsInfoService.assignRemoveDepart(item,mdcProductionList);
                handlePartRelatedDepartmentRemovals(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->{
                    handleProcessSpecVersionRelatedDepartmentRemovals(item,null, mdcProductionList);
                });
            }
        }else {
            handleComponentRemovals(componentIds, userList);
            handlePartsRemovals(componentInfo.getProductId(), componentIds, userList);
            if (childrenList != null) {
                childrenList.forEach(item->{
                    handleProcessSpecVersionRelatedRemovals(item,null, userList);
                });
            }
        }
    }

    private void handleProcessSpecVersionRelatedDepartmentRemovals(ComponentInfo componentInfo,ProcessSpecVersion processSpecVersion, 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("psv_id", processSpecVersion.getId()));
            productId=processSpecVersion.getProductId();
    /**
     * 执行部门权限操作
    */
    private boolean executeDepartmentPermissionOperation(Object entity, int type,
                                                         Collection<MdcProduction> mdcProductionList,
                                                         boolean isAddOperation) {
        switch (type) {
            case 1:
                return isAddOperation ?
                        assignAddDepartment((ProductInfo) entity, mdcProductionList) :
                        assignRemoveDepartment((ProductInfo) entity, mdcProductionList);
            case 2:
                return isAddOperation ?
                        componentInfoService.assignAddDepart((ComponentInfo) entity, mdcProductionList) :
                        componentInfoService.assignRemoveDepart((ComponentInfo) entity, mdcProductionList);
            case 3:
                return isAddOperation ?
                        partsInfoService.assignAddDepart((PartsInfo) entity, mdcProductionList) :
                        partsInfoService.assignRemoveDepart((PartsInfo) entity, mdcProductionList);
            case 4:
                return isAddOperation ?
                        processSpecVersionService.assignAddDepart((ProcessSpecVersion) entity, mdcProductionList) :
                        processSpecVersionService.assignRemoveDepart((ProcessSpecVersion) entity, mdcProductionList);
            case 5:
                return isAddOperation ?
                        processStreamService.assignAddDepart((ProcessStream) entity, mdcProductionList) :
                        processStreamService.assignRemoveDepart((ProcessStream) entity, mdcProductionList);
            case 6:
                return isAddOperation ?
                        workStepService.assignAddDepart((WorkStep) entity, mdcProductionList) :
                        workStepService.assignRemoveDepart((WorkStep) entity, mdcProductionList);
            default: return false;
        }
        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/WorkStepServiceImpl.java

@@ -482,4 +482,20 @@
        return new ArrayList<>();
    }

    @Override
    public boolean assignPermission(Object entity, Collection<SysUser> userList, boolean isAdd){
        if (isAdd) {
            return assignAddUser((WorkStep) entity, userList);
        } else {
            return assignRemoveUser((WorkStep) entity, userList);
        }
    }
    @Override
    public boolean assignDepartPermission(Object entity, Collection<MdcProduction> departments, boolean isAdd) {
        if (isAdd) {
            return assignAddDepart((WorkStep) entity, departments);
        } else {
            return assignRemoveDepart((WorkStep) entity, departments);
        }
    }
}