package com.ruoyi.outsourcing.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.basic.mapper.ProductMapper;
|
import com.ruoyi.basic.mapper.ProductModelMapper;
|
import com.ruoyi.basic.pojo.Product;
|
import com.ruoyi.basic.pojo.ProductModel;
|
import com.ruoyi.common.enums.ReviewStatusEnum;
|
import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.OrderUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.poi.ExcelUtil;
|
import com.ruoyi.outsourcing.dto.OutsourcingOrderDto;
|
import com.ruoyi.outsourcing.enums.OutsourcingOrderStatusEnum;
|
import com.ruoyi.outsourcing.excel.OutsourcingOrderExcelDto;
|
import com.ruoyi.outsourcing.mapper.OutsourcingOrderMapper;
|
import com.ruoyi.outsourcing.mapper.OutsourcingOrderProductMapper;
|
import com.ruoyi.outsourcing.mapper.OutsourcingPartnerMapper;
|
import com.ruoyi.outsourcing.pojo.OutsourcingOrder;
|
import com.ruoyi.outsourcing.pojo.OutsourcingOrderProduct;
|
import com.ruoyi.outsourcing.pojo.OutsourcingPartner;
|
import com.ruoyi.outsourcing.service.IOutsourcingOrderService;
|
import com.ruoyi.stock.dto.StockInventoryDto;
|
import com.ruoyi.stock.pojo.StockOutRecord;
|
import com.ruoyi.stock.service.StockInventoryService;
|
import com.ruoyi.stock.service.StockOutRecordService;
|
import jakarta.servlet.http.HttpServletResponse;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.beans.BeanUtils;
|
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.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
/**
|
* 委外订单 Service 实现
|
*/
|
@Service
|
@RequiredArgsConstructor
|
public class OutsourcingOrderServiceImpl extends ServiceImpl<OutsourcingOrderMapper, OutsourcingOrder>
|
implements IOutsourcingOrderService {
|
|
private static final String ORDER_NO_PREFIX = "WWDD";
|
|
private final OutsourcingOrderMapper outsourcingOrderMapper;
|
private final OutsourcingOrderProductMapper outsourcingOrderProductMapper;
|
private final OutsourcingPartnerMapper outsourcingPartnerMapper;
|
private final ProductMapper productMapper;
|
private final ProductModelMapper productModelMapper;
|
private final StockInventoryService stockInventoryService;
|
private final StockOutRecordService stockOutRecordService;
|
|
@Override
|
public List<OutsourcingOrder> selectOrderList(OutsourcingOrderDto dto) {
|
LambdaQueryWrapper<OutsourcingOrder> wrapper = new LambdaQueryWrapper<>();
|
wrapper.like(StringUtils.isNotBlank(dto.getOrderNo()), OutsourcingOrder::getOrderNo, dto.getOrderNo())
|
.eq(dto.getPartnerId() != null, OutsourcingOrder::getPartnerId, dto.getPartnerId())
|
.like(StringUtils.isNotBlank(dto.getPartnerName()), OutsourcingOrder::getPartnerName, dto.getPartnerName())
|
.eq(dto.getStatus() != null, OutsourcingOrder::getStatus, dto.getStatus())
|
.like(StringUtils.isNotBlank(dto.getProjectName()), OutsourcingOrder::getProjectName, dto.getProjectName())
|
.ge(StringUtils.isNotBlank(dto.getStartDate()), OutsourcingOrder::getApplyDate, dto.getStartDate())
|
.le(StringUtils.isNotBlank(dto.getEndDate()), OutsourcingOrder::getApplyDate, dto.getEndDate())
|
.orderByDesc(OutsourcingOrder::getId);
|
return this.list(wrapper);
|
}
|
|
@Override
|
public OutsourcingOrderDto getDetail(Long id) {
|
OutsourcingOrder order = outsourcingOrderMapper.selectById(id);
|
if (order == null) {
|
throw new ServiceException("委外订单不存在");
|
}
|
OutsourcingOrderDto dto = new OutsourcingOrderDto();
|
BeanUtils.copyProperties(order, dto);
|
dto.setProductData(listProducts(id));
|
return dto;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long saveOrder(OutsourcingOrderDto dto) {
|
OutsourcingOrder order = new OutsourcingOrder();
|
BeanUtils.copyProperties(dto, order);
|
order.setId(null);
|
order.setStatus(OutsourcingOrderStatusEnum.DRAFT.getCode());
|
order.setOrderNo(OrderUtils.countTodayByCreateTime(
|
outsourcingOrderMapper, ORDER_NO_PREFIX, "order_no", LocalDateTime.now()));
|
order.setConfirmTime(null);
|
order.setCancelReason(null);
|
fillPartnerName(order);
|
if (order.getApplyDate() == null) {
|
order.setApplyDate(LocalDate.now());
|
}
|
order.setContractAmount(sumProducts(dto.getProductData()));
|
this.save(order);
|
|
saveProducts(order.getId(), dto.getProductData());
|
return order.getId();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean updateOrder(OutsourcingOrderDto dto) {
|
if (dto.getId() == null) {
|
throw new ServiceException("委外订单id不能为空");
|
}
|
OutsourcingOrder existing = outsourcingOrderMapper.selectById(dto.getId());
|
if (existing == null) {
|
throw new ServiceException("委外订单不存在");
|
}
|
if (!OutsourcingOrderStatusEnum.DRAFT.getCode().equals(existing.getStatus())) {
|
throw new ServiceException("仅草稿状态的委外订单允许修改");
|
}
|
|
OutsourcingOrder order = new OutsourcingOrder();
|
BeanUtils.copyProperties(dto, order);
|
// 单号、状态、确认信息由系统维护，置空后 MyBatis-Plus 不会更新这些列
|
order.setOrderNo(null);
|
order.setStatus(null);
|
order.setConfirmTime(null);
|
order.setCancelReason(null);
|
order.setTenantId(null);
|
order.setDeptId(null);
|
order.setCreateUser(null);
|
order.setCreateTime(null);
|
order.setUpdateTime(null);
|
fillPartnerName(order);
|
order.setContractAmount(sumProducts(dto.getProductData()));
|
boolean updated = this.updateById(order);
|
|
if (updated) {
|
outsourcingOrderProductMapper.delete(Wrappers.<OutsourcingOrderProduct>lambdaQuery()
|
.eq(OutsourcingOrderProduct::getOutsourcingOrderId, dto.getId()));
|
saveProducts(dto.getId(), dto.getProductData());
|
}
|
return updated;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean deleteOrders(List<Long> ids) {
|
if (ids == null || ids.isEmpty()) {
|
throw new ServiceException("请选择要删除的委外订单");
|
}
|
List<String> notDraftNos = this.listByIds(ids).stream()
|
.filter(order -> !OutsourcingOrderStatusEnum.DRAFT.getCode().equals(order.getStatus()))
|
.map(OutsourcingOrder::getOrderNo)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toList());
|
if (!notDraftNos.isEmpty()) {
|
throw new ServiceException("仅草稿状态的委外订单允许删除：" + String.join("、", notDraftNos));
|
}
|
|
outsourcingOrderProductMapper.delete(Wrappers.<OutsourcingOrderProduct>lambdaQuery()
|
.in(OutsourcingOrderProduct::getOutsourcingOrderId, ids));
|
return this.removeByIds(ids);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean submit(Long id) {
|
OutsourcingOrder order = requireOrder(id);
|
if (!OutsourcingOrderStatusEnum.DRAFT.getCode().equals(order.getStatus())) {
|
throw new ServiceException("仅草稿状态的委外订单允许提交");
|
}
|
if (order.getPartnerId() == null
|
|| outsourcingPartnerMapper.selectById(order.getPartnerId()) == null) {
|
throw new ServiceException("请先选择有效合作商再提交");
|
}
|
List<OutsourcingOrderProduct> products = listProducts(id);
|
if (products.isEmpty()) {
|
throw new ServiceException("委外订单没有产品明细，无法提交");
|
}
|
if (order.getContractAmount() == null
|
|| order.getContractAmount().compareTo(BigDecimal.ZERO) <= 0) {
|
throw new ServiceException("委外订单金额必须大于 0 才能提交");
|
}
|
|
// 条件更新抢占草稿状态，避免并发下重复提交
|
boolean submitted = this.update(Wrappers.<OutsourcingOrder>lambdaUpdate()
|
.eq(OutsourcingOrder::getId, id)
|
.eq(OutsourcingOrder::getStatus, OutsourcingOrderStatusEnum.DRAFT.getCode())
|
.set(OutsourcingOrder::getStatus, OutsourcingOrderStatusEnum.CONFIRMED.getCode())
|
.set(OutsourcingOrder::getConfirmTime, LocalDateTime.now()));
|
if (!submitted) {
|
throw new ServiceException("该委外订单已提交，请勿重复操作");
|
}
|
occupyScrapStock(products);
|
return true;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean complete(Long id) {
|
OutsourcingOrder order = requireOrder(id);
|
if (!OutsourcingOrderStatusEnum.CONFIRMED.getCode().equals(order.getStatus())) {
|
throw new ServiceException("仅已确认状态的委外订单允许完成");
|
}
|
requireScrapStockOutApproved(order.getId());
|
boolean completed = this.update(Wrappers.<OutsourcingOrder>lambdaUpdate()
|
.eq(OutsourcingOrder::getId, id)
|
.eq(OutsourcingOrder::getStatus, OutsourcingOrderStatusEnum.CONFIRMED.getCode())
|
.set(OutsourcingOrder::getStatus, OutsourcingOrderStatusEnum.COMPLETED.getCode()));
|
if (!completed) {
|
throw new ServiceException("仅已确认状态的委外订单允许完成");
|
}
|
return true;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean cancel(Long id, String cancelReason) {
|
OutsourcingOrder order = requireOrder(id);
|
Integer status = order.getStatus();
|
if (!OutsourcingOrderStatusEnum.DRAFT.getCode().equals(status)
|
&& !OutsourcingOrderStatusEnum.CONFIRMED.getCode().equals(status)) {
|
throw new ServiceException("该委外订单已完成或已作废，不允许重复作废");
|
}
|
boolean cancelled = this.update(Wrappers.<OutsourcingOrder>lambdaUpdate()
|
.eq(OutsourcingOrder::getId, id)
|
.in(OutsourcingOrder::getStatus, OutsourcingOrderStatusEnum.DRAFT.getCode(),
|
OutsourcingOrderStatusEnum.CONFIRMED.getCode())
|
.set(OutsourcingOrder::getStatus, OutsourcingOrderStatusEnum.CANCELLED.getCode())
|
.set(OutsourcingOrder::getCancelReason, cancelReason));
|
if (!cancelled) {
|
throw new ServiceException("该委外订单已完成或已作废，不允许重复作废");
|
}
|
if (OutsourcingOrderStatusEnum.CONFIRMED.getCode().equals(status)) {
|
// 提交时占用的报废品库存要释放：未审批的记录删掉即释放，已审批通过的按批次归还库存
|
stockOutRecordService.releaseByRecordIds(scrapLineIds(id),
|
StockOutQualifiedRecordTypeEnum.OUTSOURCING_SCRAP_OUT.getCode());
|
}
|
return true;
|
}
|
|
@Override
|
public void exportOrders(HttpServletResponse response, OutsourcingOrderDto dto) {
|
List<OutsourcingOrder> orders = selectOrderList(dto);
|
List<OutsourcingOrderExcelDto> excelList = orders.stream().map(order -> {
|
OutsourcingOrderExcelDto excel = new OutsourcingOrderExcelDto();
|
BeanUtils.copyProperties(order, excel);
|
excel.setStatusLabel(OutsourcingOrderStatusEnum.getLabelByValue(order.getStatus()));
|
return excel;
|
}).collect(Collectors.toList());
|
ExcelUtil<OutsourcingOrderExcelDto> util = new ExcelUtil<>(OutsourcingOrderExcelDto.class);
|
util.exportExcel(response, excelList, "委外订单");
|
}
|
|
private OutsourcingOrder requireOrder(Long id) {
|
if (id == null) {
|
throw new ServiceException("委外订单id不能为空");
|
}
|
OutsourcingOrder order = outsourcingOrderMapper.selectById(id);
|
if (order == null) {
|
throw new ServiceException("委外订单不存在");
|
}
|
return order;
|
}
|
|
/**
|
* 报废品选料行的 id，作为出库记录的 record_id。
|
* 出库记录一条对应一行明细（一个规格+批号），与采购退货出库的记法一致
|
*/
|
private List<Long> scrapLineIds(Long orderId) {
|
return listProducts(orderId).stream()
|
.filter(product -> Boolean.TRUE.equals(product.getIsScrap()))
|
.map(OutsourcingOrderProduct::getId)
|
.collect(Collectors.toList());
|
}
|
|
/**
|
* 报废品选料占用库存：每条选料行写一条待审批出库记录。
|
*
|
* <p>报废品取的是<b>合格库存</b>（stock_inventory，出库记录 type=0）。
|
* 记录一落库就通过 stock_out_record 的待审批量把可用量占住
|
* （可用量 = qualitity − locked_quantity − 待审批出库量），因此同一批次不会被多张委外订单超选，
|
* 但 qualitity 本身要等出库管理审批通过才真正扣减 —— 也就是「提交即占用、审批才实扣」。</p>
|
*/
|
private void occupyScrapStock(List<OutsourcingOrderProduct> products) {
|
for (OutsourcingOrderProduct product : products) {
|
if (!Boolean.TRUE.equals(product.getIsScrap())) {
|
continue;
|
}
|
if (product.getProductModelId() == null || StringUtils.isEmpty(product.getBatchNo())) {
|
throw new ServiceException("报废品选料行缺少产品规格或批号，无法提交");
|
}
|
BigDecimal quantity = product.getQuantity();
|
if (quantity == null || quantity.compareTo(BigDecimal.ZERO) <= 0) {
|
throw new ServiceException("报废品选料行数量必须大于 0");
|
}
|
StockInventoryDto stockInventoryDto = new StockInventoryDto();
|
stockInventoryDto.setRecordId(product.getId());
|
stockInventoryDto.setRecordType(StockOutQualifiedRecordTypeEnum.OUTSOURCING_SCRAP_OUT.getCode());
|
stockInventoryDto.setProductModelId(product.getProductModelId());
|
stockInventoryDto.setBatchNo(product.getBatchNo());
|
stockInventoryDto.setQualitity(quantity);
|
try {
|
stockInventoryService.addStockOutRecordOnly(stockInventoryDto);
|
} catch (RuntimeException e) {
|
// 合格库存不足抛的是 ServiceException，不合格那种 BaseException 也一并兜住
|
throw new ServiceException("报废品「" + product.getSpecificationModel() + "」批号「"
|
+ product.getBatchNo() + "」" + e.getMessage());
|
}
|
}
|
}
|
|
/**
|
* 报废品选料的出库记录必须全部审批通过才允许完成订单，
|
* 否则会出现「委外已完成、库存没扣」的账实不符
|
*/
|
private void requireScrapStockOutApproved(Long orderId) {
|
List<Long> lineIds = scrapLineIds(orderId);
|
if (lineIds.isEmpty()) {
|
return;
|
}
|
List<StockOutRecord> records = stockOutRecordService.listByRecordIds(
|
lineIds, StockOutQualifiedRecordTypeEnum.OUTSOURCING_SCRAP_OUT.getCode());
|
if (records.size() < lineIds.size()) {
|
throw new ServiceException("报废品选料缺少出库记录，请先作废后重新提交");
|
}
|
List<String> pendingBatches = records.stream()
|
.filter(record -> !ReviewStatusEnum.APPROVED.getCode().equals(record.getApprovalStatus()))
|
.map(StockOutRecord::getOutboundBatches)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toList());
|
if (!pendingBatches.isEmpty()) {
|
throw new ServiceException("报废品出库未审批通过，请先到出库管理审批出库批次："
|
+ String.join("、", pendingBatches));
|
}
|
}
|
|
private List<OutsourcingOrderProduct> listProducts(Long orderId) {
|
return outsourcingOrderProductMapper.selectList(Wrappers.<OutsourcingOrderProduct>lambdaQuery()
|
.eq(OutsourcingOrderProduct::getOutsourcingOrderId, orderId)
|
.orderByAsc(OutsourcingOrderProduct::getId));
|
}
|
|
private void saveProducts(Long orderId, List<OutsourcingOrderProduct> products) {
|
if (products == null || products.isEmpty()) {
|
return;
|
}
|
fillProductNames(products);
|
for (OutsourcingOrderProduct product : products) {
|
product.setId(null);
|
product.setOutsourcingOrderId(orderId);
|
product.setTenantId(null);
|
product.setDeptId(null);
|
product.setCreateUser(null);
|
product.setCreateTime(null);
|
product.setUpdateTime(null);
|
outsourcingOrderProductMapper.insert(product);
|
}
|
}
|
|
/**
|
* 委外金额以明细含税总价合计为准，避免前端传入金额与明细对不上导致往来应付错乱
|
*/
|
private BigDecimal sumProducts(List<OutsourcingOrderProduct> products) {
|
if (products == null || products.isEmpty()) {
|
return BigDecimal.ZERO;
|
}
|
return products.stream()
|
.map(OutsourcingOrderProduct::getTaxInclusiveTotalPrice)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
}
|
|
/**
|
* 补全产品大类与规格型号，便于订单直接展示产品名称
|
*/
|
private void fillProductNames(List<OutsourcingOrderProduct> products) {
|
Set<Long> productIds = products.stream()
|
.map(OutsourcingOrderProduct::getProductId)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toSet());
|
Set<Long> modelIds = products.stream()
|
.map(OutsourcingOrderProduct::getProductModelId)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toSet());
|
|
Map<Long, String> productMap = new HashMap<>();
|
if (!productIds.isEmpty()) {
|
for (Product product : productMapper.selectBatchIds(productIds)) {
|
productMap.put(product.getId(), product.getProductName());
|
}
|
}
|
Map<Long, String> modelMap = new HashMap<>();
|
if (!modelIds.isEmpty()) {
|
for (ProductModel model : productModelMapper.selectBatchIds(modelIds)) {
|
modelMap.put(model.getId(), model.getModel());
|
}
|
}
|
|
for (OutsourcingOrderProduct product : products) {
|
String productName = productMap.get(product.getProductId());
|
if (productName != null) {
|
product.setProductCategory(productName);
|
}
|
String model = modelMap.get(product.getProductModelId());
|
if (model != null) {
|
product.setSpecificationModel(model);
|
}
|
}
|
}
|
|
private void fillPartnerName(OutsourcingOrder order) {
|
if (order.getPartnerId() == null) {
|
return;
|
}
|
OutsourcingPartner partner = outsourcingPartnerMapper.selectById(order.getPartnerId());
|
if (partner == null) {
|
throw new ServiceException("合作商不存在，请重新选择");
|
}
|
order.setPartnerName(partner.getPartnerName());
|
}
|
}
|
