/*
|
* Copyright (c) 2018-2025, ztt All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are met:
|
*
|
* Redistributions of source code must retain the above copyright notice,
|
* this list of conditions and the following disclaimer.
|
* Redistributions in binary form must reproduce the above copyright
|
* notice, this list of conditions and the following disclaimer in the
|
* documentation and/or other materials provided with the distribution.
|
* Neither the name of the pig4cloud.com developer nor the names of its
|
* contributors may be used to endorse or promote products derived from
|
* this software without specific prior written permission.
|
* Author: ztt
|
*/
|
package com.chinaztt.mes.technology.service.impl;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.chinaztt.mes.basic.entity.Part;
|
import com.chinaztt.mes.basic.mapper.PartMapper;
|
import com.chinaztt.mes.common.handler.StateMachineHandler;
|
import com.chinaztt.mes.common.numgen.NumberGenerator;
|
import com.chinaztt.mes.common.util.StateResult;
|
import com.chinaztt.mes.technology.dto.BomDTO;
|
import com.chinaztt.mes.technology.dto.StructureTree;
|
import com.chinaztt.mes.technology.entity.*;
|
import com.chinaztt.mes.technology.excel.BomData;
|
import com.chinaztt.mes.technology.mapper.*;
|
import com.chinaztt.mes.technology.service.BomService;
|
import com.chinaztt.mes.technology.state.bom.BomStateMachineConfig;
|
import com.chinaztt.mes.technology.state.bom.constant.BomEvents;
|
import com.chinaztt.mes.technology.state.bom.constant.BomStateStringValues;
|
import com.chinaztt.mes.technology.state.bom.constant.BomStates;
|
import com.chinaztt.ztt.common.core.util.R;
|
import lombok.AllArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.messaging.Message;
|
import org.springframework.messaging.support.MessageBuilder;
|
import org.springframework.statemachine.config.StateMachineFactory;
|
import org.springframework.statemachine.persist.StateMachinePersister;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Propagation;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
|
/**
|
* 完整bom树
|
*
|
* @author zhangxy
|
* @date 2021-05-07 15:08:17
|
*/
|
@Service
|
@AllArgsConstructor
|
@Transactional(rollbackFor = Exception.class)
|
@Slf4j
|
public class BomServiceImpl extends ServiceImpl<BomMapper, Bom> implements BomService {
|
|
private NumberGenerator<Bom> numberGenerator;
|
|
/**
|
* 随机ID，前端用
|
*/
|
public volatile static long RANDOM_ID = 0;
|
|
/**
|
* 循环层级，最多10层防止出现死循环
|
*/
|
public static final int CYCLE_DEEP = 10;
|
|
private PartMapper partMapper;
|
|
private OperationMapper operationMapper;
|
|
private StructureMapper structureMapper;
|
|
private BomComponentMapper bomComponentMapper;
|
|
private StructureComponentMapper structureComponentMapper;
|
|
private StateMachineFactory<BomStates, BomEvents> bomStateMachineFactory;
|
|
private StateMachinePersister<BomStates, BomEvents, Bom> persister;
|
|
|
@Override
|
public void importExcel(List<BomData> list) {
|
if (CollectionUtil.isEmpty(list)) {
|
return;
|
}
|
for (BomData data : list) {
|
Bom bom = new Bom();
|
bom.setInsulationColor(data.getInsulationColor());
|
bom.setSheathColor(data.getSheathColor());
|
bom.setCharacteristicOne(data.getCharacteristicOne());
|
String partNo = data.getPartNo();
|
if (StringUtils.isBlank(data.getPartNo()) || StringUtils.isBlank(data.getVersion())) {
|
log.error("bom导入:" + data + "零件号为空");
|
continue;
|
}
|
//零件号和版本号查询唯一
|
Part part = partMapper.selectOne(Wrappers.<Part>lambdaQuery()
|
.eq(Part::getPartNo, partNo).eq(Part::getEngChgLevel, data.getVersion()));
|
if (null == part) {
|
log.error("bom导入 :" + data + "零件不存在");
|
continue;
|
}
|
bom.setPartId(part.getId());
|
bom.setVersion(data.getVersion());
|
bom.setNumber(numberGenerator.generateNumberWithPrefix(Bom.DIGIT, Bom.PREFIX, Bom::getNumber));
|
bom.setState(BomStateStringValues.DRAFT);
|
baseMapper.insert(bom);
|
//查询构建树数据
|
saveBomComp(getAllBomExt(bom, 999), bom);
|
}
|
}
|
|
|
@Override
|
public IPage<List<BomDTO>> getPage(Page page, QueryWrapper<BomDTO> ew) {
|
return baseMapper.getBomPage(page, ew);
|
}
|
|
@Override
|
public R<BomDTO> saveBom(BomDTO bomDTO) {
|
Bom bom = new Bom();
|
BeanUtils.copyProperties(bomDTO, bom);
|
if (StringUtils.isBlank(bom.getNumber())) {
|
bom.setNumber(numberGenerator.generateNumberWithPrefix(Bom.DIGIT, Bom.PREFIX, Bom::getNumber));
|
}
|
bom.setState(BomStateStringValues.DRAFT);
|
baseMapper.insert(bom);
|
saveBomComp(bomDTO.getTree(), bom);
|
return R.ok(getBomDtoById(bom.getId()));
|
}
|
|
/**
|
* @Author: Hans
|
* @Description: 根据产品结构保存所有BOM
|
* @Date: 2022-06-01
|
*/
|
@Override
|
@Transactional(propagation = Propagation.NOT_SUPPORTED)
|
public R<Boolean> saveALLBom(List<Structure> structures) {
|
structures.forEach(structure -> {
|
// Structure structure = structures.get(i);
|
Bom bom = new Bom();
|
bom.setPartId(structure.getPartId());
|
bom.setBomTypeDb(structure.getBomTypeDb());
|
bom.setVersion(structure.getVersion());
|
bom.setAlternativeNo(structure.getAlternativeNo());
|
bom.setAlternativeDesc(structure.getAlternativeDesc());
|
//log.info("第一层========================》"+bom);
|
StructureTree tree = getAllBomExt(bom, 999);
|
BomDTO bomDTO = new BomDTO();
|
BeanUtils.copyProperties(bom, bomDTO);
|
bomDTO.setTree(tree);
|
//BomDTO bomDTO = getBomDtoById(structure.getPartId());
|
log.info("bomDto============>"+bomDTO);
|
saveBom(bomDTO);
|
});
|
return R.ok();
|
}
|
|
//插入头BomComp
|
@Override
|
public void saveBomComp(StructureTree structureTree, Bom bom) {
|
BomComponent bomComp = new BomComponent();
|
bomComp.setParentStructureId(structureTree.getStructureId());
|
bomComp.setQpa(structureTree.getQpa());
|
bomComp.setOriginalQpa(structureTree.getOriginalQpa());
|
bomComp.setUnit(structureTree.getUnit());
|
bomComp.setPartId(structureTree.getPartId());
|
bomComp.setBomId(bom.getId());
|
bomComp.setPlanningMethod(structureTree.getPlanningMethod());
|
bomComp.setColor(structureTree.getColor());
|
bomComp.setOperationId(structureTree.getOperationId());
|
|
bomComp.setSharpenerNo(structureTree.getSharpenerNo());
|
bomComp.setCaveNum(structureTree.getCaveNum());
|
bomComp.setGramWeight(structureTree.getGramWeight());
|
bomComp.setGateGramWeight(structureTree.getGateGramWeight());
|
bomComp.setMoldingCycle(structureTree.getMoldingCycle());
|
bomComp.setMachine(structureTree.getMachine());
|
bomComp.setScale(structureTree.getScale());
|
bomComp.setDryingTime(structureTree.getDryingTime());
|
bomComp.setDryingTemperature(structureTree.getDryingTemperature());
|
bomComp.setPackingInfo(structureTree.getPackingInfo());
|
|
bomComponentMapper.insert(bomComp);
|
saveChildren(structureTree.getChildren(), bomComp.getId(), bom, structureTree.getPartId());
|
}
|
|
@Override
|
public R<Boolean> updateBom(BomDTO bomDTO) {
|
Bom bom = new Bom();
|
BeanUtils.copyProperties(bomDTO, bom);
|
baseMapper.updateById(bom);
|
bomComponentMapper.delete(Wrappers.<BomComponent>lambdaQuery().eq(BomComponent::getBomId, bomDTO.getId()));
|
saveBomComp(bomDTO.getTree(), bom);
|
return R.ok();
|
}
|
|
/**
|
* @param children 子节点list
|
* @param parentId 父节点id
|
* @param bom 根BOM
|
* @param parentPartId 父节点的零件号
|
*/
|
private void saveChildren(List<StructureTree> children, Long parentId, Bom bom, Long parentPartId) {
|
if (CollectionUtil.isEmpty(children)) {
|
return;
|
}
|
Part parentPart = partMapper.selectById(parentPartId);
|
log.error("parentId=======>"+parentPartId);
|
log.error("bomParentId====>"+bom);
|
////"P" 虚拟件的意思 在一个BOM中，除根节点外，其余节点若不是虚拟件（零件【计划方法】不为P 和 K），则禁止为其增加子件。
|
//if (!bom.getPartId().equals(parentPartId)) {
|
// if (!"P".equals(parentPart.getPlanningMethod()) && !"K".equals(parentPart.getPlanningMethod())) {
|
// throw new RuntimeException(parentPart.getPartNo() + parentPart.getPartName() + "为非虚拟件，不可添加子件");
|
// }
|
//}
|
for (StructureTree child : children) {
|
BomComponent bomComp = new BomComponent();
|
bomComp.setQpa(child.getQpa());
|
bomComp.setParentStructureId(child.getStructureId());
|
bomComp.setOriginalQpa(child.getOriginalQpa());
|
bomComp.setUnit(child.getUnit());
|
bomComp.setPartId(child.getPartId());
|
bomComp.setParent(parentId);
|
bomComp.setBomId(bom.getId());
|
bomComp.setOperationId(child.getOperationId());
|
bomComp.setPlanningMethod(child.getPlanningMethod());
|
bomComp.setDiscNum(child.getDiscNum());
|
|
bomComp.setSharpenerNo(child.getSharpenerNo());
|
bomComp.setCaveNum(child.getCaveNum());
|
bomComp.setGramWeight(child.getGramWeight());
|
bomComp.setGateGramWeight(child.getGateGramWeight());
|
bomComp.setMoldingCycle(child.getMoldingCycle());
|
bomComp.setMachine(child.getMachine());
|
bomComp.setScale(child.getScale());
|
bomComp.setDryingTime(child.getDryingTime());
|
bomComp.setDryingTemperature(child.getDryingTemperature());
|
bomComp.setPackingInfo(child.getPackingInfo());
|
|
bomComponentMapper.insert(bomComp);
|
saveChildren(child.getChildren(), bomComp.getId(), bom, child.getPartId());
|
}
|
}
|
|
/**
|
* @author hans
|
* @date 2022-5-24
|
* 添加bomLayers，设置BOM默认递归查询层数
|
*/
|
@Override
|
public StructureTree getAllBomExt(Bom bom, int bomLayers) {
|
log.info("生成树=======》");
|
Long partId = bom.getPartId();
|
String version = bom.getVersion();
|
String alternativeNo = bom.getAlternativeNo();
|
String bomType = bom.getBomTypeDb();
|
// 判断获取BOM的三个关键字段是否为空
|
if (null == partId || version == null || alternativeNo == null) {
|
return null;
|
}
|
if (RANDOM_ID >= Integer.MAX_VALUE) {
|
RANDOM_ID = 0;
|
}
|
// 获取BOM根节点
|
StructureTree root = getRootNode(partId);
|
//通过产品结构查工序
|
Map<Long, Integer> cache = new HashMap<>(80);
|
getStructureByPartId(root, partId, cache, version, alternativeNo, bomType, bomLayers);
|
return root;
|
}
|
|
/**
|
* @Author: Hans
|
* @Description: 获取BOM根节点
|
* @Date: 2022-06-01
|
*/
|
private StructureTree getRootNode(Long partId) {
|
log.info("获取bom根节点====》"+partId);
|
Part part = partMapper.selectById(partId);
|
log.info("父级零件====》"+part);
|
StructureTree root = new StructureTree();
|
root.setPartName(part.getPartName());
|
root.setPlanningMethod(part.getPlanningMethod());
|
root.setPartId(part.getId());
|
root.setQpa(BigDecimal.ONE);
|
root.setOriginalQpa(BigDecimal.ONE);
|
root.setId(++RANDOM_ID);
|
root.setParentId(0L);
|
root.setExpand(true);
|
root.setStructureId(0L);
|
root.setUnit(part.getUnit());
|
root.setChecked(false);
|
|
return root;
|
}
|
|
/**
|
* @Author: Hans
|
* @Description: 通过零件ID查询所有版本和替代的BOM
|
* @Date: 2022-06-02
|
*/
|
@Override
|
public StructureTree getAllBomByPartId(Long partId) {
|
if (RANDOM_ID >= Integer.MAX_VALUE) {
|
RANDOM_ID = 0;
|
}
|
Part part = partMapper.selectById(partId);
|
StructureTree root = new StructureTree();
|
root.setPartName(part.getPartName());
|
root.setPartId(part.getId());
|
root.setPartNo(part.getPartNo());
|
root.setQpa(BigDecimal.ONE);
|
root.setOriginalQpa(BigDecimal.ONE);
|
root.setId(++RANDOM_ID);
|
root.setParentId(0L);
|
root.setExpand(true);
|
root.setStructureId(0L);
|
root.setUnit(part.getUnit());
|
root.setChecked(false);
|
//通过产品结构查工序
|
Map<Long, Integer> cache = new HashMap<>(80);
|
// 版本version为ALL：查询所有版本的产品结构，替代为ALL：查询所有替代的产品结构
|
getStructureByPartId(root, partId, cache, "ALL", "ALL", null, 999);
|
return root;
|
}
|
|
public Bom copyBom(Long id) {
|
Bom bom = baseMapper.selectById(id);
|
bom.setNumber(numberGenerator.generateNumberWithPrefix(Bom.DIGIT, Bom.PREFIX, Bom::getNumber));
|
List<BomComponent> bomCompList = bomComponentMapper.selectList(Wrappers.<BomComponent>lambdaQuery().eq(BomComponent::getBomId, id));
|
baseMapper.insert(bom);
|
if (CollectionUtil.isNotEmpty(bomCompList)) {
|
for (BomComponent bomComponent : bomCompList) {
|
bomComponent.setBomId(bom.getId());
|
bomComponentMapper.insert(bomComponent);
|
}
|
}
|
return bom;
|
}
|
|
@Override
|
public BomDTO getBomDtoById(Long id) {
|
Bom bom = baseMapper.selectById(id);
|
log.info("getBomDtoById=>>>"+bom);
|
//如果存在未绑定工序的 工艺路线 则会为空
|
List<StructureTree> nodes = baseMapper.getBomComponents4Tree(id);
|
if (CollectionUtil.isEmpty(nodes)) {
|
return null;
|
}
|
StructureTree root = nodes.stream().filter(e -> e.getParentId() == null || e.getParentId() == 0).findFirst().get();
|
log.info("root=======>"+root);
|
setChildren(root, nodes);
|
log.info("setChildren后========》"+root);
|
Part part = partMapper.selectById(bom.getPartId());
|
BomDTO bomDto = new BomDTO();
|
BeanUtils.copyProperties(bom, bomDto);
|
bomDto.setTree(root);
|
bomDto.setPartName(part.getPartName());
|
bomDto.setPartNo(part.getPartNo());
|
return bomDto;
|
}
|
|
|
private void setChildren(StructureTree node, List<StructureTree> list) {
|
List<StructureTree> children = list.stream().filter(e -> e.getParentId() != null && e.getParentId().equals(node.getId())).collect(Collectors.toList());
|
if (CollectionUtil.isEmpty(children)) {
|
return;
|
}
|
node.setChildren(children);
|
children.forEach(e -> {
|
setChildren(e, list);
|
});
|
}
|
|
@Override
|
public R<Boolean> delete(List<Long> ids) {
|
for (Long id : ids) {
|
bomComponentMapper.delete(Wrappers.<BomComponent>lambdaQuery().eq(BomComponent::getBomId, id));
|
}
|
baseMapper.deleteBatchIds(ids);
|
return R.ok();
|
}
|
|
@Override
|
public List<BomComponent> getComponentsById(Long bomId) {
|
return bomComponentMapper.selectList(Wrappers.<BomComponent>lambdaQuery().eq(BomComponent::getBomId, bomId));
|
}
|
|
@Override
|
public boolean changeState(List<Long> ids, String event) {
|
for (Long id : ids) {
|
Bom bom = baseMapper.selectById(id);
|
Message<BomEvents> message = MessageBuilder.withPayload(BomEvents.valueOf(event)).setHeader("bom", bom).build();
|
StateMachineHandler handler = new StateMachineHandler(bomStateMachineFactory, persister, BomStateMachineConfig.MACHINE_ID, bom);
|
StateResult res = handler.sendEvent(message, bom.getId());
|
if (!res.isSuccess()) {
|
throw new RuntimeException(res.getMsg());
|
}
|
}
|
return true;
|
}
|
|
/*private void getStructureByPartId(StructureTree parent, Long partId, Map<Long, Integer> cache, int bomLayers) {
|
Integer cycleCount = cache.get(partId) == null ? 0 : cache.get(partId);
|
if (cycleCount >= CYCLE_DEEP) {
|
return;
|
} else {
|
cache.put(partId, cycleCount + 1);
|
}
|
//根据零件找到结构主表
|
List<Structure> structures = structureMapper.selectList(Wrappers.<Structure>lambdaQuery().eq(Structure::getPartId, partId));
|
if (CollectionUtil.isNotEmpty(structures)) {
|
for (Structure s : structures) {
|
List<StructureComponent> components = structureComponentMapper.selectList(Wrappers.<StructureComponent>lambdaQuery().eq(StructureComponent::getStructureId, s.getId())
|
.orderByAsc(StructureComponent::getId));
|
if (CollectionUtil.isEmpty(components)) {
|
return;
|
}
|
BigDecimal parentQpa = parent.getQpa();
|
List<StructureTree> children = parent.getChildren() == null ? new ArrayList<>() : parent.getChildren();
|
|
// 遍历一层减少一层
|
bomLayers--;
|
for (StructureComponent c : components) {
|
Part part = partMapper.selectById(c.getPartId());
|
Operation operation = operationMapper.selectById(c.getOperationId());
|
if (part == null) {
|
continue;
|
}
|
StructureTree child = new StructureTree();
|
child.setId(++RANDOM_ID);
|
child.setParentId(parent.getId());
|
child.setCompId(c.getId());
|
child.setStructureId(s.getId());
|
child.setPartId(c.getPartId());
|
child.setPartNo(part.getPartNo());
|
child.setPartName(part.getPartName());
|
child.setExpand(true);
|
child.setUnit(part.getUnit());
|
child.setChecked(false);
|
child.setQpa(c.getQpa().multiply(parentQpa).setScale(8, BigDecimal.ROUND_HALF_UP));
|
child.setOriginalQpa(c.getQpa());
|
child.setDiscNum(null == c.getDiscNum() ? null : c.getDiscNum());
|
if (null != operation) {
|
child.setOperationId(operation.getId());
|
child.setOperationNo(operation.getOperationNo());
|
child.setOperationName(operation.getName());
|
}
|
// 判断到第几层了
|
if (bomLayers > 0)
|
getStructureByPartId(child, c.getPartId(), cache, bomLayers);
|
children.add(child);
|
}
|
parent.setChildren(children);
|
}
|
}
|
}*/
|
|
/**
|
* @Author: Hans
|
* @Description: 查询root节点
|
* @Date: 2022-06-02
|
*/
|
private List<Structure> getRootNodes(Long partId, String version, String alternativeNo, String bomType) {
|
List<Structure> structures = null;
|
if (version.equals("ALL") && alternativeNo.equals("ALL")) {
|
// 根据零件号查询
|
structures = structureMapper.selectList(Wrappers.<Structure>lambdaQuery().eq(Structure::getPartId,
|
partId).eq(StringUtils.isNotBlank(bomType), Structure::getBomTypeDb, bomType));
|
} else if (alternativeNo.equals("ALL")) {
|
// 根据零件号、版本号查询
|
structures = structureMapper.selectList(Wrappers.<Structure>lambdaQuery().eq(Structure::getPartId, partId).
|
eq(Structure::getVersion, version).eq(StringUtils.isNotBlank(bomType), Structure::getBomTypeDb,
|
bomType));
|
} else if (version.equals("ALL")) {
|
// 根据零件号、替代号查询
|
structures = structureMapper.selectList(Wrappers.<Structure>lambdaQuery().eq(Structure::getPartId, partId).
|
eq(Structure::getAlternativeNo, alternativeNo).eq(StringUtils.isNotBlank(bomType),
|
Structure::getBomTypeDb, bomType));
|
} else {
|
// 根据零件号、版本号、替代号查询
|
structures = structureMapper.selectList(Wrappers.<Structure>lambdaQuery()
|
.eq(Structure::getPartId, partId)
|
.eq(Structure::getVersion, version)
|
.eq(Structure::getAlternativeNo, alternativeNo)
|
.eq(StringUtils.isNotBlank(bomType), Structure::getBomTypeDb, bomType));
|
}
|
return structures;
|
}
|
|
/**
|
* @Author: Hans
|
* @Description: 填充BOM树
|
* @Date: 2022-06-02
|
*/
|
private void fillBomTree() {
|
|
}
|
|
/**
|
* @Author: Hans
|
* @Description: 填充child节点数据
|
* @Date: 2022-06-02
|
*/
|
private StructureTree fillChildNode(StructureTree parent, StructureComponent component, Structure structure, Part part) {
|
StructureTree child = new StructureTree();
|
Operation operation = operationMapper.selectById(component.getOperationId());
|
BigDecimal parentQpa = parent.getQpa();
|
child.setId(++RANDOM_ID);
|
child.setParentId(parent.getId());
|
child.setCompId(component.getId());
|
child.setStructureId(structure.getId());
|
child.setPartId(component.getPartId());
|
child.setColor(component.getColor());
|
|
child.setSharpenerNo(component.getSharpenerNo());
|
child.setCaveNum(component.getCaveNum());
|
child.setGramWeight(component.getGramWeight());
|
child.setGateGramWeight(component.getGateGramWeight());
|
child.setMoldingCycle(component.getMoldingCycle());
|
child.setMachine(component.getMachine());
|
child.setScale(component.getScale());
|
child.setDryingTime(component.getDryingTime());
|
child.setDryingTemperature(component.getDryingTemperature());
|
child.setPackingInfo(component.getPackingInfo());
|
|
child.setPartNo(part.getPartNo());
|
child.setPartName(part.getPartName());
|
child.setExpand(true);
|
child.setUnit(part.getUnit());
|
child.setPlanningMethod(component.getPlanningMethod());
|
child.setChecked(false);
|
child.setQpa(component.getQpa().multiply(parentQpa).setScale(8, BigDecimal.ROUND_HALF_UP));
|
child.setOriginalQpa(component.getQpa());
|
child.setDiscNum(null == component.getDiscNum() ? null : component.getDiscNum());
|
if (null != operation) {
|
child.setOperationId(operation.getId());
|
child.setOperationNo(operation.getOperationNo());
|
child.setOperationName(operation.getName());
|
}
|
|
return child;
|
}
|
|
/**
|
* @Author: Hans
|
* @Description: 重写获取产品结构方法
|
* @Date: 2022-06-02
|
*/
|
private void getStructureByPartId(StructureTree parent, Long partId, Map<Long, Integer> cache, String version,
|
String alternativeNo, String bomType, int bomLayers) {
|
log.info("每层树===================》"+parent);
|
Integer cycleCount = cache.get(partId) == null ? 0 : cache.get(partId);
|
if (cycleCount >= CYCLE_DEEP) {
|
return;
|
} else {
|
cache.put(partId, cycleCount + 1);
|
}
|
//根据零件找到结构主表
|
List<Structure> structures = getRootNodes(partId, version, alternativeNo, bomType);
|
log.info("得到结构=========》"+structures);
|
if (CollectionUtil.isNotEmpty(structures)) {
|
for (Structure structure : structures) {
|
|
parent.setSharpenerNo(structure.getSharpenerNo());
|
parent.setCaveNum(structure.getCaveNum());
|
parent.setGramWeight(structure.getGramWeight());
|
parent.setGateGramWeight(structure.getGateGramWeight());
|
parent.setMoldingCycle(structure.getMoldingCycle());
|
parent.setMachine(structure.getMachine());
|
parent.setScale(structure.getScale());
|
parent.setDryingTime(structure.getDryingTime());
|
parent.setDryingTemperature(structure.getDryingTemperature());
|
parent.setPackingInfo(structure.getPackingInfo());
|
|
// 查询BOM子节点
|
List<StructureComponent> components = structureComponentMapper.selectList(Wrappers.<StructureComponent>lambdaQuery().
|
eq(StructureComponent::getStructureId, structure.getId())
|
.orderByAsc(StructureComponent::getId));
|
if (CollectionUtil.isEmpty(components)) {
|
return;
|
}
|
List<StructureTree> children = parent.getChildren() == null ? new ArrayList<>() : parent.getChildren();
|
// 遍历一层减少一层，999代表不做限制可以一直递归
|
if (bomLayers < 999) {
|
bomLayers--;
|
}
|
for (StructureComponent component : components) {
|
Part part = partMapper.selectById(component.getPartId());
|
if (part == null) {
|
continue;
|
}
|
// 填充child节点数据
|
StructureTree child = fillChildNode(parent, component, structure, part);
|
log.info("节点数据====================》"+child);
|
if (bomLayers == 999) {
|
getStructureByPartId(child, component.getPartId(), cache, "ALL", "ALL", bomType, bomLayers);
|
// 判断到第几层了，制造类型为1-已制造，计划方法为P-虚拟件
|
} else if (bomLayers > 0 && (part.getMaterialType().equals("1") && !part.getPlanningMethod().equals(
|
"A"))) {
|
getStructureByPartId(child, component.getPartId(), cache, "ALL", "ALL", bomType, bomLayers);
|
}
|
children.add(child);
|
}
|
parent.setChildren(children);
|
}
|
}
|
}
|
}
|
