From 88ae1e650fc2fc30928edfe8f3cc39108d8d1ccd Mon Sep 17 00:00:00 2001
From: liyong <18434998025@163.com>
Date: 星期三, 06 五月 2026 15:44:26 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/dev_New_pro' into dev_New_pro
---
src/main/java/com/ruoyi/production/service/impl/ProductionOrderServiceImpl.java | 634 +++++++++++++++++++++++++++++++++++++++++---------------
1 files changed, 460 insertions(+), 174 deletions(-)
diff --git a/src/main/java/com/ruoyi/production/service/impl/ProductionOrderServiceImpl.java b/src/main/java/com/ruoyi/production/service/impl/ProductionOrderServiceImpl.java
index e48509e..9973d98 100644
--- a/src/main/java/com/ruoyi/production/service/impl/ProductionOrderServiceImpl.java
+++ b/src/main/java/com/ruoyi/production/service/impl/ProductionOrderServiceImpl.java
@@ -2,6 +2,7 @@
import cn.hutool.core.bean.BeanUtil;
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;
@@ -13,62 +14,38 @@
import com.ruoyi.basic.utils.FileUtil;
import com.ruoyi.common.constant.StorageAttachmentConstants;
import com.ruoyi.common.exception.ServiceException;
+import com.ruoyi.production.bean.dto.ProductionOperationTaskDto;
import com.ruoyi.production.bean.dto.ProductionOrderDto;
+import com.ruoyi.production.bean.vo.ProductionBomStructureVo;
+import com.ruoyi.production.bean.vo.ProductionOperationTaskVo;
+import com.ruoyi.production.bean.vo.ProductionOrderPickVo;
import com.ruoyi.production.bean.vo.ProductionOrderVo;
-import com.ruoyi.production.mapper.ProductionBomStructureMapper;
-import com.ruoyi.production.mapper.ProductionOperationTaskMapper;
-import com.ruoyi.production.mapper.ProductionOrderBomMapper;
-import com.ruoyi.production.mapper.ProductionOrderMapper;
-import com.ruoyi.production.mapper.ProductionOrderPickMapper;
-import com.ruoyi.production.mapper.ProductionOrderPickRecordMapper;
-import com.ruoyi.production.mapper.ProductionOrderRoutingMapper;
-import com.ruoyi.production.mapper.ProductionOrderRoutingOperationMapper;
-import com.ruoyi.production.mapper.ProductionOrderRoutingOperationParamMapper;
-import com.ruoyi.production.mapper.ProductionPlanMapper;
-import com.ruoyi.production.mapper.ProductionProductMainMapper;
-import com.ruoyi.production.pojo.ProductionOrderPick;
-import com.ruoyi.production.pojo.ProductionOrderPickRecord;
-import com.ruoyi.production.pojo.ProductionBomStructure;
-import com.ruoyi.production.pojo.ProductionOperationTask;
-import com.ruoyi.production.pojo.ProductionOrder;
-import com.ruoyi.production.pojo.ProductionOrderBom;
-import com.ruoyi.production.pojo.ProductionOrderRouting;
-import com.ruoyi.production.pojo.ProductionOrderRoutingOperation;
-import com.ruoyi.production.pojo.ProductionOrderRoutingOperationParam;
-import com.ruoyi.production.pojo.ProductionPlan;
-import com.ruoyi.production.pojo.ProductionProductMain;
+import com.ruoyi.production.bean.vo.ProductionPlanVo;
+import com.ruoyi.production.bean.vo.ProductionOrderWorkOrderDetailVo;
import com.ruoyi.production.enums.ProductOrderStatusEnum;
+import com.ruoyi.production.mapper.*;
+import com.ruoyi.production.pojo.*;
+import com.ruoyi.quality.mapper.QualityInspectFileMapper;
+import com.ruoyi.quality.mapper.QualityInspectMapper;
+import com.ruoyi.quality.mapper.QualityInspectParamMapper;
+import com.ruoyi.quality.pojo.QualityInspect;
+import com.ruoyi.quality.pojo.QualityInspectFile;
+import com.ruoyi.quality.pojo.QualityInspectParam;
+import com.ruoyi.production.service.ProductionOrderService;
import com.ruoyi.sales.mapper.SalesLedgerMapper;
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
-import com.ruoyi.sales.pojo.SalesLedger;
-import com.ruoyi.sales.pojo.SalesLedgerProduct;
-import com.ruoyi.production.service.ProductionOrderService;
-import com.ruoyi.technology.mapper.TechnologyBomMapper;
-import com.ruoyi.technology.mapper.TechnologyBomStructureMapper;
-import com.ruoyi.technology.mapper.TechnologyRoutingMapper;
-import com.ruoyi.technology.mapper.TechnologyRoutingOperationMapper;
-import com.ruoyi.technology.mapper.TechnologyRoutingOperationParamMapper;
-import com.ruoyi.technology.pojo.TechnologyBom;
-import com.ruoyi.technology.pojo.TechnologyBomStructure;
-import com.ruoyi.technology.pojo.TechnologyRouting;
-import com.ruoyi.technology.pojo.TechnologyRoutingOperation;
-import com.ruoyi.technology.pojo.TechnologyRoutingOperationParam;
+import com.ruoyi.stock.mapper.StockInventoryMapper;
+import com.ruoyi.stock.pojo.StockInventory;
+import com.ruoyi.technology.mapper.*;
+import com.ruoyi.technology.pojo.*;
import lombok.RequiredArgsConstructor;
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.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
+import java.util.*;
import java.util.stream.Collectors;
@Service
@@ -83,9 +60,14 @@
private final ProductionOrderBomMapper productionOrderBomMapper;
private final ProductionBomStructureMapper productionBomStructureMapper;
private final ProductionProductMainMapper productionProductMainMapper;
+ private final ProductionProductOutputMapper productionProductOutputMapper;
private final ProductionOrderPickMapper productionOrderPickMapper;
private final ProductionOrderPickRecordMapper productionOrderPickRecordMapper;
+ private final QualityInspectMapper qualityInspectMapper;
+ private final QualityInspectParamMapper qualityInspectParamMapper;
+ private final QualityInspectFileMapper qualityInspectFileMapper;
private final ProductionPlanMapper productionPlanMapper;
+ private final StockInventoryMapper stockInventoryMapper;
private final StorageAttachmentMapper storageAttachmentMapper;
private final StorageBlobMapper storageBlobMapper;
private final SalesLedgerMapper salesLedgerMapper;
@@ -93,12 +75,13 @@
private final TechnologyRoutingMapper technologyRoutingMapper;
private final TechnologyRoutingOperationMapper technologyRoutingOperationMapper;
private final TechnologyRoutingOperationParamMapper technologyRoutingOperationParamMapper;
+ private final TechnologyOperationMapper technologyOperationMapper;
private final TechnologyBomMapper technologyBomMapper;
private final TechnologyBomStructureMapper technologyBomStructureMapper;
private final FileUtil fileUtil;
@Override
- public com.baomidou.mybatisplus.core.metadata.IPage<ProductionOrderVo> pageProductionOrder(Page<ProductionOrderDto> page, ProductionOrderDto dto) {
+ public IPage<ProductionOrderVo> pageProductionOrder(Page<ProductionOrderDto> page, ProductionOrderDto dto) {
Page<ProductionOrderVo> result = (Page<ProductionOrderVo>) baseMapper.pageProductionOrder(page, dto);
fillProductImages(result.getRecords());
return result;
@@ -139,7 +122,6 @@
if (!saved) {
return false;
}
- syncProductionPlanIssueStatus(oldOrder, productionOrder);
boolean needSync = productionOrder.getTechnologyRoutingId() != null
&& (oldOrder == null
|| !Objects.equals(oldOrder.getTechnologyRoutingId(), productionOrder.getTechnologyRoutingId())
@@ -148,11 +130,7 @@
|| productionOrderRoutingMapper.selectCount(Wrappers.<ProductionOrderRouting>lambdaQuery()
.eq(ProductionOrderRouting::getProductionOrderId, productionOrder.getId())) == 0);
if (needSync) {
- // 宸ヨ壓銆佷骇鍝佹垨鏁伴噺鍙樺寲鍚庯紝璁㈠崟蹇収蹇呴』鍜屽綋鍓嶄笅鍗曟暟鎹噸鏂板榻愩��
syncProductionOrderSnapshot(productionOrder.getId());
- } else {
- // 鏈噸寤哄揩鐓ф椂锛屼篃瑕佺‘淇濆鏂欎富鍗曞拰璁㈠崟鏁伴噺淇濇寔鍚屾銆�
- upsertOrderPick(productionOrder);
}
return true;
}
@@ -171,20 +149,74 @@
}
@Override
+ public Integer bindingRoute(ProductionOrderDto productionOrderDto) {
+ if (productionOrderDto == null || productionOrderDto.getId() == null) {
+ throw new ServiceException("鐢熶骇璁㈠崟ID涓嶈兘涓虹┖");
+ }
+ ProductionOrder productionOrder = this.getById(productionOrderDto.getId());
+ if (productionOrder == null) {
+ throw new ServiceException("鐢熶骇璁㈠崟涓嶅瓨鍦�");
+ }
+
+ Long targetRoutingId = productionOrderDto.getTechnologyRoutingId() == null
+ ? productionOrder.getTechnologyRoutingId()
+ : productionOrderDto.getTechnologyRoutingId();
+ if (targetRoutingId == null) {
+ throw new ServiceException("宸ヨ壓璺嚎ID涓嶈兘涓虹┖");
+ }
+ TechnologyRouting targetRouting = technologyRoutingMapper.selectById(targetRoutingId);
+ if (targetRouting == null) {
+ throw new ServiceException("宸ヨ壓璺嚎涓嶅瓨鍦�");
+ }
+ if (productionOrder.getProductModelId() != null
+ && !Objects.equals(productionOrder.getProductModelId(), targetRouting.getProductModelId())) {
+ throw new ServiceException("宸ヨ壓璺嚎涓庣敓浜ц鍗曚骇鍝佽鏍间笉鍖归厤");
+ }
+
+ if (ProductOrderStatusEnum.isStarted(productionOrder.getStatus())
+ && !Objects.equals(productionOrder.getTechnologyRoutingId(), targetRoutingId)) {
+ throw new ServiceException("鐢熶骇璁㈠崟宸插紑宸ワ紝涓嶈兘淇敼宸ヨ壓璺嚎");
+ }
+
+ if (!Objects.equals(productionOrder.getTechnologyRoutingId(), targetRoutingId)) {
+ ProductionOrder update = new ProductionOrder();
+ update.setId(productionOrder.getId());
+ update.setTechnologyRoutingId(targetRoutingId);
+ if (!this.updateById(update)) {
+ throw new ServiceException("缁戝畾宸ヨ壓璺嚎澶辫触");
+ }
+ }
+
+ // 缁戝畾璺嚎浠呴噸寤鸿鍗曚晶蹇収鏁版嵁
+ return syncProductionOrderSnapshot(productionOrder.getId());
+ }
+
+ @Override
+ public List<ProductionPlanVo> getSource(Long id) {
+ ProductionOrder productionOrder = baseMapper.selectById(id);
+ if (productionOrder != null && productionOrder.getProductionPlanIds() != null) {
+ List<Long> planIds = parsePlanIds(productionOrder.getProductionPlanIds());
+ return productionPlanMapper.getSource(planIds);
+ }
+ return null;
+ }
+
+ @Override
public int syncProductionOrderSnapshot(Long productionOrderId) {
ProductionOrder productionOrder = this.getById(productionOrderId);
if (productionOrder == null) {
- throw new ServiceException("Production order not found");
+ throw new ServiceException("鐢熶骇璁㈠崟涓嶅瓨鍦�");
}
if (productionOrder.getTechnologyRoutingId() == null) {
- throw new ServiceException("technologyRoutingId is required");
+ throw new ServiceException("宸ヨ壓璺嚎ID涓嶈兘涓虹┖");
}
TechnologyRouting technologyRouting = technologyRoutingMapper.selectById(productionOrder.getTechnologyRoutingId());
if (technologyRouting == null) {
- throw new ServiceException("Technology routing not found");
+ throw new ServiceException("宸ヨ壓璺嚎涓嶅瓨鍦�");
}
// 璁㈠崟蹇収鎸夆�滃厛娓呭悗寤衡�濆鐞嗭紝淇濊瘉宸ヨ壓璺嚎銆佸伐搴忋�佸弬鏁般�丅OM 鍏ㄩ儴鏉ヨ嚜鍚屼竴鐗堟湰銆�
clearProductionSnapshot(productionOrderId);
+ ProductionOrderBom orderBom = syncProductionOrderBomSnapshot(productionOrder, technologyRouting);
ProductionOrderRouting orderRouting = new ProductionOrderRouting();
orderRouting.setProductionOrderId(productionOrder.getId());
@@ -193,33 +225,52 @@
orderRouting.setProcessRouteCode(technologyRouting.getProcessRouteCode());
orderRouting.setDescription(technologyRouting.getDescription());
orderRouting.setBomId(technologyRouting.getBomId());
+ orderRouting.setOrderBomId(orderBom == null ? null : orderBom.getId());
productionOrderRoutingMapper.insert(orderRouting);
int syncedParamCount = 0;
List<TechnologyRoutingOperation> routingOperations = technologyRoutingOperationMapper.selectList(
Wrappers.<TechnologyRoutingOperation>lambdaQuery()
.eq(TechnologyRoutingOperation::getTechnologyRoutingId, technologyRouting.getId())
- .orderByAsc(TechnologyRoutingOperation::getDragSort)
- .orderByAsc(TechnologyRoutingOperation::getId));
+ .orderByDesc(TechnologyRoutingOperation::getDragSort)
+ .orderByDesc(TechnologyRoutingOperation::getId));
+ Map<Long, String> operationNameMap = technologyOperationMapper.selectBatchIds(
+ routingOperations.stream()
+ .map(TechnologyRoutingOperation::getTechnologyOperationId)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toSet()))
+ .stream()
+ .collect(Collectors.toMap(TechnologyOperation::getId, TechnologyOperation::getName, (a, b) -> a));
+ Integer lastDragSort = routingOperations.stream()
+ .map(TechnologyRoutingOperation::getDragSort)
+ .filter(Objects::nonNull)
+ .max(Integer::compareTo)
+ .orElse(null);
for (TechnologyRoutingOperation sourceOperation : routingOperations) {
// 璁㈠崟宸ュ簭淇濆瓨鐨勬槸宸ヨ壓宸ュ簭蹇収锛屽悗缁姤宸ュ彧渚濊禆蹇収锛屼笉鍐嶇洿鎺ュ紩鐢ㄥ伐鑹轰富鏁版嵁銆�
ProductionOrderRoutingOperation targetOperation = new ProductionOrderRoutingOperation();
targetOperation.setProductionOrderId(productionOrder.getId());
targetOperation.setTechnologyRoutingOperationId(sourceOperation.getId());
- targetOperation.setTechnologyRoutingId(orderRouting.getId());
+ targetOperation.setOrderRoutingId(orderRouting.getId());
targetOperation.setProductModelId(sourceOperation.getProductModelId());
targetOperation.setDragSort(sourceOperation.getDragSort());
+ targetOperation.setIsProduction(sourceOperation.getIsProduction());
targetOperation.setIsQuality(sourceOperation.getIsQuality());
+ targetOperation.setOperationName(operationNameMap.get(sourceOperation.getTechnologyOperationId()));
+ targetOperation.setTechnologyOperationId(sourceOperation.getTechnologyOperationId());
productionOrderRoutingOperationMapper.insert(targetOperation);
- ProductionOperationTask task = new ProductionOperationTask();
- task.setTechnologyRoutingOperationId(targetOperation.getId());
- task.setProductionOrderId(productionOrder.getId());
- task.setPlanQuantity(defaultDecimal(productionOrder.getQuantity()));
- task.setCompleteQuantity(BigDecimal.ZERO);
- task.setWorkOrderNo(generateNextTaskNo());
- task.setStatus(2);
- productionOperationTaskMapper.insert(task);
+ boolean isLastOperation = lastDragSort != null && Objects.equals(sourceOperation.getDragSort(), lastDragSort);
+ if (isLastOperation || Boolean.TRUE.equals(targetOperation.getIsProduction())) {
+ ProductionOperationTask task = new ProductionOperationTask();
+ task.setProductionOrderRoutingOperationId(targetOperation.getId());
+ task.setProductionOrderId(productionOrder.getId());
+ task.setPlanQuantity(defaultDecimal(productionOrder.getQuantity()));
+ task.setCompleteQuantity(BigDecimal.ZERO);
+ task.setWorkOrderNo(generateNextTaskNo());
+ task.setStatus(2);
+ productionOperationTaskMapper.insert(task);
+ }
List<TechnologyRoutingOperationParam> sourceParams = technologyRoutingOperationParamMapper.selectList(
Wrappers.<TechnologyRoutingOperationParam>lambdaQuery()
@@ -229,7 +280,7 @@
// 宸ュ簭鎵ц鍙傛暟鍚屾牱鍋氬揩鐓э紝閬垮厤宸ヨ壓鍙傛暟璋冩暣褰卞搷宸蹭笅杈捐鍗曘��
ProductionOrderRoutingOperationParam targetParam = new ProductionOrderRoutingOperationParam();
targetParam.setProductionOrderId(productionOrder.getId());
- targetParam.setTechnologyRoutingOperationId(targetOperation.getId());
+ targetParam.setProductionOrderRoutingOperationId(targetOperation.getId());
targetParam.setTechnologyRoutingOperationParamId(sourceParam.getId());
targetParam.setParamId(sourceParam.getParamId());
targetParam.setTechnologyOperationId(sourceParam.getTechnologyOperationId());
@@ -246,19 +297,16 @@
syncedParamCount++;
}
}
-
- syncProductionOrderBomSnapshot(productionOrder, technologyRouting);
- upsertOrderPick(productionOrder);
return syncedParamCount;
}
- private void syncProductionOrderBomSnapshot(ProductionOrder productionOrder, TechnologyRouting technologyRouting) {
+ private ProductionOrderBom syncProductionOrderBomSnapshot(ProductionOrder productionOrder, TechnologyRouting technologyRouting) {
if (technologyRouting.getBomId() == null) {
- return;
+ return null;
}
TechnologyBom technologyBom = technologyBomMapper.selectById(technologyRouting.getBomId());
if (technologyBom == null) {
- throw new ServiceException("Technology BOM not found");
+ throw new ServiceException("宸ヨ壓BOM涓嶅瓨鍦�");
}
List<TechnologyBomStructure> structureList = technologyBomStructureMapper.selectList(
Wrappers.<TechnologyBomStructure>lambdaQuery()
@@ -271,10 +319,9 @@
orderBom.setProductionOrderId(productionOrder.getId());
orderBom.setBomId(Long.valueOf(technologyBom.getId()));
orderBom.setProductModelId(root != null ? root.getProductModelId() : productionOrder.getProductModelId());
- orderBom.setTechnologyOperationId(root == null ? null : root.getOperationId());
- orderBom.setUnitQuantity(root != null && root.getUnitQuantity() != null ? root.getUnitQuantity() : BigDecimal.ONE);
- orderBom.setDemandedQuantity(orderQuantity);
- orderBom.setUnit(root == null ? null : root.getUnit());
+ orderBom.setRemark(technologyBom.getRemark());
+ orderBom.setBomNo(technologyBom.getBomNo());
+ orderBom.setVersion(technologyBom.getVersion());
productionOrderBomMapper.insert(orderBom);
Map<Long, Long> idMap = new HashMap<>();
@@ -287,11 +334,12 @@
target.setProductModelId(source.getProductModelId());
target.setTechnologyOperationId(source.getOperationId());
target.setUnitQuantity(source.getUnitQuantity());
- target.setDemandedQuantity(resolveBomDemandQuantity(source, orderQuantity));
+ target.setDemandedQuantity(source.getUnitQuantity().multiply(orderQuantity));
target.setUnit(source.getUnit());
productionBomStructureMapper.insert(target);
idMap.put(source.getId(), target.getId());
}
+ return orderBom;
}
private void clearProductionSnapshot(Long productionOrderId) {
@@ -300,7 +348,7 @@
Wrappers.<ProductionOrderPickRecord>lambdaQuery()
.eq(ProductionOrderPickRecord::getProductionOrderId, productionOrderId)) > 0;
if (hasPickRecord) {
- throw new ServiceException("Production order pick records already exist, snapshot cannot be regenerated");
+ throw new ServiceException("鐢熶骇璁㈠崟宸插瓨鍦ㄩ鏂欒褰曪紝涓嶈兘閲嶆柊鐢熸垚蹇収");
}
List<Long> taskIds = productionOperationTaskMapper.selectList(
Wrappers.<ProductionOperationTask>lambdaQuery()
@@ -312,7 +360,7 @@
Wrappers.<ProductionProductMain>lambdaQuery()
.in(ProductionProductMain::getProductionOperationTaskId, taskIds)) > 0;
if (started) {
- throw new ServiceException("Production order already started, snapshot cannot be regenerated");
+ throw new ServiceException("鐢熶骇璁㈠崟宸插紑宸ワ紝涓嶈兘閲嶆柊鐢熸垚蹇収");
}
productionOperationTaskMapper.delete(Wrappers.<ProductionOperationTask>lambdaQuery()
.eq(ProductionOperationTask::getProductionOrderId, productionOrderId));
@@ -335,7 +383,6 @@
ProductionOrder query = dto == null ? new ProductionOrder() : dto;
return Wrappers.<ProductionOrder>lambdaQuery()
.eq(query.getId() != null, ProductionOrder::getId, query.getId())
- .eq(query.getSalesLedgerId() != null, ProductionOrder::getSalesLedgerId, query.getSalesLedgerId())
.eq(query.getProductModelId() != null, ProductionOrder::getProductModelId, query.getProductModelId())
.eq(query.getTechnologyRoutingId() != null, ProductionOrder::getTechnologyRoutingId, query.getTechnologyRoutingId())
.like(query.getNpsNo() != null && !query.getNpsNo().trim().isEmpty(), ProductionOrder::getNpsNo, query.getNpsNo())
@@ -385,15 +432,14 @@
private void validateAndFillOrder(ProductionOrder productionOrder, ProductionOrder oldOrder) {
if (productionOrder == null) {
- throw new ServiceException("Production order is required");
+ throw new ServiceException("鐢熶骇璁㈠崟涓嶈兘涓虹┖");
}
- fillFromSalesLedgerProduct(productionOrder);
fillFromProductionPlans(productionOrder);
if (productionOrder.getProductModelId() == null) {
- throw new ServiceException("productModelId is required");
+ throw new ServiceException("浜у搧瑙勬牸ID涓嶈兘涓虹┖");
}
if (defaultDecimal(productionOrder.getQuantity()).compareTo(BigDecimal.ZERO) <= 0) {
- throw new ServiceException("quantity must be greater than 0");
+ throw new ServiceException("涓嬪崟鏁伴噺蹇呴』澶т簬0");
}
if (productionOrder.getTechnologyRoutingId() == null) {
// 鏈樉寮忔寚瀹氬伐鑹鸿矾绾挎椂锛屾寜浜у搧瑙勬牸閫夋渶鏂颁竴鏉″伐鑹轰綔涓洪粯璁よ矾绾裤��
@@ -402,47 +448,16 @@
.eq(TechnologyRouting::getProductModelId, productionOrder.getProductModelId())
.orderByDesc(TechnologyRouting::getId)
.last("limit 1"));
- if (technologyRouting == null) {
- throw new ServiceException("No technology routing found for the product model");
+ if (technologyRouting != null) {
+ productionOrder.setTechnologyRoutingId(technologyRouting.getId());
}
- productionOrder.setTechnologyRoutingId(technologyRouting.getId());
}
if (oldOrder != null && ProductOrderStatusEnum.isStarted(oldOrder.getStatus())) {
// 寮�宸ュ悗鍙厑璁镐慨姝ｉ潪鏍稿績瀛楁锛屾牳蹇冪敓浜т緷鎹攣瀹氥��
if (!Objects.equals(oldOrder.getProductModelId(), productionOrder.getProductModelId())
|| !Objects.equals(oldOrder.getTechnologyRoutingId(), productionOrder.getTechnologyRoutingId())
|| compareDecimal(oldOrder.getQuantity(), productionOrder.getQuantity()) != 0) {
- throw new ServiceException("Started production orders cannot modify product, routing or quantity");
- }
- }
- }
-
- private void fillFromSalesLedgerProduct(ProductionOrder productionOrder) {
- if (productionOrder.getSaleLedgerProductId() == null) {
- return;
- }
- // 閿�鍞槑缁嗘槸璁㈠崟鏉ユ簮鏃讹紝浠ラ攢鍞槑缁嗕负鍑嗗洖濉攢鍞彴璐︺�佷骇鍝佽鏍煎拰榛樿鏁伴噺銆�
- SalesLedgerProduct salesLedgerProduct = salesLedgerProductMapper.selectById(productionOrder.getSaleLedgerProductId().longValue());
- if (salesLedgerProduct == null) {
- throw new ServiceException("Sales ledger product not found");
- }
- if (productionOrder.getSalesLedgerId() == null) {
- productionOrder.setSalesLedgerId(salesLedgerProduct.getSalesLedgerId());
- } else if (!Objects.equals(productionOrder.getSalesLedgerId(), salesLedgerProduct.getSalesLedgerId())) {
- throw new ServiceException("salesLedgerId does not match the sales ledger product");
- }
- if (productionOrder.getProductModelId() == null) {
- productionOrder.setProductModelId(salesLedgerProduct.getProductModelId());
- } else if (!Objects.equals(productionOrder.getProductModelId(), salesLedgerProduct.getProductModelId())) {
- throw new ServiceException("productModelId does not match the sales ledger product");
- }
- if (productionOrder.getQuantity() == null || productionOrder.getQuantity().compareTo(BigDecimal.ZERO) <= 0) {
- productionOrder.setQuantity(salesLedgerProduct.getQuantity());
- }
- if (productionOrder.getPlanCompleteTime() == null && productionOrder.getSalesLedgerId() != null) {
- SalesLedger salesLedger = salesLedgerMapper.selectById(productionOrder.getSalesLedgerId());
- if (salesLedger != null && salesLedger.getDeliveryDate() != null) {
- productionOrder.setPlanCompleteTime(salesLedger.getDeliveryDate());
+ throw new ServiceException("鐢熶骇璁㈠崟宸插紑宸ワ紝涓嶈兘淇敼浜у搧銆佸伐鑹鸿矾绾挎垨鏁伴噺");
}
}
}
@@ -455,22 +470,28 @@
// 澶氳鍒掑悎骞惰浆鍗曟椂锛屾墍鏈夎鍒掑繀椤诲睘浜庡悓涓�瑙勬牸锛屼笖鍙兘涓嬪彂涓�娆°��
List<ProductionPlan> productionPlans = productionPlanMapper.selectBatchIds(planIds);
if (productionPlans.size() != planIds.size()) {
- throw new ServiceException("Some production plans do not exist");
+ throw new ServiceException("閮ㄥ垎鐢熶骇璁″垝涓嶅瓨鍦�");
+ }
+ Map<Long, ProductionPlan> planMap = productionPlans.stream()
+ .collect(Collectors.toMap(ProductionPlan::getId, item -> item, (left, right) -> left));
+ ProductionPlan mainPlan = planMap.get(planIds.get(0));
+ if (mainPlan == null) {
+ throw new ServiceException("涓荤敓浜ц鍒掍笉瀛樺湪");
}
Set<Long> productModelIds = productionPlans.stream()
.map(ProductionPlan::getProductModelId)
.collect(Collectors.toSet());
if (productModelIds.size() > 1) {
- throw new ServiceException("Selected production plans must belong to the same product model");
+ throw new ServiceException("鎵�閫夌敓浜ц鍒掑繀椤诲睘浜庡悓涓�浜у搧瑙勬牸");
}
- if (Boolean.TRUE.equals(productionPlans.stream().anyMatch(item -> Boolean.TRUE.equals(item.getIssued())))) {
- throw new ServiceException("Selected production plans already issued");
+ if (productionPlans.stream().anyMatch(item -> item.getStatus() != null && item.getStatus() == 2)) {
+ throw new ServiceException("鎵�閫夌敓浜ц鍒掑凡涓嬪彂");
}
- ProductionPlan firstPlan = productionPlans.get(0);
+ ProductionPlan firstPlan = mainPlan;
if (productionOrder.getProductModelId() == null) {
productionOrder.setProductModelId(firstPlan.getProductModelId());
} else if (!Objects.equals(productionOrder.getProductModelId(), firstPlan.getProductModelId())) {
- throw new ServiceException("productModelId does not match the production plans");
+ throw new ServiceException("浜у搧瑙勬牸ID涓庣敓浜ц鍒掍笉涓�鑷�");
}
if (productionOrder.getQuantity() == null || productionOrder.getQuantity().compareTo(BigDecimal.ZERO) <= 0) {
productionOrder.setQuantity(productionPlans.stream()
@@ -488,76 +509,73 @@
productionOrder.setProductionPlanIds(formatPlanIds(planIds));
}
- private void syncProductionPlanIssueStatus(ProductionOrder oldOrder, ProductionOrder newOrder) {
- // 鍙鐞嗘湰娆″閲忓彉鍖栵紝閬垮厤鏃犲叧璁″垝琚噸澶嶅啓鐘舵�併��
- Set<Long> oldIds = new LinkedHashSet<>(parsePlanIds(oldOrder == null ? null : oldOrder.getProductionPlanIds()));
- Set<Long> newIds = new LinkedHashSet<>(parsePlanIds(newOrder == null ? null : newOrder.getProductionPlanIds()));
- Set<Long> toRelease = new LinkedHashSet<>(oldIds);
- toRelease.removeAll(newIds);
- Set<Long> toIssue = new LinkedHashSet<>(newIds);
- toIssue.removeAll(oldIds);
- if (!toRelease.isEmpty()) {
- updatePlanIssuedFlag(new ArrayList<>(toRelease), false);
- }
- if (!toIssue.isEmpty()) {
- updatePlanIssuedFlag(new ArrayList<>(toIssue), true);
- }
- }
-
private void releaseProductionPlanIssueStatus(ProductionOrder productionOrder) {
if (productionOrder == null) {
return;
}
List<Long> planIds = parsePlanIds(productionOrder.getProductionPlanIds());
if (!planIds.isEmpty()) {
- updatePlanIssuedFlag(planIds, false);
+ // 鐢熶骇璁㈠崟鍒犻櫎--瀵瑰簲鐨勭敓浜ц鍒掔殑宸蹭笅鍙戞暟閲忚鍑忓幓
+ updatePlanIssuedFlag(planIds, productionOrder.getQuantity());
}
}
- private void updatePlanIssuedFlag(List<Long> planIds, boolean issued) {
+ //鐢熶骇璁㈠崟鍒犻櫎锛岀敓浜ц鍒掔殑宸蹭笅鍙戞暟閲忓搴斿彉鏇�
+ private void updatePlanIssuedFlag(List<Long> planIds, BigDecimal remainingAssignedQuantity) {
if (planIds == null || planIds.isEmpty()) {
return;
}
List<ProductionPlan> plans = productionPlanMapper.selectBatchIds(planIds);
+ //涓嬪彂鏁伴噺鍑忓幓
+ List<ProductionPlan> updates = new ArrayList<>();
for (ProductionPlan plan : plans) {
+ BigDecimal requiredQuantity = Optional.ofNullable(plan.getQtyRequired()).orElse(BigDecimal.ZERO);
+ if (requiredQuantity.compareTo(BigDecimal.ZERO) < 0) {
+ requiredQuantity = BigDecimal.ZERO;
+ }
+ BigDecimal remainingQuantity = resolveRemainingQuantity(plan);
+ BigDecimal historicalIssuedQuantity = requiredQuantity.subtract(remainingQuantity);
+ BigDecimal issuedQuantity = remainingAssignedQuantity.min(historicalIssuedQuantity);
+ remainingAssignedQuantity = remainingAssignedQuantity.subtract(issuedQuantity);
+ BigDecimal totalIssuedQuantity = historicalIssuedQuantity.subtract(issuedQuantity);
+ int planStatus = resolvePlanStatus(requiredQuantity, totalIssuedQuantity);
ProductionPlan update = new ProductionPlan();
update.setId(plan.getId());
- update.setIssued(issued);
- productionPlanMapper.updateById(update);
+ update.setStatus(planStatus);
+ update.setQuantityIssued(totalIssuedQuantity);
+ updates.add(update);
+ }
+ if (!updates.isEmpty()) {
+ productionPlanMapper.updateById(updates);
}
}
- private void upsertOrderPick(ProductionOrder productionOrder) {
- if (productionOrder == null || productionOrder.getId() == null) {
- return;
- }
- // 璁㈠崟涓嬭揪鍚庤嚜鍔ㄧ敓鎴愪竴寮犲鏂欎富鍗曪紝鍚庣画棰嗘枡璁板綍閮芥寕鍦ㄨ繖寮犲崟涓娿��
- ProductionOrderPick orderPick = productionOrderPickMapper.selectOne(
- Wrappers.<ProductionOrderPick>lambdaQuery()
- .eq(ProductionOrderPick::getProductionOrderId, productionOrder.getId())
- .last("limit 1"));
- if (orderPick == null) {
- orderPick = new ProductionOrderPick();
- orderPick.setProductionOrderId(productionOrder.getId());
- }
- orderPick.setProductModelId(productionOrder.getProductModelId() == null ? null : Math.toIntExact(productionOrder.getProductModelId()));
- orderPick.setQuantity(defaultDecimal(productionOrder.getQuantity()));
- orderPick.setRemark("涓嬪崟鑷姩鐢熸垚");
- if (orderPick.getId() == null) {
- productionOrderPickMapper.insert(orderPick);
- } else {
- productionOrderPickMapper.updateById(orderPick);
- }
- }
-
- private BigDecimal resolveBomDemandQuantity(TechnologyBomStructure source, BigDecimal orderQuantity) {
- // 宸ヨ壓 BOM 涓殑闇�姹傞噺鎸夆�滃崟浠堕渶姹� * 璁㈠崟鏁伴噺鈥濆睍寮�鎴愯鍗曠骇闇�姹傘��
- BigDecimal baseQuantity = source.getDemandedQuantity() != null ? source.getDemandedQuantity() : source.getUnitQuantity();
- baseQuantity = baseQuantity == null ? BigDecimal.ZERO : baseQuantity;
- if (baseQuantity.compareTo(BigDecimal.ZERO) <= 0) {
+ private BigDecimal resolveRemainingQuantity(ProductionPlan plan) {
+ if (plan == null) {
return BigDecimal.ZERO;
}
- return baseQuantity.multiply(orderQuantity);
+ BigDecimal requiredQuantity = Optional.ofNullable(plan.getQtyRequired()).orElse(BigDecimal.ZERO);
+ if (requiredQuantity.compareTo(BigDecimal.ZERO) <= 0) {
+ return BigDecimal.ZERO;
+ }
+ BigDecimal issuedQuantity = Optional.ofNullable(plan.getQuantityIssued()).orElse(BigDecimal.ZERO);
+ if (issuedQuantity.compareTo(BigDecimal.ZERO) <= 0) {
+ return requiredQuantity;
+ }
+ if (issuedQuantity.compareTo(requiredQuantity) >= 0) {
+ return BigDecimal.ZERO;
+ }
+ return requiredQuantity.subtract(issuedQuantity);
+ }
+
+ private int resolvePlanStatus(BigDecimal requiredQuantity, BigDecimal issuedQuantity) {
+ if (requiredQuantity == null || requiredQuantity.compareTo(BigDecimal.ZERO) <= 0) {
+ return 0;
+ }
+ if (issuedQuantity == null || issuedQuantity.compareTo(BigDecimal.ZERO) <= 0) {
+ return 0;
+ }
+ return issuedQuantity.compareTo(requiredQuantity) < 0 ? 1 : 2;
}
private List<Long> parsePlanIds(String productionPlanIds) {
@@ -591,10 +609,10 @@
return null;
}
if (productionPlan.getPromisedDeliveryDate() != null) {
- return productionPlan.getPromisedDeliveryDate().toLocalDate();
+ return productionPlan.getPromisedDeliveryDate();
}
if (productionPlan.getRequiredDate() != null) {
- return productionPlan.getRequiredDate().toLocalDate();
+ return productionPlan.getRequiredDate();
}
return null;
}
@@ -663,4 +681,272 @@
vo.setDownloadURL(fileUtil.buildSignedDownloadUrl(vo));
return vo;
}
+
+ @Override
+ public ProductionOrderWorkOrderDetailVo getWorkOrderReportInspectDetail(ProductionOrderDto dto) {
+ Long productionOrderId = resolveProductionOrderId(dto);
+ ProductionOrderVo orderInfo = getProductionOrderInfo(productionOrderId);
+ if (orderInfo == null) {
+ throw new ServiceException("鐢熶骇璁㈠崟涓嶅瓨鍦�");
+ }
+
+ ProductionOrderWorkOrderDetailVo detailVo = new ProductionOrderWorkOrderDetailVo();
+ detailVo.setProductionOrder(orderInfo);
+
+ ProductionOperationTaskDto taskQuery = new ProductionOperationTaskDto();
+ taskQuery.setProductionOrderId(productionOrderId);
+ IPage<ProductionOperationTaskVo> workOrderPage = productionOperationTaskMapper.pageProductionOperationTask(
+ new Page<ProductionOperationTaskVo>(1, -1), taskQuery);
+ List<ProductionOperationTaskVo> workOrderList = workOrderPage == null || workOrderPage.getRecords() == null
+ ? Collections.emptyList()
+ : workOrderPage.getRecords().stream()
+ .filter(Objects::nonNull)
+ .sorted(Comparator.comparing(ProductionOperationTaskVo::getId, Comparator.nullsLast(Comparator.naturalOrder())))
+ .collect(Collectors.toList());
+ if (workOrderList == null || workOrderList.isEmpty()) {
+ detailVo.setWorkOrderList(Collections.emptyList());
+ return detailVo;
+ }
+
+ List<Long> workOrderIdList = workOrderList.stream()
+ .map(ProductionOperationTaskVo::getId)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+ List<ProductionProductMain> reportMainList = workOrderIdList.isEmpty()
+ ? Collections.emptyList()
+ : productionProductMainMapper.selectList(
+ Wrappers.<ProductionProductMain>lambdaQuery()
+ .in(ProductionProductMain::getProductionOperationTaskId, workOrderIdList)
+ .orderByAsc(ProductionProductMain::getId));
+ Map<Long, List<ProductionProductMain>> reportMainByWorkOrderMap = new LinkedHashMap<>();
+ for (ProductionProductMain reportMain : reportMainList) {
+ if (reportMain == null || reportMain.getProductionOperationTaskId() == null) {
+ continue;
+ }
+ reportMainByWorkOrderMap.computeIfAbsent(reportMain.getProductionOperationTaskId(), key -> new ArrayList<>()).add(reportMain);
+ }
+
+ List<Long> reportMainIdList = reportMainList.stream()
+ .map(ProductionProductMain::getId)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+ Map<Long, List<ProductionProductOutput>> reportOutputMap = new LinkedHashMap<>();
+ Map<Long, List<ProductionOrderRoutingOperationParam>> reportParamMap = new LinkedHashMap<>();
+ Map<Long, List<QualityInspect>> inspectMap = new LinkedHashMap<>();
+ Map<Long, List<QualityInspectParam>> inspectParamMap = new LinkedHashMap<>();
+ Map<Long, List<QualityInspectFile>> inspectFileMap = new LinkedHashMap<>();
+ if (!reportMainIdList.isEmpty()) {
+ List<ProductionProductOutput> reportOutputList = productionProductOutputMapper.selectList(
+ Wrappers.<ProductionProductOutput>lambdaQuery()
+ .in(ProductionProductOutput::getProductionProductMainId, reportMainIdList)
+ .orderByAsc(ProductionProductOutput::getId));
+ for (ProductionProductOutput reportOutput : reportOutputList) {
+ if (reportOutput == null) {
+ continue;
+ }
+ Long reportMainId = reportOutput.getProductionProductMainId() != null
+ ? reportOutput.getProductionProductMainId()
+ : reportOutput.getProductMainId();
+ if (reportMainId == null) {
+ continue;
+ }
+ reportOutputMap.computeIfAbsent(reportMainId, k -> new ArrayList<>()).add(reportOutput);
+ }
+
+ List<ProductionOrderRoutingOperationParam> reportParamList = productionOrderRoutingOperationParamMapper.selectList(
+ Wrappers.<ProductionOrderRoutingOperationParam>lambdaQuery()
+ .in(ProductionOrderRoutingOperationParam::getProductionProductMainId, reportMainIdList)
+ .orderByAsc(ProductionOrderRoutingOperationParam::getId));
+ for (ProductionOrderRoutingOperationParam reportParam : reportParamList) {
+ if (reportParam == null || reportParam.getProductionProductMainId() == null) {
+ continue;
+ }
+ reportParamMap.computeIfAbsent(reportParam.getProductionProductMainId(), k -> new ArrayList<>()).add(reportParam);
+ }
+
+ List<QualityInspect> inspectList = qualityInspectMapper.selectList(
+ Wrappers.<QualityInspect>lambdaQuery()
+ .in(QualityInspect::getProductMainId, reportMainIdList)
+ .orderByAsc(QualityInspect::getId));
+ for (QualityInspect inspect : inspectList) {
+ if (inspect == null || inspect.getProductMainId() == null) {
+ continue;
+ }
+ inspectMap.computeIfAbsent(inspect.getProductMainId(), key -> new ArrayList<>()).add(inspect);
+ }
+
+ List<Long> inspectIdList = inspectList.stream()
+ .map(QualityInspect::getId)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+ if (!inspectIdList.isEmpty()) {
+ List<QualityInspectParam> inspectParamList = qualityInspectParamMapper.selectList(
+ Wrappers.<QualityInspectParam>lambdaQuery()
+ .in(QualityInspectParam::getInspectId, inspectIdList)
+ .orderByAsc(QualityInspectParam::getId));
+ for (QualityInspectParam inspectParam : inspectParamList) {
+ if (inspectParam == null || inspectParam.getInspectId() == null) {
+ continue;
+ }
+ inspectParamMap.computeIfAbsent(inspectParam.getInspectId(), k -> new ArrayList<>()).add(inspectParam);
+ }
+
+ List<QualityInspectFile> inspectFileList = qualityInspectFileMapper.selectList(
+ Wrappers.<QualityInspectFile>lambdaQuery()
+ .in(QualityInspectFile::getInspectId, inspectIdList)
+ .orderByAsc(QualityInspectFile::getId));
+ for (QualityInspectFile inspectFile : inspectFileList) {
+ if (inspectFile == null || inspectFile.getInspectId() == null) {
+ continue;
+ }
+ inspectFileMap.computeIfAbsent(inspectFile.getInspectId(), k -> new ArrayList<>()).add(inspectFile);
+ }
+ }
+ }
+
+ List<ProductionOrderWorkOrderDetailVo.WorkOrderDetail> workOrderDetailList = new ArrayList<>();
+ for (ProductionOperationTaskVo workOrder : workOrderList) {
+ ProductionOrderWorkOrderDetailVo.WorkOrderDetail workOrderDetail = new ProductionOrderWorkOrderDetailVo.WorkOrderDetail();
+ workOrderDetail.setWorkOrder(workOrder);
+
+ List<ProductionProductMain> workOrderReportMainList = reportMainByWorkOrderMap.getOrDefault(workOrder.getId(), Collections.emptyList());
+ if (workOrderReportMainList.isEmpty()) {
+ workOrderDetail.setReportList(Collections.emptyList());
+ workOrderDetail.setInspectList(Collections.emptyList());
+ workOrderDetailList.add(workOrderDetail);
+ continue;
+ }
+
+ List<ProductionOrderWorkOrderDetailVo.ReportDetail> reportDetailList = new ArrayList<>();
+ List<ProductionOrderWorkOrderDetailVo.InspectDetail> inspectDetailList = new ArrayList<>();
+ for (ProductionProductMain reportMain : workOrderReportMainList) {
+ Long reportMainId = reportMain.getId();
+
+ ProductionOrderWorkOrderDetailVo.ReportDetail reportDetail = new ProductionOrderWorkOrderDetailVo.ReportDetail();
+ reportDetail.setReportMain(reportMain);
+ reportDetail.setReportOutputList(reportOutputMap.getOrDefault(reportMainId, Collections.emptyList()));
+ reportDetail.setReportParamList(reportParamMap.getOrDefault(reportMainId, Collections.emptyList()));
+ reportDetailList.add(reportDetail);
+
+ List<QualityInspect> reportInspectList = inspectMap.getOrDefault(reportMainId, Collections.emptyList());
+ for (QualityInspect inspect : reportInspectList) {
+ ProductionOrderWorkOrderDetailVo.InspectDetail inspectDetail = new ProductionOrderWorkOrderDetailVo.InspectDetail();
+ inspectDetail.setReportId(reportMainId);
+ inspectDetail.setReportNo(reportMain.getProductNo());
+ inspectDetail.setReportMain(reportMain);
+ inspectDetail.setInspect(inspect);
+ inspectDetail.setInspectParamList(inspectParamMap.getOrDefault(inspect.getId(), Collections.emptyList()));
+ inspectDetail.setInspectFileList(inspectFileMap.getOrDefault(inspect.getId(), Collections.emptyList()));
+ inspectDetailList.add(inspectDetail);
+ }
+ }
+
+ workOrderDetail.setReportList(reportDetailList);
+ workOrderDetail.setInspectList(inspectDetailList);
+ workOrderDetailList.add(workOrderDetail);
+ }
+
+ detailVo.setWorkOrderList(workOrderDetailList);
+ return detailVo;
+ }
+
+ private Long resolveProductionOrderId(ProductionOrderDto dto) {
+ if (dto == null) {
+ throw new ServiceException("璇蜂紶鍏ョ敓浜ц鍗旾D鎴栫敓浜ц鍗曞彿");
+ }
+ if (dto.getId() != null) {
+ return dto.getId();
+ }
+ if (dto.getNpsNo() == null || dto.getNpsNo().trim().isEmpty()) {
+ throw new ServiceException("璇蜂紶鍏ョ敓浜ц鍗旾D鎴栫敓浜ц鍗曞彿");
+ }
+ ProductionOrder productionOrder = baseMapper.selectOne(
+ Wrappers.<ProductionOrder>lambdaQuery()
+ .eq(ProductionOrder::getNpsNo, dto.getNpsNo().trim())
+ .last("limit 1"));
+ if (productionOrder == null || productionOrder.getId() == null) {
+ throw new ServiceException("鐢熶骇璁㈠崟涓嶅瓨鍦�");
+ }
+ return productionOrder.getId();
+ }
+
+ @Override
+ public List<ProductionOrderPickVo> pick(Long productionOrderId) {
+ if (productionOrderId == null) {
+ return Collections.emptyList();
+ }
+
+ ProductionOrderBom orderBom = productionOrderBomMapper.selectOne(
+ Wrappers.<ProductionOrderBom>lambdaQuery()
+ .eq(ProductionOrderBom::getProductionOrderId, productionOrderId)
+ .orderByDesc(ProductionOrderBom::getId)
+ .last("limit 1"));
+ if (orderBom == null || orderBom.getId() == null) {
+ return Collections.emptyList();
+ }
+
+ List<ProductionBomStructureVo> bomStructureList = productionBomStructureMapper.pickByBomId(orderBom.getId());
+ if (bomStructureList == null || bomStructureList.isEmpty()) {
+ return Collections.emptyList();
+ }
+
+ List<Long> productModelIds = bomStructureList.stream()
+ .map(ProductionBomStructureVo::getProductModelId)
+ .filter(Objects::nonNull)
+ .distinct()
+ .collect(Collectors.toList());
+ Map<Long, BigDecimal> stockQuantityMap = new HashMap<>();
+ Map<Long, LinkedHashSet<String>> stockBatchNoMap = new HashMap<>();
+ if (!productModelIds.isEmpty()) {
+ List<StockInventory> stockList = stockInventoryMapper.selectList(
+ Wrappers.<StockInventory>lambdaQuery()
+ .in(StockInventory::getProductModelId, productModelIds));
+ for (StockInventory stockItem : stockList) {
+ if (stockItem == null || stockItem.getProductModelId() == null) {
+ continue;
+ }
+ Long productModelId = stockItem.getProductModelId();
+ stockQuantityMap.merge(productModelId, defaultDecimal(stockItem.getQualitity()), BigDecimal::add);
+ String batchNo = stockItem.getBatchNo();
+ if (batchNo != null && !batchNo.trim().isEmpty()) {
+ stockBatchNoMap.computeIfAbsent(productModelId, key -> new LinkedHashSet<>()).add(batchNo);
+ }
+ }
+ }
+
+ Map<String, ProductionOrderPickVo> mergedPickMap = new LinkedHashMap<>();
+ for (ProductionBomStructureVo structure : bomStructureList) {
+ if (structure == null || structure.getProductModelId() == null) {
+ continue;
+ }
+ Long productModelId = structure.getProductModelId();
+ String mergeKey = String.valueOf(structure.getTechnologyOperationId()) + "#" + productModelId;
+ ProductionOrderPickVo vo = mergedPickMap.get(mergeKey);
+ if (vo == null) {
+ vo = new ProductionOrderPickVo();
+ vo.setProductModelId(productModelId);
+ vo.setOperationName(structure.getOperationName());
+ vo.setTechnologyOperationId(structure.getTechnologyOperationId());
+ vo.setProductName(structure.getProductName());
+ vo.setModel(structure.getModel());
+ vo.setDemandedQuantity(BigDecimal.ZERO);
+ vo.setUnit(structure.getUnit());
+ List<String> batchNoList = stockBatchNoMap.get(productModelId) == null
+ ? Collections.emptyList()
+ : new ArrayList<>(stockBatchNoMap.get(productModelId));
+ vo.setBatchNoList(batchNoList);
+ vo.setStockQuantity(stockQuantityMap.getOrDefault(productModelId, BigDecimal.ZERO));
+ vo.setBom(true);
+ mergedPickMap.put(mergeKey, vo);
+ }
+ vo.setDemandedQuantity(defaultDecimal(vo.getDemandedQuantity()).add(defaultDecimal(structure.getDemandedQuantity())));
+ }
+ return new ArrayList<>(mergedPickMap.values());
+ }
+
+ @Override
+ public int updateOrder(ProductionOrderDto productionOrderDto) {
+ productionOrderDto.setStatus(5);
+ return baseMapper.updateById(productionOrderDto);
+ }
}
--
Gitblit v1.9.3