From 0268f58a18bfcf061389387ef5322bf11aece154 Mon Sep 17 00:00:00 2001
From: huminmin <mac@MacBook-Pro.local>
Date: 星期二, 28 四月 2026 14:22:54 +0800
Subject: [PATCH] Merge branch 'dev_New_pro' of http://114.132.189.42:9002/r/product-inventory-management-after into dev_New_pro
---
src/main/java/com/ruoyi/production/service/impl/ProductionOrderServiceImpl.java | 725 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 715 insertions(+), 10 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 6b1bc0c..31affd2 100644
--- a/src/main/java/com/ruoyi/production/service/impl/ProductionOrderServiceImpl.java
+++ b/src/main/java/com/ruoyi/production/service/impl/ProductionOrderServiceImpl.java
@@ -1,20 +1,725 @@
package com.ruoyi.production.service.impl;
+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;
-import com.ruoyi.production.mapper.ProductionOrderMapper;
-import com.ruoyi.production.pojo.ProductionOrder;
+import com.ruoyi.basic.dto.StorageBlobVO;
+import com.ruoyi.basic.mapper.StorageAttachmentMapper;
+import com.ruoyi.basic.mapper.StorageBlobMapper;
+import com.ruoyi.basic.pojo.StorageAttachment;
+import com.ruoyi.basic.pojo.StorageBlob;
+import com.ruoyi.basic.utils.FileUtil;
+import com.ruoyi.common.constant.StorageAttachmentConstants;
+import com.ruoyi.common.exception.ServiceException;
+import com.ruoyi.production.bean.dto.ProductionOrderDto;
+import com.ruoyi.production.bean.vo.ProductionBomStructureVo;
+import com.ruoyi.production.bean.vo.ProductionOrderPickVo;
+import com.ruoyi.production.bean.vo.ProductionOrderVo;
+import com.ruoyi.production.bean.vo.ProductionPlanVo;
+import com.ruoyi.production.enums.ProductOrderStatusEnum;
+import com.ruoyi.production.mapper.*;
+import com.ruoyi.production.pojo.*;
import com.ruoyi.production.service.ProductionOrderService;
+import com.ruoyi.sales.mapper.SalesLedgerMapper;
+import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
+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;
-/**
- * <p>
- * 鐢熶骇璁㈠崟琛� 鏈嶅姟瀹炵幇绫�
- * </p>
- *
- * @author 鑺杞欢锛堟睙鑻忥級鏈夐檺鍏徃
- * @since 2026-04-21 03:55:52
- */
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.stream.Collectors;
+
@Service
+@Transactional(rollbackFor = Exception.class)
+@RequiredArgsConstructor
public class ProductionOrderServiceImpl extends ServiceImpl<ProductionOrderMapper, ProductionOrder> implements ProductionOrderService {
+ private final ProductionOrderRoutingMapper productionOrderRoutingMapper;
+ private final ProductionOrderRoutingOperationMapper productionOrderRoutingOperationMapper;
+ private final ProductionOrderRoutingOperationParamMapper productionOrderRoutingOperationParamMapper;
+ private final ProductionOperationTaskMapper productionOperationTaskMapper;
+ private final ProductionOrderBomMapper productionOrderBomMapper;
+ private final ProductionBomStructureMapper productionBomStructureMapper;
+ private final ProductionProductMainMapper productionProductMainMapper;
+ private final ProductionOrderPickMapper productionOrderPickMapper;
+ private final ProductionOrderPickRecordMapper productionOrderPickRecordMapper;
+ private final ProductionPlanMapper productionPlanMapper;
+ private final StockInventoryMapper stockInventoryMapper;
+ private final StorageAttachmentMapper storageAttachmentMapper;
+ private final StorageBlobMapper storageBlobMapper;
+ private final SalesLedgerMapper salesLedgerMapper;
+ private final SalesLedgerProductMapper salesLedgerProductMapper;
+ 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 IPage<ProductionOrderVo> pageProductionOrder(Page<ProductionOrderDto> page, ProductionOrderDto dto) {
+ Page<ProductionOrderVo> result = (Page<ProductionOrderVo>) baseMapper.pageProductionOrder(page, dto);
+ fillProductImages(result.getRecords());
+ return result;
+ }
+
+ @Override
+ public List<ProductionOrderVo> listProductionOrder(ProductionOrderDto dto) {
+ List<ProductionOrderVo> records = baseMapper.listProductionOrder(dto);
+ fillProductImages(records);
+ return records;
+ }
+
+ @Override
+ public ProductionOrderVo getProductionOrderInfo(Long id) {
+ ProductionOrderVo item = baseMapper.getProductionOrderInfo(id);
+ if (item == null) {
+ return null;
+ }
+ fillProductImages(java.util.Collections.singletonList(item));
+ return item;
+ }
+
+ @Override
+ public boolean saveProductionOrder(ProductionOrder productionOrder) {
+ ProductionOrder oldOrder = productionOrder.getId() == null ? null : this.getById(productionOrder.getId());
+ // 涓嬪崟鍏ュ彛缁熶竴琛ラ綈鏉ユ簮鍗曟嵁銆佽鍒掑拰宸ヨ壓淇℃伅锛岄伩鍏嶅墠绔垎鍒紶澶氬瀛楁銆�
+ validateAndFillOrder(productionOrder, oldOrder);
+ if (productionOrder.getNpsNo() == null || productionOrder.getNpsNo().trim().isEmpty()) {
+ productionOrder.setNpsNo(generateNextOrderNo());
+ }
+ if (productionOrder.getCompleteQuantity() == null) {
+ productionOrder.setCompleteQuantity(BigDecimal.ZERO);
+ }
+ if (productionOrder.getStatus() == null) {
+ productionOrder.setStatus(ProductOrderStatusEnum.WAIT.getCode());
+ }
+ boolean saved = this.saveOrUpdate(productionOrder);
+ if (!saved) {
+ return false;
+ }
+ boolean needSync = productionOrder.getTechnologyRoutingId() != null
+ && (oldOrder == null
+ || !Objects.equals(oldOrder.getTechnologyRoutingId(), productionOrder.getTechnologyRoutingId())
+ || !Objects.equals(oldOrder.getProductModelId(), productionOrder.getProductModelId())
+ || compareDecimal(oldOrder.getQuantity(), productionOrder.getQuantity()) != 0
+ || productionOrderRoutingMapper.selectCount(Wrappers.<ProductionOrderRouting>lambdaQuery()
+ .eq(ProductionOrderRouting::getProductionOrderId, productionOrder.getId())) == 0);
+ if (needSync) {
+ syncProductionOrderSnapshot(productionOrder.getId());
+ }
+ return true;
+ }
+
+ @Override
+ public boolean removeProductionOrder(List<Long> ids) {
+ if (ids == null || ids.isEmpty()) {
+ return false;
+ }
+ for (Long id : ids) {
+ ProductionOrder productionOrder = this.getById(id);
+ clearProductionSnapshot(id);
+ releaseProductionPlanIssueStatus(productionOrder);
+ }
+ return this.removeByIds(ids);
+ }
+
+ @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("鐢熶骇璁㈠崟涓嶅瓨鍦�");
+ }
+ if (productionOrder.getTechnologyRoutingId() == null) {
+ throw new ServiceException("宸ヨ壓璺嚎ID涓嶈兘涓虹┖");
+ }
+ TechnologyRouting technologyRouting = technologyRoutingMapper.selectById(productionOrder.getTechnologyRoutingId());
+ if (technologyRouting == null) {
+ throw new ServiceException("宸ヨ壓璺嚎涓嶅瓨鍦�");
+ }
+ // 璁㈠崟蹇収鎸夆�滃厛娓呭悗寤衡�濆鐞嗭紝淇濊瘉宸ヨ壓璺嚎銆佸伐搴忋�佸弬鏁般�丅OM 鍏ㄩ儴鏉ヨ嚜鍚屼竴鐗堟湰銆�
+ clearProductionSnapshot(productionOrderId);
+ ProductionOrderBom orderBom = syncProductionOrderBomSnapshot(productionOrder, technologyRouting);
+
+ ProductionOrderRouting orderRouting = new ProductionOrderRouting();
+ orderRouting.setProductionOrderId(productionOrder.getId());
+ orderRouting.setTechnologyRoutingId(technologyRouting.getId());
+ orderRouting.setProductModelId(technologyRouting.getProductModelId());
+ 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));
+ 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));
+ for (TechnologyRoutingOperation sourceOperation : routingOperations) {
+ // 璁㈠崟宸ュ簭淇濆瓨鐨勬槸宸ヨ壓宸ュ簭蹇収锛屽悗缁姤宸ュ彧渚濊禆蹇収锛屼笉鍐嶇洿鎺ュ紩鐢ㄥ伐鑹轰富鏁版嵁銆�
+ ProductionOrderRoutingOperation targetOperation = new ProductionOrderRoutingOperation();
+ targetOperation.setProductionOrderId(productionOrder.getId());
+ targetOperation.setTechnologyRoutingOperationId(sourceOperation.getId());
+ targetOperation.setOrderRoutingId(orderRouting.getId());
+ targetOperation.setProductModelId(sourceOperation.getProductModelId());
+ targetOperation.setDragSort(sourceOperation.getDragSort());
+ 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);
+
+ List<TechnologyRoutingOperationParam> sourceParams = technologyRoutingOperationParamMapper.selectList(
+ Wrappers.<TechnologyRoutingOperationParam>lambdaQuery()
+ .eq(TechnologyRoutingOperationParam::getTechnologyRoutingOperationId, sourceOperation.getId())
+ .orderByAsc(TechnologyRoutingOperationParam::getId));
+ for (TechnologyRoutingOperationParam sourceParam : sourceParams) {
+ // 宸ュ簭鎵ц鍙傛暟鍚屾牱鍋氬揩鐓э紝閬垮厤宸ヨ壓鍙傛暟璋冩暣褰卞搷宸蹭笅杈捐鍗曘��
+ ProductionOrderRoutingOperationParam targetParam = new ProductionOrderRoutingOperationParam();
+ targetParam.setProductionOrderId(productionOrder.getId());
+ targetParam.setProductionOrderRoutingOperationId(targetOperation.getId());
+ targetParam.setTechnologyRoutingOperationParamId(sourceParam.getId());
+ targetParam.setParamId(sourceParam.getParamId());
+ targetParam.setTechnologyOperationId(sourceParam.getTechnologyOperationId());
+ targetParam.setTechnologyOperationParamId(sourceParam.getTechnologyOperationParamId());
+ targetParam.setParamCode(sourceParam.getParamCode());
+ targetParam.setParamName(sourceParam.getParamName());
+ targetParam.setParamType(sourceParam.getParamType());
+ targetParam.setParamFormat(sourceParam.getParamFormat());
+ targetParam.setUnit(sourceParam.getUnit());
+ targetParam.setIsRequired(sourceParam.getIsRequired());
+ targetParam.setRemark(sourceParam.getRemark());
+ targetParam.setStandardValue(sourceParam.getStandardValue());
+ productionOrderRoutingOperationParamMapper.insert(targetParam);
+ syncedParamCount++;
+ }
+ }
+ return syncedParamCount;
+ }
+
+ private ProductionOrderBom syncProductionOrderBomSnapshot(ProductionOrder productionOrder, TechnologyRouting technologyRouting) {
+ if (technologyRouting.getBomId() == null) {
+ return null;
+ }
+ TechnologyBom technologyBom = technologyBomMapper.selectById(technologyRouting.getBomId());
+ if (technologyBom == null) {
+ throw new ServiceException("宸ヨ壓BOM涓嶅瓨鍦�");
+ }
+ List<TechnologyBomStructure> structureList = technologyBomStructureMapper.selectList(
+ Wrappers.<TechnologyBomStructure>lambdaQuery()
+ .eq(TechnologyBomStructure::getBomId, technologyBom.getId())
+ .orderByAsc(TechnologyBomStructure::getId));
+ TechnologyBomStructure root = structureList.stream().filter(item -> item.getParentId() == null).findFirst().orElse(null);
+ BigDecimal orderQuantity = defaultDecimal(productionOrder.getQuantity());
+
+ ProductionOrderBom orderBom = new ProductionOrderBom();
+ orderBom.setProductionOrderId(productionOrder.getId());
+ orderBom.setBomId(Long.valueOf(technologyBom.getId()));
+ orderBom.setProductModelId(root != null ? root.getProductModelId() : productionOrder.getProductModelId());
+ orderBom.setRemark(technologyBom.getRemark());
+ orderBom.setBomNo(technologyBom.getBomNo());
+ orderBom.setVersion(technologyBom.getVersion());
+ productionOrderBomMapper.insert(orderBom);
+
+ Map<Long, Long> idMap = new HashMap<>();
+ for (TechnologyBomStructure source : structureList) {
+ // 瀛愯妭鐐� parentId 闇�瑕佹槧灏勬垚鏂板揩鐓ц妭鐐� id锛屾墠鑳戒繚鐣欏師濮� BOM 灞傜骇銆�
+ ProductionBomStructure target = new ProductionBomStructure();
+ target.setProductionOrderId(productionOrder.getId());
+ target.setProductionOrderBomId(orderBom.getId());
+ target.setParentId(source.getParentId() == null ? null : idMap.get(source.getParentId()));
+ target.setProductModelId(source.getProductModelId());
+ target.setTechnologyOperationId(source.getOperationId());
+ target.setUnitQuantity(source.getUnitQuantity());
+ 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) {
+ // 宸蹭骇鐢熼鏂欒褰曞悗绂佹閲嶅缓锛岄伩鍏嶅鏂�/鎶曟枡渚濇嵁涓庤鍗曞揩鐓ц劚鑺傘��
+ boolean hasPickRecord = productionOrderPickRecordMapper.selectCount(
+ Wrappers.<ProductionOrderPickRecord>lambdaQuery()
+ .eq(ProductionOrderPickRecord::getProductionOrderId, productionOrderId)) > 0;
+ if (hasPickRecord) {
+ throw new ServiceException("鐢熶骇璁㈠崟宸插瓨鍦ㄩ鏂欒褰曪紝涓嶈兘閲嶆柊鐢熸垚蹇収");
+ }
+ List<Long> taskIds = productionOperationTaskMapper.selectList(
+ Wrappers.<ProductionOperationTask>lambdaQuery()
+ .eq(ProductionOperationTask::getProductionOrderId, productionOrderId))
+ .stream().map(ProductionOperationTask::getId).collect(Collectors.toList());
+ if (!taskIds.isEmpty()) {
+ // 宸叉湁鎶ュ伐璁板綍璇存槑璁㈠崟宸插紑宸ワ紝姝ゆ椂涓嶅厑璁稿啀閲嶅缓蹇収銆�
+ boolean started = productionProductMainMapper.selectCount(
+ Wrappers.<ProductionProductMain>lambdaQuery()
+ .in(ProductionProductMain::getProductionOperationTaskId, taskIds)) > 0;
+ if (started) {
+ throw new ServiceException("鐢熶骇璁㈠崟宸插紑宸ワ紝涓嶈兘閲嶆柊鐢熸垚蹇収");
+ }
+ productionOperationTaskMapper.delete(Wrappers.<ProductionOperationTask>lambdaQuery()
+ .eq(ProductionOperationTask::getProductionOrderId, productionOrderId));
+ }
+ productionOrderRoutingOperationParamMapper.delete(Wrappers.<ProductionOrderRoutingOperationParam>lambdaQuery()
+ .eq(ProductionOrderRoutingOperationParam::getProductionOrderId, productionOrderId));
+ productionOrderRoutingOperationMapper.delete(Wrappers.<ProductionOrderRoutingOperation>lambdaQuery()
+ .eq(ProductionOrderRoutingOperation::getProductionOrderId, productionOrderId));
+ productionOrderRoutingMapper.delete(Wrappers.<ProductionOrderRouting>lambdaQuery()
+ .eq(ProductionOrderRouting::getProductionOrderId, productionOrderId));
+ productionBomStructureMapper.delete(Wrappers.<ProductionBomStructure>lambdaQuery()
+ .eq(ProductionBomStructure::getProductionOrderId, productionOrderId));
+ productionOrderBomMapper.delete(Wrappers.<ProductionOrderBom>lambdaQuery()
+ .eq(ProductionOrderBom::getProductionOrderId, productionOrderId));
+ productionOrderPickMapper.delete(Wrappers.<ProductionOrderPick>lambdaQuery()
+ .eq(ProductionOrderPick::getProductionOrderId, productionOrderId));
+ }
+
+ private LambdaQueryWrapper<ProductionOrder> buildQueryWrapper(ProductionOrderDto dto) {
+ ProductionOrder query = dto == null ? new ProductionOrder() : dto;
+ return Wrappers.<ProductionOrder>lambdaQuery()
+ .eq(query.getId() != null, ProductionOrder::getId, query.getId())
+ .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())
+ .orderByDesc(ProductionOrder::getId);
+ }
+
+ private String generateNextOrderNo() {
+ String datePrefix = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
+ String prefix = "SC" + datePrefix;
+ ProductionOrder latestOrder = this.getOne(Wrappers.<ProductionOrder>lambdaQuery()
+ .likeRight(ProductionOrder::getNpsNo, prefix)
+ .orderByDesc(ProductionOrder::getNpsNo)
+ .last("limit 1"));
+ int sequence = 1;
+ if (latestOrder != null && latestOrder.getNpsNo() != null && latestOrder.getNpsNo().startsWith(prefix)) {
+ try {
+ sequence = Integer.parseInt(latestOrder.getNpsNo().substring(prefix.length())) + 1;
+ } catch (NumberFormatException ignored) {
+ sequence = 1;
+ }
+ }
+ return prefix + String.format("%04d", sequence);
+ }
+
+ private String generateNextTaskNo() {
+ String datePrefix = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
+ String prefix = "GD" + datePrefix;
+ ProductionOperationTask lastTask = productionOperationTaskMapper.selectOne(
+ Wrappers.<ProductionOperationTask>lambdaQuery()
+ .likeRight(ProductionOperationTask::getWorkOrderNo, prefix)
+ .orderByDesc(ProductionOperationTask::getWorkOrderNo)
+ .last("limit 1"));
+ int sequence = 1;
+ if (lastTask != null && lastTask.getWorkOrderNo() != null && lastTask.getWorkOrderNo().startsWith(prefix)) {
+ try {
+ sequence = Integer.parseInt(lastTask.getWorkOrderNo().substring(prefix.length())) + 1;
+ } catch (NumberFormatException ignored) {
+ sequence = 1;
+ }
+ }
+ return prefix + String.format("%03d", sequence);
+ }
+
+ private BigDecimal defaultDecimal(BigDecimal value) {
+ return value == null ? BigDecimal.ZERO : value;
+ }
+
+ private void validateAndFillOrder(ProductionOrder productionOrder, ProductionOrder oldOrder) {
+ if (productionOrder == null) {
+ throw new ServiceException("鐢熶骇璁㈠崟涓嶈兘涓虹┖");
+ }
+ fillFromProductionPlans(productionOrder);
+ if (productionOrder.getProductModelId() == null) {
+ throw new ServiceException("浜у搧瑙勬牸ID涓嶈兘涓虹┖");
+ }
+ if (defaultDecimal(productionOrder.getQuantity()).compareTo(BigDecimal.ZERO) <= 0) {
+ throw new ServiceException("涓嬪崟鏁伴噺蹇呴』澶т簬0");
+ }
+ if (productionOrder.getTechnologyRoutingId() == null) {
+ // 鏈樉寮忔寚瀹氬伐鑹鸿矾绾挎椂锛屾寜浜у搧瑙勬牸閫夋渶鏂颁竴鏉″伐鑹轰綔涓洪粯璁よ矾绾裤��
+ TechnologyRouting technologyRouting = technologyRoutingMapper.selectOne(
+ Wrappers.<TechnologyRouting>lambdaQuery()
+ .eq(TechnologyRouting::getProductModelId, productionOrder.getProductModelId())
+ .orderByDesc(TechnologyRouting::getId)
+ .last("limit 1"));
+ if (technologyRouting != null) {
+ 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("鐢熶骇璁㈠崟宸插紑宸ワ紝涓嶈兘淇敼浜у搧銆佸伐鑹鸿矾绾挎垨鏁伴噺");
+ }
+ }
+ }
+
+ private void fillFromProductionPlans(ProductionOrder productionOrder) {
+ List<Long> planIds = parsePlanIds(productionOrder.getProductionPlanIds());
+ if (planIds.isEmpty()) {
+ return;
+ }
+ // 澶氳鍒掑悎骞惰浆鍗曟椂锛屾墍鏈夎鍒掑繀椤诲睘浜庡悓涓�瑙勬牸锛屼笖鍙兘涓嬪彂涓�娆°��
+ List<ProductionPlan> productionPlans = productionPlanMapper.selectBatchIds(planIds);
+ if (productionPlans.size() != planIds.size()) {
+ throw new ServiceException("閮ㄥ垎鐢熶骇璁″垝涓嶅瓨鍦�");
+ }
+ Set<Long> productModelIds = productionPlans.stream()
+ .map(ProductionPlan::getProductModelId)
+ .collect(Collectors.toSet());
+ if (productModelIds.size() > 1) {
+ throw new ServiceException("鎵�閫夌敓浜ц鍒掑繀椤诲睘浜庡悓涓�浜у搧瑙勬牸");
+ }
+ if (productionPlans.stream().anyMatch(item -> item.getStatus() != null && item.getStatus() == 2)) {
+ throw new ServiceException("鎵�閫夌敓浜ц鍒掑凡涓嬪彂");
+ }
+ ProductionPlan firstPlan = productionPlans.get(0);
+ if (productionOrder.getProductModelId() == null) {
+ productionOrder.setProductModelId(firstPlan.getProductModelId());
+ } else if (!Objects.equals(productionOrder.getProductModelId(), firstPlan.getProductModelId())) {
+ throw new ServiceException("浜у搧瑙勬牸ID涓庣敓浜ц鍒掍笉涓�鑷�");
+ }
+ if (productionOrder.getQuantity() == null || productionOrder.getQuantity().compareTo(BigDecimal.ZERO) <= 0) {
+ productionOrder.setQuantity(productionPlans.stream()
+ .map(ProductionPlan::getQtyRequired)
+ .reduce(BigDecimal.ZERO, BigDecimal::add));
+ }
+ if (productionOrder.getPlanCompleteTime() == null) {
+ LocalDate planCompleteTime = productionPlans.stream()
+ .map(this::resolvePlanCompleteDate)
+ .filter(Objects::nonNull)
+ .min(Comparator.naturalOrder())
+ .orElse(null);
+ productionOrder.setPlanCompleteTime(planCompleteTime);
+ }
+ productionOrder.setProductionPlanIds(formatPlanIds(planIds));
+ }
+
+ private void releaseProductionPlanIssueStatus(ProductionOrder productionOrder) {
+ if (productionOrder == null) {
+ return;
+ }
+ List<Long> planIds = parsePlanIds(productionOrder.getProductionPlanIds());
+ if (!planIds.isEmpty()) {
+ // 鐢熶骇璁㈠崟鍒犻櫎--瀵瑰簲鐨勭敓浜ц鍒掔殑宸蹭笅鍙戞暟閲忚鍑忓幓
+ updatePlanIssuedFlag(planIds, productionOrder.getQuantity());
+ }
+ }
+
+ //鐢熶骇璁㈠崟鍒犻櫎锛岀敓浜ц鍒掔殑宸蹭笅鍙戞暟閲忓搴斿彉鏇�
+ 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.setStatus(planStatus);
+ update.setQuantityIssued(totalIssuedQuantity);
+ updates.add(update);
+ }
+ if (!updates.isEmpty()) {
+ productionPlanMapper.updateById(updates);
+ }
+ }
+
+ private BigDecimal resolveRemainingQuantity(ProductionPlan plan) {
+ if (plan == null) {
+ return BigDecimal.ZERO;
+ }
+ 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) {
+ if (productionPlanIds == null || productionPlanIds.trim().isEmpty()) {
+ return new ArrayList<>();
+ }
+ String normalized = productionPlanIds.replace("[", "").replace("]", "").trim();
+ if (normalized.isEmpty()) {
+ return new ArrayList<>();
+ }
+ return java.util.Arrays.stream(normalized.split(","))
+ .map(String::trim)
+ .filter(item -> !item.isEmpty())
+ .map(Long::valueOf)
+ .distinct()
+ .collect(Collectors.toList());
+ }
+
+ private String formatPlanIds(List<Long> planIds) {
+ if (planIds == null || planIds.isEmpty()) {
+ return null;
+ }
+ return planIds.stream()
+ .distinct()
+ .map(String::valueOf)
+ .collect(Collectors.joining(",", "[", "]"));
+ }
+
+ private LocalDate resolvePlanCompleteDate(ProductionPlan productionPlan) {
+ if (productionPlan == null) {
+ return null;
+ }
+ if (productionPlan.getPromisedDeliveryDate() != null) {
+ return productionPlan.getPromisedDeliveryDate();
+ }
+ if (productionPlan.getRequiredDate() != null) {
+ return productionPlan.getRequiredDate();
+ }
+ return null;
+ }
+
+ private int compareDecimal(BigDecimal left, BigDecimal right) {
+ return defaultDecimal(left).compareTo(defaultDecimal(right));
+ }
+
+ private void fillProductImages(List<ProductionOrderVo> records) {
+ if (records == null || records.isEmpty()) {
+ return;
+ }
+ List<Long> productModelIds = records.stream()
+ .map(ProductionOrderVo::getProductModelId)
+ .filter(Objects::nonNull)
+ .distinct()
+ .collect(Collectors.toList());
+ if (productModelIds.isEmpty()) {
+ return;
+ }
+
+ List<StorageAttachment> attachments = storageAttachmentMapper.selectList(
+ Wrappers.<StorageAttachment>lambdaQuery()
+ .in(StorageAttachment::getRecordId, productModelIds)
+ .eq(StorageAttachment::getApplication, StorageAttachmentConstants.StorageAttachmentImage)
+ .eq(StorageAttachment::getDeleted, 0L)
+ .orderByAsc(StorageAttachment::getId));
+ if (attachments == null || attachments.isEmpty()) {
+ return;
+ }
+
+ Map<Long, List<StorageAttachment>> attachmentMap = attachments.stream()
+ .collect(Collectors.groupingBy(StorageAttachment::getRecordId, java.util.LinkedHashMap::new, Collectors.toList()));
+ List<Long> blobIds = attachments.stream()
+ .map(StorageAttachment::getStorageBlobId)
+ .filter(Objects::nonNull)
+ .distinct()
+ .collect(Collectors.toList());
+ if (blobIds.isEmpty()) {
+ return;
+ }
+
+ Map<Long, StorageBlob> blobMap = storageBlobMapper.selectBatchIds(blobIds).stream()
+ .filter(Objects::nonNull)
+ .collect(Collectors.toMap(StorageBlob::getId, item -> item));
+ for (ProductionOrderVo record : records) {
+ List<StorageAttachment> modelAttachments = attachmentMap.get(record.getProductModelId());
+ if (modelAttachments == null || modelAttachments.isEmpty()) {
+ continue;
+ }
+ List<StorageBlobVO> images = modelAttachments.stream()
+ .map(StorageAttachment::getStorageBlobId)
+ .map(blobMap::get)
+ .filter(Objects::nonNull)
+ .map(this::toStorageBlobVO)
+ .collect(Collectors.toList());
+ if (!images.isEmpty()) {
+ record.setProductImages(images);
+ }
+ }
+ }
+
+ private StorageBlobVO toStorageBlobVO(StorageBlob blob) {
+ StorageBlobVO vo = BeanUtil.copyProperties(blob, StorageBlobVO.class);
+ vo.setPreviewURL(fileUtil.buildSignedPreviewUrl(vo));
+ vo.setDownloadURL(fileUtil.buildSignedDownloadUrl(vo));
+ return vo;
+ }
+
+ @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);
+ }
+ }
+ }
+
+ List<ProductionOrderPickVo> result = new ArrayList<>(bomStructureList.size());
+ for (ProductionBomStructureVo structure : bomStructureList) {
+ if (structure == null || structure.getProductModelId() == null) {
+ continue;
+ }
+ Long productModelId = structure.getProductModelId();
+ ProductionOrderPickVo vo = new ProductionOrderPickVo();
+ vo.setProductModelId(productModelId);
+ vo.setOperationName(structure.getOperationName());
+ vo.setTechnologyOperationId(structure.getTechnologyOperationId());
+ vo.setProductName(structure.getProductName());
+ vo.setModel(structure.getModel());
+ vo.setDemandedQuantity(defaultDecimal(structure.getDemandedQuantity()));
+ 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);
+ result.add(vo);
+ }
+ return result;
+ }
}
--
Gitblit v1.9.3