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.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.production.bean.dto.ProductionPlanDto;
|
import com.ruoyi.production.bean.dto.ProductionOrderDto;
|
import com.ruoyi.production.bean.vo.ProductionPlanVo;
|
import com.ruoyi.production.mapper.ProductionPlanMapper;
|
import com.ruoyi.production.pojo.ProductionOrder;
|
import com.ruoyi.production.pojo.ProductionPlan;
|
import com.ruoyi.production.service.ProductionOrderService;
|
import com.ruoyi.production.service.ProductionPlanService;
|
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 jakarta.servlet.http.HttpServletResponse;
|
import lombok.AllArgsConstructor;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.Comparator;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.stream.Collectors;
|
|
@Service
|
@RequiredArgsConstructor
|
@Transactional(rollbackFor = Exception.class)
|
public class ProductionPlanServiceImpl extends ServiceImpl<ProductionPlanMapper, ProductionPlan> implements ProductionPlanService {
|
|
private final ProductionOrderService productionOrderService;
|
private final SalesLedgerMapper salesLedgerMapper;
|
private final SalesLedgerProductMapper salesLedgerProductMapper;
|
|
@Override
|
public IPage<ProductionPlanVo> listPage(Page<ProductionPlanDto> page, ProductionPlanDto productionPlanDto) {
|
Page<ProductionPlan> entityPage = new Page<>(page.getCurrent(), page.getSize(), page.getTotal());
|
return this.page(entityPage, buildQueryWrapper(productionPlanDto))
|
.convert(item -> BeanUtil.copyProperties(item, ProductionPlanVo.class));
|
}
|
|
@Override
|
public void loadProdData() {
|
// 用销售明细作为来源同步生产计划，source 字段承担幂等去重作用。
|
List<SalesLedgerProduct> salesLedgerProducts = salesLedgerProductMapper.selectList(
|
Wrappers.<SalesLedgerProduct>lambdaQuery()
|
.isNotNull(SalesLedgerProduct::getProductModelId)
|
.gt(SalesLedgerProduct::getQuantity, BigDecimal.ZERO));
|
for (SalesLedgerProduct salesLedgerProduct : salesLedgerProducts) {
|
String source = buildSalesSource(salesLedgerProduct.getId());
|
long exists = this.count(Wrappers.<ProductionPlan>lambdaQuery().eq(ProductionPlan::getSource, source));
|
if (exists > 0) {
|
continue;
|
}
|
SalesLedger salesLedger = salesLedgerMapper.selectById(salesLedgerProduct.getSalesLedgerId());
|
ProductionPlan productionPlan = new ProductionPlan();
|
productionPlan.setMpsNo(generateNextPlanNo());
|
productionPlan.setProductModelId(salesLedgerProduct.getProductModelId());
|
productionPlan.setQtyRequired(defaultDecimal(salesLedgerProduct.getQuantity()));
|
productionPlan.setRequiredDate(resolveDeliveryTime(salesLedger));
|
productionPlan.setPromisedDeliveryDate(resolveDeliveryTime(salesLedger));
|
productionPlan.setSource(source);
|
productionPlan.setIssued(Boolean.FALSE);
|
productionPlan.setState("1");
|
this.save(productionPlan);
|
}
|
}
|
|
@Override
|
public void syncProdDataJob() {
|
loadProdData();
|
}
|
|
@Override
|
public boolean combine(ProductionPlanDto productionPlanDto) {
|
// 多个计划合并转单后，仍统一走生产订单保存逻辑，避免两套下单流程不一致。
|
if (productionPlanDto == null || productionPlanDto.getIds() == null || productionPlanDto.getIds().isEmpty()) {
|
throw new ServiceException("请选择生产计划");
|
}
|
List<ProductionPlan> productionPlans = this.listByIds(productionPlanDto.getIds());
|
if (productionPlans.size() != productionPlanDto.getIds().size()) {
|
throw new ServiceException("部分生产计划不存在");
|
}
|
if (productionPlans.stream().anyMatch(item -> Boolean.TRUE.equals(item.getIssued()))) {
|
throw new ServiceException("已下发的生产计划不能重复转单");
|
}
|
Long productModelId = productionPlans.stream()
|
.map(ProductionPlan::getProductModelId)
|
.distinct()
|
.reduce((left, right) -> {
|
throw new ServiceException("仅支持相同产品规格的生产计划合并转单");
|
})
|
.orElseThrow(() -> new ServiceException("生产计划缺少产品规格"));
|
BigDecimal totalRequiredQuantity = productionPlans.stream()
|
.map(ProductionPlan::getQtyRequired)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
BigDecimal assignedQuantity = defaultDecimal(productionPlanDto.getTotalAssignedQuantity());
|
if (assignedQuantity.compareTo(BigDecimal.ZERO) <= 0) {
|
assignedQuantity = totalRequiredQuantity;
|
}
|
if (assignedQuantity.compareTo(totalRequiredQuantity) > 0) {
|
throw new ServiceException("下发数量不能大于计划总需求数量");
|
}
|
|
ProductionOrder productionOrder = new ProductionOrder();
|
productionOrder.setProductModelId(productModelId);
|
productionOrder.setQuantity(assignedQuantity);
|
productionOrder.setProductionPlanIds(formatPlanIds(productionPlans));
|
productionOrder.setPlanCompleteTime(productionPlanDto.getPlanCompleteTime() != null
|
? productionPlanDto.getPlanCompleteTime()
|
: resolveEarliestPlanDate(productionPlans));
|
productionOrder.setStrength(productionPlanDto.getStrength());
|
return productionOrderService.saveProductionOrder(productionOrder);
|
}
|
|
@Override
|
public boolean add(ProductionPlanDto productionPlanDto) {
|
// 手工建计划时补齐默认编号和状态，保证后续可以直接下发转单。
|
ProductionPlan productionPlan = BeanUtil.copyProperties(productionPlanDto, ProductionPlan.class);
|
validateProductionPlan(productionPlan, false);
|
if (productionPlan.getMpsNo() == null || productionPlan.getMpsNo().trim().isEmpty()) {
|
productionPlan.setMpsNo(generateNextPlanNo());
|
}
|
if (productionPlan.getIssued() == null) {
|
productionPlan.setIssued(Boolean.FALSE);
|
}
|
if (productionPlan.getState() == null || productionPlan.getState().trim().isEmpty()) {
|
productionPlan.setState("1");
|
}
|
return this.save(productionPlan);
|
}
|
|
@Override
|
public boolean update(ProductionPlanDto productionPlanDto) {
|
// 已下发计划的核心字段不能再变更，否则会和已生成订单脱节。
|
if (productionPlanDto == null || productionPlanDto.getId() == null) {
|
throw new ServiceException("生产计划ID不能为空");
|
}
|
ProductionPlan current = this.getById(productionPlanDto.getId());
|
if (current == null) {
|
throw new ServiceException("生产计划不存在");
|
}
|
if (Boolean.TRUE.equals(current.getIssued()) && hasPlanCoreChanges(current, productionPlanDto)) {
|
throw new ServiceException("已下发的生产计划不允许修改产品、数量和交期");
|
}
|
ProductionPlan update = BeanUtil.copyProperties(productionPlanDto, ProductionPlan.class);
|
validateProductionPlan(update, true);
|
return this.updateById(update);
|
}
|
|
@Override
|
public boolean delete(List<Long> ids) {
|
// 删除前校验 issued，避免把已转单计划直接从源头删掉。
|
if (ids == null || ids.isEmpty()) {
|
return false;
|
}
|
List<ProductionPlan> productionPlans = this.listByIds(ids);
|
if (productionPlans.stream().anyMatch(item -> Boolean.TRUE.equals(item.getIssued()))) {
|
throw new ServiceException("已下发的生产计划不允许删除");
|
}
|
return this.removeByIds(ids);
|
}
|
|
@Override
|
public void importProdData(MultipartFile file) {
|
|
}
|
|
@Override
|
public void exportProdData(HttpServletResponse response, List<Long> ids) {
|
|
}
|
|
private LambdaQueryWrapper<ProductionPlan> buildQueryWrapper(ProductionPlanDto dto) {
|
ProductionPlan query = dto == null ? new ProductionPlan() : dto;
|
return Wrappers.<ProductionPlan>lambdaQuery()
|
.eq(query.getId() != null, ProductionPlan::getId, query.getId())
|
.eq(query.getProductModelId() != null, ProductionPlan::getProductModelId, query.getProductModelId())
|
.eq(query.getIssued() != null, ProductionPlan::getIssued, query.getIssued())
|
.eq(query.getState() != null && !query.getState().trim().isEmpty(), ProductionPlan::getState, query.getState())
|
.eq(query.getIsAudit() != null && !query.getIsAudit().trim().isEmpty(), ProductionPlan::getIsAudit, query.getIsAudit())
|
.like(query.getMpsNo() != null && !query.getMpsNo().trim().isEmpty(), ProductionPlan::getMpsNo, query.getMpsNo())
|
.like(query.getSource() != null && !query.getSource().trim().isEmpty(), ProductionPlan::getSource, query.getSource())
|
.orderByDesc(ProductionPlan::getId);
|
}
|
|
private void validateProductionPlan(ProductionPlan productionPlan, boolean update) {
|
if (productionPlan == null) {
|
throw new ServiceException("生产计划不能为空");
|
}
|
if (update && productionPlan.getId() == null) {
|
throw new ServiceException("生产计划ID不能为空");
|
}
|
if (productionPlan.getProductModelId() == null) {
|
throw new ServiceException("productModelId不能为空");
|
}
|
if (defaultDecimal(productionPlan.getQtyRequired()).compareTo(BigDecimal.ZERO) <= 0) {
|
throw new ServiceException("qtyRequired必须大于0");
|
}
|
}
|
|
private boolean hasPlanCoreChanges(ProductionPlan current, ProductionPlanDto update) {
|
// 这些字段会直接影响转单结果，用来判断是否属于核心变更。
|
return !Objects.equals(current.getProductModelId(), update.getProductModelId())
|
|| defaultDecimal(current.getQtyRequired()).compareTo(defaultDecimal(update.getQtyRequired())) != 0
|
|| !Objects.equals(toLocalDate(current.getPromisedDeliveryDate()), update.getPlanCompleteTime())
|
|| !Objects.equals(toLocalDate(current.getRequiredDate()), toLocalDate(update.getRequiredDate()));
|
}
|
|
private String generateNextPlanNo() {
|
// 编号按日期递增生成，方便和订单、工单统一追踪。
|
String datePrefix = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
|
String prefix = "MPS" + datePrefix;
|
ProductionPlan latestPlan = this.getOne(Wrappers.<ProductionPlan>lambdaQuery()
|
.likeRight(ProductionPlan::getMpsNo, prefix)
|
.orderByDesc(ProductionPlan::getMpsNo)
|
.last("limit 1"));
|
int sequence = 1;
|
if (latestPlan != null && latestPlan.getMpsNo() != null && latestPlan.getMpsNo().startsWith(prefix)) {
|
try {
|
sequence = Integer.parseInt(latestPlan.getMpsNo().substring(prefix.length())) + 1;
|
} catch (NumberFormatException ignored) {
|
sequence = 1;
|
}
|
}
|
return prefix + String.format("%04d", sequence);
|
}
|
|
private String formatPlanIds(List<ProductionPlan> productionPlans) {
|
return productionPlans.stream()
|
.map(ProductionPlan::getId)
|
.distinct()
|
.map(String::valueOf)
|
.collect(Collectors.joining(",", "[", "]"));
|
}
|
|
private LocalDate resolveEarliestPlanDate(List<ProductionPlan> productionPlans) {
|
return productionPlans.stream()
|
.map(this::resolvePlanDate)
|
.filter(Objects::nonNull)
|
.min(Comparator.naturalOrder())
|
.orElse(null);
|
}
|
|
private LocalDate resolvePlanDate(ProductionPlan productionPlan) {
|
if (productionPlan.getPromisedDeliveryDate() != null) {
|
return productionPlan.getPromisedDeliveryDate().toLocalDate();
|
}
|
if (productionPlan.getRequiredDate() != null) {
|
return productionPlan.getRequiredDate().toLocalDate();
|
}
|
return null;
|
}
|
|
private LocalDateTime resolveDeliveryTime(SalesLedger salesLedger) {
|
if (salesLedger == null || salesLedger.getDeliveryDate() == null) {
|
return null;
|
}
|
return salesLedger.getDeliveryDate().atStartOfDay();
|
}
|
|
private String buildSalesSource(Long salesLedgerProductId) {
|
return "salesLedgerProduct:" + salesLedgerProductId;
|
}
|
|
private LocalDate toLocalDate(LocalDateTime value) {
|
return value == null ? null : value.toLocalDate();
|
}
|
|
private BigDecimal defaultDecimal(BigDecimal value) {
|
return value == null ? BigDecimal.ZERO : value;
|
}
|
}
|
