package com.ruoyi.production.service.impl;
|
|
import com.alibaba.fastjson2.JSON;
|
import com.alibaba.fastjson2.JSONArray;
|
import com.alibaba.fastjson2.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
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.mapper.ProductMapper;
|
import com.ruoyi.basic.mapper.ProductModelMapper;
|
import com.ruoyi.basic.pojo.Product;
|
import com.ruoyi.basic.pojo.ProductModel;
|
import com.ruoyi.common.enums.StockInQualifiedRecordTypeEnum;
|
import com.ruoyi.common.enums.StockInUnQualifiedRecordTypeEnum;
|
import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.bean.BeanUtils;
|
import com.ruoyi.procurementrecord.utils.StockUtils;
|
import com.ruoyi.production.dto.ProductStructureDto;
|
import com.ruoyi.production.dto.ProductionProductMainDto;
|
import com.ruoyi.production.mapper.*;
|
import com.ruoyi.production.pojo.*;
|
import com.ruoyi.production.service.ProductionProductMainService;
|
import com.ruoyi.project.system.domain.SysUser;
|
import com.ruoyi.project.system.mapper.SysUserMapper;
|
import com.ruoyi.project.system.service.ISysNoticeService;
|
import com.ruoyi.quality.mapper.*;
|
import com.ruoyi.quality.pojo.*;
|
import com.ruoyi.quality.service.IQualityInspectService;
|
import com.ruoyi.stock.support.FinishedProductStockDimensionResolver;
|
import lombok.AllArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
|
@Service
|
@AllArgsConstructor
|
@Transactional(rollbackFor = Exception.class)
|
public class ProductionProductMainServiceImpl extends ServiceImpl<ProductionProductMainMapper, ProductionProductMain> implements ProductionProductMainService {
|
|
private static final String PROCESS_VOLTAGE_SORT = "电压分选";
|
private static final String PROCESS_OPTICAL_INSPECTION = "光检外观";
|
private static final String PROCESS_PACKAGING = "包装";
|
private static final String INPUT_WEIGHT_PARAMETER = "投入重量/数量";
|
private static final String INPUT_WEIGHT_FIELD = "inputWeight";
|
private static final Object PRODUCT_MAIN_NO_LOCK = new Object();
|
|
private IQualityInspectService qualityInspectService;
|
private ProductionProductMainMapper productionProductMainMapper;
|
private ProductWorkOrderMapper productWorkOrderMapper;
|
private ProductProcessRouteItemMapper productProcessRouteItemMapper;
|
private SysUserMapper userMapper;
|
private ProductionProductOutputMapper productionProductOutputMapper;
|
private ProductModelMapper productModelMapper;
|
private QualityInspectMapper qualityInspectMapper;
|
private QualityUnqualifiedMapper qualityUnqualifiedMapper;
|
private ProductProcessMapper productProcessMapper;
|
private ProductProcessRouteMapper productProcessRouteMapper;
|
private ProductMapper productMapper;
|
private QualityTestStandardParamMapper qualityTestStandardParamMapper;
|
private QualityTestStandardMapper qualityTestStandardMapper;
|
private QualityInspectParamMapper qualityInspectParamMapper;
|
private ProductStructureMapper productStructureMapper;
|
private ProductionProductInputMapper productionProductInputMapper;
|
private ProductOrderMapper productOrderMapper;
|
private SalesLedgerProductionAccountingMapper salesLedgerProductionAccountingMapper;
|
private StockUtils stockUtils;
|
private FinishedProductStockDimensionResolver finishedProductStockDimensionResolver;
|
private ISysNoticeService sysNoticeService;
|
|
@Override
|
public IPage<ProductionProductMainDto> listPageProductionProductMainDto(Page page, ProductionProductMainDto productionProductMainDto) {
|
return productionProductMainMapper.listPageProductionProductMainDto(page, productionProductMainDto);
|
}
|
|
// 新增报工，并按照报工主流程处理投入扣库、产出、质检、入库、工单订单进度和核算数据
|
@Override
|
public Boolean addProductMain(ProductionProductMainDto dto) {
|
// 第一步：先校验报工入参，避免空值和非法数量进入后续流程
|
if (dto == null) {
|
throw new ServiceException("报工参数不能为空");
|
}
|
if (dto.getProductProcessRouteItemId() == null) {
|
throw new ServiceException("工艺路线工序项不能为空");
|
}
|
if (dto.getWorkOrderId() == null) {
|
throw new ServiceException("生产工单不能为空");
|
}
|
|
BigDecimal reportQty = dto.getQuantity();
|
BigDecimal scrapQty = dto.getScrapQty() == null ? BigDecimal.ZERO : dto.getScrapQty();
|
BigDecimal bomInputQty = dto.getInputWeight();
|
if (bomInputQty == null) {
|
bomInputQty = resolveInputWeight(dto.getOtherData());
|
}
|
if (reportQty == null || reportQty.compareTo(BigDecimal.ZERO) <= 0) {
|
throw new ServiceException("报工数量必须大于0");
|
}
|
if (scrapQty.compareTo(BigDecimal.ZERO) < 0) {
|
throw new ServiceException("报废数量不能小于0");
|
}
|
if (scrapQty.compareTo(reportQty) > 0) {
|
throw new ServiceException("报废数量不能大于报工数量");
|
}
|
if (bomInputQty == null || bomInputQty.compareTo(BigDecimal.ZERO) < 0) {
|
throw new ServiceException("产品结构投入数量不能小于0");
|
}
|
|
// 第二步：加载当前工序、工单、工艺路线和订单数据，并校验基础关联关系
|
ProductProcessRouteItem productProcessRouteItem =
|
productProcessRouteItemMapper.selectById(dto.getProductProcessRouteItemId());
|
if (productProcessRouteItem == null) {
|
throw new ServiceException("工艺路线工序项不存在");
|
}
|
|
ProductProcess productProcess = productProcessMapper.selectById(productProcessRouteItem.getProcessId());
|
if (productProcess == null) {
|
throw new ServiceException("当前工序不存在");
|
}
|
|
ProductModel productModel = productModelMapper.selectById(productProcessRouteItem.getProductModelId());
|
if (productModel == null) {
|
throw new ServiceException("当前工序对应的产品型号不存在");
|
}
|
|
ProductProcessRoute productProcessRoute =
|
productProcessRouteMapper.selectById(productProcessRouteItem.getProductRouteId());
|
if (productProcessRoute == null) {
|
throw new ServiceException("工艺路线不存在");
|
}
|
|
ProductWorkOrder productWorkOrder = productWorkOrderMapper.selectById(dto.getWorkOrderId());
|
if (productWorkOrder == null) {
|
throw new ServiceException("生产工单不存在");
|
}
|
if (!Objects.equals(productWorkOrder.getProductProcessRouteItemId(), productProcessRouteItem.getId())) {
|
throw new ServiceException("生产工单与当前工序不匹配");
|
}
|
|
ProductOrder productOrder = productOrderMapper.selectById(productWorkOrder.getProductOrderId());
|
if (productOrder == null) {
|
throw new ServiceException("生产订单不存在");
|
}
|
|
// 第三步：校验工序流转逻辑，必须是同一订单的上一道工序已报工且前序无未解除隔离记录
|
Integer currentDragSort = productProcessRouteItem.getDragSort();
|
if (currentDragSort != null && currentDragSort > 1) {
|
boolean isPreviousReported = productionProductMainMapper.checkPreviousProcessReported(
|
productWorkOrder.getId(),
|
currentDragSort
|
);
|
if (!isPreviousReported) {
|
throw new ServiceException("上一道工序尚未报工，当前工序不能报工");
|
}
|
|
ProductProcessRouteItem previousRouteItem = productProcessRouteItemMapper.selectOne(
|
Wrappers.<ProductProcessRouteItem>lambdaQuery()
|
.eq(ProductProcessRouteItem::getProductRouteId, productProcessRouteItem.getProductRouteId())
|
.eq(ProductProcessRouteItem::getDragSort, currentDragSort - 1)
|
);
|
if (previousRouteItem == null) {
|
throw new ServiceException("上一道工序不存在");
|
}
|
|
ProductWorkOrder previousWorkOrder = productWorkOrderMapper.selectOne(
|
Wrappers.<ProductWorkOrder>lambdaQuery()
|
.eq(ProductWorkOrder::getProductOrderId, productOrder.getId())
|
.eq(ProductWorkOrder::getProductProcessRouteItemId, previousRouteItem.getId())
|
);
|
if (previousWorkOrder == null) {
|
throw new ServiceException("上一道工序工单不存在");
|
}
|
|
BigDecimal currentReportedQty = BigDecimal.ZERO;
|
List<ProductionProductMain> currentMainList = productionProductMainMapper.selectList(
|
Wrappers.<ProductionProductMain>lambdaQuery()
|
.eq(ProductionProductMain::getWorkOrderId, productWorkOrder.getId())
|
);
|
if (CollectionUtils.isNotEmpty(currentMainList)) {
|
List<Long> currentMainIds = currentMainList.stream().map(ProductionProductMain::getId).collect(Collectors.toList());
|
List<ProductionProductOutput> currentOutputList = productionProductOutputMapper.selectList(
|
Wrappers.<ProductionProductOutput>lambdaQuery()
|
.in(ProductionProductOutput::getProductMainId, currentMainIds)
|
);
|
currentReportedQty = currentOutputList.stream()
|
.map(ProductionProductOutput::getQuantity)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
}
|
|
BigDecimal previousCompleteQty =
|
previousWorkOrder.getCompleteQuantity() == null ? BigDecimal.ZERO : previousWorkOrder.getCompleteQuantity();
|
if (currentReportedQty.add(reportQty).compareTo(previousCompleteQty) > 0) {
|
throw new ServiceException("本次报工数量超过上道工序可流转数量");
|
}
|
|
List<ProductProcessRouteItem> previousItems = productProcessRouteItemMapper.selectList(
|
Wrappers.<ProductProcessRouteItem>lambdaQuery()
|
.eq(ProductProcessRouteItem::getProductRouteId, productProcessRouteItem.getProductRouteId())
|
.lt(ProductProcessRouteItem::getDragSort, currentDragSort)
|
);
|
|
if (CollectionUtils.isNotEmpty(previousItems)) {
|
List<String> previousProcessNames = new ArrayList<>();
|
for (ProductProcessRouteItem item : previousItems) {
|
ProductProcess process = productProcessMapper.selectById(item.getProcessId());
|
if (process != null && StringUtils.isNotBlank(process.getName())) {
|
previousProcessNames.add(process.getName().trim());
|
}
|
}
|
|
if (CollectionUtils.isNotEmpty(previousProcessNames)) {
|
List<QualityUnqualified> unqualifiedList =
|
qualityUnqualifiedMapper.selectUnqualifiedByProductOrderAndProcessNames(productOrder.getId(), previousProcessNames);
|
if (CollectionUtils.isNotEmpty(unqualifiedList)) {
|
throw new ServiceException("前序工序存在隔离记录，当前工序不能报工");
|
}
|
}
|
}
|
}
|
|
// 第四步：控制当前工单总报工量不能超过计划量
|
BigDecimal currentWorkOrderReportedQty = BigDecimal.ZERO;
|
List<ProductionProductMain> workOrderMainList = productionProductMainMapper.selectList(
|
Wrappers.<ProductionProductMain>lambdaQuery()
|
.eq(ProductionProductMain::getWorkOrderId, productWorkOrder.getId())
|
);
|
if (CollectionUtils.isNotEmpty(workOrderMainList)) {
|
List<Long> workOrderMainIds = workOrderMainList.stream().map(ProductionProductMain::getId).collect(Collectors.toList());
|
List<ProductionProductOutput> workOrderOutputList = productionProductOutputMapper.selectList(
|
Wrappers.<ProductionProductOutput>lambdaQuery()
|
.in(ProductionProductOutput::getProductMainId, workOrderMainIds)
|
);
|
currentWorkOrderReportedQty = workOrderOutputList.stream()
|
.map(ProductionProductOutput::getQuantity)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
}
|
if (productWorkOrder.getPlanQuantity() != null
|
&& currentWorkOrderReportedQty.add(reportQty).compareTo(productWorkOrder.getPlanQuantity()) > 0) {
|
throw new ServiceException("本次报工数量超过工单可报数量");
|
}
|
|
// 第五步：生成报工单号并确定报工人信息
|
String productNo;
|
synchronized (PRODUCT_MAIN_NO_LOCK) {
|
String datePrefix = "BG" + LocalDate.now().format(DateTimeFormatter.ofPattern("yyMMdd"));
|
QueryWrapper<ProductionProductMain> queryWrapper = new QueryWrapper<>();
|
queryWrapper.select("MAX(product_no) as maxNo")
|
.likeRight("product_no", datePrefix);
|
List<Map<String, Object>> resultList = productionProductMainMapper.selectMaps(queryWrapper);
|
|
int sequenceNumber = 1;
|
if (CollectionUtils.isNotEmpty(resultList)) {
|
Map<String, Object> result = resultList.get(0);
|
if (result != null && result.get("maxNo") != null) {
|
String lastNo = result.get("maxNo").toString();
|
if (lastNo.startsWith(datePrefix)) {
|
try {
|
sequenceNumber = Integer.parseInt(lastNo.substring(datePrefix.length())) + 1;
|
} catch (NumberFormatException e) {
|
sequenceNumber = 1;
|
}
|
}
|
}
|
}
|
productNo = String.format("%s%03d", datePrefix, sequenceNumber);
|
}
|
|
Long userId = dto.getUserId();
|
String userName = dto.getUserName();
|
if (userId == null) {
|
userId = SecurityUtils.getLoginUser().getUserId();
|
userName = SecurityUtils.getLoginUser().getNickName();
|
} else if (StringUtils.isBlank(userName)) {
|
SysUser user = userMapper.selectUserById(userId);
|
userName = user == null ? null : user.getNickName();
|
}
|
|
// 第六步：先写报工主表
|
ProductionProductMain productionProductMain = new ProductionProductMain();
|
productionProductMain.setProductNo(productNo);
|
productionProductMain.setUserId(userId);
|
productionProductMain.setUserName(userName);
|
productionProductMain.setProductProcessRouteItemId(dto.getProductProcessRouteItemId());
|
productionProductMain.setWorkOrderId(dto.getWorkOrderId());
|
productionProductMain.setStatus(0);
|
productionProductMainMapper.insert(productionProductMain);
|
|
// 第七步：根据 BOM 生成投入记录并扣减原料库存
|
List<ProductStructureDto> productStructureDtos =
|
productStructureMapper.listBybomAndProcess(productProcessRoute.getBomId(), productProcess.getId());
|
|
if (CollectionUtils.isEmpty(productStructureDtos)) {
|
ProductStructureDto productStructureDto = new ProductStructureDto();
|
productStructureDto.setProductModelId(productProcessRouteItem.getProductModelId());
|
productStructureDto.setUnitQuantity(BigDecimal.ONE);
|
productStructureDtos.add(productStructureDto);
|
}
|
|
Set<Long> parentIds = productStructureDtos.stream()
|
.map(ProductStructureDto::getParentId)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toSet());
|
|
Map<Long, ProductStructureDto> parentMap = new HashMap<>();
|
if (CollectionUtils.isNotEmpty(parentIds)) {
|
parentMap = productStructureMapper.selectByIds(parentIds)
|
.stream()
|
.collect(Collectors.toMap(ProductStructureDto::getId, Function.identity(), (a, b) -> a));
|
}
|
|
// 第七步-1：投入数量强制取前端传入的 bomInputQty
|
BigDecimal inputBaseQty = bomInputQty;
|
|
for (ProductStructureDto productStructureDto : productStructureDtos) {
|
if (productStructureDto.getProductModelId() == null) {
|
throw new ServiceException("投入物料产品型号不能为空");
|
}
|
|
BigDecimal childQty = productStructureDto.getUnitQuantity();
|
if (childQty == null || childQty.compareTo(BigDecimal.ZERO) <= 0) {
|
throw new ServiceException("投入物料用量必须大于0");
|
}
|
|
BigDecimal parentQty = BigDecimal.ONE;
|
if (productStructureDto.getParentId() != null) {
|
ProductStructureDto parent = parentMap.get(productStructureDto.getParentId());
|
if (parent != null) {
|
parentQty = parent.getUnitQuantity();
|
}
|
}
|
|
if (parentQty == null || parentQty.compareTo(BigDecimal.ZERO) <= 0) {
|
throw new ServiceException("父级物料用量必须大于0");
|
}
|
|
BigDecimal needQty = inputBaseQty;
|
|
ProductionProductInput productionProductInput = new ProductionProductInput();
|
productionProductInput.setProductModelId(productStructureDto.getProductModelId());
|
productionProductInput.setQuantity(needQty == null ? BigDecimal.ZERO : needQty);
|
productionProductInput.setProductMainId(productionProductMain.getId());
|
productionProductInputMapper.insert(productionProductInput);
|
|
stockUtils.substractStock(
|
productStructureDto.getProductModelId(),
|
needQty,
|
StockOutQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_OUT.getCode(),
|
productionProductMain.getId(),
|
null,
|
null
|
);
|
}
|
|
// 第八步：写产出记录并计算本次合格数量
|
ProductionProductOutput productionProductOutput = new ProductionProductOutput();
|
productionProductOutput.setProductMainId(productionProductMain.getId());
|
productionProductOutput.setProductModelId(productProcessRouteItem.getProductModelId());
|
productionProductOutput.setQuantity(reportQty);
|
productionProductOutput.setScrapQty(scrapQty);
|
productionProductOutput.setOtherData(dto.getOtherData() == null ? "" : dto.getOtherData());
|
productionProductOutputMapper.insert(productionProductOutput);
|
|
BigDecimal qualifiedQty = reportQty.subtract(scrapQty);
|
|
List<ProductProcessRouteItem> productProcessRouteItems = productProcessRouteItemMapper.selectList(
|
Wrappers.<ProductProcessRouteItem>lambdaQuery()
|
.eq(ProductProcessRouteItem::getProductRouteId, productProcessRouteItem.getProductRouteId())
|
);
|
|
Integer maxDragSort = productProcessRouteItems.stream()
|
.map(ProductProcessRouteItem::getDragSort)
|
.filter(Objects::nonNull)
|
.max(Integer::compareTo)
|
.orElse(null);
|
|
boolean isRouteLastProcess = Objects.equals(productProcessRouteItem.getDragSort(), maxDragSort);
|
ReportStockRule reportStockRule =
|
resolveReportStockRule(productProcessRouteItem, productProcess, productProcessRouteItems);
|
|
// 第九步：如果有合格数量，则根据是否质检决定走质检或直接入库
|
if (qualifiedQty.compareTo(BigDecimal.ZERO) > 0) {
|
if (Boolean.TRUE.equals(productProcessRouteItem.getIsQuality())) {
|
Product product = productMapper.selectById(productModel.getProductId());
|
if (product == null) {
|
throw new ServiceException("质检产品不存在");
|
}
|
|
int inspectType = 1;
|
String process = productProcess.getName();
|
|
if (reportStockRule.finishedGoodsStockIn) {
|
inspectType = 2;
|
process = null;
|
}
|
|
QualityInspect qualityInspect = new QualityInspect();
|
qualityInspect.setProductId(product.getId());
|
qualityInspect.setProductName(product.getProductName());
|
qualityInspect.setModel(productModel.getModel());
|
qualityInspect.setUnit(productModel.getUnit());
|
qualityInspect.setQuantity(reportQty);
|
qualityInspect.setProcess(process);
|
qualityInspect.setInspectState(0);
|
qualityInspect.setInspectType(inspectType);
|
qualityInspect.setDefectiveQuantity(scrapQty);
|
qualityInspect.setProductMainId(productionProductMain.getId());
|
qualityInspect.setProductModelId(productModel.getId());
|
qualityInspectMapper.insert(qualityInspect);
|
|
List<QualityTestStandard> qualityTestStandardList =
|
qualityTestStandardMapper.getQualityTestStandardByProductId(product.getId(), inspectType, process);
|
|
if (CollectionUtils.isNotEmpty(qualityTestStandardList)) {
|
QualityTestStandard qualityTestStandard = qualityTestStandardList.get(0);
|
qualityInspect.setTestStandardId(qualityTestStandard.getId());
|
qualityInspectMapper.updateById(qualityInspect);
|
|
qualityTestStandardParamMapper.selectList(
|
Wrappers.<QualityTestStandardParam>lambdaQuery()
|
.eq(QualityTestStandardParam::getTestStandardId, qualityTestStandard.getId())
|
).forEach(qualityTestStandardParam -> {
|
QualityInspectParam param = new QualityInspectParam();
|
BeanUtils.copyProperties(qualityTestStandardParam, param);
|
param.setId(null);
|
param.setInspectId(qualityInspect.getId());
|
qualityInspectParamMapper.insert(param);
|
});
|
}
|
} else if (reportStockRule.createStockIn) {
|
//成品入库需要电压，工序类别（铜，银）
|
if (reportStockRule.finishedGoodsStockIn) {
|
String processCategory =
|
finishedProductStockDimensionResolver.resolveProcessCategory(productionProductMain.getId());
|
String voltage =
|
finishedProductStockDimensionResolver.resolveVoltage(productionProductMain.getId());
|
|
stockUtils.addStock(
|
productProcessRouteItem.getProductModelId(),
|
qualifiedQty,
|
StockInQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_IN.getCode(),
|
productionProductMain.getId(),
|
processCategory,
|
voltage
|
);
|
} else {
|
stockUtils.addStockNoReview(
|
productProcessRouteItem.getProductModelId(),
|
qualifiedQty,
|
StockInQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_IN.getCode(),
|
productionProductMain.getId()
|
);
|
}
|
}
|
|
// 第十步：更新工单、订单完成进度和计件核算数据
|
BigDecimal workOrderCompleteQuantity =
|
productWorkOrder.getCompleteQuantity() == null ? BigDecimal.ZERO : productWorkOrder.getCompleteQuantity();
|
productWorkOrder.setCompleteQuantity(workOrderCompleteQuantity.add(qualifiedQty));
|
|
if (ObjectUtils.isNull(productWorkOrder.getActualStartTime())) {
|
productWorkOrder.setActualStartTime(LocalDate.now());
|
}
|
if (productWorkOrder.getPlanQuantity() != null
|
&& productWorkOrder.getCompleteQuantity().compareTo(productWorkOrder.getPlanQuantity()) >= 0) {
|
productWorkOrder.setActualEndTime(LocalDate.now());
|
}
|
productWorkOrderMapper.updateById(productWorkOrder);
|
|
if (ObjectUtils.isNull(productOrder.getStartTime())) {
|
productOrder.setStartTime(LocalDateTime.now());
|
}
|
|
if (isRouteLastProcess) {
|
BigDecimal orderCompleteQuantity =
|
productOrder.getCompleteQuantity() == null ? BigDecimal.ZERO : productOrder.getCompleteQuantity();
|
productOrder.setCompleteQuantity(orderCompleteQuantity.add(qualifiedQty));
|
|
if (productOrder.getQuantity() != null
|
&& productOrder.getCompleteQuantity().compareTo(productOrder.getQuantity()) >= 0) {
|
productOrder.setEndTime(LocalDateTime.now());
|
}
|
}
|
productOrderMapper.updateById(productOrder);
|
|
SalesLedgerProductionAccounting salesLedgerProductionAccounting =
|
SalesLedgerProductionAccounting.builder()
|
.productMainId(productionProductMain.getId())
|
.schedulingUserId(userId)
|
.schedulingUserName(userName)
|
.finishedNum(qualifiedQty)
|
.workHours(productProcess.getSalaryQuota())
|
.process(productProcess.getName())
|
.schedulingDate(LocalDate.now())
|
.tenantId(dto.getTenantId())
|
.build();
|
salesLedgerProductionAccountingMapper.insert(salesLedgerProductionAccounting);
|
}
|
|
// 第十一步：统一处理报废数量入不合格库存，避免在主流程中重复入库
|
handleScrapStock(productModel.getId(), scrapQty, isRouteLastProcess, productionProductMain.getId());
|
|
return true;
|
}
|
|
// 判断当前报工是否需要入库，以及是否按成品入库处理
|
private ReportStockRule resolveReportStockRule(ProductProcessRouteItem currentRouteItem,
|
ProductProcess currentProcess,
|
List<ProductProcessRouteItem> routeItems) {
|
Integer maxDragSort = CollectionUtils.isEmpty(routeItems)
|
? null
|
: routeItems.stream()
|
.map(ProductProcessRouteItem::getDragSort)
|
.filter(Objects::nonNull)
|
.max(Integer::compareTo)
|
.orElse(null);
|
|
boolean isRouteLastProcess = Objects.equals(currentRouteItem.getDragSort(), maxDragSort);
|
String currentProcessName = currentProcess == null || currentProcess.getName() == null
|
? ""
|
: currentProcess.getName().trim();
|
|
if (PROCESS_VOLTAGE_SORT.equals(currentProcessName)) {
|
return new ReportStockRule(false, false);
|
}
|
|
Set<Long> processIds = CollectionUtils.isEmpty(routeItems)
|
? Collections.emptySet()
|
: routeItems.stream()
|
.map(ProductProcessRouteItem::getProcessId)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toSet());
|
|
Map<Long, String> processNameMap = new HashMap<>();
|
if (CollectionUtils.isNotEmpty(processIds)) {
|
processNameMap = productProcessMapper.selectBatchIds(processIds)
|
.stream()
|
.collect(Collectors.toMap(
|
ProductProcess::getId,
|
process -> process.getName() == null ? "" : process.getName().trim(),
|
(a, b) -> a
|
));
|
}
|
|
Set<String> routeProcessNames = CollectionUtils.isEmpty(routeItems)
|
? Collections.emptySet()
|
: routeItems.stream()
|
.map(ProductProcessRouteItem::getProcessId)
|
.map(processNameMap::get)
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.toSet());
|
|
boolean hasVoltageSort = routeProcessNames.contains(PROCESS_VOLTAGE_SORT);
|
boolean hasOpticalInspection = routeProcessNames.contains(PROCESS_OPTICAL_INSPECTION);
|
boolean hasPackaging = routeProcessNames.contains(PROCESS_PACKAGING);
|
|
if (hasPackaging && PROCESS_PACKAGING.equals(currentProcessName)) {
|
return new ReportStockRule(true, true);
|
}
|
|
if (hasPackaging && PROCESS_OPTICAL_INSPECTION.equals(currentProcessName)) {
|
return new ReportStockRule(false, false);
|
}
|
|
if (!hasPackaging
|
&& hasVoltageSort
|
&& hasOpticalInspection
|
&& PROCESS_OPTICAL_INSPECTION.equals(currentProcessName)) {
|
return new ReportStockRule(true, true);
|
}
|
|
return new ReportStockRule(true, isRouteLastProcess);
|
}
|
|
// 统一处理报废数量入不合格库存，避免重复入库
|
private void handleScrapStock(Long productModelId,
|
BigDecimal scrapQty,
|
boolean isRouteLastProcess,
|
Long productMainId) {
|
if (productModelId == null) {
|
throw new ServiceException("报废产品型号不能为空");
|
}
|
|
if (scrapQty == null || scrapQty.compareTo(BigDecimal.ZERO) <= 0) {
|
return;
|
}
|
|
if (isRouteLastProcess) {
|
stockUtils.addUnStock(
|
productModelId,
|
scrapQty,
|
StockInUnQualifiedRecordTypeEnum.PRODUCTION_SCRAP.getCode(),
|
productMainId
|
);
|
} else {
|
stockUtils.addUnStockNoReview(
|
productModelId,
|
scrapQty,
|
StockInUnQualifiedRecordTypeEnum.PRODUCTION_SCRAP.getCode(),
|
productMainId
|
);
|
}
|
}
|
|
// 单次报工对应的入库规则
|
private static final class ReportStockRule {
|
private final boolean createStockIn;
|
private final boolean finishedGoodsStockIn;
|
|
private ReportStockRule(boolean createStockIn, boolean finishedGoodsStockIn) {
|
this.createStockIn = createStockIn;
|
this.finishedGoodsStockIn = finishedGoodsStockIn;
|
}
|
}
|
|
@Override
|
public Boolean removeProductMain(Long id) {
|
// 删除报工前先检查是否已经完成不合格处理
|
List<QualityInspect> qualityInspects = qualityInspectMapper.selectList(
|
Wrappers.<QualityInspect>lambdaQuery().eq(QualityInspect::getProductMainId, id)
|
);
|
if (!qualityInspects.isEmpty()) {
|
List<QualityUnqualified> qualityUnqualifieds = qualityUnqualifiedMapper.selectList(
|
Wrappers.<QualityUnqualified>lambdaQuery()
|
.in(QualityUnqualified::getInspectId, qualityInspects.stream().map(QualityInspect::getId).collect(Collectors.toList()))
|
);
|
if (!qualityUnqualifieds.isEmpty() && qualityUnqualifieds.get(0).getInspectState() == 1) {
|
throw new ServiceException("该报工已完成不合格处理，不能删除");
|
}
|
}
|
|
ProductionProductMain productionProductMain = productionProductMainMapper.selectById(id);
|
ProductProcessRouteItem productProcessRouteItem = productProcessRouteItemMapper.selectById(productionProductMain.getProductProcessRouteItemId());
|
ProductionProductOutput productionProductOutput = productionProductOutputMapper.selectList(
|
Wrappers.<ProductionProductOutput>lambdaQuery().eq(ProductionProductOutput::getProductMainId, productionProductMain.getId())
|
).get(0);
|
|
salesLedgerProductionAccountingMapper.delete(
|
new LambdaQueryWrapper<SalesLedgerProductionAccounting>()
|
.eq(SalesLedgerProductionAccounting::getProductMainId, productionProductMain.getId())
|
);
|
|
ProductWorkOrder productWorkOrder = productWorkOrderMapper.selectById(productionProductMain.getWorkOrderId());
|
if (productWorkOrder != null && productionProductOutput != null) {
|
BigDecimal outputQty = productionProductOutput.getQuantity() == null ? BigDecimal.ZERO : productionProductOutput.getQuantity();
|
BigDecimal scrapQty = productionProductOutput.getScrapQty() == null ? BigDecimal.ZERO : productionProductOutput.getScrapQty();
|
BigDecimal completeQty = productWorkOrder.getCompleteQuantity() == null ? BigDecimal.ZERO : productWorkOrder.getCompleteQuantity();
|
|
BigDecimal validQuantity = outputQty.subtract(scrapQty);
|
productWorkOrder.setCompleteQuantity(completeQty.subtract(validQuantity));
|
productWorkOrder.setActualEndTime(null);
|
productWorkOrderMapper.updateById(productWorkOrder);
|
} else {
|
throw new ServiceException("操作失败：工单信息或产出记录不存在");
|
}
|
|
List<ProductProcessRouteItem> productProcessRouteItems = productProcessRouteItemMapper.selectList(
|
Wrappers.<ProductProcessRouteItem>lambdaQuery().eq(ProductProcessRouteItem::getProductRouteId, productProcessRouteItem.getProductRouteId())
|
);
|
if (productProcessRouteItem.getDragSort() != null
|
&& productProcessRouteItems != null
|
&& productProcessRouteItem.getDragSort() == productProcessRouteItems.size()) {
|
ProductOrder productOrder = productOrderMapper.selectById(productWorkOrder.getProductOrderId());
|
if (productOrder != null) {
|
BigDecimal orderCompleteQty = productOrder.getCompleteQuantity() == null ? BigDecimal.ZERO : productOrder.getCompleteQuantity();
|
BigDecimal totalQty = productionProductOutput.getQuantity() != null ? productionProductOutput.getQuantity() : BigDecimal.ZERO;
|
BigDecimal scrapQty = productionProductOutput.getScrapQty() != null ? productionProductOutput.getScrapQty() : BigDecimal.ZERO;
|
BigDecimal actualQualifiedQty = totalQty.subtract(scrapQty);
|
BigDecimal newCompleteQty = orderCompleteQty.subtract(actualQualifiedQty);
|
productOrder.setCompleteQuantity(newCompleteQty.compareTo(BigDecimal.ZERO) < 0 ? BigDecimal.ZERO : newCompleteQty);
|
productOrder.setEndTime(null);
|
productOrderMapper.updateById(productOrder);
|
} else {
|
throw new ServiceException("关联的生产订单不存在");
|
}
|
}
|
|
qualityInspectMapper.selectList(
|
new LambdaQueryWrapper<QualityInspect>()
|
.eq(QualityInspect::getProductMainId, productionProductMain.getId())
|
).forEach(q -> {
|
qualityInspectParamMapper.delete(
|
new LambdaQueryWrapper<QualityInspectParam>()
|
.eq(QualityInspectParam::getInspectId, q.getId())
|
);
|
qualityInspectMapper.deleteById(q.getId());
|
stockUtils.deleteStockInRecord(q.getId(), StockInQualifiedRecordTypeEnum.QUALITYINSPECT_STOCK_IN.getCode());
|
});
|
|
productionProductOutputMapper.delete(
|
new LambdaQueryWrapper<ProductionProductOutput>()
|
.eq(ProductionProductOutput::getProductMainId, productionProductMain.getId())
|
);
|
productionProductInputMapper.delete(
|
new LambdaQueryWrapper<ProductionProductInput>()
|
.eq(ProductionProductInput::getProductMainId, productionProductMain.getId())
|
);
|
stockUtils.deleteStockInRecord(productionProductMain.getId(), StockInUnQualifiedRecordTypeEnum.PRODUCTION_SCRAP.getCode());
|
stockUtils.deleteStockInRecord(productionProductMain.getId(), StockInQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_IN.getCode());
|
stockUtils.deleteStockOutRecord(productionProductMain.getId(), StockOutQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_OUT.getCode());
|
productionProductMainMapper.deleteById(productionProductMain.getId());
|
return true;
|
}
|
|
@Override
|
public ArrayList<Long> listMain(List<Long> idList) {
|
return productionProductMainMapper.listMain(idList);
|
}
|
|
@Override
|
public List<ProductionProductMainDto> getByProductWorkOrderId(Long productWorkOrderId) {
|
List<ProductionProductMainDto> productionProductMainDtos = productionProductMainMapper.getByProductWorkOrderId(productWorkOrderId);
|
if (productionProductMainDtos == null || productionProductMainDtos.isEmpty()) {
|
return productionProductMainDtos;
|
}
|
|
List<Long> productMainIds = productionProductMainDtos.stream()
|
.map(ProductionProductMainDto::getId)
|
.collect(Collectors.toList());
|
|
List<QualityInspect> qualityInspects = qualityInspectMapper.selectList(
|
Wrappers.<QualityInspect>lambdaQuery()
|
.in(QualityInspect::getProductMainId, productMainIds)
|
);
|
|
if (!qualityInspects.isEmpty()) {
|
List<Long> inspectIds = qualityInspects.stream()
|
.map(QualityInspect::getId)
|
.collect(Collectors.toList());
|
|
List<QualityUnqualified> qualityUnqualifieds = qualityUnqualifiedMapper.selectList(
|
Wrappers.<QualityUnqualified>lambdaQuery()
|
.in(QualityUnqualified::getInspectId, inspectIds)
|
);
|
|
Map<Long, QualityUnqualified> inspectIdToUnqualifiedMap = qualityUnqualifieds.stream()
|
.collect(Collectors.toMap(QualityUnqualified::getInspectId, q -> q, (q1, q2) -> q1));
|
|
Map<Long, QualityInspect> productMainIdToInspectMap = qualityInspects.stream()
|
.collect(Collectors.toMap(QualityInspect::getProductMainId, q -> q, (q1, q2) -> q1));
|
|
productionProductMainDtos.forEach(p -> {
|
QualityInspect qualityInspect = productMainIdToInspectMap.get(p.getId());
|
if (qualityInspect != null) {
|
p.setDefectiveQuantity(qualityInspect.getDefectiveQuantity());
|
p.setQualifiedQty(p.getQuantity().subtract(p.getScrapQty()).subtract(p.getDefectiveQuantity()));
|
QualityUnqualified qualityUnqualified = inspectIdToUnqualifiedMap.get(qualityInspect.getId());
|
if (qualityUnqualified != null) {
|
p.setDealResult(qualityUnqualified.getDealResult() == null ? "" : qualityUnqualified.getDealResult());
|
}
|
}
|
});
|
}
|
|
return productionProductMainDtos;
|
}
|
|
private BigDecimal resolveInputWeight(String otherData) {
|
if (StringUtils.isBlank(otherData)) {
|
return null;
|
}
|
Object parsed;
|
try {
|
parsed = JSON.parse(otherData);
|
} catch (Exception ex) {
|
throw new ServiceException("报工参数格式错误，无法解析投入重量/数量");
|
}
|
String inputWeight = StringUtils.trim(findParameterValue(parsed, INPUT_WEIGHT_PARAMETER));
|
if (StringUtils.isBlank(inputWeight)) {
|
inputWeight = StringUtils.trim(findFieldValue(parsed, INPUT_WEIGHT_FIELD));
|
}
|
if (StringUtils.isBlank(inputWeight)) {
|
return null;
|
}
|
try {
|
return new BigDecimal(inputWeight);
|
} catch (NumberFormatException ex) {
|
throw new ServiceException("报工参数中的投入重量/数量格式错误");
|
}
|
}
|
|
private String findParameterValue(Object node, String parameterItem) {
|
if (node instanceof JSONArray) {
|
JSONArray array = (JSONArray) node;
|
for (Object item : array) {
|
String value = findParameterValue(item, parameterItem);
|
if (StringUtils.isNotBlank(value)) {
|
return value;
|
}
|
}
|
return null;
|
}
|
if (node instanceof JSONObject) {
|
JSONObject object = (JSONObject) node;
|
if (parameterItem.equals(StringUtils.trim(object.getString("parameterItem")))) {
|
String value = StringUtils.trim(object.getString("value"));
|
if (StringUtils.isNotBlank(value)) {
|
return value;
|
}
|
}
|
for (Object value : object.values()) {
|
String matched = findParameterValue(value, parameterItem);
|
if (StringUtils.isNotBlank(matched)) {
|
return matched;
|
}
|
}
|
}
|
return null;
|
}
|
|
private String findFieldValue(Object node, String fieldName) {
|
if (node instanceof JSONArray) {
|
JSONArray array = (JSONArray) node;
|
for (Object item : array) {
|
String value = findFieldValue(item, fieldName);
|
if (StringUtils.isNotBlank(value)) {
|
return value;
|
}
|
}
|
return null;
|
}
|
if (node instanceof JSONObject) {
|
JSONObject object = (JSONObject) node;
|
Object fieldValue = object.get(fieldName);
|
if (fieldValue != null) {
|
String value = StringUtils.trim(String.valueOf(fieldValue));
|
if (StringUtils.isNotBlank(value)) {
|
return value;
|
}
|
}
|
for (Object value : object.values()) {
|
String matched = findFieldValue(value, fieldName);
|
if (StringUtils.isNotBlank(matched)) {
|
return matched;
|
}
|
}
|
}
|
return null;
|
}
|
}
|
