From a56420ff2042a3f6b1e824341a717a28c692cad4 Mon Sep 17 00:00:00 2001
From: chen.lin <1442464845@qq.com>
Date: 星期五, 30 一月 2026 16:39:15 +0800
Subject: [PATCH] 查询库存明细
---
rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/ReceiveMsgServiceImpl.java | 888 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 874 insertions(+), 14 deletions(-)
diff --git a/rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/ReceiveMsgServiceImpl.java b/rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/ReceiveMsgServiceImpl.java
index f8c7c5d..8e1fe0c 100644
--- a/rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/ReceiveMsgServiceImpl.java
+++ b/rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/ReceiveMsgServiceImpl.java
@@ -3,32 +3,51 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.api.controller.erp.params.*;
+import com.vincent.rsf.server.api.controller.erp.params.dto.CheckDiffDto;
+import com.vincent.rsf.server.api.controller.erp.params.dto.TransferInfoDto;
+import com.vincent.rsf.server.api.controller.erp.params.dto.WkOrderDto;
+import com.vincent.rsf.server.api.utils.TimeConverterUtils;
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.manager.controller.dto.LocStockDto;
+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.OrderType;
+import com.vincent.rsf.server.manager.enums.*;
import com.vincent.rsf.server.manager.service.*;
-import com.vincent.rsf.server.manager.service.impl.LocAreaServiceImpl;
import com.vincent.rsf.server.manager.service.impl.MatnrServiceImpl;
+import com.vincent.rsf.server.manager.service.impl.WarehouseAreasItemServiceImpl;
+import com.vincent.rsf.server.system.constant.DictTypeCode;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
+import com.vincent.rsf.server.system.entity.DictData;
import com.vincent.rsf.server.system.entity.Fields;
-import com.vincent.rsf.server.system.service.FieldsItemService;
+import com.vincent.rsf.server.system.service.DictDataService;
+import com.vincent.rsf.server.system.service.DictTypeService;
import com.vincent.rsf.server.system.service.FieldsService;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
import com.vincent.rsf.server.api.service.ReceiveMsgService;
import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+
+import static com.vincent.rsf.server.manager.enums.OrderWorkType.*;
/**
* @author Ryan
@@ -48,13 +67,13 @@
@Autowired
private FieldsService fieldsService;
@Autowired
- private FieldsItemService fieldsItemService;
- @Autowired
private MatnrGroupService matnrGroupService;
@Autowired
private MatnrServiceImpl matnrService;
@Autowired
private AsnOrderService asnOrderService;
+ @Autowired
+ private AsnOrderLogService asnOrderLogService;
@Autowired
private AsnOrderItemService asnOrderItemService;
@Autowired
@@ -64,11 +83,36 @@
@Autowired
private LocService locService;
@Autowired
- private LocItemService locItemService;
- @Autowired
private WarehouseAreasService warehouseAreasService;
@Autowired
private WarehouseService warehouseService;
+ @Autowired
+ private CompanysService companysService;
+ @Autowired
+ private TransferService transferService;
+ @Autowired
+ private TransferItemService transferItemService;
+ @Autowired
+ private LocReviseService locReviseService;
+ @Autowired
+ private ReviseLogService reviseLogService;
+ @Autowired
+ private ReviseLogItemService reviseLogItemService;
+ @Autowired
+ private CheckDiffService checkDiffService;
+ @Autowired
+ private CheckDiffItemService checkDiffItemService;
+ @Autowired
+ private DictDataService dictDataService;
+ @Autowired
+ private DictTypeService dictTypeService;
+ @Autowired
+ private WaitPakinService waitPakinService;
+ @Autowired
+ private WarehouseAreasItemServiceImpl warehouseAreasItemService;
+ @Autowired
+ private LocItemService locItemService;
+
/**
* @author Ryan
@@ -77,7 +121,7 @@
* @version 1.0
*/
@Override
- @Transactional(rollbackFor = Exception.class)
+ @Transactional(timeout = 60, rollbackFor = Exception.class)
public boolean syncPurchasee(List<OrderParams> orders) {
if (orders.isEmpty()) {
throw new CoolException("鍗曟嵁鍐呭涓嶈兘涓虹┖锛侊紒");
@@ -159,6 +203,7 @@
* @param matnrs
*/
@Override
+ @Transactional(timeout = 60, rollbackFor = Exception.class)
public void syncMatnrs(List<BaseMatParms> matnrs) {
List<Matnr> syncMatnrs = new ArrayList<>();
if (!matnrs.isEmpty()) {
@@ -193,11 +238,20 @@
@Override
public R queryOrderStatus(QueryOrderParam queryParams) {
WkOrder wkOrders = asnOrderService.getOne(new LambdaQueryWrapper<WkOrder>()
- .eq(WkOrder::getCode, queryParams.getOrderNo())
- .eq(WkOrder::getType, queryParams.getType()));
+ .eq(WkOrder::getPoCode, queryParams.getOrderNo()));
if (Objects.isNull(wkOrders)) {
- throw new CoolException("鍗曟嵁涓嶅瓨鍦紒锛�");
+ Map<String, Object> map = new HashMap<>();
+ map.put("exceStatus", "-1");
+ return R.ok("鍗曟嵁涓嶅瓨鍦� 锛侊紒").add(map);
}
+
+ AsnOrderLog orderLog = asnOrderLogService.getOne(new LambdaQueryWrapper<AsnOrderLog>().eq(AsnOrderLog::getCode, queryParams.getOrderNo()));
+ if (!Objects.isNull(orderLog)) {
+ Map<String, Object> map = new HashMap<>();
+ map.put("exceStatus", "4");
+ return R.ok("鍗曟嵁宸插畬鎴� 锛侊紒").add(map);
+ }
+
List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, wkOrders.getId()));
WkOrderDto wkorderDto = new WkOrderDto();
@@ -216,7 +270,7 @@
public R syncLocsDetl(PageParam<Loc, BaseParam> pageParam, QueryWrapper<Loc> wrapper) {
Page<Object> page = new Page<>();
page.setCurrent(pageParam.getCurrent()).setSize(pageParam.getSize());
- IPage<LocStockDto> locStocks = locService.getLocDetls(page);
+ IPage<LocStockDto> locStocks = locService.getLocDetls(page);
return R.ok().add(locStocks);
}
@@ -245,7 +299,7 @@
/**
* @author Ryan
* @date 2025/8/18
- * @description: 鐗╂枡淇℃伅鍚屾
+ * @description: 鐗╂枡鍒嗙粍淇℃伅鍚屾
* @version 1.0
*/
@Override
@@ -286,7 +340,7 @@
BeanUtils.copyProperties(param, locArea);
WarehouseAreas warehouseAreas = warehouseAreasService
.getOne(new LambdaQueryWrapper<WarehouseAreas>()
- .eq(WarehouseAreas::getName, param.getName()));
+ .eq(WarehouseAreas::getName, param.getName()));
if (!Objects.isNull(warehouseAreas)) {
locArea.setWarehouseId(warehouseAreas.getId());
}
@@ -320,4 +374,810 @@
return R.ok();
}
+ /**
+ * @author Ryan
+ * @date 2025/8/19
+ * @description: 鍚屾浼佷笟淇℃伅
+ * @version 1.0
+ */
+ @Override
+ @Transactional(timeout = 60, rollbackFor = Exception.class)
+ public R syncCompanies(List<CompaniesParam> companyParams) {
+ companyParams.forEach(param -> {
+ Companys companys = new Companys();
+ BeanUtils.copyProperties(param, companys);
+ if (Objects.isNull(companys.getCode())) {
+ throw new CoolException("浼佷笟缂栫爜涓嶈兘涓虹┖锛侊紒");
+ }
+ Companys one = companysService.getOne(new LambdaQueryWrapper<Companys>().eq(Companys::getName, param.getName()));
+ if (Objects.isNull(one)) {
+ String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_COMPANYS_CODE, null);
+ companys.setCode(ruleCode);
+ } else {
+ throw new CoolException(one.getName() + "锛屼紒涓氬悕閲嶅锛侊紒");
+ }
+ companys.setType(CompanysType.getCustomVal(param.getType()))
+ .setId(null);
+ if (!companysService.save(companys)) {
+ throw new CoolException("浼佷笟淇濆瓨澶辫触锛侊紒");
+ }
+ });
+ return R.ok();
+ }
+
+ /**
+ * @author Ryan
+ * @date 2025/8/26
+ * @description: 鍗曟嵁鍚屾
+ * @version 1.0
+ */
+ @Override
+ @Transactional(timeout = 60, rollbackFor = Exception.class)
+ public R syncCheckOrder(List<SyncOrderParams> syncOrders, Long loginUserId) {
+ if (!syncOrders.isEmpty()) {
+ syncOrders.forEach(syncOrder -> {
+ WkOrder wkOrder = new WkOrder(syncOrder);
+ DictData one = dictDataService.getOne(new LambdaQueryWrapper<DictData>().eq(DictData::getDictTypeCode, DictTypeCode.DICT_SYS_BUSINESS_TYPE)
+ .eq(DictData::getValue, syncOrder.getWkType()), false);
+ if (Objects.isNull(one)) {
+ throw new CoolException("鍗曟嵁锛�" + syncOrder.getOrderNo() + ", 涓氬姟绫诲瀷涓嶅瓨鍦紒锛�");
+ }
+ WkOrder order = asnOrderService.getOne(new LambdaQueryWrapper<WkOrder>()
+ .eq(!Objects.isNull(syncOrder.getOrderId()), WkOrder::getPoId, syncOrder.getOrderId())
+ .eq(WkOrder::getPoCode, syncOrder.getOrderNo()));
+ if (!Objects.isNull(order)) {
+ if (order.getExceStatus().equals(AsnExceStatus.ASN_EXCE_STATUS_UN_EXCE.val) ||
+ order.getExceStatus().equals(AsnExceStatus.OUT_STOCK_STATUS_TASK_INIT.val)) {
+ /**鍒犻櫎鍗曟嵁鏄庣粏*/
+ asnOrderItemService.remove(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, order.getId()));
+ /**鍒犻櫎涓诲崟*/
+ asnOrderService.removeById(order.getId());
+ } else {
+ throw new CoolException("鍗曟嵁宸叉坊鍔狅紝涓嶅彲鎵ц淇敼鎴栨坊鍔犳搷浣滐紒锛�");
+ }
+ }
+ String rule = SerialRuleCode.SYS_ASN_ORDER;
+ if (syncOrder.getType().equals(OrderType.ORDER_OUT.type)) {
+ rule = SerialRuleCode.SYS_OUT_STOCK_CODE;
+ }
+
+ //閾跺骇鐗逛緵
+ String orderNs = null;
+ if (rule.equals(SerialRuleCode.SYS_ASN_ORDER) || rule.equals(SerialRuleCode.SYS_OUT_STOCK_CODE)) {
+ StringBuffer buffer = new StringBuffer();
+ Object poCode = syncOrder.getOrderNo();
+ orderNs = poCode == null ? "" : buffer.append(poCode).toString();
+ }
+ String ruleCode = orderNs;
+ wkOrder.setType(syncOrder.getType())
+ .setWkType(one.getValue())
+ .setAnfme(syncOrder.getAnfme())
+ .setPoCode(syncOrder.getOrderNo())
+ .setWorkQty(0.0)//鎵ц鏁伴噺
+ .setQty(0.0)//瀹屾垚鏁伴噺
+ .setPoId(syncOrder.getOrderInternalCode())
+ .setCode(ruleCode)
+ .setArrTime(syncOrder.getArrTime())
+ .setId(null)
+ .setCreateTime(new TimeConverterUtils().timestampToDate(syncOrder.getCreateTime()))
+ .setBusinessTime(new TimeConverterUtils().timestampToDate(syncOrder.getBusinessTime()))
+ .setUpdateTime(new Date())
+ .setCreateBy(loginUserId)
+ .setUpdateBy(loginUserId);
+
+ if (syncOrder.getType().equals(OrderType.ORDER_OUT.type)) {
+ wkOrder.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_INIT.val);
+ }
+ if (!asnOrderService.save(wkOrder)) {
+ throw new CoolException("鍗曟嵁淇濆瓨澶辫触锛侊紒");
+ }
+ AtomicReference<String> palletId = new AtomicReference<>();
+ syncOrder.getOrderItems().forEach(orderItem -> {
+ if (Cools.isEmpty(palletId.get())) {
+ palletId.set(orderItem.getPalletId());
+ } else {
+ if (!palletId.get().equals(orderItem.getPalletId())) {
+ throw new CoolException("鍚屼竴涓崟鎹槑缁嗕腑鐨勬墭鐩樼爜蹇呴』涓�鑷达紒锛侊紒");
+ }
+ }
+ Map<String, Object> map = new ObjectMapper().convertValue(orderItem, Map.class);
+ map.put("orderId", wkOrder.getId());
+ map.put("poId", wkOrder.getPoId());
+ map.put("poCode", wkOrder.getPoCode());
+ map.put("order_code", wkOrder.getCode());
+ map.put("matnrCode", orderItem.getMatnr());
+ map.put("platWorkCode", orderItem.getPlanNo());
+ map.put("platItemId", orderItem.getLineId());
+ map.put("splrBatch", orderItem.getBatch());
+ map.put("batch", orderItem.getBatch());
+ map.put("spec", orderItem.getSpecs());
+ map.put("model", orderItem.getModel());
+ map.put("stockUnit", orderItem.getUnit());
+ map.put("purUnit", orderItem.getUnit());
+ map.put("baseUnit", orderItem.getBaseUnitId());
+ map.put("useOrgId", orderItem.getUseOrgId());
+ map.put("useOrgName", orderItem.getUseOrgName());
+ map.put("erpClsId", orderItem.getErpClsId());
+ map.put("priceUnitId", orderItem.getPriceUnitId());
+ map.put("inStockType", orderItem.getInStockType());
+ map.put("ownerTypeId", orderItem.getOwnerTypeId());
+ map.put("ownerId", orderItem.getOwnerId());
+ map.put("ownerName", orderItem.getOwnerName());
+ map.put("keeperTypeId", orderItem.getKeeperTypeId());
+ map.put("keeperId", orderItem.getKeeperId());
+ map.put("keeperName", orderItem.getKeeperName());
+ map.put("targetWarehouseId", orderItem.getTargetWarehouseId());
+ map.put("sourceWarehouseId", orderItem.getSourceWarehouseId());
+ map.put("createBy", loginUserId);
+ map.put("updateBy", loginUserId);
+
+ if (!asnOrderItemService.fieldsSave(map, loginUserId)) {
+ throw new CoolException("鏄庣粏淇濆瓨澶辫触锛侊紒");
+ }
+ });
+ List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
+ .eq(WkOrderItem::getOrderId, wkOrder.getId()));
+ double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
+ wkOrder.setAnfme(sum);
+ if (!asnOrderService.updateById(wkOrder)) {
+ throw new CoolException("璁″垝鏀惰揣鏁伴噺淇敼澶辫触锛侊紒");
+ }
+
+ // 绔嬪嵆瑙﹀彂寮傛浠诲姟锛屼笉绛夊緟缁撴灉
+ if (!Cools.isEmpty(palletId.get()) && StringUtils.isNotBlank(syncOrder.getOrderNo()) && !Cools.isEmpty(syncOrder.getStationId())) {
+ //缁勬墭
+ WaitPakinParam pakinParam = new WaitPakinParam();
+ pakinParam.setBarcode(palletId.get());
+ pakinParam.setStaNo(syncOrder.getStationId());
+
+ boolean itemsCheck = waitPakinService.mergeItemsCheck(pakinParam, loginUserId);
+ if (itemsCheck) {
+ CompletableFuture.runAsync(() -> {
+ try {
+ asyncMergeItemsWcs(pakinParam, syncOrder.getOrderNo(), loginUserId);
+ } catch (Exception e) {
+ log.warn("璁㈠崟 {} 寮�濮嬭嚜鍔ㄧ粍鎵�", syncOrder.getOrderNo());
+ }
+ });
+ }
+ }
+ });
+ }
+
+ return R.ok();
+ }
+
+ @Async
+ public void asyncMergeItemsWcs(WaitPakinParam param, String orderNo, Long loginUserId) {
+ try {
+ int i = 0;
+ while (true) {
+ i++;
+ if (i > 5) return;
+ Thread.sleep(3000);
+ List<WarehouseAreasItem> list = warehouseAreasItemService.list(new LambdaQueryWrapper<WarehouseAreasItem>()
+ .eq(WarehouseAreasItem::getAsnCode, orderNo));
+
+ if (list.isEmpty()) {
+ log.warn("璁㈠崟 {} 娌℃湁鎵惧埌搴撳尯椤圭洰锛岃烦杩囩粍鎵�", orderNo);
+ continue;
+ }
+ List<PakinItem> itemList = list.stream().map(item -> {
+ PakinItem pakinItem = new PakinItem();
+ pakinItem.setAsnCode(item.getAsnCode());
+ pakinItem.setId(item.getId());
+ pakinItem.setMatnrId(item.getMatnrId());
+ pakinItem.setReceiptQty(item.getAnfme());
+ return pakinItem;
+ }).collect(Collectors.toList());
+ param.setItems(itemList);
+ break;
+ }
+ waitPakinService.mergeItemsWcs(param, loginUserId);
+ log.info("璁㈠崟 {} 鑷姩缁勬墭瀹屾垚锛屽叡澶勭悊 {} 涓」鐩�", orderNo, param.getItems().size());
+ } catch (Exception e) {
+ log.error("璁㈠崟 {} 鑷姩缁勬墭澶辫触: {}", orderNo, e.getMessage(), e);
+ }
+ }
+
+ /**
+ * @author Ryan
+ * @date 2025/8/19
+ * @description: 璋冩嫈鍗曟嵁鍚屾
+ * @version 1.0
+ */
+ @Override
+ @Transactional(timeout = 60, rollbackFor = Exception.class)
+ public R syncTransfer(SyncTransferParams transferParams, Long loginUserId) {
+ Transfer transfer = new Transfer();
+ WarehouseAreas warehouseAreas = warehouseAreasService
+ .getOne(new LambdaQueryWrapper<WarehouseAreas>()
+ .eq(WarehouseAreas::getName, transferParams.getOrgAreaName()));
+ if (Objects.isNull(warehouseAreas)) {
+ throw new CoolException("鍘熷簱鍖轰笉瀛樺湪锛侊紒");
+ }
+
+ WarehouseAreas warehouseAreas1 = warehouseAreasService.getOne(new LambdaQueryWrapper<WarehouseAreas>()
+ .eq(WarehouseAreas::getName, transferParams.getTarAreaName()));
+ if (Objects.isNull(warehouseAreas1)) {
+ throw new CoolException("鐩爣搴撳尯涓嶅瓨鍦紒锛�");
+ }
+
+ transfer.setOrgAreaName(warehouseAreas.getName())
+ .setOrgAreaId(warehouseAreas.getId())
+ .setOrgWareName(warehouseAreas.getWarehouseId$())
+ .setOrgWareId(warehouseAreas.getWarehouseId())
+ .setTarWareName(warehouseAreas1.getWarehouseId$())
+ .setTarAreaName(warehouseAreas1.getName())
+ .setTarAreaId(warehouseAreas1.getId())
+ .setTarWareName(warehouseAreas1.getWarehouseId$())
+ .setTarWareId(warehouseAreas1.getWarehouseId())
+ .setCreateBy(loginUserId)
+ .setCreateTime(new Date())
+ .setUpdateTime(new Date())
+ .setUpdateBy(loginUserId)
+ .setCode(SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_TRANSFER_ORDER_CODE, null))
+ .setSource(OrderSourceType.ORDER_SOURCE_TYPE_ERP.val);
+
+ if (!transferService.save(transfer)) {
+ throw new CoolException("璋冩嫈鍗曟嵁淇濆瓨澶辫触锛侊紒");
+ }
+
+ transferParams.getItems().forEach(item -> {
+ TransferItem transferItem = new TransferItem();
+ BeanUtils.copyProperties(item, transferItem);
+ Matnr matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>().eq(Matnr::getCode, item.getMatnrCode()));
+ if (Objects.isNull(matnr)) {
+ throw new CoolException("鐗╂枡涓嶅瓨鍦紒锛�");
+ }
+ transferItem.setMatnrId(matnr.getId())
+ .setTransferId(transfer.getId())
+ .setCreateBy(loginUserId)
+ .setUpdateBy(loginUserId)
+ .setCreateTime(new Date())
+ .setUpdateTime(new Date())
+ .setTransferCode(transfer.getCode());
+
+ if (!transferItemService.save(transferItem)) {
+ throw new CoolException("璋冩嫈鍗曟槑缁嗕繚瀛樺け璐ワ紒锛�");
+ }
+ });
+
+ return R.ok();
+ }
+
+ /**
+ * @author Ryan
+ * @date 2025/8/20
+ * @description: 搴撳瓨璋冩暣鍗曞悓姝�
+ * @version 1.0
+ */
+ @Override
+ @Transactional(timeout = 60, rollbackFor = Exception.class)
+ public R syncLocRevise(SyncLocReviseParams reviseParams, Long loginUserId) {
+ LocRevise locRevise = new LocRevise();
+ if (Objects.isNull(reviseParams.getAreaName())) {
+ throw new CoolException("搴撳尯涓嶈兘涓虹┖锛侊紒");
+ }
+ WarehouseAreas warehouseAreas = warehouseAreasService
+ .getOne(new LambdaQueryWrapper<WarehouseAreas>()
+ .eq(WarehouseAreas::getName, reviseParams.getAreaName()));
+ if (Objects.isNull(warehouseAreas)) {
+ throw new CoolException("搴撳尯涓嶅瓨鍦紒锛�");
+ }
+
+ locRevise.setAreaName(warehouseAreas.getName())
+ .setType(LocReviseType.getLocRevise(reviseParams.getType()))
+ .setCreateBy(loginUserId)
+ .setUpdateBy(loginUserId)
+ .setCreateTime(new Date())
+ .setUpdateTime(new Date())
+ .setAreaId(warehouseAreas.getId());
+ locRevise.setCode(SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_LOC_REVISE_CODE, null));
+
+ if (!locReviseService.save(locRevise)) {
+ throw new CoolException("搴撳瓨璋冩暣鍗曚繚瀛樺け璐ワ紒锛�");
+ }
+
+ reviseParams.getReviseItems().forEach(revise -> {
+ Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, revise.getLocCode()));
+ ReviseLog reviseLog = new ReviseLog();
+ BeanUtils.copyProperties(loc, reviseLog);
+ reviseLog.setReviseId(locRevise.getId())
+ .setLocCode(loc.getCode())
+ .setType(Integer.parseInt(loc.getType()))
+ .setCreateBy(loginUserId)
+ .setUpdateBy(loginUserId)
+ .setCreateTime(new Date())
+ .setUpdateTime(new Date())
+ .setReviseCode(locRevise.getCode());
+ if (!reviseLogService.save(reviseLog)) {
+ throw new CoolException("搴撳瓨璋冩暣鍗曚笉鑳戒负绌猴紒锛�");
+ }
+ revise.getItems().forEach(reviseItem -> {
+ ReviseLogItem logItem = new ReviseLogItem();
+ BeanUtils.copyProperties(reviseItem, logItem);
+ Matnr matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>().eq(Matnr::getCode, reviseItem.getMatnr()));
+ if (Objects.isNull(matnr)) {
+ throw new CoolException("鐗╂枡涓嶅瓨鍦紒锛�");
+ }
+ logItem.setLocId(loc.getId())
+ .setLocCode(loc.getCode())
+ .setId(null)
+ .setMaktx(matnr.getName())
+ .setMatnrCode(matnr.getCode())
+ .setMatnrId(matnr.getId())
+ .setReviseLogId(reviseLog.getId())
+ .setCreateBy(loginUserId)
+ .setUpdateBy(loginUserId)
+ .setCreateTime(new Date())
+ .setUpdateTime(new Date())
+ .setReviseQty(reviseItem.getAnfme());
+ if (!reviseLogItemService.save(logItem)) {
+ throw new CoolException("璋冩暣搴撳瓨鏄庣粏淇濆瓨澶辫触锛侊紒");
+ }
+ });
+ });
+
+ return R.ok();
+ }
+
+ /**
+ * @author Ryan
+ * @date 2025/8/20
+ * @description: 鍗曟嵁淇敼--鏀惰揣閫氱煡鍗�/鍑哄簱鍗�/鐩樼偣鍗�
+ * @version 1.0
+ */
+ @Override
+ @Transactional(timeout = 60, rollbackFor = Exception.class)
+ public R syncOrderUpdate(List<SyncOrderParams> orders) {
+ orders.forEach(order -> {
+ List<Short> list = Arrays.asList(AsnExceStatus.ASN_EXCE_STATUS_UN_EXCE.val,
+ AsnExceStatus.OUT_STOCK_STATUS_TASK_INIT.val);
+ WkOrder wkOrder = asnOrderService.getOne(new LambdaQueryWrapper<WkOrder>()
+ .in(WkOrder::getExceStatus, list)
+ .eq(WkOrder::getCode, order.getOrderNo()));
+ if (Objects.isNull(wkOrder)) {
+ throw new CoolException("璇风‘璁ゅ崟鎹細" + order.getOrderNo() + "鏄惁宸茬粡鎵ц鎴栨槸鍚﹀悓姝ワ紒锛�");
+ }
+ order.getOrderItems().forEach(orderItem -> {
+ WkOrderItem wkOrderItem = asnOrderItemService.getOne(new LambdaUpdateWrapper<WkOrderItem>()
+ .eq(WkOrderItem::getMatnrCode, orderItem.getMatnr())
+ .eq(StringUtils.isNotEmpty(orderItem.getBatch()), WkOrderItem::getSplrBatch, orderItem.getBatch())
+ .eq(WkOrderItem::getOrderCode, wkOrder.getCode()));
+ if (!Objects.isNull(wkOrderItem)) {
+ if (!asnOrderItemService.update(new LambdaUpdateWrapper<WkOrderItem>()
+ .eq(WkOrderItem::getOrderCode, wkOrder.getCode())
+ .eq(WkOrderItem::getMatnrCode, orderItem.getMatnr())
+ .eq(StringUtils.isNotEmpty(orderItem.getBatch()), WkOrderItem::getSplrBatch, orderItem.getBatch())
+ .eq(StringUtils.isNotEmpty(orderItem.getPlatItemId()), WkOrderItem::getPlatItemId, orderItem.getPlatItemId())
+ .set(WkOrderItem::getAnfme, orderItem.getAnfme()))) {
+ throw new CoolException("鍗曟嵁淇敼澶辫触锛侊紒");
+ }
+ } else {
+ WkOrderItem wkOrderItem1 = new WkOrderItem();
+ BeanUtils.copyProperties(orderItem, wkOrderItem1);
+ wkOrderItem1.setOrderCode(wkOrder.getCode())
+ .setOrderId(wkOrder.getId());
+ if (!asnOrderItemService.save(wkOrderItem1)) {
+ throw new CoolException("鍗曟嵁淇濆瓨澶辫触锛侊紒");
+ }
+ }
+ });
+ wkOrder.setAnfme(order.getAnfme());
+ if (!asnOrderService.updateById(wkOrder)) {
+ throw new CoolException("涓诲崟鎹慨鏀瑰け璐ワ紒锛�");
+ }
+ });
+ return R.ok();
+ }
+
+ /**
+ * @author Ryan
+ * @date 2025/8/21
+ * @description: 鍒犻櫎鍗曟嵁
+ * @version 1.0
+ */
+ @Override
+ @Transactional(timeout = 60, rollbackFor = Exception.class)
+ public R syncOrderDelete(List<SyncOrderParams> orders) {
+ orders.forEach(order -> {
+ List<Short> list = Arrays.asList(AsnExceStatus.ASN_EXCE_STATUS_UN_EXCE.val,
+ AsnExceStatus.OUT_STOCK_STATUS_TASK_INIT.val);
+ WkOrder wkOrder = asnOrderService.getOne(new LambdaQueryWrapper<WkOrder>()
+ .in(WkOrder::getExceStatus, list)
+ .eq(WkOrder::getCode, order.getOrderNo()));
+ if (Objects.isNull(wkOrder)) {
+ throw new CoolException("璁㈠崟锛�" + wkOrder.getCode() + "锛屽綋鍓嶇姸鎬侊紝涓嶅彲鎵ц鍒犻櫎鎿嶄綔锛侊紒");
+ }
+ order.getOrderItems().forEach(orderItem -> {
+ if (!asnOrderItemService.remove(new LambdaQueryWrapper<WkOrderItem>()
+ .eq(WkOrderItem::getMatnrCode, orderItem.getMatnr())
+ .eq(StringUtils.isNotEmpty(orderItem.getBatch()), WkOrderItem::getSplrBatch, orderItem.getBatch())
+ .eq(StringUtils.isNotEmpty(orderItem.getPlatItemId()), WkOrderItem::getPlatItemId, orderItem.getPlatItemId())
+ .eq(WkOrderItem::getOrderCode, wkOrder.getCode()))) {
+ throw new CoolException("鍗曟嵁鏄庣粏鍒犻櫎澶辫触锛侊紒");
+ }
+ List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, wkOrder.getId()));
+ if (orderItems.isEmpty()) {
+ if (!asnOrderService.removeById(wkOrder.getId())) {
+ throw new CoolException("鍗曟嵁鍒犻櫎澶辫触锛侊紒");
+ }
+ } else {
+ Double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
+ if (!asnOrderService.update(new LambdaUpdateWrapper<WkOrder>()
+ .eq(WkOrder::getId, wkOrder.getId())
+ .set(WkOrder::getAnfme, sum))) {
+ throw new CoolException("涓诲崟鏁伴噺淇敼澶辫触锛侊紒");
+ }
+ }
+ });
+ });
+ return R.ok();
+ }
+
+ /**
+ * @author Ryan
+ * @date 2025/8/21
+ * @description: 璋冩嫈鍗曟槑缁嗘煡璇�
+ * @version 1.0
+ */
+ @Override
+ public R queryTransfer(QueryOrderParam queryParams) {
+ Transfer transfer = transferService.getOne(new LambdaQueryWrapper<Transfer>()
+ .in(Transfer::getCode, queryParams.getOrderNo()));
+ if (Objects.isNull(transfer)) {
+ throw new CoolException("鍗曟嵁涓嶅瓨鍦紒锛�");
+ }
+ List<TransferItem> orderItems = transferItemService.list(new LambdaQueryWrapper<TransferItem>()
+ .eq(TransferItem::getTransferId, transfer.getId()));
+ TransferInfoDto wkorderDto = new TransferInfoDto();
+ wkorderDto.setTransfer(transfer).setItems(orderItems);
+ return R.ok().add(wkorderDto);
+ }
+
+ /**
+ * @author Ryan
+ * @date 2025/8/22
+ * @description: 鐩樼偣宸紓鍗曞悓姝�
+ * @version 1.0
+ */
+ @Override
+ @Transactional(timeout = 60, rollbackFor = Exception.class)
+ public R syncCheckDiffs(SyncCheckDiffParams syncParams) {
+ List<CheckDiff> diffs = checkDiffService.list(new LambdaQueryWrapper<CheckDiff>()
+ .eq(CheckDiff::getExceStatus, CheckDiffExceStatus.CHECK_DIFF_EXCE_STATUS_END.val)
+ .in(CheckDiff::getOrderCode, syncParams.getDiffCode()));
+ if (diffs.isEmpty()) {
+ return R.ok();
+ }
+ List<CheckDiffDto> dtos = new ArrayList<>();
+ diffs.forEach(check -> {
+ CheckDiffDto checkDto = new CheckDiffDto();
+ CheckDiff checkDiff = new CheckDiff();
+ BeanUtils.copyProperties(check, checkDiff);
+ List<CheckDiffItem> items = checkDiffItemService.list(new LambdaQueryWrapper<CheckDiffItem>()
+ .eq(CheckDiffItem::getCheckId, check.getId()));
+ checkDto.setItems(items)
+ .setCheckDiff(checkDiff);
+ dtos.add(checkDto);
+ });
+
+ return R.ok().add(dtos);
+ }
+
+ /**
+ * 鍩虹鐗╂枡淇℃伅鍙樻洿
+ *
+ * @param baseMatParms
+ * @return
+ */
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public R matUpdate(BaseMatParms baseMatParms) {
+ if (StringUtils.isBlank(baseMatParms.getMatnr())) {
+ throw new CoolException("鐗╂枡缂栫爜涓嶈兘涓虹┖锛侊紒");
+ }
+ Matnr matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>().eq(Matnr::getCode, baseMatParms.getMatnr()));
+ if (Objects.isNull(matnr)) {
+ Matnr matnr1 = new Matnr();
+ BeanUtils.copyProperties(baseMatParms, matnr1);
+ matnr1.setCode(baseMatParms.getMatnr());
+ matnr1.setName(baseMatParms.getMaktx());
+ if (!Objects.isNull(baseMatParms.getGroupName())) {
+ MatnrGroup matnrGroup = matnrGroupService.getOne(new LambdaQueryWrapper<MatnrGroup>()
+ .eq(MatnrGroup::getName, baseMatParms.getGroupName()));
+ if (!Objects.isNull(matnrGroup)) {
+ matnr1.setGroupCode(matnrGroup.getCode()).setGroupId(matnrGroup.getId());
+ }
+ }
+ if (!matnrService.save(matnr1)) {
+ throw new CoolException("鐗╂枡鏂板澶辫触锛侊紒");
+ }
+ } else {
+ if (!Objects.isNull(baseMatParms.getGroupName())) {
+ MatnrGroup matnrGroup = matnrGroupService.getOne(new LambdaQueryWrapper<MatnrGroup>()
+ .eq(MatnrGroup::getName, baseMatParms.getGroupName()));
+ if (!Objects.isNull(matnrGroup)) {
+ matnr.setGroupCode(matnrGroup.getCode()).setGroupId(matnrGroup.getId());
+ }
+ }
+ matnr.setName(baseMatParms.getMaktx())
+ .setColor(baseMatParms.getColor())
+ .setModel(baseMatParms.getModel())
+ .setSpec(baseMatParms.getSpec());
+
+ if (!matnrService.updateById(matnr)) {
+ throw new CoolException("鐗╂枡鏇存柊澶辫触锛侊紒");
+ }
+ }
+
+ return R.ok();
+ }
+
+ /**
+ * 搴撳瓨鏌ヨ鏄庣粏锛堜緵open-api璋冪敤锛�
+ *
+ * @param condition 鏌ヨ鏉′欢瀹炰綋绫�
+ * @return 搴撳瓨鏄庣粏鍒楄〃
+ */
+ @Override
+ public R erpQueryInventoryDetails(InventoryQueryConditionParam condition) {
+ try {
+ // 鍙傛暟楠岃瘉
+ if (condition == null) {
+ return R.error("鏌ヨ鏉′欢涓嶈兘涓虹┖");
+ }
+
+ // 灏咵RP鍙傛暟鏄犲皠涓篔ava瀹炰綋瀛楁鍚嶏紙椹煎嘲鏍煎紡锛夛紝PageParam浼氳嚜鍔ㄨ浆鎹负鏁版嵁搴撳瓧娈靛悕锛堜笅鍒掔嚎鏍煎紡锛�
+ Map<String, Object> queryMap = new HashMap<>();
+
+ // 浠庡疄浣撶被涓彁鍙栨煡璇㈡潯浠讹紝鏄犲皠涓烘暟鎹簱瀛楁鍚�
+ if (StringUtils.isNotBlank(condition.getLocId())) {
+ queryMap.put("locCode", condition.getLocId());
+ }
+ if (StringUtils.isNotBlank(condition.getMatNr())) {
+ queryMap.put("matnrCode", condition.getMatNr());
+ }
+ if (StringUtils.isNotBlank(condition.getPlanNo())) {
+ queryMap.put("trackCode", condition.getPlanNo());
+ }
+ if (StringUtils.isNotBlank(condition.getBatch())) {
+ queryMap.put("batch", condition.getBatch());
+ }
+
+ BaseParam baseParam = new BaseParam();
+ baseParam.syncMap(queryMap);
+ PageParam<LocItem, BaseParam> pageParam = new PageParam<>(baseParam, LocItem.class);
+
+ QueryWrapper<LocItem> wrapper = pageParam.buildWrapper(false);
+
+ // 璁㈠崟鍙�/宸ュ崟鍙�/MES宸ュ崟鍙�
+ if (StringUtils.isNotBlank(condition.getOrderNo())) {
+ String orderNo = condition.getOrderNo();
+ wrapper.and(w -> w.eq("plat_order_code", orderNo)
+ .or().eq("plat_work_code", orderNo));
+ }
+
+ // 鐗╂枡缁勶紙闇�瑕侀�氳繃鐗╂枡琛ㄥ叧鑱旀煡璇級
+ if (StringUtils.isNotBlank(condition.getMatGroup())) {
+ // 璋冪敤鐗╂枡Service鏌ヨ鐗╂枡缁勫搴旂殑鐗╂枡ID鍒楄〃锛堝鐢ㄥ凡鏈夋柟娉曪級
+ LambdaQueryWrapper<Matnr> matnrWrapper = new LambdaQueryWrapper<>();
+ matnrWrapper.eq(Matnr::getGroupId, condition.getMatGroup());
+ List<Matnr> matnrs = matnrService.list(matnrWrapper);
+ if (!matnrs.isEmpty()) {
+ List<Long> matnrIds = matnrs.stream().map(Matnr::getId).collect(Collectors.toList());
+ wrapper.in("matnr_id", matnrIds);
+ } else {
+ // 濡傛灉娌℃湁鎵惧埌鐗╂枡锛岃繑鍥炵┖缁撴灉
+ return R.ok().add(new ArrayList<>());
+ }
+ }
+
+ // 鍙煡璇㈡甯哥姸鎬佺殑搴撳瓨锛坰tatus=1琛ㄧず姝ｅ父锛�
+ wrapper.eq("status", 1);
+
+ pageParam.setCurrent(1);
+ pageParam.setSize(Integer.MAX_VALUE);
+ PageParam<LocItem, BaseParam> pageResult = locItemService.page(pageParam, wrapper);
+ List<LocItem> locItems = pageResult.getRecords();
+
+ if (locItems.isEmpty()) {
+ return R.ok().add(new ArrayList<>());
+ }
+
+ // 鑾峰彇鎵�鏈夐渶瑕佸叧鑱旂殑ID
+ List<Long> locIds = locItems.stream()
+ .map(LocItem::getLocId)
+ .filter(Objects::nonNull)
+ .distinct()
+ .collect(Collectors.toList());
+
+ List<Long> warehouseIds = new ArrayList<>();
+ List<Long> orderIds = locItems.stream()
+ .map(LocItem::getOrderId)
+ .filter(Objects::nonNull)
+ .distinct()
+ .collect(Collectors.toList());
+
+ // 璋冪敤LocService鏌ヨ搴撲綅淇℃伅锛堝鐢⊿ervice灞傛柟娉曪級
+ Map<Long, Loc> locMap = new HashMap<>();
+ if (!locIds.isEmpty()) {
+ List<Loc> locs = locService.listByIds(locIds);
+ locMap = locs.stream().collect(Collectors.toMap(Loc::getId, loc -> loc));
+
+ // 鏀堕泦浠撳簱ID
+ warehouseIds = locs.stream()
+ .map(Loc::getWarehouseId)
+ .filter(Objects::nonNull)
+ .distinct()
+ .collect(Collectors.toList());
+ }
+
+ // 浠撳簱缂栫爜杩囨护
+ if (StringUtils.isNotBlank(condition.getWareHouseId())) {
+ String wareHouseId = condition.getWareHouseId();
+ LambdaQueryWrapper<Warehouse> whWrapper = new LambdaQueryWrapper<>();
+ whWrapper.eq(Warehouse::getCode, wareHouseId);
+ // 璋冪敤WarehouseService鏌ヨ浠撳簱淇℃伅锛堝鐢⊿ervice灞傛柟娉曪級
+ List<Warehouse> warehouses = warehouseService.list(whWrapper);
+ if (!warehouses.isEmpty()) {
+ Long targetWarehouseId = warehouses.get(0).getId();
+ // 杩囨护搴撲綅锛屽彧淇濈暀鐩爣浠撳簱鐨勫簱浣�
+ locMap = locMap.entrySet().stream()
+ .filter(entry -> Objects.equals(entry.getValue().getWarehouseId(), targetWarehouseId))
+ .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+ // 杩囨护locItems锛屽彧淇濈暀鐩爣浠撳簱鐨�
+ Set<Long> validLocIds = locMap.keySet();
+ locItems = locItems.stream()
+ .filter(item -> item.getLocId() != null && validLocIds.contains(item.getLocId()))
+ .collect(Collectors.toList());
+
+ warehouseIds = Collections.singletonList(targetWarehouseId);
+ } else {
+ return R.ok().add(new ArrayList<>());
+ }
+ }
+
+ // 璋冪敤WarehouseService鏌ヨ浠撳簱淇℃伅锛堝鐢⊿ervice灞傛柟娉曪級
+ Map<Long, Warehouse> warehouseMap = new HashMap<>();
+ if (!warehouseIds.isEmpty()) {
+ List<Warehouse> warehouses = warehouseService.listByIds(warehouseIds);
+ warehouseMap = warehouses.stream().collect(Collectors.toMap(Warehouse::getId, wh -> wh));
+ }
+
+ // 璋冪敤AsnOrderService鏌ヨ璁㈠崟淇℃伅锛堝鐢⊿ervice灞傛柟娉曪級
+ Map<Long, WkOrder> orderMap = new HashMap<>();
+ if (!orderIds.isEmpty()) {
+ List<WkOrder> orders = asnOrderService.listByIds(orderIds);
+ orderMap = orders.stream().collect(Collectors.toMap(WkOrder::getId, order -> order));
+ }
+
+ // 杞崲缁撴灉
+ List<Map<String, Object>> result = new ArrayList<>();
+ for (LocItem locItem : locItems) {
+ Map<String, Object> details = convertToInventoryDetails(locItem, locMap, warehouseMap, orderMap);
+ if (details != null) {
+ result.add(details);
+ }
+ }
+
+ return R.ok().add(result);
+ } catch (Exception e) {
+ log.error("搴撳瓨鏌ヨ鏄庣粏澶辫触", e);
+ return R.error("鏌ヨ澶辫触锛�" + e.getMessage());
+ }
+ }
+
+ /**
+ * 杞崲涓哄簱瀛樻槑缁嗗璞�
+ */
+ private Map<String, Object> convertToInventoryDetails(LocItem locItem, Map<Long, Loc> locMap,
+ Map<Long, Warehouse> warehouseMap,
+ Map<Long, WkOrder> orderMap) {
+ Map<String, Object> details = new HashMap<>();
+
+ // 搴撲綅缂栫爜
+ details.put("locId", locItem.getLocCode());
+
+ // 浠撳簱淇℃伅
+ Loc loc = null;
+ if (locItem.getLocId() != null) {
+ loc = locMap.get(locItem.getLocId());
+ }
+
+ if (loc != null) {
+ // 鎵樼洏鐮侊紙浠庡簱浣嶇殑barcode鑾峰彇锛�
+ details.put("palletId", loc.getBarcode());
+
+ // 浠撳簱淇℃伅
+ if (loc.getWarehouseId() != null && warehouseMap.containsKey(loc.getWarehouseId())) {
+ Warehouse warehouse = warehouseMap.get(loc.getWarehouseId());
+ if (warehouse != null) {
+ details.put("wareHouseId", warehouse.getCode());
+ details.put("wareHouseName", warehouse.getName());
+ }
+ }
+ }
+
+ // 鐗╂枡淇℃伅
+ details.put("matNr", locItem.getMatnrCode());
+ details.put("makTx", locItem.getMaktx());
+ details.put("spec", locItem.getSpec());
+ details.put("anfme", locItem.getAnfme());
+ details.put("unit", locItem.getUnit());
+
+ // 搴撳瓨鐘舵�侊細1-姝ｅ父(鍙敤)锛�0-鍐荤粨
+ if (locItem.getStatus() != null) {
+ details.put("status", locItem.getStatus() == 1 ? "鍙敤" : "鍐荤粨");
+ }
+
+ // 鎵规鍙�
+ details.put("batch", locItem.getBatch());
+
+ // 璁″垝璺熻釜鍙�
+ details.put("planNo", locItem.getTrackCode());
+
+ // 璁㈠崟淇℃伅
+ if (locItem.getOrderId() != null && orderMap.containsKey(locItem.getOrderId())) {
+ WkOrder order = orderMap.get(locItem.getOrderId());
+ if (order != null) {
+ // 璁㈠崟鍙�
+ details.put("orderNo", order.getCode());
+ details.put("orderType", null);
+ // 璁㈠崟绫诲瀷锛�1-鍑哄簱鍗曪紝2-鍏ュ簱鍗曪紝3-璋冩嫈鍗�
+ // 瀛楃涓茬被鍨嬫槧灏勶細out->1(鍑哄簱鍗�), in->2(鍏ュ簱鍗�), revise->(璋冩嫈鍗�), check->(鐩樼偣鍗�))
+ if (StringUtils.isNotBlank(order.getType())) {
+ String orderTypeStr = order.getType().toLowerCase().trim();
+ switch (orderTypeStr) {
+ case "out":
+ details.put("orderType", 1);
+ break;
+ case "in":
+ details.put("orderType", 2);
+ break;
+ case "revise":
+ break;
+ case "check":
+ break;
+ default:
+ break;
+ }
+
+ //鍖呭惈 澶囨枡鍗曞叧閿瘝灏卞彉鎴�3
+ if (StringUtils.isNotBlank(order.getWkType())) {
+ String workDesc = getWorkDesc(order.getWkType());
+ if (workDesc != null && workDesc.contains("澶囨枡鍗�")) {
+ details.put("orderType", 3);
+ }
+ }
+ }
+
+ // 澶囨枡绫诲瀷锛氭牴鎹笟鍔＄被鍨嬪垽鏂�
+ // 姝ｅ父棰嗘枡(1)锛岀敓浜цˉ鏂�(2)
+ details.put("prepareType", 1);
+ if (StringUtils.isNotBlank(order.getWkType())) {
+ String workDesc = getWorkDesc(order.getWkType());
+ if (workDesc != null && workDesc.contains("鐢熶骇琛ユ枡")) {
+ details.put("prepareType", 2);
+ }
+ }
+ }
+ }
+
+ // 濡傛灉璁㈠崟鍙蜂负绌猴紝灏濊瘯浠巔latOrderCode鎴杙latWorkCode鑾峰彇
+ if (!details.containsKey("orderNo") || details.get("orderNo") == null) {
+ if (StringUtils.isNotBlank(locItem.getPlatOrderCode())) {
+ details.put("orderNo", locItem.getPlatOrderCode());
+ } else if (StringUtils.isNotBlank(locItem.getPlatWorkCode())) {
+ details.put("orderNo", locItem.getPlatWorkCode());
+ }
+ }
+
+ // 搴撳瓨缁勭粐锛堜粠useOrgId鑾峰彇锛�
+ details.put("stockOrgId", locItem.getUseOrgId());
+
+ return details;
+ }
}
--
Gitblit v1.9.1