package com.vincent.rsf.server.manager.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.vincent.rsf.framework.common.R;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.manager.controller.params.PakinItem;
|
import com.vincent.rsf.server.manager.controller.params.WaitPakinParam;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.enums.PakinIOStatus;
|
import com.vincent.rsf.server.manager.mapper.WaitPakinMapper;
|
import com.vincent.rsf.server.manager.mapper.MatnrMapper;
|
import com.vincent.rsf.server.manager.service.*;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.vincent.rsf.server.common.utils.QuantityUtils;
|
import com.vincent.rsf.server.system.constant.GlobalConfigCode;
|
import com.vincent.rsf.server.system.constant.SerialRuleCode;
|
import com.vincent.rsf.server.system.entity.Config;
|
import com.vincent.rsf.server.system.service.ConfigService;
|
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Service("waitPakinService")
|
public class WaitPakinServiceImpl extends ServiceImpl<WaitPakinMapper, WaitPakin> implements WaitPakinService {
|
|
|
@Autowired
|
private AsnOrderService asnOrderService;
|
@Autowired
|
private AsnOrderItemService asnOrderItemService;
|
@Autowired
|
private WaitPakinService waitPakinService;
|
@Autowired
|
private WaitPakinItemService waitPakinItemService;
|
@Autowired
|
private WarehouseAreasItemService warehouseAreasItemService;
|
@Autowired
|
private LocService locService;
|
@Autowired
|
private TaskService taskService;
|
@Autowired
|
private TaskItemService taskItemService;
|
@Autowired
|
private MatnrMapper matnrMapper;
|
@Autowired
|
private ConfigService configService;
|
|
|
/**
|
* @param
|
* @param userId
|
* @return
|
* @author Ryan
|
* @description 组托
|
* @time 2025/3/29 14:42
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public synchronized WaitPakin mergeItems(WaitPakinParam waitPakin, Long userId) {
|
if (Objects.isNull(waitPakin.getItems()) || waitPakin.getItems().isEmpty()) {
|
throw new CoolException("参数错误：物料跟踪码为空！");
|
}
|
if (StringUtils.isBlank(waitPakin.getBarcode())) {
|
throw new CoolException("参数错误：料箱码为空！！");
|
}
|
WaitPakin pakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, waitPakin.getBarcode()));
|
|
// 半箱时允许同一料箱码继续组托追加；非半箱时料箱码已组托则不可再用
|
if (!Objects.isNull(pakin) && !Boolean.TRUE.equals(waitPakin.getIsHalf())) {
|
throw new CoolException("已组托，请更换料箱码");
|
}
|
|
List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, waitPakin.getBarcode()));
|
if (!tasks.isEmpty()) {
|
throw new CoolException("当前料箱已有任务档在执行，不能再次组托！！");
|
}
|
|
// 检查料箱码是否在库存中存在（通过库位表查询）
|
List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getBarcode, waitPakin.getBarcode()));
|
if (!locs.isEmpty()) {
|
throw new CoolException("在库，请更换料箱码");
|
}
|
|
Double sum = QuantityUtils.roundToScale(waitPakin.getItems().stream().mapToDouble(PakinItem::getReceiptQty).sum());
|
|
Config directPakinConfig = configService.getOne(new LambdaQueryWrapper<Config>().eq(Config::getFlag, GlobalConfigCode.DIRECT_WAIT_PAKIN));
|
boolean directWaitPakin = directPakinConfig != null && Boolean.parseBoolean(directPakinConfig.getVal());
|
|
WaitPakin waitPakin1;
|
if (Objects.isNull(pakin)) {
|
waitPakin1 = new WaitPakin();
|
String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_WAIT_PAKIN_CODE, null);
|
if (StringUtils.isBlank(ruleCode)) {
|
throw new CoolException("编码规则错误： 编码规则「SYS_WAIT_PAKIN_CODE」规则是不存在");
|
}
|
waitPakin1.setCode(ruleCode)
|
.setIoStatus(PakinIOStatus.PAKIN_IO_STATUS_DONE.val)
|
.setAnfme(sum)
|
.setUpdateBy(userId)
|
.setCreateBy(userId)
|
.setBarcode(waitPakin.getBarcode());
|
if (!this.save(waitPakin1)) {
|
throw new CoolException("主单保存失败！！");
|
}
|
} else {
|
// 半箱追加：沿用已有组托单，只追加明细
|
waitPakin1 = pakin;
|
}
|
|
List<WaitPakinItem> items = new ArrayList<>();
|
if (directWaitPakin) {
|
// DirectWaitPakin 启用：组托来自收货区，param 中 id 为 WarehouseAreasItem.id
|
for (PakinItem pakinItem1 : waitPakin.getItems()) {
|
WarehouseAreasItem areaItem = warehouseAreasItemService.getById(pakinItem1.getId());
|
if (areaItem == null) {
|
throw new CoolException("物料未送至收货区！！");
|
}
|
WaitPakinItem pakinItem = new WaitPakinItem();
|
pakinItem.setPakinId(waitPakin1.getId())
|
.setSource(areaItem.getId())
|
.setAsnId(areaItem.getAsnId())
|
.setAsnCode(areaItem.getAsnCode())
|
.setAsnItemId(areaItem.getAsnItemId())
|
.setIsptResult(areaItem.getIsptResult())
|
.setPlatItemId(areaItem.getPlatItemId())
|
.setPlatOrderCode(areaItem.getPlatOrderCode())
|
.setPlatWorkCode(areaItem.getPlatWorkCode())
|
.setProjectCode(areaItem.getProjectCode())
|
.setBatch(areaItem.getSplrBatch())
|
.setUnit(areaItem.getStockUnit())
|
.setFieldsIndex(areaItem.getFieldsIndex())
|
.setMatnrId(areaItem.getMatnrId())
|
.setMaktx(areaItem.getMaktx())
|
.setUpdateBy(userId)
|
.setCreateBy(userId)
|
.setMatnrCode(areaItem.getMatnrCode());
|
WkOrder order = asnOrderService.getById(areaItem.getAsnId());
|
if (order != null) {
|
pakinItem.setType(order.getType()).setWkType(StringUtils.isNotBlank(order.getWkType()) ? Short.parseShort(order.getWkType()) : null);
|
}
|
if (pakinItem1.getReceiptQty() == null || pakinItem1.getReceiptQty().compareTo(0.0) <= 0) {
|
throw new CoolException("组托数量不能小于等于零！！");
|
}
|
if (QuantityUtils.compare(pakinItem1.getReceiptQty(), areaItem.getAnfme()) > 0) {
|
throw new CoolException("组托数量不能大于收货数量！！");
|
}
|
pakinItem.setAnfme(QuantityUtils.roundToScale(pakinItem1.getReceiptQty())).setTrackCode(pakinItem1.getTrackCode());
|
items.add(pakinItem);
|
}
|
if (!waitPakinItemService.saveBatch(items)) {
|
throw new CoolException("组托明细保存失败！！");
|
}
|
for (WaitPakinItem pakinItem : items) {
|
WarehouseAreasItem one = warehouseAreasItemService.getOne(new LambdaQueryWrapper<WarehouseAreasItem>().eq(WarehouseAreasItem::getId, pakinItem.getSource()));
|
if (one == null) {
|
throw new CoolException("收货区数据错误！！");
|
}
|
Double workQty = QuantityUtils.roundToScale(QuantityUtils.add(one.getWorkQty() != null ? one.getWorkQty() : 0.0, pakinItem.getAnfme()));
|
Double qty = QuantityUtils.roundToScale(QuantityUtils.add(workQty, one.getQty() != null ? one.getQty() : 0.0));
|
one.setWorkQty(workQty);
|
if (QuantityUtils.compare(qty, one.getAnfme() != null ? one.getAnfme() : 0.0) > 0) {
|
throw new CoolException("组托数量不能大于收货数量！！");
|
}
|
if (!warehouseAreasItemService.saveOrUpdate(one)) {
|
throw new CoolException("收货区执行数量修改失败！！");
|
}
|
}
|
// 半箱追加时需按该组托单下全部明细重算总数量
|
List<WaitPakinItem> allItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin1.getId()));
|
waitPakin1.setAnfme(QuantityUtils.roundToScale(allItems.stream().mapToDouble(w -> w.getAnfme() != null ? w.getAnfme() : 0.0).sum()));
|
if (!this.updateById(waitPakin1)) {
|
throw new CoolException("组托数量修改失败！！");
|
}
|
return waitPakin1;
|
}
|
|
// 有ASN时：按订单明细汇总已组托数量，校验 已组托+本次组盘 ≤ 计划数量
|
Map<Long, Double> alreadyPalletizedByItemId = new java.util.HashMap<>();
|
for (PakinItem p : waitPakin.getItems()) {
|
if (StringUtils.isNotBlank(p.getAsnCode()) && p.getId() != null) {
|
alreadyPalletizedByItemId.putIfAbsent(p.getId(), null);
|
}
|
}
|
if (!alreadyPalletizedByItemId.isEmpty()) {
|
for (Long asnItemId : alreadyPalletizedByItemId.keySet()) {
|
double alreadySum = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getAsnItemId, asnItemId).eq(WaitPakinItem::getDeleted, 0))
|
.stream().mapToDouble(w -> w.getAnfme() != null ? w.getAnfme() : 0.0).sum();
|
alreadyPalletizedByItemId.put(asnItemId, QuantityUtils.roundToScale(alreadySum));
|
}
|
}
|
|
for (PakinItem pakinItem1 : waitPakin.getItems()) {
|
WaitPakinItem pakinItem = new WaitPakinItem();
|
if (StringUtils.isBlank(pakinItem1.getAsnCode())) {
|
if (Objects.isNull(pakinItem1.getMatnrId())) {
|
throw new CoolException("物料ID不能为空！！");
|
}
|
|
// 从物料信息表获取物料信息
|
Matnr matnr = matnrMapper.selectById(pakinItem1.getMatnrId());
|
if (Objects.isNull(matnr)) {
|
throw new CoolException("物料信息不存在，物料ID：" + pakinItem1.getMatnrId());
|
}
|
|
// 设置组托明细信息（不设置source，因为不在收货区）
|
pakinItem.setPakinId(waitPakin1.getId())
|
.setSource(null) // 不在收货区，source设为null
|
.setAsnId(null)
|
.setAsnCode(null)
|
.setAsnItemId(null)
|
.setIsptResult(null)
|
.setPlatItemId(null)
|
.setPlatOrderCode(null)
|
.setPlatWorkCode(null)
|
.setProjectCode(null)
|
.setBatch(null)
|
.setUnit(matnr.getStockUnit())
|
.setFieldsIndex(matnr.getFieldsIndex())
|
.setMatnrId(matnr.getId())
|
.setMaktx(matnr.getName())
|
.setUpdateBy(userId)
|
.setCreateBy(userId)
|
.setMatnrCode(matnr.getCode());
|
|
// 设置组托数量
|
if (pakinItem1.getReceiptQty() == null || pakinItem1.getReceiptQty().compareTo(0.0) <= 0) {
|
throw new CoolException("组托数量不能小于等于零！！");
|
}
|
pakinItem.setAnfme(QuantityUtils.roundToScale(pakinItem1.getReceiptQty()))
|
.setTrackCode(pakinItem1.getTrackCode());
|
} else {
|
// 收货区已停用：有ASN单号时从订单明细获取物料信息
|
WkOrderItem orderItem = asnOrderItemService.getById(pakinItem1.getId());
|
if (null == orderItem) {
|
throw new CoolException("订单明细不存在！！");
|
}
|
WkOrder order = asnOrderService.getById(orderItem.getOrderId());
|
if (null == order) {
|
throw new CoolException("订单不存在！！");
|
}
|
pakinItem.setAnfme(QuantityUtils.roundToScale(orderItem.getAnfme()))
|
.setPakinId(waitPakin1.getId())
|
.setSource(null) // 收货区已停用，不关联收货区
|
.setAsnId(order.getId())
|
.setAsnCode(order.getCode())
|
.setAsnItemId(orderItem.getId())
|
.setIsptResult(orderItem.getIsptResult())
|
.setPlatItemId(orderItem.getPlatItemId())
|
.setPlatOrderCode(orderItem.getPlatOrderCode())
|
.setPlatWorkCode(orderItem.getPlatWorkCode())
|
.setProjectCode(orderItem.getProjectCode())
|
.setBatch(orderItem.getSplrBatch())
|
.setUnit(orderItem.getStockUnit())
|
.setFieldsIndex(orderItem.getFieldsIndex())
|
.setMatnrId(orderItem.getMatnrId())
|
.setMaktx(orderItem.getMaktx())
|
.setUpdateBy(userId)
|
.setCreateBy(userId)
|
.setMatnrCode(orderItem.getMatnrCode());
|
pakinItem.setType(null == order.getType() ? null : order.getType())
|
.setWkType(StringUtils.isNotBlank(order.getWkType()) ? Short.parseShort(order.getWkType()) : null);
|
|
for (PakinItem waitPakinItem : waitPakin.getItems()) {
|
if (waitPakinItem.getId().equals(orderItem.getId())) {
|
if (waitPakinItem.getReceiptQty() == null || waitPakinItem.getReceiptQty().compareTo(0.0) <= 0) {
|
throw new CoolException("组托数量不能小于等于零！！");
|
}
|
Double anfme = orderItem.getAnfme() != null ? orderItem.getAnfme() : 0.0;
|
Double already = alreadyPalletizedByItemId.getOrDefault(orderItem.getId(), 0.0);
|
if (QuantityUtils.compare(QuantityUtils.add(already, waitPakinItem.getReceiptQty()), anfme) > 0) {
|
throw new CoolException("组托数量不能超过可组盘数量（计划" + anfme + "，已组托" + already + "，本次最多" + QuantityUtils.subtract(anfme, already) + "）！！");
|
}
|
pakinItem.setAnfme(QuantityUtils.roundToScale(waitPakinItem.getReceiptQty()))
|
.setTrackCode(waitPakinItem.getTrackCode());
|
}
|
}
|
}
|
|
items.add(pakinItem);
|
}
|
|
if (!waitPakinItemService.saveBatch(items)) {
|
throw new CoolException("组托明细保存失败！！");
|
}
|
|
List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin1.getId()));
|
Double waitSum = 0.0;
|
if (!pakinItems.isEmpty()) {
|
waitSum = QuantityUtils.roundToScale(pakinItems.stream().mapToDouble(WaitPakinItem::getAnfme).sum());
|
}
|
// Double total = Math.round((sum + waitSum) * 100) / 100.0;
|
|
// 收货区已停用，不再更新收货区
|
// for (WaitPakinItem pakinItem : items) {
|
// if (Objects.isNull(pakinItem.getSource())) continue;
|
// WarehouseAreasItem one = warehouseAreasItemService.getOne(new LambdaQueryWrapper<WarehouseAreasItem>()
|
// .eq(WarehouseAreasItem::getId, pakinItem.getSource()));
|
// if (Objects.isNull(one)) throw new CoolException("收货区数据错误！！");
|
// Double workQty = Math.round((one.getWorkQty() + pakinItem.getAnfme()) * 1000000) / 1000000.0;
|
// Double qty = Math.round((workQty + one.getQty()) * 1000000) / 1000000.0;
|
// one.setWorkQty(workQty);
|
// if (qty.compareTo(one.getAnfme()) > 0) throw new CoolException("组托数量不能大于收货数量！！");
|
// if (!warehouseAreasItemService.saveOrUpdate(one)) throw new CoolException("收货区执行数量修改失败！！");
|
// }
|
|
waitPakin1.setAnfme(waitSum);
|
if (!this.updateById(waitPakin1)) {
|
throw new CoolException("组托数量修改失败！！");
|
}
|
return waitPakin1;
|
}
|
|
/**
|
* @param
|
* @return
|
* @author Ryan
|
* @description 组托解绑
|
* @time 2025/3/29 14:42
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public synchronized WaitPakin unBind(WaitPakinParam param) {
|
String barcode = param.getBarcode();
|
if (StringUtils.isNotBlank(barcode)) {
|
WaitPakin waitPakins = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, barcode));
|
if (Objects.isNull(waitPakins)) {
|
throw new CoolException("组托不存在！！");
|
}
|
List<PakinItem> paramItems = param.getItems();
|
|
if (Objects.isNull(paramItems) || paramItems.isEmpty()) {
|
throw new CoolException("解绑物料不能为空！！");
|
}
|
List<Long> list = paramItems.stream().map(PakinItem::getId).collect(Collectors.toList());
|
List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>()
|
.in(WaitPakinItem::getId, list)
|
);
|
if (pakinItems.isEmpty()) {
|
throw new CoolException("数据错误：组托明细不存在！！");
|
}
|
// List<Long> ids = pakinItems.stream().map(WaitPakinItem::getId).collect(Collectors.toList());
|
// if (!waitPakinItemService.removeByIds(ids)) {
|
// throw new CoolException("组托明细解绑失败！！");
|
// }
|
// 收货区已停用：仅保留非空 source 用于兼容旧数据，不再更新收货区
|
List<Long> list2 = pakinItems.stream().map(WaitPakinItem::getSource).filter(Objects::nonNull).collect(Collectors.toList());
|
List<WarehouseAreasItem> warehouseAreasItems = list2.isEmpty() ? Collections.emptyList() : warehouseAreasItemService.listByIds(list2);
|
for (int i1 = 0; i1 < pakinItems.size(); i1++) {
|
for (PakinItem item : paramItems) {
|
if (item.getId().equals(pakinItems.get(i1).getId())) {
|
if (QuantityUtils.compare(pakinItems.get(i1).getAnfme(), item.getReceiptQty()) > 0) {
|
if (QuantityUtils.compare(item.getReceiptQty(), 0.00) == 0) {
|
throw new CoolException("解绑数量不能为零！！");
|
}
|
Double reslt = QuantityUtils.subtract(QuantityUtils.subtract(pakinItems.get(i1).getAnfme(), pakinItems.get(i1).getWorkQty()), pakinItems.get(i1).getQty());
|
if (QuantityUtils.compare(item.getReceiptQty(), reslt) > 0) {
|
throw new CoolException("解绑数量不能大于剩余可执行数！！");
|
}
|
|
Double anfme = QuantityUtils.subtract(pakinItems.get(i1).getAnfme(), item.getReceiptQty());
|
pakinItems.get(i1).setAnfme(anfme);
|
if (!waitPakinItemService.updateById(pakinItems.get(i1))) {
|
throw new CoolException("组托明细数量修改失败！！");
|
}
|
} else {
|
if (!waitPakinItemService.removeById(pakinItems.get(i1).getId())) {
|
throw new CoolException("组托明细删除失败！！");
|
}
|
}
|
// DirectWaitPakin 启用时组托来自收货区，解绑需回写收货区 workQty
|
if (Objects.nonNull(pakinItems.get(i1).getSource())) {
|
for (WarehouseAreasItem areaItem : warehouseAreasItems) {
|
if (areaItem.getId().equals(pakinItems.get(i1).getSource())) {
|
Double v = QuantityUtils.roundToScale(QuantityUtils.subtract(areaItem.getWorkQty() != null ? areaItem.getWorkQty() : 0.0, item.getReceiptQty()));
|
areaItem.setWorkQty(v);
|
if (!warehouseAreasItemService.updateById(areaItem)) {
|
throw new CoolException("收货区数量修改失败！！");
|
}
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
Double anfmes = QuantityUtils.roundToScale(paramItems.stream().mapToDouble(PakinItem::getReceiptQty).sum());
|
// double anfmes = warehouseAreasItems.stream().mapToDouble(WarehouseAreasItem::getAnfme).sum();
|
if (QuantityUtils.compare(waitPakins.getAnfme(), anfmes) <= 0) {
|
if (!waitPakinService.removeById(waitPakins.getId())) {
|
throw new CoolException("组托删除失败！！");
|
}
|
} else {
|
waitPakins.setAnfme(QuantityUtils.subtract(waitPakins.getAnfme(), anfmes));
|
if (!waitPakinService.updateById(waitPakins)) {
|
throw new CoolException("组托数据修改失败！！");
|
}
|
}
|
return waitPakins;
|
}
|
return new WaitPakin();
|
}
|
|
/**
|
* @author Ryan
|
* @date 2025/5/7
|
* @description: 删除组拖信息
|
* @version 1.0
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R removePakin(List<Long> pakinIds) {
|
List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>()
|
.in(WaitPakinItem::getPakinId, pakinIds));
|
if (!pakinItems.isEmpty()) {
|
List<Long> list = pakinItems.stream().map(WaitPakinItem::getId).collect(Collectors.toList());
|
List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().in(TaskItem::getSource, list));
|
if (!taskItems.isEmpty()) {
|
return R.error("组拖档有明细任务");
|
}
|
|
Set<Long> sourceIds = pakinItems.stream().map(WaitPakinItem::getSource).filter(Objects::nonNull).collect(Collectors.toSet());
|
|
List<WarehouseAreasItem> areasItems = sourceIds.isEmpty() ? Collections.emptyList() : warehouseAreasItemService.list(new LambdaQueryWrapper<WarehouseAreasItem>().in(WarehouseAreasItem::getId, sourceIds));
|
|
// 收货区已停用，仅兼容旧数据时回滚收货区数量
|
if (!areasItems.isEmpty()) {
|
Map<Long, List<WaitPakinItem>> listMap = pakinItems.stream().collect(Collectors.groupingBy(WaitPakinItem::getSource));
|
for (WarehouseAreasItem item : areasItems) {
|
List<WaitPakinItem> pakin = listMap.get(item.getId());
|
if (Objects.isNull(pakin)) {
|
continue;
|
}
|
Double sum = QuantityUtils.roundToScale(pakin.stream().mapToDouble(WaitPakinItem::getAnfme).sum());
|
item.setWorkQty(QuantityUtils.subtract(item.getWorkQty(), sum));
|
if (!warehouseAreasItemService.updateById(item)) {
|
throw new CoolException("收货区数据回滚失败！！");
|
}
|
}
|
}
|
|
Set<Long> pakinItemIds = pakinItems.stream().map(WaitPakinItem::getId).collect(Collectors.toSet());
|
|
if (!waitPakinItemService.removeByIds(pakinItemIds)) {
|
throw new CoolException("明细删除失败！！");
|
}
|
}
|
|
if (!waitPakinService.removeByIds(pakinIds)) {
|
return R.error("Delete Fail");
|
}
|
|
return R.ok("Delete Success").add(pakinIds);
|
}
|
}
|
