From 98d88ac8caf7f0991d741079474c262f1e252927 Mon Sep 17 00:00:00 2001
From: chen.lin <1442464845@qq.com>
Date: 星期五, 06 三月 2026 08:14:54 +0800
Subject: [PATCH] 拣货过程中的出库库存匹配
---
rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/PdaOutStockServiceImpl.java | 685 ++++++++++++++++++++++++++++++++++++++++++++++----------
1 files changed, 558 insertions(+), 127 deletions(-)
diff --git a/rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/PdaOutStockServiceImpl.java b/rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/PdaOutStockServiceImpl.java
index 625095e..fb2e32f 100644
--- a/rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/PdaOutStockServiceImpl.java
+++ b/rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/PdaOutStockServiceImpl.java
@@ -5,25 +5,48 @@
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.api.entity.dto.ContainerWaveDto;
+import com.vincent.rsf.server.api.entity.dto.ContainerWaveItemDto;
+import com.vincent.rsf.server.api.entity.dto.QuickPickOrderModuleDto;
import com.vincent.rsf.server.api.entity.params.ContainerWaveParam;
+import com.vincent.rsf.server.api.entity.params.WavePickItemsParams;
import com.vincent.rsf.server.api.service.PdaOutStockService;
+import com.vincent.rsf.server.common.utils.FieldsUtils;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
import com.vincent.rsf.server.manager.enums.TaskStsType;
+import com.vincent.rsf.server.manager.enums.TaskType;
import com.vincent.rsf.server.manager.service.*;
+import com.vincent.rsf.server.manager.service.impl.LocItemWorkingServiceImpl;
+import com.vincent.rsf.server.manager.service.impl.StockItemServiceImpl;
+import com.vincent.rsf.server.manager.service.impl.StockServiceImpl;
+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.entity.Fields;
import com.vincent.rsf.server.system.entity.FieldsItem;
import com.vincent.rsf.server.system.service.FieldsItemService;
+import com.vincent.rsf.server.system.service.FieldsService;
+import com.vincent.rsf.server.system.service.impl.ConfigServiceImpl;
import com.vincent.rsf.server.system.service.impl.FieldsItemServiceImpl;
+import com.vincent.rsf.server.system.service.impl.FieldsServiceImpl;
+import com.vincent.rsf.server.system.utils.SerialRuleUtils;
+import com.vincent.rsf.server.common.constant.Constants;
+import com.vincent.rsf.server.system.utils.SystemAuthUtils;
import lombok.Synchronized;
import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.RequestBody;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;
+import java.util.Date;
@Service
public class PdaOutStockServiceImpl implements PdaOutStockService {
@@ -42,49 +65,148 @@
private WaveOrderRelaService waveOrderRelaService;
@Autowired
private FieldsItemService fieldsItemService;
+ @Autowired
+ private FieldsService fieldsService;
+ @Autowired
+ private StockService stockService;
+ @Autowired
+ private StockItemServiceImpl stockItemService;
+ @Autowired
+ private LocItemService locItemService;
+ @Autowired
+ private LocItemWorkingService locItemWorkingService;
+ @Autowired
+ private ConfigServiceImpl configService;
+ /**
+ * 蹇�熸嫞璐ф煡璇細鍚屼竴绠辩爜鍙兘鏈夊鏉′换鍔★紝浠� RCS 鍑哄簱鍥炶皟鍚庡彉涓� 199 鐨勬墠灞曠ず锛涜绠辩爜涓嬩粛涓嶆槸 199 鐨� PDA 涓嶆樉绀恒��
+ * 杩斿洖锛歰rders 鎸夊嚭搴撳崟鍒嗘ā鍧椼�乴ist/taskItems 璇ョ鐮佷笅 199 浠诲姟鏄庣粏銆�
+ */
@Override
public R getOutStockTaskItem(String barcode) {
- LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
- lambdaQueryWrapper.eq(Task::getBarcode, barcode);
- Task task = taskService.getOne(lambdaQueryWrapper);
- if (null == task) {
- return R.error("鏈煡璇㈠埌鐩稿叧浠诲姟");
+ // 鍙煡 199锛圵AVE_SEED锛�/AWAIT锛氬凡纭鍙樻垚 200 鐨勭粷涓嶈兘鎵嚭鏉ワ紝鏄庣‘鎺掗櫎 200 閬垮厤绗簩娆℃壂鍒�
+ List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
+ .eq(Task::getBarcode, barcode)
+ .in(Task::getTaskStatus, Arrays.asList(TaskStsType.WAVE_SEED.id, TaskStsType.AWAIT.id))
+ .ne(Task::getTaskStatus, TaskStsType.UPDATED_OUT.id)
+ .orderByAsc(Task::getId));
+ if (tasks == null || tasks.isEmpty()) {
+ return R.error("鏈煡璇㈠埌寰呯‘璁や换鍔�");
}
- List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
- if (null == taskItems || taskItems.size() <= 0) {
+ List<Long> taskIds = tasks.stream().map(Task::getId).collect(Collectors.toList());
+ List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().in(TaskItem::getTaskId, taskIds));
+ if (taskItems == null || taskItems.isEmpty()) {
return R.error("浠诲姟鍑洪敊锛屾湭鏌ヨ鍒扮浉鍏充换鍔℃槑缁�");
}
-
-
- return R.ok(taskItems);
+ // 鍚屼竴绠辩爜涓嬪彲鑳芥湁澶氭潯锛堝涓嚭搴撳崟锛夛紝鎸夊嚭搴撳崟鍒嗙粍锛涗粎杩斿洖灏氭湭鎷ｅ畬鐨勮鍗曟ā鍧�
+ String nullKey = "__none__";
+ Map<String, List<TaskItem>> byOrder = taskItems.stream()
+ .collect(Collectors.groupingBy(ti -> ti.getOrderId() != null ? "o_" + ti.getOrderId() : (StringUtils.isNotBlank(ti.getSourceCode()) ? "s_" + ti.getSourceCode() : nullKey)));
+ List<QuickPickOrderModuleDto> orders = new ArrayList<>();
+ for (Map.Entry<String, List<TaskItem>> e : byOrder.entrySet()) {
+ List<TaskItem> items = e.getValue();
+ boolean allPicked = items.stream().allMatch(ti -> ti.getQty() != null && ti.getAnfme() != null && ti.getQty().compareTo(ti.getAnfme()) >= 0);
+ if (allPicked) continue;
+ TaskItem first = items.get(0);
+ orders.add(new QuickPickOrderModuleDto()
+ .setOrderId(first.getOrderId())
+ .setOrderCode(StringUtils.isNotBlank(first.getSourceCode()) ? first.getSourceCode() : ("鍗曞彿:" + (first.getOrderId() != null ? first.getOrderId() : "鈥�")))
+ .setItems(items));
+ }
+ R r = orders.isEmpty() ? R.ok("鍏ㄩ儴鎷ｈ揣宸插畬鎴�") : R.ok();
+ r.put("orders", orders);
+ r.put("taskItems", taskItems);
+ r.put("list", taskItems); // 鍚屼竴绠辩爜涓嬪鏉℃槑缁嗭紝渚夸簬鐩存帴灞曠ず
+ return r;
}
@Override
+ @Transactional(rollbackFor = Exception.class)
+ @Synchronized
public R saveOutTaskSts(String barcode) {
- LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
- lambdaQueryWrapper.eq(Task::getBarcode, barcode);
- Task task = taskService.getOne(lambdaQueryWrapper);
- if (null == task) {
- throw new CoolException("鏈壘鍒板鍣ㄥ彿瀵瑰簲浠诲姟");
+ // 鍙粺璁″綋鍓嶃�屽緟纭銆嶄换鍔★細鍑哄簱鍗曟湁3鍗曚絾鍙笅鍙戜簡2涓换鍔℃椂锛�2涓换鍔￠兘鎷ｅ畬鍗冲彲纭骞剁敓鎴愭嫞鏂欏叆搴擄紱鏈変换鍔¤鍙栨秷鍒欏彧澶勭悊鍓╀綑浠诲姟
+ List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
+ .eq(Task::getBarcode, barcode)
+ .in(Task::getTaskStatus, Arrays.asList(TaskStsType.WAVE_SEED.id, TaskStsType.AWAIT.id))
+ .orderByAsc(Task::getId));
+ if (tasks == null || tasks.isEmpty()) {
+ throw new CoolException("鏈壘鍒版枡绠辩爜瀵瑰簲浠诲姟鎴栦换鍔＄姸鎬佷笉鏄瓑寰呯‘璁�");
}
- if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
- return R.error("浠诲姟鐘舵�佷笉鏄瓑寰呯‘璁�");
+ Long loginUserId = SystemAuthUtils.getLoginUserId();
+ if (loginUserId == null) {
+ loginUserId = 1L;
}
- List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
- Map<Long, List<TaskItem>> maps = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
- maps.keySet().forEach(key -> {
- WkOrderItem orderItem = asnOrderItemService.getById(key);
- if (Objects.isNull(orderItem)) {
- throw new CoolException("鍗曟嵁鏄庣粏涓嶅瓨鍦紒锛�");
+ try {
+ Task first = tasks.get(0);
+ if (first.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)) {
+ // 纭鍓嶈绠辩爜涓嬪凡鏈� 200 鐨勶紙渚嬪绗竴娆″凡纭鐨勶級锛氭湰娆″彧鎶婂綋鍓� 199 缃负 200锛屼笉鐢熸垚鎷ｆ枡鍏ュ簱锛岄伩鍏嶁�滅浜屾璇‘璁も�濆鑷撮敊璇墸鍑忓拰鐢熸垚鍏ュ簱
+ long already200 = taskService.count(new LambdaQueryWrapper<Task>()
+ .eq(Task::getBarcode, barcode)
+ .eq(Task::getTaskType, TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
+ .eq(Task::getTaskStatus, TaskStsType.UPDATED_OUT.id));
+ // 纭鍗冲凡纭锛氬綋鍓� 199 浠诲姟鍏ㄩ儴缃负 200锛屽苟鍥炲啓宸叉嫞鏁伴噺(qty)锛涗粎褰撴湰娆＄‘璁ゅ墠娌℃湁浠讳綍 200 涓旂‘璁ゅ悗鍏ㄩ儴 200 鏃舵墠缁熶竴鎵ｅ噺骞剁敓鎴愭嫞鏂欏叆搴�
+ for (Task task : tasks) {
+ task.setTaskStatus(TaskStsType.UPDATED_OUT.id)
+ .setUpdateBy(loginUserId)
+ .setUpdateTime(new Date());
+ if (!taskService.updateById(task)) {
+ return R.error("鏇存柊浠诲姟鐘舵�佸け璐�");
+ }
+ List<TaskItem> items = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
+ for (TaskItem ti : items) {
+ if (ti.getQty() == null || ti.getQty().compareTo(0.0) <= 0) {
+ ti.setQty(ti.getAnfme() != null ? ti.getAnfme() : 0.0);
+ ti.setUpdateBy(loginUserId);
+ ti.setUpdateTime(new Date());
+ taskItemService.updateById(ti);
+ }
+ }
+ }
+ long not200 = taskService.count(new LambdaQueryWrapper<Task>()
+ .eq(Task::getBarcode, barcode)
+ .ne(Task::getTaskStatus, TaskStsType.UPDATED_OUT.id));
+ if (not200 > 0) {
+ return R.ok("纭鎴愬姛");
+ }
+ // 鏈纭鍓嶈绠辩爜涓嬪凡鏈� 200 鐨勶紝涓嶅湪姝ゅ鐢熸垚鎷ｆ枡鍏ュ簱锛岀敱瀹氭椂浠诲姟鍦ㄢ�滃叏閮� 200鈥濇椂缁熶竴澶勭悊
+ if (already200 > 0) {
+ return R.ok("纭鎴愬姛锛涘悓绠卞凡鏈夎繃纭浠诲姟锛屾墸鍑忎笌鎷ｆ枡鍏ュ簱鐢辩郴缁熷湪鍏ㄩ儴200鍚庣粺涓�澶勭悊");
+ }
+ // 鏈纭鍓嶆病鏈変换浣� 200锛屼笖纭鍚庡悓绠辩爜宸插叏閮� 200锛氱粺涓�鎵ｅ噺銆佹湁浣欓噺鎵嶇敓鎴愭嫞鏂欏叆搴撳崟
+ List<Task> all200 = taskService.list(new LambdaQueryWrapper<Task>()
+ .eq(Task::getBarcode, barcode)
+ .eq(Task::getTaskType, TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
+ .eq(Task::getTaskStatus, TaskStsType.UPDATED_OUT.id)
+ .orderByAsc(Task::getId));
+ for (Task task : all200) {
+ taskService.pickOrCheckTask(task.getId(), "");
+ }
+ return R.ok("纭鎴愬姛锛屽凡缁熶竴鎵ｅ噺骞剁敓鎴愭嫞鏂欏叆搴撲换鍔★紙鏈変綑閲忔椂锛�");
}
- });
- task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
- if (!taskService.updateById(task)) {
- return R.error("鏇存柊浠诲姟鐘舵�佸け璐�");
+ if (first.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)) {
+ for (Task task : tasks) {
+ taskService.pickOrCheckTask(task.getId(), Constants.TASK_TYPE_OUT_CHECK);
+ }
+ return R.ok("纭鎴愬姛锛屽凡鍒涘缓鐩樼偣鍏ュ簱浠诲姟");
+ }
+ if (first.getTaskType().equals(TaskType.TASK_TYPE_OUT.type)) {
+ for (Task task : tasks) {
+ taskService.completeFullOutStock(task.getId(), loginUserId);
+ }
+ return R.ok("纭鎴愬姛锛屽叏鐗堝嚭搴撳凡瀹屾垚");
+ }
+ for (Task task : tasks) {
+ task.setTaskStatus(TaskStsType.UPDATED_OUT.id)
+ .setUpdateBy(loginUserId)
+ .setUpdateTime(new Date());
+ if (!taskService.updateById(task)) {
+ return R.error("鏇存柊浠诲姟鐘舵�佸け璐�");
+ }
+ }
+ return R.ok("纭鎴愬姛");
+ } catch (Exception e) {
+ throw new CoolException("蹇�熸嫞璐х‘璁ゅけ璐ワ細" + e.getMessage());
}
-
- return R.ok("纭鎴愬姛");
}
@Override
@@ -98,48 +220,344 @@
@Override
public R getContainerWaveList(Map<String, String> map) {
String barcode = map.get("barcode");
-
if (Cools.isEmpty(barcode)) {
throw new CoolException("鍙傛暟鏈夎");
}
- Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, barcode));
+ Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, barcode)
+ .orderByDesc(Task::getId)
+ .last("limit 1"));
if (null == task) {
- throw new CoolException("鏈壘鍒板鍣ㄥ彿瀵瑰簲浠诲姟");
+ throw new CoolException("鏈壘鍒版枡绠辩爜瀵瑰簲浠诲姟");
}
- if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
- return R.error("浠诲姟鐘舵�佷笉鏄瓑寰呯‘璁�");
+ if (!task.getTaskStatus().equals(TaskStsType.WAVE_SEED.id)) {
+ return R.error("浠诲姟鐘舵�佷笉鏄弨鏂欑媭鎱�");
}
- ArrayList<ContainerWaveDto> containerWaveDtos = new ArrayList<>();
- List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
- for (TaskItem taskItem : taskItems) {
- ContainerWaveDto containerWaveDto = new ContainerWaveDto();
- containerWaveDto.setTaskItem(taskItem);
- Wave wave = waveService.getById(taskItem.getSourceId());
- if (null == wave) {
- throw new CoolException("鏈壘鍒板鍣ㄥ彿瀵瑰簲娉㈡");
+ // 褰撳墠鏂欑瀵瑰簲搴撲綅涓嬫墍鏈夊浜庛�岄绾﹀嚭搴�/鎷ｈ揣涓�嶇殑浠诲姟锛堝惈鍙拷鍔犵殑鍚庣画璁㈠崟锛�
+ String orgLoc = task.getOrgLoc();
+ List<Integer> pickingStatuses = Arrays.asList(TaskStsType.GENERATE_OUT.id, TaskStsType.WAVE_SEED.id);
+ List<Task> sameLocTasks = taskService.list(new LambdaQueryWrapper<Task>()
+ .eq(Task::getOrgLoc, orgLoc)
+ .in(Task::getTaskStatus, pickingStatuses));
+ Set<Long> waveIds = new java.util.HashSet<>();
+ Set<String> matnrCodes = new java.util.HashSet<>();
+ for (Task t : sameLocTasks) {
+ List<TaskItem> items = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, t.getId()));
+ for (TaskItem ti : items) {
+ if (ti.getSourceId() != null) waveIds.add(ti.getSourceId());
+ if (StringUtils.isNotBlank(ti.getMatnrCode())) matnrCodes.add(ti.getMatnrCode());
}
- List<WaveOrderRela> waveOrderRelas = waveOrderRelaService.list(new LambdaQueryWrapper<WaveOrderRela>().eq(WaveOrderRela::getWaveId, wave.getId()));
- if (Cools.isEmpty(waveOrderRelas)) {
- throw new CoolException("娉㈡瀵瑰簲鍏宠仈鍗曟湭鎵惧埌");
+ }
+ if (waveIds.isEmpty()) {
+ throw new CoolException("娉㈡瀵瑰簲鍏宠仈鍗曟湭鎵惧埌");
+ }
+ List<WaveOrderRela> waveOrderRelas = waveOrderRelaService.list(new LambdaQueryWrapper<WaveOrderRela>()
+ .in(WaveOrderRela::getWaveId, waveIds));
+ Set<Long> orderIds = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
+ List<WkOrder> wkOrders = asnOrderService.listByIds(orderIds);
+ if (wkOrders.isEmpty()) {
+ throw new CoolException("鍗曟嵁涓嶅瓨鍦紒锛�");
+ }
+ // 鎸夎鍗曞垱寤烘椂闂存帓搴忥紝鍏堝垱寤虹殑涓轰富璁㈠崟锛屽悗缁负鍙拷鍔�
+ wkOrders.sort(Comparator.comparing(WkOrder::getCreateTime, Comparator.nullsLast(Comparator.naturalOrder())));
+ Set<String> codes = matnrCodes.isEmpty() ? taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()))
+ .stream().map(TaskItem::getMatnrCode).filter(StringUtils::isNotBlank).collect(Collectors.toSet()) : matnrCodes;
+ List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
+ .in(WkOrderItem::getMatnrCode, codes)
+ .in(WkOrderItem::getOrderId, orderIds));
+ List<ContainerWaveItemDto> result = new ArrayList<>();
+ Long firstOrderId = wkOrders.isEmpty() ? null : wkOrders.get(0).getId();
+ for (WkOrderItem item : orderItems) {
+ boolean appendable = firstOrderId != null && !firstOrderId.equals(item.getOrderId());
+ result.add(new ContainerWaveItemDto().setOrderItem(item).setAppendable(appendable));
+ }
+ R r = R.ok("鏌ヨ鎴愬姛");
+ r.put("list", result);
+ return r;
+
+// ArrayList<ContainerWaveDto> containerWaveDtos = new ArrayList<>();
+//// List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
+// for (TaskItem taskItem : taskItems) {
+// ContainerWaveDto containerWaveDto = new ContainerWaveDto();
+// containerWaveDto.setTaskItem(taskItem);
+// Wave wave = waveService.getById(taskItem.getSourceId());
+// if (null == wave) {
+// throw new CoolException("鏈壘鍒版枡绠辩爜瀵瑰簲娉㈡");
+// }
+// List<WaveOrderRela> waveOrderRelas = waveOrderRelaService.list(new LambdaQueryWrapper<WaveOrderRela>()
+// .eq(WaveOrderRela::getWaveId, wave.getId()));
+// if (Cools.isEmpty(waveOrderRelas)) {
+// throw new CoolException("娉㈡瀵瑰簲鍏宠仈鍗曟湭鎵惧埌");
+// }
+// Set<Long> ids = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
+// ArrayList<WkOrderItem> list = new ArrayList<>();
+// List<WkOrder> wkOrderList = asnOrderService.list(new LambdaQueryWrapper<WkOrder>().in(WkOrder::getId, ids));
+// for (WkOrder wkOrder : wkOrderList) {
+// List<WkOrderItem> orderItem = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
+// .eq(WkOrderItem::getOrderId, wkOrder.getId())
+// .eq(StringUtils.isNotEmpty(taskItem.getMatnrCode()), WkOrderItem::getMatnrCode, taskItem.getMatnrCode())
+// .eq(StringUtils.isNotEmpty(taskItem.getBatch()), WkOrderItem::getSplrBatch, taskItem.getBatch()));
+// if (null != orderItem) {
+// list.addAll(orderItem);
+// }
+// }
+// containerWaveDto.setWkOrderItems(list);
+// containerWaveDtos.add(containerWaveDto);
+// }
+// return R.ok("鏌ヨ鎴愬姛").add(wkOrders);
+ }
+
+ /**
+ * @author Ryan
+ * @date 2025/11/13
+ * @description: 鑾峰彇娉㈡鎷ｈ揣鏄庣粏
+ * @version 1.0
+ */
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public R getWaveOrderItems(Map<String, Object> param) {
+ if (Objects.isNull(param)) {
+ return R.error("鍙傛暟涓嶈兘涓虹┖锛侊紒");
+ }
+ // 绁ㄥ彿鏆備笉浣跨敤锛屾敞閲婃牎楠�
+ // if (Objects.isNull(param.get("fieldsIndex"))) {
+ // return R.error("绁ㄥ彿涓嶈兘涓虹┖锛侊紒");
+ // }
+ if (Objects.isNull(param.get("barcode"))) {
+ return R.error("鏂欑鐮佷笉鑳戒负绌猴紒锛�");
+ }
+ if (Objects.isNull(param.get("orderId"))) {
+ return R.error("璁㈠崟ID涓嶈兘涓虹┖锛侊紒");
+ }
+ Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, param.get("barcode").toString())
+ .orderByDesc(Task::getId)
+ .last("limit 1"));
+ if (Objects.isNull(task)) {
+ throw new CoolException("鏁版嵁閿欒锛屼换鍔℃。宸蹭笉瀛樺湪锛侊紒");
+ }
+ // 绁ㄥ彿鏆備笉浣跨敤锛屾寜浠诲姟鍙栫涓�鏉℃槑缁�
+ // FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>()
+ // .eq(FieldsItem::getValue, param.get("fieldsIndex").toString())
+ // .last("limit 1"));
+ // if (Objects.isNull(fieldsItem)) {
+ // return R.error("鏁版嵁閿欒锛岀エ鍙蜂笉瀛樺湪锛侊紒");
+ // }
+ TaskItem taskItem = null;
+ FieldsItem fieldsItem = null;
+ if (param.get("fieldsIndex") != null && StringUtils.isNotBlank(param.get("fieldsIndex").toString())) {
+ fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>()
+ .eq(FieldsItem::getValue, param.get("fieldsIndex").toString())
+ .last("limit 1"));
+ if (fieldsItem != null) {
+ taskItem = taskItemService.getOne(new LambdaQueryWrapper<TaskItem>()
+ .eq(TaskItem::getFieldsIndex, fieldsItem.getUuid())
+ .eq(TaskItem::getTaskId, task.getId()));
}
- Set<Long> ids = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
- ArrayList<WkOrderItem> list = new ArrayList<>();
- List<WkOrder> wkOrderList = asnOrderService.list(new LambdaQueryWrapper<WkOrder>().in(WkOrder::getId, ids));
- for (WkOrder wkOrder : wkOrderList) {
- List<WkOrderItem> orderItem = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
- .eq(WkOrderItem::getOrderId, wkOrder.getId())
- .eq(StringUtils.isNotEmpty(taskItem.getMatnrCode()), WkOrderItem::getMatnrCode, taskItem.getMatnrCode())
- .eq(StringUtils.isNotEmpty(taskItem.getBatch()), WkOrderItem::getSplrBatch, taskItem.getBatch()));
- if (null != orderItem) {
- list.addAll(orderItem);
- }
+ }
+ if (taskItem == null) {
+ taskItem = taskItemService.getOne(new LambdaQueryWrapper<TaskItem>()
+ .eq(TaskItem::getTaskId, task.getId())
+ .last("limit 1"));
+ }
+ if (Objects.isNull(taskItem)) {
+ return R.error("鏁版嵁閿欒锛屼换鍔℃。鏄庣粏涓嶅瓨鍦紒锛�");
+ }
+ // 绁ㄥ彿鏆備笉浣跨敤锛氫粎褰撴湁 fieldsItem 鏃惰缃� extendFields
+ if (fieldsItem != null) {
+ Fields fields1 = fieldsService.getById(fieldsItem.getFieldsId());
+ if (fields1 != null) {
+ Map<String, String> fields = new HashMap<>();
+ fields.put(fields1.getFields(), fieldsItem.getValue());
+ taskItem.setExtendFields(fields);
}
- containerWaveDto.setWkOrderItems(list);
- containerWaveDtos.add(containerWaveDto);
}
- return R.ok(containerWaveDtos);
+ return R.ok().add(taskItem);
}
+
+ /**
+ * @author Ryan
+ * @date 2025/11/13
+ * @description: 娉㈡鏄庣粏鎷ｈ揣
+ * @version 1.0
+ */
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public synchronized R wavePickItems(WavePickItemsParams params) {
+ if (Objects.isNull(params.getBarcode())) {
+ return R.error("鏂欑鐮佷笉鑳戒负绌猴紒锛�");
+ }
+ if (Objects.isNull(params.getOrderId())) {
+ return R.error("璁㈠崟ID涓嶈兘涓虹┖锛侊紒");
+ }
+ if (Objects.isNull(params.getTaskItems()) || params.getTaskItems().isEmpty()) {
+ return R.error("鎷ｈ揣鏄庣粏涓嶈兘涓虹┖锛�");
+ }
+ Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, params.getBarcode())
+ .orderByDesc(Task::getId)
+ .last("limit 1"));
+ if (null == task) {
+ return R.error("鏈壘鍒版枡绠卞搴旂殑浠诲姟");
+ }
+ if (!task.getTaskStatus().equals(TaskStsType.WAVE_SEED.id)) {
+ return R.error("浠诲姟鐘舵�佷笉鏄弨鏂欑媭鎱�");
+ }
+ WkOrder order = asnOrderService.getById(params.getOrderId());
+ if (Objects.isNull(order)) {
+ return R.error("鍗曟嵁淇℃伅涓嶅瓨鍦紒锛�");
+ }
+ List<TaskItem> taskItems = params.getTaskItems();
+ Map<String, List<TaskItem>> listMap = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getMatnrCode));
+ // 鎷ｈ揣瀹屾垚浠呮墸鍑忓簱浣嶆暟閲忓苟绱姞 TaskItem.qty锛屼笉鏇存柊鍑哄簱鍗�/璁㈠崟锛涘緟鎵樼洏鍏ㄩ儴鎷ｅ畬鍦� saveWavePick 鍐嶆寜椤哄簭鏇存柊搴撳瓨骞舵牎楠�
+ Config config = configService.getOne(new LambdaQueryWrapper<Config>().eq(Config::getFlag, GlobalConfigCode.ALLOW_OVER_CHANGE));
+ listMap.keySet().forEach(code -> {
+ List<TaskItem> items = listMap.get(code);
+ WkOrderItem orderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<WkOrderItem>()
+ .eq(WkOrderItem::getMatnrCode, code)
+ .eq(WkOrderItem::getOrderId, order.getId()));
+ if (Objects.isNull(orderItem)) {
+ throw new CoolException("鏁版嵁閿欒锛屾嫞鏂欎笉鍦ㄥ崟鎹渶姹備腑锛侊紒");
+ }
+ Double summed = items.stream().mapToDouble(ti -> ti.getAnfme() != null ? ti.getAnfme() : 0.0).sum();
+ Double pickQty = Math.round((orderItem.getQty() != null ? orderItem.getQty() : 0.0) + summed) * 1000000.0 / 1000000.0;
+ if (!Objects.isNull(config) && !Boolean.parseBoolean(config.getVal())) {
+ if (pickQty.compareTo(orderItem.getAnfme()) > 0.0) {
+ throw new CoolException("鎾鏁伴噺涓嶈兘瓒呭嚭璁㈠崟闇�姹傛暟閲�");
+ }
+ }
+
+ items.forEach(taskItem -> {
+ TaskItem item = taskItemService.getById(taskItem.getId());
+ if (Objects.isNull(item)) {
+ throw new CoolException("浠诲姟鏄庣粏涓嶅瓨鍦紒锛�");
+ }
+ if (!Objects.isNull(config) && !Boolean.parseBoolean(config.getVal())) {
+ Double v = Math.round(((item.getQty() != null ? item.getQty() : 0.0) + (taskItem.getAnfme() != null ? taskItem.getAnfme() : 0.0)) * 1000000.0) / 1000000.0;
+ if (item.getAnfme() != null && item.getAnfme().compareTo(v) < 0.0) {
+ throw new CoolException("褰撳墠鐗╂枡宸茶秴鍑哄彲鎷ｈ寖鍥达紝璇锋牳瀵瑰悗鍐嶆搷浣滐紒锛�");
+ }
+ }
+ Double picQty = Math.round(((item.getQty() != null ? item.getQty() : 0.0) + (taskItem.getAnfme() != null ? taskItem.getAnfme() : 0.0)) * 1000000.0) / 1000000.0;
+ item.setQty(picQty).setOrderId(order.getId()).setOrderItemId(orderItem.getId());
+ if (!taskItemService.updateById(item)) {
+ throw new CoolException("鎷ｈ揣鏁伴噺鏇存柊澶辫触锛侊紒");
+ }
+ if (StringUtils.isNotBlank(task.getOrgLoc())) {
+ LocItem locItem = locItemService.getOne(new LambdaQueryWrapper<LocItem>()
+ .eq(LocItem::getLocCode, task.getOrgLoc())
+ .eq(LocItem::getMatnrId, item.getMatnrId())
+ .eq(StringUtils.isNotBlank(item.getBatch()), LocItem::getBatch, item.getBatch())
+ .eq(StringUtils.isNotBlank(item.getFieldsIndex()), LocItem::getFieldsIndex, item.getFieldsIndex()));
+ if (Objects.nonNull(locItem)) {
+ Double pickAmt = taskItem.getAnfme() != null ? taskItem.getAnfme() : 0.0;
+ Double newAnfme = Math.round((locItem.getAnfme() - pickAmt) * 1000000.0) / 1000000.0;
+ if (newAnfme.compareTo(0.0) <= 0) {
+ locItemService.removeById(locItem.getId());
+ } else {
+ locItem.setAnfme(newAnfme)
+ .setUpdateBy(SystemAuthUtils.getLoginUserId())
+ .setUpdateTime(new Date());
+ if (!locItemService.updateById(locItem)) {
+ throw new CoolException("搴撲綅鏄庣粏鏁伴噺鎵ｅ噺澶辫触锛侊紒");
+ }
+ }
+ }
+ }
+ });
+ });
+ return R.ok();
+ }
+
+ /**
+ * @author Ryan
+ * @date 2025/11/19
+ * @description: 鑾峰彇鍑哄簱浠诲姟鎷ｈ揣鏄庣粏
+ * @version 1.0
+ */
+ @Override
+ public R getTaskItems(Map<String, String> params) {
+ if (Objects.isNull(params.get("barcode"))) {
+ throw new CoolException("鎷栫洏鐮佷笉鑳戒负绌猴紒锛�");
+ }
+ List<Integer> integers = Arrays.asList(TaskType.TASK_TYPE_OUT.type, TaskType.TASK_TYPE_EMPITY_OUT.type, TaskType.TASK_TYPE_PICK_AGAIN_OUT.type, TaskType.TASK_TYPE_CHECK_OUT.type);
+ Task task = taskService.getOne(new LambdaQueryWrapper<Task>()
+ .in(Task::getTaskType, integers)
+ .eq(Task::getBarcode, params.get("barcode")), false);
+ if (Objects.isNull(task)) {
+ return R.error("鏂欑鎵�鍦ㄤ换鍔′笉瀛樺湪锛侊紒");
+ }
+ List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
+ taskItems.forEach(taskItem -> {
+ if (!Objects.isNull(taskItem.getFieldsIndex())) {
+ Map<String, String> fields = FieldsUtils.getFields(taskItem.getFieldsIndex());
+ taskItem.setExtendFields(fields);
+ }
+ });
+ return R.ok().add(taskItems);
+ }
+
+ /**
+ * @author Ryan
+ * @date 2025/11/19
+ * @description: 淇敼鍑哄簱浠诲姟妗ｆ槑缁嗙エ鍙�
+ * @version 1.0
+ */
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public R modifyTaskItem(List<TaskItem> items) {
+ if (Objects.isNull(items) || items.isEmpty()) {
+ return R.error("鍙傛暟涓嶈兘涓虹┖锛侊紒");
+ }
+ for (TaskItem item : items) {
+ // 绁ㄥ彿鏆備笉浣跨敤锛岃烦杩囦慨鏀瑰嚭搴撲换鍔℃。鏄庣粏绁ㄥ彿閫昏緫
+ continue;
+ /*
+ if (Objects.isNull(item.getCrushNo())) {
+ continue;
+ }
+ TaskItem byId = taskItemService.getById(item.getId());
+ if (!Objects.isNull(byId.getFieldsIndex())) {
+ Map<String, String> fields = FieldsUtils.getFields(byId.getFieldsIndex());
+ byId.setExtendFields(fields);
+ }
+ if (byId.getExtendFields() != null && byId.getExtendFields().get("crushNo") != null && byId.getExtendFields().get("crushNo").equals(item.getCrushNo())) {
+ continue;
+ }
+ FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>()
+ .eq(FieldsItem::getValue, item.getCrushNo())
+ .last("limit 1"));
+ if (Objects.isNull(fieldsItem)) {
+ throw new CoolException("搴撳瓨涓嶅瓨鍦�!!");
+ }
+ String uuid = fieldsItem.getUuid();
+ item.setFieldsIndex(uuid).setExtendFields(null);
+ if (!taskItemService.updateById(item)) {
+ throw new CoolException("浠诲姟鏄庣粏淇敼澶辫触");
+ }
+ LocItemWorking oldOne = locItemWorkingService.getOne(new LambdaQueryWrapper<LocItemWorking>()
+ .eq(LocItemWorking::getTaskId, byId.getTaskId())
+ .eq(LocItemWorking::getMatnrCode, byId.getMatnrCode())
+ .eq(LocItemWorking::getFieldsIndex, byId.getFieldsIndex()));
+ if (Objects.isNull(oldOne)) {
+ throw new CoolException("鏄庣粏涓嶅瓨鍦ㄦ垨宸插嚭搴擄紒锛�");
+ }
+ LocItemWorking one = locItemWorkingService.getOne(new LambdaQueryWrapper<LocItemWorking>()
+ .eq(LocItemWorking::getTaskId, byId.getTaskId())
+ .eq(LocItemWorking::getMatnrCode, byId.getMatnrCode())
+ .eq(LocItemWorking::getFieldsIndex, uuid));
+ if (Objects.isNull(one)) {
+ throw new CoolException("鏄庣粏涓嶅瓨鍦ㄦ垨宸插嚭搴擄紒锛�");
+ }
+ one.setWorkQty(oldOne.getWorkQty());
+ oldOne.setWorkQty(0.0);
+
+ //鏇存柊搴撲綅淇℃伅
+ locItemWorkingService.updateById(oldOne);
+ locItemWorkingService.updateById(one);
+ */
+ }
+ return R.ok();
+ }
+
/**
* @author Ryan
@@ -151,86 +569,99 @@
@Transactional(rollbackFor = Exception.class)
@Synchronized
public R saveWavePick(ContainerWaveParam containerWaveParam, Long loginUserId) {
- if (null == containerWaveParam || containerWaveParam.getContainerWaveDtos().size() <= 0) {
+ if (null == containerWaveParam ) {
return R.error("鍙傛暟閿欒");
}
- Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, containerWaveParam.getContainer()));
+ List<WkOrderItem> orderItems = containerWaveParam.getContainerWaveDtos();
+ if (Objects.isNull(orderItems) || orderItems.isEmpty()) {
+ return R.error("鏁版嵁閿欒锛侊紒");
+ }
+
+ Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, containerWaveParam.getContainer())
+ .orderByDesc(Task::getId)
+ .last("limit 1"));
if (null == task) {
- return R.error("鏈壘鍒版墭鐩樺搴旂殑浠诲姟");
+ return R.error("鏈壘鍒版枡绠卞搴旂殑浠诲姟");
}
- if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
- return R.error("浠诲姟鐘舵�佷笉鏄瓑寰呯‘璁�");
+ if (!task.getTaskStatus().equals(TaskStsType.WAVE_SEED.id)) {
+ return R.error("浠诲姟鐘舵�佷笉鏄緟鎻�鐙�鎱�");
}
- for (ContainerWaveDto containerWaveDto : containerWaveParam.getContainerWaveDtos()) {
- //鍋氫竴娆℃牎楠岋紝鍒ゆ柇鍓嶇鎵�鏈夊嚭搴撴暟閲忔槸鍚﹁秴杩囨湰鎵樺嚭搴撴暟閲�
- double sum = containerWaveDto.getWkOrderItems().stream().mapToDouble(WkOrderItem::getDemandQty).sum();
- BigDecimal total = new BigDecimal(String.valueOf(sum));
- BigDecimal anfme = new BigDecimal(containerWaveDto.getTaskItem().getAnfme().toString());
- if (!anfme.equals(total)) {
- throw new CoolException("鎾鏁伴噺涓嶇瓑浜庡鍣ㄥ嚭搴撴暟閲忥紝璇锋鏌�");
+ List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
+ // 蹇呴』褰撳墠鎵樼洏鍏宠仈鍑哄簱鍗曞叏閮ㄦ嫞璐у畬鎴愭墠鍏佽纭
+ for (TaskItem ti : taskItems) {
+ Double q = ti.getQty() != null ? ti.getQty() : 0.0;
+ Double a = ti.getAnfme() != null ? ti.getAnfme() : 0.0;
+ if (q.compareTo(a) < 0) {
+ throw new CoolException("鏈夊崟鎹墿鏂欐湭鎷ｅ畬锛岃瀹屾垚璇ユ墭鐩樹笅鎵�鏈夎鍗曟嫞璐у悗鍐嶇‘璁わ紒锛�");
}
- for (WkOrderItem oldOrderItem : containerWaveDto.getWkOrderItems()) {
- if (Double.compare(oldOrderItem.getDemandQty(), 0.0) == 0) {
- continue;
- }
- WkOrderItem orderItem = asnOrderItemService.getById(oldOrderItem.getId());
- BigDecimal num = new BigDecimal(orderItem.getWorkQty().toString()).subtract(new BigDecimal(orderItem.getQty().toString()));
- BigDecimal orderDemandQty = new BigDecimal(oldOrderItem.getDemandQty().toString());
- if (num.compareTo(orderDemandQty) < 0) {
- throw new CoolException("鎾鏁伴噺澶т簬鍗曟嵁鍑哄簱鏁伴噺锛岃妫�鏌�");
- }
- WkOrder wkOrder = asnOrderService.getById(orderItem.getOrderId());
- if (Cools.isEmpty(wkOrder)) {
- throw new CoolException("鍑哄簱鍗曚富鍗曟湭鎵惧埌");
- }
- wkOrder.setQty(new BigDecimal(wkOrder.getQty().toString()).add(orderDemandQty).doubleValue());
- if (!asnOrderService.updateById(wkOrder)) {
- throw new CoolException("鍑哄簱鍗曟洿鏂扮姸鎬佸け璐�");
- }
+ }
- if (!Objects.isNull(oldOrderItem.getFieldsIndex())) {
- throw new CoolException("绁ㄥ彿涓嶈兘涓虹┖锛侊紒");
+ // 鎸夐『搴忔洿鏂板嚭搴撳崟鏄庣粏銆佽鍗曞強搴撳瓨娴佹按锛堜笌 wavePickItems 鍘熼�昏緫涓�鑷达紝鍦ㄥ叏閮ㄦ嫞瀹屽悗缁熶竴鎵ц锛�
+ Map<Long, List<TaskItem>> byOrder = taskItems.stream()
+ .filter(ti -> ti.getOrderId() != null)
+ .collect(Collectors.groupingBy(TaskItem::getOrderId));
+ List<Long> orderIds = new ArrayList<>(byOrder.keySet());
+ orderIds.sort(Long::compareTo);
+ for (Long orderId : orderIds) {
+ WkOrder order = asnOrderService.getById(orderId);
+ if (order == null) continue;
+ List<TaskItem> items = byOrder.get(orderId);
+ Map<String, List<TaskItem>> byMatnr = items.stream().collect(Collectors.groupingBy(TaskItem::getMatnrCode));
+ for (String code : byMatnr.keySet()) {
+ List<TaskItem> matItems = byMatnr.get(code);
+ WkOrderItem orderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<WkOrderItem>()
+ .eq(WkOrderItem::getMatnrCode, code)
+ .eq(WkOrderItem::getOrderId, orderId));
+ if (orderItem == null) continue;
+ Double summed = matItems.stream().mapToDouble(t -> t.getQty() != null ? t.getQty() : 0.0).sum();
+ orderItem.setQty(summed);
+ asnOrderItemService.updateById(orderItem);
+ String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_STOCK_CODE, null);
+ if (StringUtils.isBlank(ruleCode)) continue;
+ Stock stock = new Stock();
+ stock.setCode(ruleCode)
+ .setUpdateBy(loginUserId)
+ .setBarcode(task.getBarcode())
+ .setLocCode(task.getOrgLoc())
+ .setType(order.getType())
+ .setWkType(Short.parseShort(order.getWkType()))
+ .setSourceId(orderItem.getOrderId())
+ .setSourceCode(orderItem.getOrderCode())
+ .setUpdateTime(new Date())
+ .setAnfme(summed);
+ if (!stockService.save(stock)) continue;
+ List<StockItem> stockItems = new ArrayList<>();
+ for (TaskItem ti : matItems) {
+ StockItem si = new StockItem();
+ BeanUtils.copyProperties(ti, si);
+ si.setStockId(stock.getId()).setAnfme(ti.getQty()).setStockCode(stock.getCode()).setSourceItemId(orderItem.getId());
+ stockItems.add(si);
}
- //Fix 杩欓噷鍙拡瀵瑰笇鏃ラ」鐩殑绁ㄥ彿鍔熻兘锛岀エ鍙峰拰uuid涓轰竴瀵逛竴鐨勬儏鍐碉紝涓嶄細鍑虹幇閲嶅鐨勬儏鍐�
- FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>().eq(FieldsItem::getValue, oldOrderItem.getFieldsIndex()));
- if (!Objects.isNull(fieldsItem)) {
- orderItem.setFieldsIndex(fieldsItem.getUuid());
- }
- orderItem.setQty(new BigDecimal(orderItem.getQty().toString()).add(orderDemandQty).doubleValue());
- if (!asnOrderItemService.updateById(orderItem)) {
- throw new CoolException("鍗曟嵁鏄庣粏鏇存柊澶辫触");
- }
- //妫�鏌ュ崟鎹槸鍚﹀畬鎴�
- Boolean orderChecked = checkOrderComplete(orderItem);
- if (orderChecked) {
- wkOrder.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
- if (!asnOrderService.updateById(wkOrder)) {
- throw new CoolException("鍑哄簱鍗曟洿鏂扮姸鎬佸け璐�");
- }
+ stockItemService.saveBatch(stockItems);
+ }
+ List<WkOrderItem> ois = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, orderId));
+ Double total = ois.stream().mapToDouble(oi -> oi.getQty() != null ? oi.getQty() : 0.0).sum();
+ Double wkQty = ois.stream().mapToDouble(oi -> oi.getWorkQty() != null ? oi.getWorkQty() : 0.0).sum();
+ double v = (order.getWorkQty() != null && order.getWorkQty().compareTo(wkQty) < 0) ? 0.0 : Math.round((total - wkQty) * 1000000.0) / 1000000.0;
+ order.setQty(total).setWorkQty(v);
+ asnOrderService.updateById(order);
+ }
+
+ try {
+ if (task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)) {
+ taskService.pickOrCheckTask(task.getId(), "");
+ } else if (task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)) {
+ taskService.pickOrCheckTask(task.getId(), Constants.TASK_TYPE_OUT_CHECK);
+ } else {
+ task.setTaskStatus(TaskStsType.UPDATED_OUT.id);
+ if (!taskService.updateById(task)) {
+ throw new CoolException("浠诲姟鐘舵�佹洿鏂板け璐�");
}
}
- //妫�鏌ユ尝娆℃槸鍚﹀畬鎴�
-// Boolean waveChecked = checkWaveComplete(containerWaveDto.getTaskItem());
-// if (waveChecked){
-// Wave wave = waveService.getById(containerWaveDto.getTaskItem().getSourceId());
-// if (null == wave){
-// throw new CoolException("鏈壘鍒板鍣ㄥ彿瀵瑰簲娉㈡");
-// }
-// wave.setExceStatus(WaveExceStatus.WAVE_EXCE_STATUS_TASK.val);
-// if (!waveService.updateById(wave)){
-// throw new CoolException("娉㈡鍗曟洿鏂扮姸鎬佸け璐�");
-// }
-// }
-
+ } catch (Exception e) {
+ throw new CoolException("鍒嗘嫞澶辫触锛�" + e.getMessage());
}
-
- task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
- if (!taskService.updateById(task)) {
- throw new CoolException("浠诲姟鐘舵�佹洿鏂板け璐�");
- }
-
-
return R.ok();
}
--
Gitblit v1.9.1