package com.ruoyi.production.service.impl;
|
|
import com.ruoyi.basic.mapper.ProductMapper;
|
import com.ruoyi.basic.mapper.ProductModelMapper;
|
import com.ruoyi.basic.pojo.Product;
|
import com.ruoyi.basic.pojo.ProductModel;
|
import com.ruoyi.production.bean.vo.MaterialConsumptionActualVo;
|
import com.ruoyi.production.bean.vo.MaterialConsumptionOrderVo;
|
import com.ruoyi.production.bean.vo.MaterialConsumptionStatVo;
|
import com.ruoyi.production.bean.vo.MaterialConsumptionStructureVo;
|
import com.ruoyi.production.mapper.MaterialConsumptionMapper;
|
import com.ruoyi.production.service.MaterialConsumptionService;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.LocalDate;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
@Service
|
@RequiredArgsConstructor
|
public class MaterialConsumptionServiceImpl implements MaterialConsumptionService {
|
|
private final MaterialConsumptionMapper materialConsumptionMapper;
|
private final ProductModelMapper productModelMapper;
|
private final ProductMapper productMapper;
|
|
@Override
|
public List<MaterialConsumptionStatVo> stat(LocalDate startDate, LocalDate endDate,
|
String npsNo, String productName, Boolean onlyDiff) {
|
List<MaterialConsumptionOrderVo> orders =
|
materialConsumptionMapper.listOrders(startDate, endDate, npsNo, productName);
|
if (orders.isEmpty()) {
|
return new ArrayList<>();
|
}
|
List<Long> orderIds = orders.stream().map(MaterialConsumptionOrderVo::getProductionOrderId)
|
.filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
List<MaterialConsumptionStructureVo> structures = materialConsumptionMapper.listStructures(orderIds);
|
List<MaterialConsumptionActualVo> actuals = materialConsumptionMapper.listActualInputs(orderIds);
|
|
Map<Long, MaterialConsumptionStructureVo> structureById = structures.stream()
|
.collect(Collectors.toMap(MaterialConsumptionStructureVo::getId, s -> s, (a, b) -> a));
|
Map<String, BigDecimal> actualMap = new HashMap<>();
|
for (MaterialConsumptionActualVo actual : actuals) {
|
actualMap.merge(actual.getProductionOrderId() + "_" + actual.getProductModelId(),
|
nvl(actual.getActualQty()), BigDecimal::add);
|
}
|
|
//BOM逐层展开：累计单耗=上级累计×本级单耗，按物料合并
|
Map<Long, Map<Long, BigDecimal>> orderStandard = new HashMap<>();
|
for (MaterialConsumptionStructureVo row : structures) {
|
if (isRoot(row)) {
|
continue;
|
}
|
BigDecimal cumulative = cumulativeUnitQuantity(row, structureById);
|
orderStandard.computeIfAbsent(row.getProductionOrderId(), k -> new LinkedHashMap<>())
|
.merge(row.getProductModelId(), cumulative, BigDecimal::add);
|
}
|
|
Set<Long> materialModelIds = new HashSet<>();
|
orderStandard.values().forEach(m -> materialModelIds.addAll(m.keySet()));
|
materialModelIds.addAll(actualMap.keySet().stream()
|
.map(k -> Long.valueOf(k.substring(k.indexOf('_') + 1))).collect(Collectors.toSet()));
|
Map<Long, ProductModel> modelMap = modelIds(materialModelIds);
|
Map<Long, Product> productMap = products(modelMap.values());
|
|
List<MaterialConsumptionStatVo> result = new ArrayList<>();
|
for (MaterialConsumptionOrderVo order : orders) {
|
Map<Long, BigDecimal> standardMap = orderStandard.getOrDefault(order.getProductionOrderId(), new LinkedHashMap<>());
|
//报工投入了但BOM没有的物料也要展示（超标/误领）
|
Set<Long> materialIds = new java.util.LinkedHashSet<>(standardMap.keySet());
|
actualMap.keySet().stream()
|
.filter(k -> k.startsWith(order.getProductionOrderId() + "_"))
|
.forEach(k -> materialIds.add(Long.valueOf(k.substring(k.indexOf('_') + 1))));
|
if (materialIds.isEmpty()) {
|
continue;
|
}
|
BigDecimal outputQty = nvl(order.getCompleteQty()).compareTo(BigDecimal.ZERO) > 0
|
? order.getCompleteQty() : nvl(order.getPlanQty());
|
for (Long materialId : materialIds) {
|
BigDecimal unitQty = standardMap.getOrDefault(materialId, BigDecimal.ZERO);
|
BigDecimal standard = unitQty.multiply(outputQty).setScale(4, RoundingMode.HALF_UP);
|
BigDecimal actual = actualMap.getOrDefault(
|
order.getProductionOrderId() + "_" + materialId, BigDecimal.ZERO);
|
BigDecimal diff = actual.subtract(standard);
|
if (Boolean.TRUE.equals(onlyDiff) && diff.compareTo(BigDecimal.ZERO) == 0) {
|
continue;
|
}
|
MaterialConsumptionStatVo vo = new MaterialConsumptionStatVo();
|
vo.setProductionOrderId(order.getProductionOrderId());
|
vo.setNpsNo(order.getNpsNo());
|
vo.setFinishedProduct(order.getFinishedProduct());
|
vo.setMaterialModelId(materialId);
|
ProductModel pm = modelMap.get(materialId);
|
if (pm != null) {
|
vo.setMaterialModel(pm.getModel());
|
vo.setUnit(pm.getUnit());
|
Product p = productMap.get(pm.getProductId());
|
if (p != null) {
|
vo.setMaterialName(p.getProductName());
|
}
|
}
|
vo.setUnitQuantity(unitQty);
|
vo.setCompleteQty(outputQty);
|
vo.setStandardQty(standard);
|
vo.setActualQty(actual);
|
vo.setDiffQty(diff);
|
if (standard.compareTo(BigDecimal.ZERO) > 0) {
|
vo.setDiffRate(diff.multiply(BigDecimal.valueOf(100))
|
.divide(standard, 2, RoundingMode.HALF_UP));
|
}
|
result.add(vo);
|
}
|
}
|
return result;
|
}
|
|
private boolean isRoot(MaterialConsumptionStructureVo row) {
|
return row.getParentId() == null || row.getParentId() == 0L;
|
}
|
|
private BigDecimal cumulativeUnitQuantity(MaterialConsumptionStructureVo row,
|
Map<Long, MaterialConsumptionStructureVo> structureById) {
|
BigDecimal cumulative = nvl(row.getUnitQuantity());
|
Long parentId = row.getParentId();
|
int guard = 0;
|
while (parentId != null && parentId != 0L && guard++ < 20) {
|
MaterialConsumptionStructureVo parent = structureById.get(parentId);
|
if (parent == null) {
|
break;
|
}
|
cumulative = cumulative.multiply(nvl(parent.getUnitQuantity()));
|
parentId = parent.getParentId();
|
}
|
return cumulative.setScale(6, RoundingMode.HALF_UP);
|
}
|
|
private Map<Long, ProductModel> modelIds(Set<Long> ids) {
|
if (ids.isEmpty()) {
|
return new HashMap<>();
|
}
|
return productModelMapper.selectBatchIds(ids).stream()
|
.collect(Collectors.toMap(ProductModel::getId, m -> m, (a, b) -> a));
|
}
|
|
private Map<Long, Product> products(java.util.Collection<ProductModel> models) {
|
List<Long> ids = models.stream().map(ProductModel::getProductId)
|
.filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
if (ids.isEmpty()) {
|
return new HashMap<>();
|
}
|
return productMapper.selectBatchIds(ids).stream()
|
.collect(Collectors.toMap(Product::getId, p -> p, (a, b) -> a));
|
}
|
|
private BigDecimal nvl(BigDecimal value) {
|
return value == null ? BigDecimal.ZERO : value;
|
}
|
}
|
