package com.ruoyi.technology.service.impl;
|
|
import cn.hutool.core.collection.CollUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
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.ruoyi.basic.pojo.Product;
|
import com.ruoyi.basic.pojo.ProductModel;
|
import com.ruoyi.basic.service.IProductModelService;
|
import com.ruoyi.basic.service.IProductService;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.bean.BeanUtils;
|
import com.ruoyi.common.utils.poi.ExcelUtil;
|
import com.ruoyi.framework.web.domain.R;
|
import com.ruoyi.production.bean.dto.BomImportDto;
|
import com.ruoyi.production.bean.dto.ProductStructureDto;
|
import com.ruoyi.technology.bean.dto.TechnologyBomDto;
|
import com.ruoyi.technology.bean.dto.TechnologyBomStructureDto;
|
import com.ruoyi.technology.bean.vo.TechnologyBomStructureVo;
|
import com.ruoyi.technology.bean.vo.TechnologyBomVo;
|
import com.ruoyi.technology.mapper.TechnologyBomMapper;
|
import com.ruoyi.technology.mapper.TechnologyBomStructureMapper;
|
import com.ruoyi.technology.mapper.TechnologyRoutingMapper;
|
import com.ruoyi.technology.pojo.TechnologyBom;
|
import com.ruoyi.technology.pojo.TechnologyBomStructure;
|
import com.ruoyi.technology.pojo.TechnologyRouting;
|
import com.ruoyi.technology.service.TechnologyBomService;
|
import com.ruoyi.technology.service.TechnologyBomStructureService;
|
import jakarta.servlet.http.HttpServletResponse;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.concurrent.ThreadLocalRandom;
|
import java.util.stream.Collectors;
|
|
@Service
|
@RequiredArgsConstructor
|
public class TechnologyBomServiceImpl extends ServiceImpl<TechnologyBomMapper, TechnologyBom> implements TechnologyBomService {
|
|
private final TechnologyBomMapper technologyBomMapper;
|
private final IProductModelService productModelService;
|
private final TechnologyBomStructureService technologyBomStructureService;
|
private final TechnologyRoutingMapper technologyRoutingMapper;
|
private final IProductService productService;
|
private final TechnologyBomStructureMapper technologyBomStructureMapper;
|
|
/**
|
* 分页查询BOM列表。
|
*/
|
@Override
|
public IPage<TechnologyBomVo> listPage(Page<TechnologyBomDto> page, TechnologyBomDto technologyBomDto) {
|
return technologyBomMapper.listPage(page, technologyBomDto);
|
}
|
|
/**
|
* 根据规格查询BOM并转换为返回对象。
|
*/
|
@Override
|
public List<TechnologyBomVo> listByModel(Long productModelId) {
|
List<TechnologyBom> list = this.list(Wrappers.<TechnologyBom>lambdaQuery()
|
.eq(TechnologyBom::getProductModelId, productModelId));
|
List<TechnologyBomVo> result = new ArrayList<>(list.size());
|
for (TechnologyBom item : list) {
|
TechnologyBomVo vo = new TechnologyBomVo();
|
vo.setId(item.getId());
|
vo.setProductModelId(item.getProductModelId());
|
vo.setRemark(item.getRemark());
|
vo.setVersion(item.getVersion());
|
vo.setCreateTime(item.getCreateTime());
|
vo.setUpdateTime(item.getUpdateTime());
|
vo.setCreateUser(item.getCreateUser());
|
vo.setUpdateUser(item.getUpdateUser());
|
vo.setBomNo(item.getBomNo());
|
vo.setDeptId(item.getDeptId());
|
result.add(vo);
|
}
|
return result;
|
}
|
|
/**
|
* 新增BOM并初始化根结构节点。
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R add(TechnologyBom technologyBom) {
|
validateProductModel(technologyBom.getProductModelId());
|
boolean saved = technologyBomMapper.insert(technologyBom) > 0;
|
if (!saved) {
|
return R.fail("Add BOM failed");
|
}
|
technologyBom.setBomNo("BM." + String.format("%05d", technologyBom.getId()));
|
technologyBomMapper.updateById(technologyBom);
|
initRootStructure(technologyBom.getId().longValue(), technologyBom.getProductModelId());
|
return R.ok();
|
}
|
|
/**
|
* 修改BOM，规格变化时同步刷新关联结构与路线数据。
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R update(TechnologyBom technologyBom) {
|
if (technologyBom.getId() == null) {
|
throw new ServiceException("BOM id is required");
|
}
|
validateProductModel(technologyBom.getProductModelId());
|
TechnologyBom oldBom = technologyBomMapper.selectById(technologyBom.getId());
|
if (oldBom == null) {
|
throw new ServiceException("BOM not found");
|
}
|
if (oldBom.getProductModelId() != null && !oldBom.getProductModelId().equals(technologyBom.getProductModelId())) {
|
technologyRoutingMapper.updateProductModelByBomId(technologyBom.getProductModelId(), technologyBom.getId().longValue());
|
technologyBomStructureService.remove(Wrappers.<TechnologyBomStructure>lambdaQuery()
|
.eq(TechnologyBomStructure::getBomId, technologyBom.getId().longValue()));
|
initRootStructure(technologyBom.getId().longValue(), technologyBom.getProductModelId());
|
}
|
if (technologyBom.getBomNo() == null) {
|
technologyBom.setBomNo(oldBom.getBomNo());
|
}
|
technologyBomMapper.updateById(technologyBom);
|
return R.ok();
|
}
|
|
/**
|
* 删除BOM前校验是否已被工艺路线引用。
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean batchDelete(List<Long> ids) {
|
if (ids == null || ids.isEmpty()) {
|
throw new ServiceException("Select at least one BOM");
|
}
|
List<TechnologyRouting> list = technologyRoutingMapper.selectList(Wrappers.<TechnologyRouting>lambdaQuery()
|
.in(TechnologyRouting::getBomId, ids));
|
if (!list.isEmpty()) {
|
throw new ServiceException("BOM is referenced by routing");
|
}
|
technologyBomStructureService.remove(Wrappers.<TechnologyBomStructure>lambdaQuery()
|
.in(TechnologyBomStructure::getBomId, ids));
|
return this.removeBatchByIds(ids);
|
}
|
|
/**
|
* 校验产品规格是否存在。
|
*/
|
private void validateProductModel(Long productModelId) {
|
if (productModelId == null) {
|
throw new ServiceException("Product model is required");
|
}
|
ProductModel productModel = productModelService.getById(productModelId);
|
if (productModel == null) {
|
throw new ServiceException("Product model not found");
|
}
|
}
|
|
/**
|
* 初始化BOM根节点结构。
|
*/
|
private void initRootStructure(Long bomId, Long productModelId) {
|
ProductModel productModel = productModelService.getById(productModelId);
|
TechnologyBomStructure root = new TechnologyBomStructure();
|
root.setBomId(bomId);
|
root.setParentId(null);
|
root.setProductModelId(productModelId);
|
root.setUnit(productModel.getUnit());
|
root.setUnitQuantity(BigDecimal.ONE);
|
technologyBomStructureService.save(root);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R uploadBom(MultipartFile file) {
|
ExcelUtil<BomImportDto> util = new ExcelUtil<>(BomImportDto.class);
|
List<BomImportDto> list;
|
try {
|
list = util.importExcel(file.getInputStream());
|
} catch (Exception e) {
|
return R.fail("Excel解析失败");
|
}
|
|
if (list == null || list.isEmpty()) return R.fail("数据为空");
|
|
// 处理工序
|
list.forEach(dto -> {
|
dto.setParentName(clean(dto.getParentName()));
|
dto.setParentSpec(clean(dto.getParentSpec()));
|
dto.setChildName(clean(dto.getChildName()));
|
dto.setChildSpec(clean(dto.getChildSpec()));
|
});
|
handleProcess(list);
|
// Map<String, Long> processMap = productProcessService.list().stream()
|
// .collect(Collectors.toMap(ProductProcess::getName, ProductProcess::getId, (k1, k2) -> k1));
|
|
// 创建 BOM 数据
|
BomImportDto first = list.get(0);
|
ProductModel rootModel = findModel(first.getParentName(), first.getParentSpec());
|
TechnologyBom bom = new TechnologyBom();
|
bom.setProductModelId(rootModel.getId());
|
bom.setVersion("1.0");
|
technologyBomMapper.insert(bom);
|
bom.setBomNo("BM." + String.format("%05d", bom.getId()));
|
technologyBomMapper.updateById(bom);
|
|
// 记录已经插入结构的节点：Key = "名称+规格", Value = structure_id
|
Map<String, Long> treePathMap = new HashMap<>();
|
|
for (int i = 0; i < list.size(); i++) {
|
BomImportDto dto = list.get(i);
|
String parentKey = dto.getParentName() + "|" + dto.getParentSpec();
|
String childKey = dto.getChildName() + "|" + dto.getChildSpec();
|
|
//处理根节点,第一行且子项为空
|
if (i == 0 && StringUtils.isBlank(dto.getChildName())) {
|
TechnologyBomStructure rootNode = new TechnologyBomStructure();
|
rootNode.setBomId(bom.getId().longValue());
|
rootNode.setParentId(null); // 顶层没有父节点
|
rootNode.setProductModelId(rootModel.getId());
|
rootNode.setUnitQuantity(BigDecimal.ONE);
|
rootNode.setUnit(rootModel.getUnit());
|
technologyBomStructureService.save(rootNode);
|
|
treePathMap.put(parentKey, rootNode.getId());
|
continue;
|
}
|
|
// 处理子层级节点
|
// 找到父节点在数据库里的 ID
|
Long parentStructureId = treePathMap.get(parentKey);
|
if (parentStructureId == null) {
|
// 如果 Map 里找不到，说明 Excel 顺序乱了或者数据有误
|
throw new ServiceException("导入失败: 父项[" + dto.getParentName() + "]必须在其子项之前定义");
|
}
|
|
// 获取子项模型信息
|
ProductModel childModel = findModel(dto.getChildName(), dto.getChildSpec());
|
|
// 插入结构表
|
TechnologyBomStructure node = new TechnologyBomStructure();
|
node.setBomId(bom.getId().longValue());
|
node.setParentId(parentStructureId); // 父节点ID
|
node.setProductModelId(childModel.getId());
|
node.setUnitQuantity(dto.getUnitQty());
|
node.setUnit(childModel.getUnit());
|
// if (processMap.containsKey(dto.getProcess())) {
|
// node.setProcessId(processMap.get(dto.getProcess()));
|
// }
|
technologyBomStructureService.save(node);
|
|
// 把当前子项记录到 Map,作为以后更深层级的父项查找依据
|
// 同一父项下的同名子项不需要重复记录
|
treePathMap.put(childKey, node.getId());
|
}
|
|
return R.ok("BOM导入成功");
|
}
|
|
|
@Override
|
public void exportBom(HttpServletResponse response, Integer bomId) {
|
if (bomId == null) {
|
return;
|
}
|
|
// List<ProductStructureDto> treeData = productStructureService.listBybomId(bomId);
|
// if (treeData == null || treeData.isEmpty()) {
|
// return;
|
// }
|
//
|
// // 将树形结构扁平化 使用 BFS算法 导出,按层级顺序
|
// List<BomImportDto> exportList = new ArrayList<>();
|
//
|
// // Map<ID, Node> idMap 用于查找父节点
|
// Map<Long, ProductStructureDto> idMap = new HashMap<>();
|
// populateMap(treeData, idMap);
|
//
|
// // treeData 的第一个是根节点
|
// for (ProductStructureDto root : treeData) {
|
// // 添加根节点
|
// BomImportDto rootRow = new BomImportDto();
|
// rootRow.setParentName(root.getProductName());
|
// rootRow.setParentSpec(root.getModel());
|
// rootRow.setUnitQty(root.getUnitQuantity());
|
// rootRow.setRemark("");
|
// exportList.add(rootRow);
|
//
|
// // BFS 遍历-队列
|
// Queue<ProductStructureDto> queue = new LinkedList<>();
|
// if (root.getChildren() != null) {
|
// queue.addAll(root.getChildren());
|
// }
|
//
|
// while (!queue.isEmpty()) {
|
// ProductStructureDto child = queue.poll();
|
//
|
// // 查找父节点
|
// ProductStructureDto parent = idMap.get(child.getParentId());
|
// if (parent == null) {
|
// // 除了最外层节点,其他节点的父类肯定是不会为空的
|
// continue;
|
// }
|
//
|
// BomImportDto row = new BomImportDto();
|
// // 父类信息
|
// row.setParentName(parent.getProductName());
|
// row.setParentSpec(parent.getModel());
|
// // 子类信息
|
// row.setChildName(child.getProductName());
|
// row.setChildSpec(child.getModel());
|
// row.setUnitQty(child.getUnitQuantity());
|
// row.setProcess(child.getProcessName());
|
//
|
// exportList.add(row);
|
//
|
// // 将子节点的子节点加入队列-下一层
|
// if (child.getChildren() != null && !child.getChildren().isEmpty()) {
|
// queue.addAll(child.getChildren());
|
// }
|
// }
|
// }
|
|
ExcelUtil<BomImportDto> util = new ExcelUtil<>(BomImportDto.class);
|
// util.exportExcel(response, exportList, "BOM结构导出");
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R copy(TechnologyBom technologyBom) {
|
TechnologyBom oldTechnologyBom = technologyBomMapper.selectById(technologyBom.getId());
|
List<TechnologyBomStructureVo> oldTechnologyBomStructureVos = technologyBomStructureService.listByBomId(technologyBom.getId().longValue());
|
//校验产品规格是否存在。
|
validateProductModel(oldTechnologyBom.getProductModelId());
|
TechnologyBom newTechnologyBom = new TechnologyBom();
|
newTechnologyBom.setProductModelId(oldTechnologyBom.getProductModelId());
|
newTechnologyBom.setVersion("FZ" + oldTechnologyBom.getVersion());
|
newTechnologyBom.setRemark(oldTechnologyBom.getRemark());
|
boolean saved = technologyBomMapper.insert(newTechnologyBom) > 0;
|
if (!saved) {
|
return R.fail("Copy BOM failed");
|
}
|
newTechnologyBom.setBomNo("BM." + String.format("%05d", newTechnologyBom.getId()));
|
technologyBomMapper.updateById(newTechnologyBom);
|
//初始化BOM根节点结构。
|
initRootStructure(newTechnologyBom.getId().longValue(), newTechnologyBom.getProductModelId());
|
//把产品结构里面的数据也全部都复制
|
TechnologyBomStructureVo technologyBomStructureVo = oldTechnologyBomStructureVos.get(0);
|
TechnologyBomStructureDto technologyBomStructureDto = convertTree(technologyBomStructureVo);
|
technologyBomStructureDto.setBomId(newTechnologyBom.getId().longValue());
|
technologyBomStructureService.addTechnologyBomStructure(technologyBomStructureDto);
|
return R.ok();
|
}
|
|
private ProductModel findModel(String name, String spec) {
|
Product product = productService.getOne(new LambdaQueryWrapper<Product>()
|
.eq(Product::getProductName, name).last("limit 1"));
|
if (product == null) throw new ServiceException("产品未维护：" + name);
|
|
ProductModel model = productModelService.getOne(new LambdaQueryWrapper<ProductModel>()
|
.eq(ProductModel::getProductId, product.getId())
|
.eq(ProductModel::getModel, spec).last("limit 1"));
|
if (model == null) throw new ServiceException("规格未维护：" + name + "[" + spec + "]");
|
return model;
|
}
|
|
private void handleProcess(List<BomImportDto> list) {
|
|
Set<String> processNames = list.stream()
|
.map(BomImportDto::getProcess)
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.toSet());
|
|
if (processNames.isEmpty()) {
|
return;
|
}
|
|
// List<ProductProcess> exists = productProcessService.list(
|
// new LambdaQueryWrapper<ProductProcess>().in(ProductProcess::getName, processNames)
|
// );
|
|
// Set<String> existNames = exists.stream()
|
// .map(ProductProcess::getName)
|
// .collect(Collectors.toSet());
|
//
|
// List<ProductProcess> needSave = processNames.stream()
|
// .filter(n -> !existNames.contains(n))
|
// .map(n -> {
|
// ProductProcess p = new ProductProcess();
|
// p.setName(n);
|
// return p;
|
// })
|
// .collect(Collectors.toList());
|
//
|
// if (!needSave.isEmpty()) {
|
// productProcessService.saveBatch(needSave);
|
// needSave.forEach(p -> p.setNo("GX" + String.format("%08d", p.getId())));
|
// productProcessService.updateBatchById(needSave);
|
// }
|
}
|
|
private String clean(String s) {
|
if (s == null) return null;
|
return s.replaceAll("[\\u00A0\\u3000]", "").trim();
|
}
|
|
private void populateMap(List<ProductStructureDto> nodes, Map<Long, ProductStructureDto> map) {
|
if (nodes == null || nodes.isEmpty()) {
|
return;
|
}
|
for (ProductStructureDto node : nodes) {
|
map.put(node.getId(), node);
|
populateMap(node.getChildren(), map);
|
}
|
}
|
|
/**
|
* 递归转换树形结构 VO -> DTO
|
* 自动生成虚拟 tempId / parentTempId，保证任意层级树结构正确
|
*/
|
public static TechnologyBomStructureDto convertTree(TechnologyBomStructureVo vo) {
|
if (vo == null) {
|
return null;
|
}
|
TechnologyBomStructureDto realDto = convertNode(vo, "0"); // 根节点父ID=0（纯数字）
|
TechnologyBomStructureDto rootDto = new TechnologyBomStructureDto();
|
rootDto.setTempId("0");
|
rootDto.setChildren(Collections.singletonList(realDto));
|
|
return rootDto;
|
}
|
|
/**
|
* 核心递归方法
|
* @param vo 原始节点
|
* @param parentTempId 父节点 纯数字ID
|
* @return 转换后DTO
|
*/
|
private static TechnologyBomStructureDto convertNode(TechnologyBomStructureVo vo, String parentTempId) {
|
if (vo == null) {
|
return null;
|
}
|
|
TechnologyBomStructureDto dto = new TechnologyBomStructureDto();
|
BeanUtils.copyProperties(vo, dto);
|
|
String currentTempId = getNumberId();
|
dto.setTempId(currentTempId);
|
dto.setParentTempId(parentTempId);
|
|
|
dto.setId(null);
|
dto.setParentId(null);
|
|
// ===================== 递归子节点 =====================
|
List<TechnologyBomStructureVo> voChildren = vo.getChildren();
|
if (CollUtil.isNotEmpty(voChildren)) {
|
List<TechnologyBomStructureDto> dtoChildren = new ArrayList<>();
|
for (TechnologyBomStructureVo childVo : voChildren) {
|
// 子节点的父ID = 当前节点的数字ID
|
dtoChildren.add(convertNode(childVo, currentTempId));
|
}
|
dto.setChildren(dtoChildren);
|
} else {
|
dto.setChildren(new ArrayList<>());
|
}
|
|
return dto;
|
}
|
|
/**
|
* 生成 13位 纯数字随机ID（安全、不重复、高性能）
|
*/
|
private static String getNumberId() {
|
// 生成 1000000000000 ~ 9999999999999 之间的数字
|
long min = 1000000000000L;
|
long max = 9999999999999L;
|
long randomNum = ThreadLocalRandom.current().nextLong(min, max + 1);
|
return String.valueOf(randomNum);
|
}
|
}
|
