package com.vincent.rsf.server.manager.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
import com.vincent.rsf.framework.common.R;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.manager.controller.params.ReviseLogParams;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
|
import com.vincent.rsf.server.manager.enums.CommonExceStatus;
|
import com.vincent.rsf.server.manager.enums.OrderType;
|
import com.vincent.rsf.server.manager.enums.OrderWorkType;
|
import com.vincent.rsf.server.manager.mapper.ReviseLogMapper;
|
import com.vincent.rsf.server.manager.service.*;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.ArrayList;
|
import java.util.Date;
|
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("reviseLogService")
|
public class ReviseLogServiceImpl extends ServiceImpl<ReviseLogMapper, ReviseLog> implements ReviseLogService {
|
|
@Autowired
|
private LocReviseService locReviseService;
|
|
@Autowired
|
private ReviseLogService reviseLogService;
|
|
@Autowired
|
private LocItemService locItemService;
|
|
@Autowired
|
private LocService locService;
|
|
@Autowired
|
private ReviseLogItemService reviseLogItemService;
|
|
@Autowired
|
private OutStockService outStockService;
|
|
@Autowired
|
private OutStockItemService outStockItemService;
|
|
/**
|
* 库存调整单明细添加
|
*
|
* @param revise
|
* @param loginUserId
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public List<ReviseLog> reviseLoc(ReviseLogParams revise, Long loginUserId) {
|
LocRevise locRevise = locReviseService.getById(revise.getReviseId());
|
if (Objects.isNull(locRevise)) {
|
throw new CoolException("调整单据不存在！！");
|
}
|
List<ReviseLog> items = revise.getItems();
|
if (items.isEmpty()) {
|
throw new CoolException("调整单明细参数为空！！");
|
}
|
items.forEach(item -> {
|
ReviseLog reviseLog = new ReviseLog();
|
BeanUtils.copyProperties(item, reviseLog);
|
reviseLog.setAreaId(locRevise.getAreaId())
|
.setReviseId(locRevise.getId())
|
.setCreateBy(loginUserId)
|
.setUpdateBy(loginUserId)
|
.setReviseCode(locRevise.getCode());
|
if (!reviseLogService.save(reviseLog)) {
|
throw new CoolException("调整单明细保存失败！！");
|
}
|
|
List<LocItem> locItems = locItemService.list(new LambdaQueryWrapper<LocItem>()
|
.eq(LocItem::getLocCode, item.getLocCode()));
|
if (!locItems.isEmpty()) {
|
locItems.forEach(ote -> {
|
ReviseLogItem logItem = new ReviseLogItem();
|
BeanUtils.copyProperties(ote, logItem);
|
logItem.setReviseLogId(reviseLog.getId());
|
if (!reviseLogItemService.save(logItem)) {
|
throw new CoolException("明细保存失败！！");
|
}
|
});
|
}
|
|
Double sum = locItems.stream().mapToDouble(LocItem::getAnfme).sum();
|
|
locRevise.setAnfme(Math.round((sum + locRevise.getAnfme()) * 1000000) / 1000000.0);
|
});
|
|
locRevise.setExceStatus(CommonExceStatus.COMMON_EXCE_STATUS_UN_EXCE.val);
|
|
if (!locReviseService.updateById(locRevise)) {
|
throw new CoolException("状态更新失败！！");
|
}
|
return items;
|
}
|
|
/**
|
* @author Ryan
|
* @date 2025/8/18
|
* @description: 确认调整库存
|
* @version 1.0
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R complete(Long id, Long loginUserId) {
|
LocRevise revise = locReviseService.getById(id);
|
if (Objects.isNull(revise)) {
|
throw new CoolException("调整单不存在！！");
|
}
|
if (!revise.getExceStatus().equals(CommonExceStatus.COMMON_EXCE_STATUS_EXCE_ING.val)) {
|
throw new CoolException("单据状态未执行或已完成，无法执行完成操作！！");
|
}
|
List<ReviseLog> logs = reviseLogService.list(new LambdaQueryWrapper<ReviseLog>().eq(ReviseLog::getReviseId, revise.getId()));
|
if (logs.isEmpty()) {
|
throw new CoolException("库存日志不存在！！");
|
}
|
Set<Long> longs = logs.stream().map(ReviseLog::getId).collect(Collectors.toSet());
|
List<ReviseLogItem> logItems = reviseLogItemService.list(new LambdaQueryWrapper<ReviseLogItem>().in(ReviseLogItem::getReviseLogId, longs));
|
if (logItems.isEmpty()) {
|
throw new CoolException("调整明细为空!!");
|
}
|
// 按库位ID分组，如果locId为null则按locCode分组
|
Map<String, List<ReviseLogItem>> listMap = logItems.stream()
|
.filter(item -> item.getLocCode() != null && !item.getLocCode().isEmpty())
|
.collect(Collectors.groupingBy(item -> {
|
// 优先使用locId，如果为null则使用locCode作为key
|
return item.getLocId() != null ? String.valueOf(item.getLocId()) : item.getLocCode();
|
}));
|
|
// 优化：在循环外查询所有未完成的出库单和明细，避免重复查询
|
// 查询所有未完成的出库单状态：初始化、待处理、生成波次、生成工作档、作业中
|
List<WkOrder> outOrders = outStockService.list(new LambdaQueryWrapper<WkOrder>()
|
.eq(WkOrder::getType, OrderType.ORDER_OUT.type)
|
.in(WkOrder::getExceStatus,
|
AsnExceStatus.OUT_STOCK_STATUS_TASK_INIT.val,
|
AsnExceStatus.OUT_STOCK_STATUS_TASK_EXCE.val,
|
AsnExceStatus.OUT_STOCK_STATUS_TASK_WAVE.val,
|
AsnExceStatus.OUT_STOCK_STATUS_TASK_CREATE.val,
|
AsnExceStatus.OUT_STOCK_STATUS_TASK_WORKING.val));
|
|
// 预先查询所有出库单的明细，建立索引以提高查询效率
|
Map<Long, List<WkOrderItem>> orderItemsMap = new HashMap<>();
|
Map<Long, Boolean> orderHasItemsMap = new HashMap<>();
|
if (!outOrders.isEmpty()) {
|
Set<Long> orderIds = outOrders.stream().map(WkOrder::getId).collect(Collectors.toSet());
|
List<WkOrderItem> allOrderItems = outStockItemService.list(
|
new LambdaQueryWrapper<WkOrderItem>().in(WkOrderItem::getOrderId, orderIds));
|
|
// 按orderId分组建立索引
|
orderItemsMap = allOrderItems.stream()
|
.collect(Collectors.groupingBy(WkOrderItem::getOrderId));
|
|
// 记录每个出库单是否有明细
|
for (Long orderId : orderIds) {
|
orderHasItemsMap.put(orderId, orderItemsMap.containsKey(orderId) && !orderItemsMap.get(orderId).isEmpty());
|
}
|
}
|
|
// 使用final变量以便在lambda中使用
|
final Map<Long, List<WkOrderItem>> finalOrderItemsMap = orderItemsMap;
|
final Map<Long, Boolean> finalOrderHasItemsMap = orderHasItemsMap;
|
|
// 批量收集需要创建的WkOrderItem
|
List<WkOrderItem> newOrderItems = new ArrayList<>();
|
|
listMap.keySet().forEach(key -> {
|
List<ReviseLogItem> reviseItems = listMap.get(key);
|
if (Objects.isNull(reviseItems) || reviseItems.isEmpty()) {
|
throw new CoolException("调整明细为空！！");
|
}
|
|
// 获取第一个明细的库位信息
|
ReviseLogItem firstItem = reviseItems.get(0);
|
String locCode = firstItem.getLocCode();
|
Long locId = firstItem.getLocId();
|
|
// 查询库位：优先使用locId，如果为null则使用locCode
|
Loc loc = null;
|
if (locId != null) {
|
loc = locService.getById(locId);
|
}
|
if (loc == null && locCode != null && !locCode.isEmpty()) {
|
loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, locCode).eq(Loc::getDeleted, 0));
|
}
|
|
if (Objects.isNull(loc)) {
|
throw new CoolException("库位不存在！库位编码:" + locCode + ", 库位ID:" + locId);
|
}
|
|
// 删除原库位的库存明细（如果存在）
|
locItemService.remove(new LambdaQueryWrapper<LocItem>().eq(LocItem::getLocId, loc.getId()));
|
|
Loc finalLoc = loc;
|
reviseItems.forEach(logItem -> {
|
LocItem locDetl = new LocItem();
|
BeanUtils.copyProperties(logItem, locDetl);
|
locDetl.setLocId(finalLoc.getId())
|
.setType(OrderType.ORDER_REVISE.type)
|
.setWkType(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_STOCK_REVISE.type))
|
.setLocCode(finalLoc.getCode())
|
.setAnfme(logItem.getReviseQty())
|
// 如果batch不为空，同时设置splrBatch，以便查询时能匹配
|
.setSplrBatch(StringUtils.isNotBlank(logItem.getBatch()) ? logItem.getBatch() : null)
|
.setUpdateBy(loginUserId)
|
.setId(null)
|
.setCreateBy(loginUserId);
|
if (!locItemService.save(locDetl)) {
|
throw new CoolException("库存明细保存失败！！");
|
}
|
|
// 为库存调整产生的库存创建对应的WkOrderItem
|
// 遍历所有未完成的出库单，检查是否需要这些物料
|
for (WkOrder outOrder : outOrders) {
|
// 从预加载的索引中查找该出库单的明细
|
List<WkOrderItem> orderItems = finalOrderItemsMap.getOrDefault(outOrder.getId(), new ArrayList<>());
|
|
// 检查该出库单是否已有匹配的明细
|
boolean hasMatchingItem = orderItems.stream().anyMatch(item -> {
|
// 物料ID必须匹配
|
if (!Objects.equals(item.getMatnrId(), logItem.getMatnrId())) {
|
return false;
|
}
|
|
// 如果有批次信息，需要匹配批次
|
if (StringUtils.isNotBlank(logItem.getBatch())) {
|
boolean batchMatch = Objects.equals(item.getBatch(), logItem.getBatch()) ||
|
Objects.equals(item.getSplrBatch(), logItem.getBatch());
|
if (!batchMatch) {
|
return false;
|
}
|
}
|
|
// 如果有字段索引，需要匹配
|
if (StringUtils.isNotBlank(logItem.getFieldsIndex())) {
|
if (!Objects.equals(item.getFieldsIndex(), logItem.getFieldsIndex())) {
|
return false;
|
}
|
}
|
|
return true;
|
});
|
|
// 如果该出库单需要这个物料但没有对应的明细，则创建
|
if (!hasMatchingItem) {
|
// 为所有未完成的出库单创建WkOrderItem，即使出库单没有其他明细
|
// 因为库存调整的物料可能需要出库
|
WkOrderItem newOrderItem = new WkOrderItem();
|
newOrderItem.setOrderId(outOrder.getId())
|
.setOrderCode(outOrder.getCode())
|
.setMatnrId(logItem.getMatnrId())
|
.setMatnrCode(logItem.getMatnrCode())
|
.setMaktx(logItem.getMaktx())
|
.setBatch(logItem.getBatch())
|
// 如果batch不为空，同时设置splrBatch，以便查询时能匹配
|
.setSplrBatch(StringUtils.isNotBlank(logItem.getBatch()) ? logItem.getBatch() : null)
|
.setFieldsIndex(logItem.getFieldsIndex())
|
.setAnfme(logItem.getReviseQty())
|
.setWorkQty(0.0)
|
.setStockUnit(logItem.getUnit())
|
.setPurUnit(logItem.getUnit())
|
.setSpec(logItem.getSpec())
|
.setModel(logItem.getModel())
|
.setCreateBy(loginUserId)
|
.setUpdateBy(loginUserId)
|
.setCreateTime(new Date())
|
.setUpdateTime(new Date());
|
|
newOrderItems.add(newOrderItem);
|
}
|
}
|
});
|
});
|
|
// 批量保存WkOrderItem，减少数据库操作次数
|
if (!newOrderItems.isEmpty()) {
|
if (!outStockItemService.saveBatch(newOrderItems)) {
|
throw new CoolException("库存调整单据明细创建失败！！");
|
}
|
}
|
revise.setExceStatus(CommonExceStatus.COMMON_EXCE_STATUS_TASK_DONE.val);
|
if (!locReviseService.updateById(revise)) {
|
throw new CoolException("调整单修改失败！！");
|
}
|
return R.ok();
|
}
|
}
|
