Merge branch 'mdc_hyjs_master'

zhangherong

2025-06-25 23855599412c4d61b38d78f0f3abd3430a48b5b1

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

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

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.FillRuleConstant;
import org.jeecg.common.system.vo.DictModel;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.FillRuleUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.mapper.MdcProductionEquipmentMapper;
import org.jeecg.modules.system.mapper.MdcProductionMapper;
import org.jeecg.modules.system.mapper.MdcUserProductionMapper;
import org.jeecg.modules.system.mapper.SysUserMapper;
import org.jeecg.modules.system.model.MdcProductionTreeModel;
import org.jeecg.modules.system.model.ProductionIdModel;
import org.jeecg.modules.system.service.IMdcProductionService;
import org.jeecg.modules.system.service.ISysDictService;
import org.jeecg.modules.system.service.ISysParamsService;
import org.jeecg.modules.system.util.FindsProductionsChildrenUtil;
import org.jeecg.modules.system.vo.MdcProOptionsVo;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Description: äº§çº¿è¡¨
 * @Author: liuS
 * @Date: 2023-03-23
 * @Version: V1.0
 */
@Service
public class MdcProductionServiceImpl extends ServiceImpl<MdcProductionMapper, MdcProduction> implements IMdcProductionService {

    @Resource
    private SysUserMapper sysUserMapper;

    @Resource
    private MdcUserProductionMapper userProductionMapper;

    @Resource
    private MdcProductionEquipmentMapper productionEquipmentMapper;

    @Resource
    private ISysParamsService sysParamsService;

    @Resource
    private ISysDictService sysDictService;
    /**
     * queryTreeList å¯¹åº” queryTreeList æŸ¥è¯¢æ‰€æœ‰çš„产线数据,以树结构形式响应给前端
     */
    @Override
    @Cacheable(value = "mdc:cache:production:alldata")
    public List<MdcProductionTreeModel> queryTreeList() {
        LambdaQueryWrapper<MdcProduction> query = new LambdaQueryWrapper<MdcProduction>();
        query.eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        query.orderByAsc(MdcProduction::getProductionOrder);
        List<MdcProduction> list = this.list(query);
        //设置用户id，让前台显示
        this.setUserIdsByProList(list);
        //调用wrapTreeDataToTreeList方法生成树状数据
        return FindsProductionsChildrenUtil.wrapTreeDataToTreeList(list);
    }

    /**
     * æŸ¥è¯¢æ‰€æœ‰äº§çº¿ä¿¡æ¯ï¼Œå¹¶åˆ†èŠ‚点进行显示(添加系统配置)
     */
    @Override
    public List<MdcProductionTreeModel> queryTreeListByConfig(){
        SysParams sysParams = sysParamsService.getSysPramBySettingKey("dnc_production");
        LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        LambdaQueryWrapper<MdcProduction> query = new LambdaQueryWrapper<MdcProduction>();
        if (sysParams == null) {
            return null;
        }else {
            List<String> productionIds = new ArrayList<>();
            if (!("admin").equals(loginUser.getUsername())) {
                //不是超级管理员，获取用户拥有的产线
                if (loginUser.getProductionIds() != null) {
                    if (loginUser.getProductionIds().contains(",")) {
                        productionIds = Arrays.asList(loginUser.getProductionIds().split(","));
                    } else {
                        productionIds = Collections.singletonList(loginUser.getProductionIds());
                    }
                }
            }
            if (("0").equals(sysParams.getSettingValue())){
                query.eq(MdcProduction::getOrgType,"2");
                query.in(!productionIds.isEmpty(), MdcProduction::getId, productionIds);
                query.eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
                query.orderByAsc(MdcProduction::getProductionOrder);
                List<MdcProduction> list = this.list(query);
                //设置用户id，让前台显示
                this.setUserIdsByProList(list);
                //封装一级树
                List<MdcProductionTreeModel> listResult = new ArrayList<>();
                for (MdcProduction production : list) {
                    if (production.getDescription().isEmpty()){
                        production.setDescription("");
                    }
                    listResult.add(new MdcProductionTreeModel(production));
                }
                //调用wrapTreeDataToTreeList方法生成树状数据
                return listResult;
            }else {
                query.eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
                query.orderByAsc(MdcProduction::getProductionOrder);
                List<MdcProduction> list = this.list(query);
                //设置用户id，让前台显示
                this.setUserIdsByProList(list);
                //调用wrapTreeDataToTreeList方法生成树状数据
                return FindsProductionsChildrenUtil.wrapTreeDataToTreeList(list);
            }
        }
    }

    /**
     * queryTreeList æ ¹æ®äº§çº¿id查询,前端回显调用
     */
    @Override
    public List<MdcProductionTreeModel> queryTreeList(String ids) {
        List<MdcProductionTreeModel> listResult = new ArrayList<>();
        LambdaQueryWrapper<MdcProduction> query = new LambdaQueryWrapper<MdcProduction>();
        query.eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        if (oConvertUtils.isNotEmpty(ids)) {
            query.in(true, MdcProduction::getId, ids.split(","));
        }
        query.orderByAsc(MdcProduction::getProductionOrder);
        List<MdcProduction> list = this.list(query);
        for (MdcProduction production : list) {
            if (production.getDescription().isEmpty()){
                production.setDescription("");
            }
            listResult.add(new MdcProductionTreeModel(production));
        }
        return listResult;
    }

    @Override
    @Cacheable(value = "mdc:cache:production:allids")
    public List<ProductionIdModel> queryProductionIdTreeList() {
        LambdaQueryWrapper<MdcProduction> query = new LambdaQueryWrapper<>();
        query.eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        query.orderByAsc(MdcProduction::getProductionOrder);
        List<MdcProduction> list = this.list(query);
        //调用wrapTreeDataToTreeList方法生成树状数据
        return FindsProductionsChildrenUtil.wrapTreeDataToProductionIdTreeList(list);
    }

    /**
     * æ ¹æ®å…³é”®å­—搜索相关的部门数据
     */
    @Override
    public List<MdcProductionTreeModel> searchByKeyWord(String keyWord) {
        LambdaQueryWrapper<MdcProduction> query = new LambdaQueryWrapper<>();
        List<MdcProductionTreeModel> newList = new ArrayList<>();
        query.like(MdcProduction::getProductionName, keyWord);
        MdcProductionTreeModel model = new MdcProductionTreeModel();
        List<MdcProduction> productionList = this.list(query);
        if (!productionList.isEmpty()) {
            for (MdcProduction mdcProduction : productionList) {
                model = new MdcProductionTreeModel(mdcProduction);
                model.setChildren(null);
                newList.add(model);
            }
            return newList;
        }
        return Collections.emptyList();
    }

    /**
     * saveProductionData å¯¹åº” add ä¿å­˜ç”¨æˆ·åœ¨é¡µé¢æ·»åŠ çš„新的产线对象数据
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveProductionData(MdcProduction mdcProduction) {
        if (mdcProduction != null) {
            if (mdcProduction.getParentId() == null) {
                mdcProduction.setParentId("");
            }
            mdcProduction.setId(IdWorker.getIdStr(mdcProduction));
            // å…ˆåˆ¤æ–­è¯¥å¯¹è±¡æœ‰æ— çˆ¶çº§ID,有则意味着不是最高级,否则意味着是最高级
            // èŽ·å–父级ID
            String parentId = mdcProduction.getParentId();
            JSONObject formData = new JSONObject();
            formData.put("parentId",parentId);
            String[] codeArray = (String[]) FillRuleUtil.executeRule(FillRuleConstant.PRODUCTION,formData);
            mdcProduction.setOrgCode(codeArray[0]);
            String orgType = codeArray[1];
            mdcProduction.setOrgType(String.valueOf(orgType));
            mdcProduction.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
            this.save(mdcProduction);

            //处理存在父子关系 mdc标记统一的问题
            //1.mdc标记 ä¸º 1 å¼€å¯ çˆ¶çº§èŠ‚点要统一开启
            //2.mdc标记 ä¸º 0 å…³é—­ å­çº§èŠ‚点要统一关闭  æ–°å¢žæ“ä½œ ä¸å­˜åœ¨æ­¤æƒ…况
            if(StringUtils.isNotBlank(parentId) && CommonConstant.DEFAULT_1.equals(mdcProduction.getMdcFlag())){
                openParentMdcFlag(parentId);
            }
        }
    }

    /**
     * updateProductionDataById å¯¹åº” edit æ ¹æ®äº§çº¿ä¸»é”®æ¥æ›´æ–°å¯¹åº”的产线数据
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateProductionDataById(MdcProduction mdcProduction) {
        if (mdcProduction != null) {
            this.updateById(mdcProduction);

            //处理存在父子关系 mdc标记统一的问题
            //1.mdc标记 ä¸º 1 å¼€å¯ çˆ¶çº§èŠ‚点要统一开启
            //2.mdc标记 ä¸º 0 å…³é—­ å­çº§èŠ‚点要统一关闭
            String parentId = mdcProduction.getParentId();
            if(StringUtils.isNotBlank(parentId) && CommonConstant.DEFAULT_1.equals(mdcProduction.getMdcFlag())){
                openParentMdcFlag(parentId);
            }
            if(CommonConstant.DEFAULT_0.equals(mdcProduction.getMdcFlag())){
                //关闭
                closeChildrenMdcFlag(mdcProduction.getId());
            }
            return true;
        }
        return false;
    }

    /**
     * æ ¹æ®äº§çº¿id删除并删除其可能存在的子级产线
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean delete(String id) {
        List<String> idList = new ArrayList<>();
        idList.add(id);
        this.checkChildrenExists(id, idList);
        boolean result = this.removeByIds(idList);
        //根据产线id删除用户与产线关系
        userProductionMapper.delete(new LambdaQueryWrapper<MdcUserProduction>().in(MdcUserProduction::getProId, idList));
        //根据产线id删除产线与设备关系
        productionEquipmentMapper.delete(new LambdaQueryWrapper<MdcProductionEquipment>().in(MdcProductionEquipment::getProductionId, idList));
        return result;
    }

    /**
     * æ ¹æ®äº§çº¿id批量删除并删除其可能存在的子级产线
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteBatchWithChildren(List<String> ids) {
        List<String> idList = new ArrayList<>();
        for (String id : ids) {
            idList.add(id);
            this.checkChildrenExists(id, idList);
        }
        this.removeByIds(idList);
        //根据产线id删除用户与产线关系
        userProductionMapper.delete(new LambdaQueryWrapper<MdcUserProduction>().in(MdcUserProduction::getProId, idList));
        //根据产线id删除产线与设备关系
        productionEquipmentMapper.delete(new LambdaQueryWrapper<MdcProductionEquipment>().in(MdcProductionEquipment::getProductionId, idList));
    }

    /**
     * æ ¹æ®id查询下级产线
     */
    @Override
    public List<MdcProduction> queryProdByPid(String pid) {
        return this.baseMapper.queryProdByPid(pid);
    }

    /**
     * é€’归查询所有子节点
     */
    @Override
    public List<MdcProduction> recursionChildrenByPid(String pid){
        List<String> ids=this.recursionChildren(pid);
        return super.list(new LambdaQueryWrapper<MdcProduction>().eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString()).in(MdcProduction::getId, ids));
    }

    /**
     * æ ¹æ®ç”¨æˆ·id获取产线下拉树选项
     */
    @Override
    public List<ProductionIdModel> loadProductionTreeOptions(String userId) {
        //获取所有产线数据
        List<MdcProduction> productionList = this.baseMapper.selectList(new LambdaQueryWrapper<MdcProduction>().eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString()).orderByAsc(MdcProduction::getProductionOrder));
        //根据用户id获取拥有的产线信息集合
        List<String> productionIds = userProductionMapper.queryProductionIdsByUserId(userId);
        List<String> allProductionIds = new ArrayList<>();
        //找到所有产线id的上级id
        if (productionIds != null && !productionIds.isEmpty()) {
            for (String productionId : productionIds) {
                this.getAllProductionIds(productionList, productionId, allProductionIds);
            }
        }
        //过滤产线数据
        List<MdcProduction> list = productionList.stream().filter((MdcProduction mdcProduction) -> allProductionIds.contains(mdcProduction.getId())).collect(Collectors.toList());
        return FindsProductionsChildrenUtil.wrapTreeDataToProductionIdTreeList(list);
    }

    /**
     * é€’归查询所有子节点id
     */
    @Override
    public List<String> recursionChildren(String productionId) {
        return this.baseMapper.recursionChildren(productionId);
    }

    /**
     * æ ¹æ®ç”¨æˆ·id和车间id获取用户拥有的车间id
     * @param userId
     * @param productionId
     * @return
     */
    @Override
    public String findFirstProduction(String userId, String productionId) {
        return this.baseMapper.findFirstProduction(userId, productionId);
    }

    /**
     * æ ¹æ®ç”¨æˆ·id查询用户工段权限
     */
    @Override
    public String findThreeProductionId(String userId) {
        return this.baseMapper.findThreeProductionId(userId);
    }

    /**
     * delete æ–¹æ³•è°ƒç”¨ é€’归查找子集id
     */
    private void checkChildrenExists(String id, List<String> idList) {
        LambdaQueryWrapper<MdcProduction> query = new LambdaQueryWrapper<>();
        query.eq(MdcProduction::getParentId, id);
        List<MdcProduction> productionList = this.list(query);
        if (productionList != null && !productionList.isEmpty()) {
            for (MdcProduction production : productionList) {
                idList.add(production.getId());
                this.checkChildrenExists(production.getId(), idList);
            }
        }
    }

    /**
     * èŽ·å–所有的产线id（包含所有上级）
     */
    private void getAllProductionIds(List<MdcProduction> productionList, String productionId, List<String> allProductionIds) {
        if (!allProductionIds.contains(productionId)) {
            allProductionIds.add(productionId);
        }
        for (MdcProduction mdcProduction : productionList) {
            if (StringUtils.isEmpty(mdcProduction.getParentId())) {
                continue;
            }
            if (productionId.equals(mdcProduction.getId())) {
                if (!allProductionIds.contains(mdcProduction.getParentId())) {
                    allProductionIds.add(mdcProduction.getParentId());
                    getAllProductionIds(productionList, mdcProduction.getParentId(), allProductionIds);
                }
            }
        }
    }

    /**
     * é€šè¿‡äº§çº¿é›†åˆä¸ºäº§çº¿è®¾ç½®ç”¨æˆ·id，用于前台展示
     */
    private void setUserIdsByProList(List<MdcProduction> productionList) {
        //查询负责部门不为空的情况
        LambdaQueryWrapper<SysUser> query = new LambdaQueryWrapper<>();
        query.isNotNull(SysUser::getDepartIds);
        List<SysUser> users = sysUserMapper.selectList(query);
        Map<String, Object> map = new HashMap(5);
        //先循环一遍找到不同的负责产线id
        for (SysUser user : users) {
            String productionIds = user.getProductionIds();
            if (StringUtils.isNotBlank(productionIds)) {
                String[] productionIdArray = productionIds.split(",");
                for (String productionId : productionIdArray) {
                    if (map.containsKey(productionId)) {
                        String userIds = map.get(productionId) + "," + user.getId();
                        map.put(productionId, userIds);
                    } else {
                        map.put(productionId, user.getId());
                    }
                }
            }
        }
        //循环产线集合找到产线id对应的负责用户
        for (MdcProduction mdcProduction : productionList) {
            if (map.containsKey(mdcProduction.getId())) {
                mdcProduction.setDirectorUserIds(map.get(mdcProduction.getId()).toString());
            }
        }
    }

    /**
     *  æŸ¥è¯¢æ‰€æœ‰çˆ¶èŠ‚点和本节点名称
     * @param id
     * @return
     */
    @Override
    public List<String> findListParentTreeAll(String id){
        MdcProductionEquipment mdcProductionEquipment=productionEquipmentMapper.selectOne(new QueryWrapper<MdcProductionEquipment>().eq("equipment_id",id));
        if (mdcProductionEquipment==null) {
            return null;
        }
        List<String> strings = new ArrayList<>();
        MdcProduction en=super.getById(mdcProductionEquipment.getProductionId());
        if (en == null) {
            return null;
        }
        strings.add(en.getProductionName());
        if (StringUtils.isEmpty(en.getParentId())) {
            return strings;
        } else {
            return findListParentTree(en.getParentId(),strings);
        }
    }

    //  æŸ¥è¯¢æ‰€ä»¥çˆ¶èŠ‚点
    @Override
    public List<String> findListParentTree(String parentId,List<String> stringList){
        if (StringUtils.isEmpty(parentId)) {
            return null;
        }
        if (stringList == null || stringList.isEmpty()) {
            stringList = new ArrayList<>();
        }
        boolean p = true;
        if (p) {
            MdcProduction en = super.getById(parentId);
            if (en != null) {
                stringList.add(0,en.getProductionName());
            }
            if (StringUtils.isNotBlank(en.getParentId())) {
                parentId = en.getParentId();
                findListParentTree(parentId,stringList);
            } else {
                p = false;
                return stringList;
            }
        }
        return stringList;
    }

    /**
     * èŽ·å–用户已分配的部门列表
     * @param userId
     * @return
     */
     @Override
     public Map<String, MdcProduction> getUserAssignedDepart(String userId){
         if(StrUtil.isEmpty(userId))
             return null;
         List<MdcProduction> userPermDepart = this.baseMapper.findAllProductionId(userId);
         if(userPermDepart == null || userPermDepart.isEmpty())
             return null;
         Map<String, MdcProduction> map = new HashMap<>();
         userPermDepart.forEach(item -> {
             map.put(item.getId(), item);
         });
         return map;
    }

    /**
     * é€šè¿‡ä¸€ç»„id获取部门
     * @param ids
     * @return
     */
    @Override
    public List<String> findAllProductionIds(List<String> ids){
        return this.baseMapper.recursionChildrenByList(ids);
    }

    @Override
    public List<String> findParentIdsForProduction(String parentId, List<String> idList) {
        if (StringUtils.isEmpty(parentId)) {
            return null;
        }
        if (idList == null || idList.isEmpty()) {
            idList = new ArrayList<>();
        }
        boolean p = true;
        if (p) {
            MdcProduction en = super.getById(parentId);
            if (en != null) {
                idList.add(0, en.getId());
            }
            if (StringUtils.isNotBlank(en.getParentId())) {
                parentId = en.getParentId();
                findParentIdsForProduction(parentId, idList);
            } else {
                p = false;
                return idList;
            }
        }
        return idList;
    }

    @Override
    public List<MdcProductionTreeModel> queryTreeListByMdc(String ids) {
        List<MdcProductionTreeModel> listResult = new ArrayList<>();
        LambdaQueryWrapper<MdcProduction> query = new LambdaQueryWrapper<MdcProduction>();
        query.eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        query.eq(MdcProduction::getMdcFlag, CommonConstant.DEFAULT_1);
        if (oConvertUtils.isNotEmpty(ids)) {
            query.in(true, MdcProduction::getId, ids.split(","));
        }
        query.orderByAsc(MdcProduction::getProductionOrder);
        List<MdcProduction> list = this.list(query);
        for (MdcProduction production : list) {
            if (production.getDescription().isEmpty()){
                production.setDescription("");
            }
            listResult.add(new MdcProductionTreeModel(production));
        }
        return listResult;
    }

    @Override
    public List<MdcProductionTreeModel> queryTreeListByMdc() {
        LambdaQueryWrapper<MdcProduction> query = new LambdaQueryWrapper<MdcProduction>();
        query.eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        query.eq(MdcProduction::getMdcFlag, CommonConstant.DEFAULT_1);
        query.orderByAsc(MdcProduction::getProductionOrder);
        List<MdcProduction> list = this.list(query);
        //设置用户id，让前台显示
        this.setUserIdsByProList(list);
        //调用wrapTreeDataToTreeList方法生成树状数据
        return FindsProductionsChildrenUtil.wrapTreeDataToTreeList(list);
    }

    @Override
    public List<String> findChildren(List<String> mdcProductionIds) {
        return this.baseMapper.findChildren(mdcProductionIds);
    }

    /**
     * æ ¹æ®ç”¨æˆ·id获取产线(中心)或班组下拉选项
     * @param userId
     * @param productionId
     * @return
     */
    @Override
    public List<MdcProOptionsVo> loadProductionOptions(String userId, String productionId) {
        List<MdcProOptionsVo> result = new ArrayList<>();
        List<MdcProduction> mdcProductionList = this.baseMapper.loadProductionOptions(userId, productionId);
        if (mdcProductionList != null && !mdcProductionList.isEmpty()) {
            for (MdcProduction mdcProduction : mdcProductionList) {
                MdcProOptionsVo vo = new MdcProOptionsVo().convert(mdcProduction);
                result.add(vo);
            }
        }
        return result;
    }

    @Override
    public List<MdcProduction> findMdcPros(String userId, String productionId) {
        return this.baseMapper.loadProductionOptions(userId, productionId);
    }

    @Override
    public List<MdcProOptionsVo> loadTeamOptions(String userId, String productionId) {
        List<MdcProOptionsVo> result = new ArrayList<>();
        List<String> productionList = this.findChildren(Arrays.asList(productionId.split(",")));
        if (productionList != null && !productionList.isEmpty()) {
            List<String> dictValues = this.baseMapper.findTeamValue(userId, productionList);
            if (dictValues != null && !dictValues.isEmpty()) {
                List<DictModel> dictModels = sysDictService.queryEnableDictItemsByCode(CommonConstant.DICT_MDC_STAFF_TEAM);
                if (dictModels != null && !dictModels.isEmpty()) {
                    for (DictModel dictModel : dictModels) {
                        if (dictValues.contains(dictModel.getValue())) {
                            MdcProOptionsVo vo = new MdcProOptionsVo();
                            vo.setKey(dictModel.getValue());
                            vo.setValue(dictModel.getValue());
                            vo.setTitle(dictModel.getText());
                            result.add(vo);
                        }
                    }
                }
            }
        }
        return result;
    }

    @Override
    public List<String> findProIdsByUId(String userId, List<String> allProductionIds) {
        return this.baseMapper.findProIdsByUId(userId, allProductionIds);
    }

    /**
     * æ‰“å¼€ çˆ¶èŠ‚点 åŠ ä»¥ä¸Šçš„mdc标记
     * @param parentId
     */
    private void openParentMdcFlag(String parentId) {
        List<String> listParentTree = findParentIdsForProduction(parentId, new ArrayList<>());
        if (!CollectionUtil.isEmpty(listParentTree)) {
            UpdateWrapper<MdcProduction> updateWrapper = new UpdateWrapper<>();
            updateWrapper.in("id", listParentTree);
            updateWrapper.set("mdc_flag", "1");
            super.update(updateWrapper);
        }
    }

    /**
     * å…³é—­æ‰€æœ‰å­èŠ‚点的mdc标记
     * @param productionId
     */
    private void closeChildrenMdcFlag(String productionId) {
        List<String> childrenList = recursionChildren(productionId);
        if (!CollectionUtil.isEmpty(childrenList)) {
            UpdateWrapper<MdcProduction> updateWrapper = new UpdateWrapper<>();
            updateWrapper.in("id", childrenList);
            updateWrapper.set("mdc_flag", "0");
            super.update(updateWrapper);
        }
    }

    @Override
    public List<String> findChildByProId(String productionId) {
        return this.baseMapper.findChildByProId(productionId);
    }

    @Override
    public String findProName(String equipmentId) {
        return this.baseMapper.findProName(equipmentId);
    }

    @Override
    public MdcProduction findByOrgCode(String orgCode){
        return this.baseMapper.selectOne(new LambdaQueryWrapper<MdcProduction>().eq(MdcProduction::getOrgCode, orgCode));
    }
}