package com.ruoyi.production.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.DateUtils;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.other.mapper.TempFileMapper;
|
import com.ruoyi.other.pojo.TempFile;
|
import com.ruoyi.production.dto.*;
|
import com.ruoyi.production.enums.ProductOrderStatusEnum;
|
import com.ruoyi.production.pojo.*;
|
import com.ruoyi.production.service.*;
|
import com.ruoyi.production.vo.ProductionOrderRouteItemParamVo;
|
import com.ruoyi.production.vo.ProductionOrderRouteItemVo;
|
import com.ruoyi.production.vo.ProductionOrderStructureVo;
|
import com.ruoyi.production.vo.ProductionRecordVo;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.io.FilenameUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.nio.file.Files;
|
import java.nio.file.Path;
|
import java.nio.file.Paths;
|
import java.nio.file.StandardCopyOption;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.UUID;
|
import java.util.stream.Collectors;
|
|
/**
|
* <br>
|
* 生产报工记录Service实现类
|
* </br>
|
*
|
* @author deslrey
|
* @version 1.0
|
* @since 2026/03/23 10:23
|
*/
|
@Slf4j
|
@Service
|
public class ProductionRecordServiceImpl implements ProductionRecordService {
|
|
@Value("${file.upload-dir}")
|
private String uploadDir;
|
|
@Autowired
|
private ProductionProductMainService productionProductMainService;
|
|
@Autowired
|
private ProductionProductInputService productionProductInputService;
|
|
@Autowired
|
private ProductionProductOutputService productionProductOutputService;
|
|
@Autowired
|
private IProductionProductRouteItemService productionProductRouteItemService;
|
|
@Autowired
|
private IProductionProductRouteItemParamService productionProductRouteItemParamService;
|
|
@Autowired
|
private IProductionProductRouteItemFileService productionProductRouteItemFileService;
|
|
@Autowired
|
private ProductOrderService productOrderService;
|
|
@Autowired
|
private IProductionOrderRouteItemService productionOrderRouteItemService;
|
|
@Autowired
|
private IProductionOrderRouteItemParamService productionOrderRouteItemParamService;
|
|
@Autowired
|
private IProductionOrderStructureService productionOrderStructureService;
|
|
@Autowired
|
private ProductProcessService productProcessService;
|
|
@Autowired
|
private ProductMaterialSkuService productMaterialSkuService;
|
|
@Autowired
|
private ProductMaterialService productMaterialService;
|
|
@Autowired
|
private TempFileMapper tempFileMapper;
|
|
@Override
|
public ProductionRecordVo productRouteItem(Long productOrderId) {
|
if (productOrderId == null) {
|
throw new ServiceException("请选择生产订单再新增报工");
|
}
|
|
// 查询出生产订单绑定的工艺路线
|
ProductOrder productOrder = productOrderService.getById(productOrderId);
|
if (productOrder == null) {
|
throw new ServiceException("未查询到该生产订单的信息");
|
}
|
// 通过工艺路线查询出绑定的工序及参数
|
List<ProductionOrderRouteItem> productionOrderRouteItemList = productionOrderRouteItemService.list(new LambdaQueryWrapper<ProductionOrderRouteItem>()
|
.eq(ProductionOrderRouteItem::getOrderId, productOrderId)
|
.eq(ProductionOrderRouteItem::getRouteId, productOrder.getRouteId()));
|
|
if (productionOrderRouteItemList == null || productionOrderRouteItemList.isEmpty()) {
|
throw new ServiceException("该生产订单绑定的工艺路线无工序");
|
}
|
|
ProductionRecordVo productionRecordVo = new ProductionRecordVo();
|
productionRecordVo.setProductOrderId(productOrderId);
|
productionRecordVo.setProductRouteId(productOrder.getRouteId());
|
|
List<ProductionOrderRouteItemVo> productionOrderRouteItemVoList = new ArrayList<>();
|
|
// 根据绑定的工序查询出工序参数及BOM需要消耗的产品
|
for (ProductionOrderRouteItem orderRouteItem : productionOrderRouteItemList) {
|
ProductionOrderRouteItemVo productionOrderRouteItemVo = new ProductionOrderRouteItemVo();
|
productionOrderRouteItemVo.setProcessId(orderRouteItem.getProcessId());
|
|
if (orderRouteItem.getProcessId() != null) {
|
ProductProcess process = productProcessService.getById(orderRouteItem.getProcessId());
|
if (process != null) {
|
productionOrderRouteItemVo.setProcessName(process.getName());
|
}
|
}
|
|
List<ProductionOrderRouteItemParam> orderRouteItemParamList = productionOrderRouteItemParamService.list(new LambdaQueryWrapper<ProductionOrderRouteItemParam>()
|
.eq(ProductionOrderRouteItemParam::getOrderId, productOrderId)
|
.eq(ProductionOrderRouteItemParam::getRouteItemId, orderRouteItem.getId()));
|
|
if (orderRouteItemParamList != null && !orderRouteItemParamList.isEmpty()) {
|
List<ProductionOrderRouteItemParamVo> paraVoList = orderRouteItemParamList.stream().map(param -> {
|
ProductionOrderRouteItemParamVo paraVo = new ProductionOrderRouteItemParamVo();
|
BeanUtils.copyProperties(param, paraVo);
|
paraVo.setParamFormat(DateUtils.toUpperCasePattern(paraVo.getParamFormat()));
|
return paraVo;
|
}).collect(Collectors.toList());
|
productionOrderRouteItemVo.setOrderRouteItemParaVos(paraVoList);
|
}
|
|
List<ProductionOrderStructure> orderStructureList = productionOrderStructureService.list(new LambdaQueryWrapper<ProductionOrderStructure>()
|
.eq(ProductionOrderStructure::getOrderId, productOrderId)
|
.eq(ProductionOrderStructure::getProcessId, orderRouteItem.getProcessId()));
|
|
if (orderStructureList != null && !orderStructureList.isEmpty()) {
|
List<ProductionOrderStructureVo> structureVoList = orderStructureList.stream().map(struct -> {
|
ProductionOrderStructureVo structureVo = new ProductionOrderStructureVo();
|
BeanUtils.copyProperties(struct, structureVo);
|
// 查询出产品的名称/模型
|
ProductMaterialSku productMaterialSku = productMaterialSkuService.getById(structureVo.getProductModelId());
|
ProductMaterial productMaterial = productMaterialService.getById(productMaterialSku.getProductId());
|
structureVo.setProductName(productMaterial.getProductName());
|
structureVo.setModel(productMaterialSku.getModel());
|
return structureVo;
|
}).collect(Collectors.toList());
|
productionOrderRouteItemVo.setOrderStructureVos(structureVoList);
|
}
|
|
// 每一个工序的参数、BOM消耗产品
|
productionOrderRouteItemVoList.add(productionOrderRouteItemVo);
|
}
|
|
productionRecordVo.setProductionOrderRouteItemVos(productionOrderRouteItemVoList);
|
return productionRecordVo;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void addProductionRecordService(ProductionRecordDto dto) {
|
if (dto == null) {
|
throw new ServiceException("报工失败,数据不能为空");
|
}
|
if (dto.getProductOrderId() == null) {
|
throw new ServiceException("报工失败,生产订单ID不能为空");
|
}
|
if (dto.getProductId() == null) {
|
throw new ServiceException("报工失败,产品信息不能为空");
|
}
|
if (StringUtils.isEmpty(dto.getPostName()) || StringUtils.isEmpty(dto.getSchedule())) {
|
throw new ServiceException("报工失败,岗位人员/班次信息不能为空");
|
}
|
|
// 更新生产订单数据
|
ProductOrder productOrder = productOrderService.getById(dto.getProductOrderId());
|
if (productOrder == null) {
|
throw new ServiceException("报工失败,生产订单不存在");
|
}
|
|
// 当前报工合格数量（前端已保证 = 投入数量 - 不合格数量，直接使用）
|
BigDecimal qualifiedQty = dto.getQualifiedQuantity() == null ? BigDecimal.ZERO : dto.getQualifiedQuantity();
|
// 订单已完成数量（历史累计）
|
BigDecimal completeQty = productOrder.getCompleteQuantity() == null ? BigDecimal.ZERO : productOrder.getCompleteQuantity();
|
// 需求数量
|
BigDecimal totalQty = productOrder.getQuantity() == null ? BigDecimal.ZERO : productOrder.getQuantity();
|
// 剩余可报工数量
|
BigDecimal remainQty = totalQty.subtract(completeQty);
|
// 本次报工合格数量不能超过剩余数量（校验必须在累加前执行）
|
if (qualifiedQty.compareTo(remainQty) > 0) {
|
throw new ServiceException("报工失败，本次报工数量不能大于剩余可报工数量，剩余报工数量:[" + remainQty + "]");
|
}
|
// 历史已完成 + 本次合格数量
|
BigDecimal newCompleteQty = completeQty.add(qualifiedQty);
|
productOrder.setCompleteQuantity(newCompleteQty);
|
// 设置开始时间（第一次报工）
|
if (productOrder.getStartTime() == null) {
|
productOrder.setStartTime(LocalDateTime.now());
|
}
|
// 状态判断
|
if (newCompleteQty.compareTo(totalQty) >= 0 && totalQty.compareTo(BigDecimal.ZERO) > 0) {
|
productOrder.setStatus(ProductOrderStatusEnum.FINISHED.getCode());
|
productOrder.setEndTime(LocalDateTime.now());
|
} else {
|
productOrder.setStatus(ProductOrderStatusEnum.RUNNING.getCode());
|
}
|
boolean update = productOrderService.updateById(productOrder);
|
if (!update) {
|
throw new ServiceException("报工失败,生产订单更新失败");
|
}
|
|
// 完成报工主表-投入表-产出表数据
|
ProductionProductMain productionProductMain = new ProductionProductMain();
|
productionProductMain.setProductNo(productionProductMainService.generateProductNo());
|
productionProductMain.setProductOrderId(dto.getProductOrderId());
|
productionProductMain.setSchedule(dto.getSchedule());
|
productionProductMain.setPostName(dto.getPostName());
|
productionProductMain.setReportingTime(LocalDateTime.now());
|
boolean result = productionProductMainService.save(productionProductMain);
|
if (!result) {
|
throw new ServiceException("报工失败,数据存储失败");
|
}
|
|
ProductionProductInput productionProductInput = new ProductionProductInput();
|
productionProductInput.setProductMainId(productionProductMain.getId());
|
productionProductInput.setProductModelId(dto.getProductId());
|
productionProductInput.setQuantity(dto.getQuantity());
|
result = productionProductInputService.save(productionProductInput);
|
if (!result) {
|
throw new ServiceException("报工失败,生产投入存储失败");
|
}
|
|
ProductionProductOutput productionProductOutput = new ProductionProductOutput();
|
productionProductOutput.setProductMainId(productionProductMain.getId());
|
productionProductOutput.setProductModelId(dto.getProductId());
|
productionProductOutput.setQuantity(dto.getQualifiedQuantity());
|
productionProductOutput.setScrapQty(dto.getUnqualifiedQuantity());
|
result = productionProductOutputService.save(productionProductOutput);
|
if (!result) {
|
throw new ServiceException("报工失败,生产产出存储失败");
|
}
|
|
// 处理工序
|
List<ProductionProductRouteItemDto> productionProductRouteItemDtoList = dto.getProductionProductRouteItemDtoList();
|
if (productionProductRouteItemDtoList == null || productionProductRouteItemDtoList.isEmpty()) {
|
throw new ServiceException("报工失败,工序参数不能为空");
|
}
|
for (ProductionProductRouteItemDto productRouteItemDto : productionProductRouteItemDtoList) {
|
// 处理工序主表
|
ProductionProductRouteItem productRouteItemEntity = new ProductionProductRouteItem();
|
BeanUtils.copyProperties(productRouteItemDto, productRouteItemEntity, "id");
|
productRouteItemEntity.setProductMainId(productionProductMain.getId());
|
productionProductRouteItemService.save(productRouteItemEntity);
|
|
// 处理参数及消耗产品
|
List<ProductionProductRouteItemParamDto> productionProductRouteItemParamDtoList = productRouteItemDto.getProductionProductRouteItemParamDtoList();
|
if (productionProductRouteItemParamDtoList != null && !productionProductRouteItemParamDtoList.isEmpty()) {
|
for (ProductionProductRouteItemParamDto productRouteItemParamDto : productionProductRouteItemParamDtoList) {
|
ProductionProductRouteItemParam paramEntity = new ProductionProductRouteItemParam();
|
BeanUtils.copyProperties(productRouteItemParamDto, paramEntity, "id");
|
paramEntity.setProductionProductRouteItemId(productRouteItemEntity.getId());
|
paramEntity.setOrderItemParamId(productRouteItemParamDto.getId());
|
if (paramEntity.getProductId() == null) {
|
ProductionOrderRouteItemParam productionOrderRouteItemParam = productionOrderRouteItemParamService.getById(productRouteItemParamDto.getId());
|
paramEntity.setParamName(productionOrderRouteItemParam.getParamName());
|
paramEntity.setParamType(productionOrderRouteItemParam.getParamType());
|
paramEntity.setParamFormat(productionOrderRouteItemParam.getParamFormat());
|
paramEntity.setValueMode(productionOrderRouteItemParam.getValueMode());
|
}
|
|
productionProductRouteItemParamService.save(paramEntity);
|
}
|
}
|
|
// 处理工序上传的附件
|
List<String> files = productRouteItemDto.getFiles();
|
if (files != null && !files.isEmpty()) {
|
for (String tempId : files) {
|
TempFile tempFile = tempFileMapper.selectById(tempId);
|
if (tempFile == null) {
|
log.warn("未找到临时文件记录: {}", tempId);
|
continue;
|
}
|
|
try {
|
// 正式目录路径（按日期分组）
|
String formalDir = uploadDir + LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE);
|
Path formalDirPath = Paths.get(formalDir);
|
if (!Files.exists(formalDirPath)) {
|
Files.createDirectories(formalDirPath);
|
}
|
|
// 正式文件名
|
String originalFilename = tempFile.getOriginalName();
|
String fileExtension = FilenameUtils.getExtension(originalFilename);
|
String formalFilename = productRouteItemEntity.getId() + "_" +
|
System.currentTimeMillis() + "_" +
|
UUID.randomUUID().toString().substring(0, 8) +
|
(StringUtils.hasText(fileExtension) ? "." + fileExtension : "");
|
|
Path formalFilePath = formalDirPath.resolve(formalFilename);
|
|
// 文件迁移 (复制+删除)
|
Files.copy(Paths.get(tempFile.getTempPath()), formalFilePath, StandardCopyOption.REPLACE_EXISTING);
|
Files.deleteIfExists(Paths.get(tempFile.getTempPath()));
|
|
// 保存报工附件记录
|
ProductionProductRouteItemFile fileEntity = new ProductionProductRouteItemFile();
|
fileEntity.setProductionProductRouteItemId(productRouteItemEntity.getId());
|
fileEntity.setFileName(originalFilename);
|
fileEntity.setFileUrl(formalFilePath.toString());
|
fileEntity.setFileSuffix(fileExtension);
|
fileEntity.setFileSize(Files.size(formalFilePath));
|
fileEntity.setCreateTime(LocalDateTime.now());
|
fileEntity.setTenantId(SecurityUtils.getLoginUser().getTenantId());
|
productionProductRouteItemFileService.save(fileEntity);
|
|
// 删除临时文件记录
|
tempFileMapper.deleteById(tempId);
|
log.info("工序附件迁移成功: {} -> {}", tempFile.getTempPath(), formalFilePath);
|
|
} catch (IOException e) {
|
log.error("工序附件迁移失败: {}", tempFile.getTempPath(), e);
|
throw new ServiceException("工序附件处理异常: " + e.getMessage());
|
}
|
}
|
}
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteProductMain(Long productMainId) {
|
if (productMainId == null) {
|
throw new ServiceException("删除失败，报工ID不能为空");
|
}
|
|
// 校验报工主表是否存在
|
ProductionProductMain productMain = productionProductMainService.getById(productMainId);
|
if (productMain == null) {
|
throw new ServiceException("删除失败，报工记录不存在");
|
}
|
|
// 查询该报工下所有工序记录
|
List<ProductionProductRouteItem> routeItemList = productionProductRouteItemService.list(new LambdaQueryWrapper<ProductionProductRouteItem>()
|
.eq(ProductionProductRouteItem::getProductMainId, productMainId));
|
|
if (routeItemList != null && !routeItemList.isEmpty()) {
|
List<Long> routeItemIds = routeItemList.stream()
|
.map(ProductionProductRouteItem::getId)
|
.collect(Collectors.toList());
|
|
// 查询并删除每个工序下的附件
|
List<ProductionProductRouteItemFile> fileList = productionProductRouteItemFileService.list(new LambdaQueryWrapper<ProductionProductRouteItemFile>()
|
.in(ProductionProductRouteItemFile::getProductionProductRouteItemId, routeItemIds));
|
|
if (fileList != null && !fileList.isEmpty()) {
|
for (ProductionProductRouteItemFile file : fileList) {
|
if (StringUtils.hasText(file.getFileUrl())) {
|
try {
|
Files.deleteIfExists(Paths.get(file.getFileUrl()));
|
} catch (IOException e) {
|
log.warn("删除附件文件失败: {}", file.getFileUrl(), e);
|
}
|
}
|
}
|
productionProductRouteItemFileService.remove(new LambdaQueryWrapper<ProductionProductRouteItemFile>()
|
.in(ProductionProductRouteItemFile::getProductionProductRouteItemId, routeItemIds));
|
}
|
|
// 删除工序参数
|
productionProductRouteItemParamService.remove(new LambdaQueryWrapper<ProductionProductRouteItemParam>()
|
.in(ProductionProductRouteItemParam::getProductionProductRouteItemId, routeItemIds));
|
|
// 删除工序记录
|
productionProductRouteItemService.remove(new LambdaQueryWrapper<ProductionProductRouteItem>()
|
.eq(ProductionProductRouteItem::getProductMainId, productMainId));
|
}
|
|
// 删除投入表
|
productionProductInputService.remove(new LambdaQueryWrapper<ProductionProductInput>()
|
.eq(ProductionProductInput::getProductMainId, productMainId));
|
|
// 回滚生产订单完成数量
|
ProductionProductOutput output = productionProductOutputService.getOne(new LambdaQueryWrapper<ProductionProductOutput>()
|
.eq(ProductionProductOutput::getProductMainId, productMainId)
|
.last("LIMIT 1"));
|
|
ProductOrder productOrder = productOrderService.getById(productMain.getProductOrderId());
|
if (productOrder == null) {
|
throw new ServiceException("删除失败，关联的生产订单不存在");
|
}
|
|
BigDecimal qualifiedQty = (output != null && output.getQuantity() != null)
|
? output.getQuantity() : BigDecimal.ZERO;
|
BigDecimal currentCompleteQty = productOrder.getCompleteQuantity() == null
|
? BigDecimal.ZERO : productOrder.getCompleteQuantity();
|
BigDecimal totalQty = productOrder.getQuantity() == null ? BigDecimal.ZERO : productOrder.getQuantity();
|
|
// 扣减本条报工贡献的合格数量，不允许出现负数
|
BigDecimal updatedCompleteQty = currentCompleteQty.subtract(qualifiedQty).max(BigDecimal.ZERO);
|
productOrder.setCompleteQuantity(updatedCompleteQty);
|
|
// 重新判断订单状态
|
if (updatedCompleteQty.compareTo(totalQty) >= 0 && totalQty.compareTo(BigDecimal.ZERO) > 0) {
|
// 完成数 >= 需求数 → 已完成
|
productOrder.setStatus(ProductOrderStatusEnum.FINISHED.getCode());
|
} else if (updatedCompleteQty.compareTo(BigDecimal.ZERO) == 0) {
|
// 完成数归零 → 回到待开始，清空开始/结束时间
|
productOrder.setStatus(ProductOrderStatusEnum.WAIT.getCode());
|
productOrder.setStartTime(null);
|
productOrder.setEndTime(null);
|
} else {
|
// 完成数介于 0 ~ 需求数之间 → 进行中
|
productOrder.setStatus(ProductOrderStatusEnum.RUNNING.getCode());
|
productOrder.setEndTime(null);
|
}
|
productOrderService.updateById(productOrder);
|
|
// 删除产出表
|
productionProductOutputService.remove(new LambdaQueryWrapper<ProductionProductOutput>()
|
.eq(ProductionProductOutput::getProductMainId, productMainId));
|
|
// 删除报工主表
|
productionProductMainService.removeById(productMainId);
|
log.info("报工记录删除成功，productMainId={}", productMainId);
|
}
|
|
@Override
|
public ProductionRecordDto detailProductMain(Long productMainId) {
|
if (productMainId == null) {
|
throw new ServiceException("查询失败，报工ID不能为空");
|
}
|
|
// 查询报工主表
|
ProductionProductMain productMain = productionProductMainService.getById(productMainId);
|
if (productMain == null) {
|
throw new ServiceException("查询失败，报工记录不存在");
|
}
|
|
ProductionRecordDto dto = new ProductionRecordDto();
|
dto.setProductMainId(productMainId);
|
dto.setProductOrderId(productMain.getProductOrderId());
|
dto.setPostName(productMain.getPostName());
|
dto.setSchedule(productMain.getSchedule());
|
dto.setReportingTime(productMain.getReportingTime());
|
dto.setCreateTime(productMain.getCreateTime());
|
dto.setUpdateTime(productMain.getUpdateTime());
|
|
// 生产订单信息
|
ProductOrder productOrder = productOrderService.getById(productMain.getProductOrderId());
|
if (productOrder == null) {
|
throw new ServiceException("查询失败,未查询到生产订单信息");
|
}
|
dto.setNpsNo(productOrder.getNpsNo());
|
|
/// 产品信息
|
ProductMaterialSkuDto productMaterialSkuDto = productMaterialService.selectProductByProductMainId(productOrder.getId());
|
dto.setProductName(productMaterialSkuDto.getProductName());
|
dto.setMaterialCode(productMaterialSkuDto.getMaterialCode());
|
dto.setModel(productMaterialSkuDto.getModel());
|
|
// 查询投入表（获取产品ID和投入数量）
|
ProductionProductInput input = productionProductInputService.getOne(
|
new LambdaQueryWrapper<ProductionProductInput>()
|
.eq(ProductionProductInput::getProductMainId, productMainId)
|
.last("LIMIT 1"));
|
if (input != null) {
|
dto.setProductId(input.getProductModelId());
|
dto.setQuantity(input.getQuantity());
|
}
|
|
// 查询产出表（获取合格/不合格数量）
|
ProductionProductOutput output = productionProductOutputService.getOne(
|
new LambdaQueryWrapper<ProductionProductOutput>()
|
.eq(ProductionProductOutput::getProductMainId, productMainId)
|
.last("LIMIT 1"));
|
if (output != null) {
|
dto.setQualifiedQuantity(output.getQuantity());
|
dto.setUnqualifiedQuantity(output.getScrapQty());
|
}
|
|
// 查询工序列表
|
List<ProductionProductRouteItem> routeItemList = productionProductRouteItemService.list(
|
new LambdaQueryWrapper<ProductionProductRouteItem>()
|
.eq(ProductionProductRouteItem::getProductMainId, productMainId));
|
|
if (routeItemList != null && !routeItemList.isEmpty()) {
|
List<ProductionProductRouteItemDto> routeItemDtoList = routeItemList.stream().map(routeItem -> {
|
ProductionProductRouteItemDto routeItemDto = new ProductionProductRouteItemDto();
|
BeanUtils.copyProperties(routeItem, routeItemDto);
|
|
// 查询工序参数
|
List<ProductionProductRouteItemParam> paramList = productionProductRouteItemParamService.list(
|
new LambdaQueryWrapper<ProductionProductRouteItemParam>()
|
.eq(ProductionProductRouteItemParam::getProductionProductRouteItemId, routeItem.getId()));
|
if (paramList != null && !paramList.isEmpty()) {
|
List<ProductionProductRouteItemParamDto> paramDtoList = paramList.stream().map(param -> {
|
ProductionProductRouteItemParamDto paramDto = new ProductionProductRouteItemParamDto();
|
BeanUtils.copyProperties(param, paramDto);
|
if (paramDto.getProductId() != null) {
|
ProductMaterialSkuDto materialSkuDto = productMaterialService.selectProductByModelId(paramDto.getProductId());
|
productMaterialService.selectProductByModelId(paramDto.getProductId());
|
paramDto.setParamName(materialSkuDto.getProductName());
|
}
|
return paramDto;
|
}).collect(Collectors.toList());
|
routeItemDto.setProductionProductRouteItemParamDtoList(paramDtoList);
|
}
|
|
// 查询工序附件
|
List<ProductionProductRouteItemFile> fileRecordList = productionProductRouteItemFileService.list(
|
new LambdaQueryWrapper<ProductionProductRouteItemFile>()
|
.eq(ProductionProductRouteItemFile::getProductionProductRouteItemId, routeItem.getId()));
|
if (fileRecordList != null && !fileRecordList.isEmpty()) {
|
List<ProductionProductRouteItemFileDto> fileDtoList = fileRecordList.stream().map(file -> {
|
ProductionProductRouteItemFileDto fileDto = new ProductionProductRouteItemFileDto();
|
BeanUtils.copyProperties(file, fileDto);
|
return fileDto;
|
}).collect(Collectors.toList());
|
routeItemDto.setFileList(fileDtoList);
|
}
|
|
return routeItemDto;
|
}).collect(Collectors.toList());
|
|
dto.setProductionProductRouteItemDtoList(routeItemDtoList);
|
}
|
|
return dto;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void editProductMain(ProductionRecordDto dto) {
|
if (dto == null || dto.getProductMainId() == null) {
|
throw new ServiceException("编辑失败，报工ID不能为空");
|
}
|
if (dto.getProductId() == null) {
|
throw new ServiceException("编辑失败，产品信息不能为空");
|
}
|
if (StringUtils.isEmpty(dto.getPostName()) || StringUtils.isEmpty(dto.getSchedule())) {
|
throw new ServiceException("编辑失败，岗位人员/班次信息不能为空");
|
}
|
|
Long productMainId = dto.getProductMainId();
|
|
// 查询报工主表是否存在
|
ProductionProductMain productMain = productionProductMainService.getById(productMainId);
|
if (productMain == null) {
|
throw new ServiceException("编辑失败，报工记录不存在");
|
}
|
|
// 回滚生产订单的合格数量
|
ProductionProductOutput oldOutput = productionProductOutputService.getOne(new LambdaQueryWrapper<ProductionProductOutput>()
|
.eq(ProductionProductOutput::getProductMainId, productMainId)
|
.last("LIMIT 1"));
|
|
ProductOrder productOrder = productOrderService.getById(productMain.getProductOrderId());
|
if (productOrder == null) {
|
throw new ServiceException("编辑失败，关联的生产订单不存在");
|
}
|
|
BigDecimal oldQualifiedQty = (oldOutput != null && oldOutput.getQuantity() != null)
|
? oldOutput.getQuantity() : BigDecimal.ZERO;
|
BigDecimal newQualifiedQty = dto.getQualifiedQuantity() == null ? BigDecimal.ZERO : dto.getQualifiedQuantity();
|
BigDecimal currentCompleteQty = productOrder.getCompleteQuantity() == null
|
? BigDecimal.ZERO : productOrder.getCompleteQuantity();
|
BigDecimal totalQty = productOrder.getQuantity() == null ? BigDecimal.ZERO : productOrder.getQuantity();
|
|
// 回滚旧值，计算本次编辑后的新完成数量
|
BigDecimal baseQty = currentCompleteQty.subtract(oldQualifiedQty);
|
BigDecimal updatedCompleteQty = baseQty.add(newQualifiedQty);
|
|
// 新的合格数量不能超过（需求数量 - 报工总完成数量）
|
if (newQualifiedQty.compareTo(totalQty.subtract(baseQty)) > 0) {
|
throw new ServiceException("编辑失败，本次报工合格数量不能大于剩余可报工数量");
|
}
|
|
// 重新判断生产订单状态
|
productOrder.setCompleteQuantity(updatedCompleteQty);
|
if (updatedCompleteQty.compareTo(totalQty) >= 0 && totalQty.compareTo(BigDecimal.ZERO) > 0) {
|
productOrder.setStatus(ProductOrderStatusEnum.FINISHED.getCode());
|
productOrder.setEndTime(LocalDateTime.now());
|
} else {
|
productOrder.setStatus(ProductOrderStatusEnum.RUNNING.getCode());
|
productOrder.setEndTime(null);
|
}
|
productOrderService.updateById(productOrder);
|
|
// 更新报工主表
|
productMain.setPostName(dto.getPostName());
|
productMain.setSchedule(dto.getSchedule());
|
productMain.setReportingTime(dto.getReportingTime());
|
productionProductMainService.updateById(productMain);
|
|
// 更新投入表
|
ProductionProductInput input = productionProductInputService.getOne(new LambdaQueryWrapper<ProductionProductInput>()
|
.eq(ProductionProductInput::getProductMainId, productMainId)
|
.last("LIMIT 1"));
|
if (input != null) {
|
input.setProductModelId(dto.getProductId());
|
input.setQuantity(dto.getQuantity());
|
productionProductInputService.updateById(input);
|
}
|
|
// 更新产出表
|
if (oldOutput != null) {
|
oldOutput.setProductModelId(dto.getProductId());
|
oldOutput.setQuantity(dto.getQualifiedQuantity());
|
oldOutput.setScrapQty(dto.getUnqualifiedQuantity());
|
productionProductOutputService.updateById(oldOutput);
|
}
|
|
// 处理工序列表
|
List<ProductionProductRouteItemDto> routeItemDtoList = dto.getProductionProductRouteItemDtoList();
|
if (routeItemDtoList == null || routeItemDtoList.isEmpty()) {
|
throw new ServiceException("编辑失败，工序参数不能为空");
|
}
|
|
for (ProductionProductRouteItemDto routeItemDto : routeItemDtoList) {
|
// 更新已有工序
|
ProductionProductRouteItem routeItemEntity = productionProductRouteItemService.getById(routeItemDto.getId());
|
if (routeItemEntity == null) {
|
log.error("编辑失败,工序记录不存在,ID={}", routeItemDto.getId());
|
throw new ServiceException("编辑失败，工序记录不存在");
|
}
|
BeanUtils.copyProperties(routeItemDto, routeItemEntity, "id", "productMainId", "createTime", "tenantId");
|
productionProductRouteItemService.updateById(routeItemEntity);
|
|
final Long routeItemId = routeItemEntity.getId();
|
|
// 处理工序参数: 先删除该工序下所有旧参数，再重新插入传入的参数
|
productionProductRouteItemParamService.remove(new LambdaQueryWrapper<ProductionProductRouteItemParam>()
|
.eq(ProductionProductRouteItemParam::getProductionProductRouteItemId, routeItemId));
|
|
List<ProductionProductRouteItemParamDto> paramDtoList = routeItemDto.getProductionProductRouteItemParamDtoList();
|
if (paramDtoList != null && !paramDtoList.isEmpty()) {
|
for (ProductionProductRouteItemParamDto paramDto : paramDtoList) {
|
ProductionProductRouteItemParam paramEntity = new ProductionProductRouteItemParam();
|
BeanUtils.copyProperties(paramDto, paramEntity, "id");
|
paramEntity.setProductionProductRouteItemId(routeItemId);
|
if (paramEntity.getProductId() == null && paramDto.getId() != null) {
|
ProductionOrderRouteItemParam orderParam = productionOrderRouteItemParamService.getById(paramDto.getId());
|
if (orderParam != null) {
|
paramEntity.setOrderItemParamId(orderParam.getId());
|
paramEntity.setParamName(orderParam.getParamName());
|
paramEntity.setParamType(orderParam.getParamType());
|
paramEntity.setParamFormat(orderParam.getParamFormat());
|
paramEntity.setValueMode(orderParam.getValueMode());
|
}
|
}
|
productionProductRouteItemParamService.save(paramEntity);
|
}
|
}
|
|
// 处理新上传的临时附件
|
List<String> newFiles = routeItemDto.getFiles();
|
if (newFiles != null && !newFiles.isEmpty()) {
|
for (String tempId : newFiles) {
|
TempFile tempFile = tempFileMapper.selectById(tempId);
|
if (tempFile == null) {
|
log.warn("未找到临时文件记录: {}", tempId);
|
continue;
|
}
|
try {
|
String formalDir = uploadDir + LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE);
|
Path formalDirPath = Paths.get(formalDir);
|
if (!Files.exists(formalDirPath)) {
|
Files.createDirectories(formalDirPath);
|
}
|
String originalFilename = tempFile.getOriginalName();
|
String fileExtension = FilenameUtils.getExtension(originalFilename);
|
String formalFilename = routeItemId + "_"
|
+ System.currentTimeMillis() + "_"
|
+ UUID.randomUUID().toString().substring(0, 8)
|
+ (StringUtils.hasText(fileExtension) ? "." + fileExtension : "");
|
Path formalFilePath = formalDirPath.resolve(formalFilename);
|
|
Files.copy(Paths.get(tempFile.getTempPath()), formalFilePath, StandardCopyOption.REPLACE_EXISTING);
|
Files.deleteIfExists(Paths.get(tempFile.getTempPath()));
|
|
ProductionProductRouteItemFile fileEntity = new ProductionProductRouteItemFile();
|
fileEntity.setProductionProductRouteItemId(routeItemId);
|
fileEntity.setFileName(originalFilename);
|
fileEntity.setFileUrl(formalFilePath.toString());
|
fileEntity.setFileSuffix(fileExtension);
|
fileEntity.setFileSize(Files.size(formalFilePath));
|
fileEntity.setCreateTime(LocalDateTime.now());
|
fileEntity.setTenantId(SecurityUtils.getLoginUser().getTenantId());
|
productionProductRouteItemFileService.save(fileEntity);
|
|
tempFileMapper.deleteById(tempId);
|
log.info("编辑-工序附件迁移成功: {} -> {}", tempFile.getTempPath(), formalFilePath);
|
} catch (IOException e) {
|
log.error("编辑-工序附件迁移失败: {}", tempFile.getTempPath(), e);
|
throw new ServiceException("工序附件处理异常: " + e.getMessage());
|
}
|
}
|
}
|
List<Long> delFileIds = routeItemDto.getDelFileIds();
|
if (delFileIds != null && !delFileIds.isEmpty()) {
|
delFileIds.forEach(productionProductRouteItemFileService::deleteFile);
|
}
|
}
|
log.info("报工记录编辑成功，productMainId={}", productMainId);
|
}
|
}
|
