selectAvailableReturnAssetList(AmsAsset asset, Long currentOrderId,
+ Long originWarehouseId, Boolean missingOriginOnly)
+ {
+ return amsReturnOrderMapper.selectAvailableReturnAssetList(asset, currentOrderId,
+ originWarehouseId, missingOriginOnly,
+ AssetStatus.IN_USE, ReturnOrderStatus.DRAFT, ReturnOrderStatus.PENDING_CONFIRM);
+ }
+
+ /**
+ * 保存退库草稿单。
+ *
+ * 业务意图与安全设计：
+ * 1. 申请人、申请部门信息进行合法性审查，并强制校验“申请人是否属于申请部门”，防范非法的业务提交；
+ * 2. 调用自动编码规则 `sysCodeRuleService.nextCode` 生成全局唯一的退库单号，该调用在事务内执行锁行；
+ * 3. 对单据中的每个资产明细项锁定并写入原始状态及当前使用归属的快照（作为后续确认时防脏写的版本基准）。
+ *
+ */
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public int insertAmsReturnOrder(AmsReturnOrder order, Long applicantId, String applicantName,
+ Long applyDeptId)
+ {
+ validateOrderRequest(order);
+ fillApplicantSnapshots(order, applicantId, applicantName, applyDeptId);
+ order.setReturnNo(sysCodeRuleService.nextCode(RETURN_ORDER_RULE));
+ order.setOrderStatus(ReturnOrderStatus.DRAFT);
+ order.setConfirmUserId(null);
+ order.setConfirmUserName(null);
+ order.setConfirmTime(null);
+ order.setDelFlag(DEL_FLAG_NORMAL);
+ order.setCreateTime(DateUtils.getNowDate());
+ fillOrderSnapshots(order, null);
+
+ if (amsReturnOrderMapper.insertAmsReturnOrder(order) != 1 || StringUtils.isNull(order.getOrderId()))
+ {
+ throw new ServiceException("退库单保存失败");
+ }
+ insertReturnOrderItems(order);
+ return 1;
+ }
+
+ /**
+ * 更新退库草稿单。
+ *
+ * 业务意图与防篡改：
+ * 1. 只有处于“草稿(DRAFT)”状态的退库单才允许修改；
+ * 2. 防篡改设计：退库单号 `returnNo`、申请人/部门快照等字段具有受控特性，不允许通过前台直接修改。
+ * 故在此处强制使用数据库中现存的原始值覆盖传入的值，然后再持久化。
+ * 3. 修改时采取“先删明细再重新插入”的方式，确保保存后单据明细项与前台选择的状态完全一致。
+ *
+ */
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public int updateAmsReturnOrder(AmsReturnOrder order)
+ {
+ if (StringUtils.isNull(order) || StringUtils.isNull(order.getOrderId()))
+ {
+ throw new ServiceException("退库单ID不能为空");
+ }
+ AmsReturnOrder current = requireOrderForUpdate(order.getOrderId(), ReturnOrderStatus.DRAFT,
+ "仅草稿退库单允许修改");
+ validateOrderRequest(order);
+
+ // 受控字段必须使用数据库当前值，防止普通编辑绕过单据状态和申请人快照。
+ order.setReturnNo(current.getReturnNo());
+ order.setApplicantId(current.getApplicantId());
+ order.setApplicantName(current.getApplicantName());
+ order.setApplyDeptId(current.getApplyDeptId());
+ order.setApplyDeptName(current.getApplyDeptName());
+ order.setOrderStatus(ReturnOrderStatus.DRAFT);
+ order.setConfirmUserId(null);
+ order.setConfirmUserName(null);
+ order.setConfirmTime(null);
+ order.setUpdateTime(DateUtils.getNowDate());
+ fillOrderSnapshots(order, order.getOrderId());
+
+ amsReturnOrderMapper.deleteAmsReturnOrderItemByOrderId(order.getOrderId());
+ insertReturnOrderItems(order);
+ if (amsReturnOrderMapper.updateAmsReturnOrder(order) != 1)
+ {
+ throw new ServiceException("退库单状态已变化，保存失败");
+ }
+ return 1;
+ }
+
+ /**
+ * 提交退库单。
+ *
+ * 业务意图与防呆设计：
+ * 1. 采用分布式/单机锁方案的前置机制：使用 `requireOrderForUpdate` 发送 `FOR UPDATE` 对退库单主行加排他锁，
+ * 并校验其状态必须为“草稿(DRAFT)”。防止其它并发事务重复提交或在审批流转时篡改数据；
+ * 2. 调用 `validateOrderReadyForFlow` 重新对该退库单关联的所有资产执行资产状态（必须是在用）与使用归属（不可在草稿期间改变）的强校验。
+ * 3. 在单据更新时校验影响行数，以确保更新的安全一致性。
+ *
+ */
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public int submitReturn(Long orderId, String operateLoginName)
+ {
+ AmsReturnOrder order = requireOrderForUpdate(orderId, ReturnOrderStatus.DRAFT,
+ "仅草稿退库单允许提交");
+ validateLoginName(operateLoginName);
+ validateOrderReadyForFlow(order);
+
+ order.setOrderStatus(ReturnOrderStatus.PENDING_CONFIRM);
+ order.setUpdateBy(StringUtils.trim(operateLoginName));
+ order.setUpdateTime(DateUtils.getNowDate());
+ if (amsReturnOrderMapper.submitAmsReturnOrder(order) != 1)
+ {
+ throw new ServiceException("退库单状态已变化，提交失败");
+ }
+ return 1;
+ }
+
+ /**
+ * 确认退库。
+ *
+ * 业务意图与事务一致性设计：
+ * 1. 使用 `requireOrderForUpdate` 对单据加排他锁，验证当前状态为“待确认(PENDING_CONFIRM)”。
+ * 2. 调用 `validateOrderReadyForFlow` 进行最终状态锁定：该方法会锁住单据内所有资产并再次确认没有发生属性篡改。
+ * 3. 流转委托设计：退库核心逻辑（清空使用责任人及部门，回退到目标在库仓库/位置，生成资产履历）被统一收口在公共的资产生命周期流转服务
+ * `assetStatusTransitionService.confirmReturn` 中。
+ * 这样做能防止我们在不同业务模块重复手写资产状态修改 SQL 导致数据不一致（如遗漏履历记录或 RFID 绑定未处理）。
+ *
+ */
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public int confirmReturn(Long orderId, Long operateUserId, String operateUserName,
+ String operateLoginName)
+ {
+ AmsReturnOrder order = requireOrderForUpdate(orderId, ReturnOrderStatus.PENDING_CONFIRM,
+ "仅待确认退库单允许确认");
+ validateOperator(operateUserId, operateUserName, "确认人");
+ validateLoginName(operateLoginName);
+ validateOrderReadyForFlow(order);
+
+ for (AmsReturnOrderItem item : sortedItems(order))
+ {
+ AssetTransitionContext context = new AssetTransitionContext();
+ context.setSourceOrderId(order.getOrderId());
+ context.setSourceOrderNo(order.getReturnNo());
+ context.setSourceItemId(item.getItemId());
+ context.setOperateUserId(operateUserId);
+ context.setOperateUserName(StringUtils.trim(operateUserName));
+ context.setOperateLoginName(StringUtils.trim(operateLoginName));
+ context.setChangeSummary("确认资产退库");
+ context.setRemark(order.getRemark());
+ assetStatusTransitionService.confirmReturn(item.getAssetId(), item.getAfterWarehouseId(),
+ item.getAfterLocationId(), context);
+ }
+
+ Date now = DateUtils.getNowDate();
+ order.setOrderStatus(ReturnOrderStatus.RETURNED);
+ order.setConfirmUserId(operateUserId);
+ order.setConfirmUserName(StringUtils.trim(operateUserName));
+ order.setConfirmTime(now);
+ order.setUpdateBy(StringUtils.trim(operateLoginName));
+ order.setUpdateTime(now);
+ if (amsReturnOrderMapper.confirmAmsReturnOrder(order) != 1)
+ {
+ throw new ServiceException("退库单状态已变化，确认退库失败");
+ }
+ return 1;
+ }
+
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public int deleteAmsReturnOrderByOrderIds(String orderIds)
+ {
+ Long[] sortedIds = Arrays.stream(Convert.toStrArray(orderIds))
+ .map(Long::valueOf).sorted().toArray(Long[]::new);
+ int rows = 0;
+ for (Long orderId : sortedIds)
+ {
+ AmsReturnOrder order = amsReturnOrderMapper.selectAmsReturnOrderByOrderIdForUpdate(orderId);
+ if (StringUtils.isNull(order))
+ {
+ continue;
+ }
+ requireDraft(order);
+ amsReturnOrderMapper.deleteAmsReturnOrderItemByOrderId(orderId);
+ rows += amsReturnOrderMapper.deleteAmsReturnOrderByOrderId(orderId);
+ }
+ return rows;
+ }
+
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public int deleteAmsReturnOrderByOrderId(Long orderId)
+ {
+ AmsReturnOrder order = amsReturnOrderMapper.selectAmsReturnOrderByOrderIdForUpdate(orderId);
+ if (StringUtils.isNull(order))
+ {
+ return 0;
+ }
+ requireDraft(order);
+ amsReturnOrderMapper.deleteAmsReturnOrderItemByOrderId(orderId);
+ return amsReturnOrderMapper.deleteAmsReturnOrderByOrderId(orderId);
+ }
+
+ private void validateOrderRequest(AmsReturnOrder order)
+ {
+ if (StringUtils.isNull(order))
+ {
+ throw new ServiceException("退库单不能为空");
+ }
+ if (order.getAmsReturnOrderItemList() == null || order.getAmsReturnOrderItemList().isEmpty())
+ {
+ throw new ServiceException("退库单明细不能为空");
+ }
+ validateLength(order.getRemark(), 500, "备注");
+ }
+
+ private void fillApplicantSnapshots(AmsReturnOrder order, Long applicantId, String applicantName,
+ Long applyDeptId)
+ {
+ validateOperator(applicantId, applicantName, "申请人");
+ SysUser applicant = requireNormalUser(applicantId, "申请人");
+ SysDept applyDept = requireNormalDept(applyDeptId, "申请部门");
+ if (!Objects.equals(applicant.getDeptId(), applyDept.getDeptId()))
+ {
+ throw new ServiceException("申请人不属于当前申请部门");
+ }
+ order.setApplicantId(applicantId);
+ order.setApplicantName(StringUtils.trim(applicantName));
+ order.setApplyDeptId(applyDept.getDeptId());
+ order.setApplyDeptName(applyDept.getDeptName());
+ }
+
+ /**
+ * 保存草稿时按资产ID升序锁定，回填退库前使用归属和退库后仓位快照。
+ */
+ private void fillOrderSnapshots(AmsReturnOrder order, Long currentOrderId)
+ {
+ AmsWarehouse warehouse = requireEnabledWarehouse(order.getReceiveWarehouseId());
+ order.setReceiveWarehouseCode(warehouse.getWarehouseCode());
+ order.setReceiveWarehouseName(warehouse.getWarehouseName());
+
+ Set assetIds = new HashSet<>();
+ ReturnOriginGroup originGroup = new ReturnOriginGroup();
+ List items = sortedItems(order);
+ order.setAmsReturnOrderItemList(items);
+ for (AmsReturnOrderItem item : items)
+ {
+ AmsAsset asset = lockReturnableAsset(item.getAssetId());
+ if (!assetIds.add(asset.getAssetId()))
+ {
+ throw new ServiceException("同一退库单不能重复选择资产");
+ }
+ validateNotOccupied(asset, currentOrderId);
+ originGroup.accept(asset, fillOriginReference(item));
+ fillAssetSnapshots(item, asset);
+ fillTargetSnapshots(item, asset, warehouse);
+ item.setReturnNo(order.getReturnNo());
+ item.setDelFlag(DEL_FLAG_NORMAL);
+ validateLength(item.getRemark(), 500, "明细备注");
+ }
+ }
+
+ /**
+ * 提交和确认前重新锁定资产，阻断草稿期间使用归属变化或资产被其他退库单占用。
+ */
+ private void validateOrderReadyForFlow(AmsReturnOrder order)
+ {
+ AmsWarehouse warehouse = requireEnabledWarehouse(order.getReceiveWarehouseId());
+ List items = sortedItems(order);
+ if (items.isEmpty())
+ {
+ throw new ServiceException("退库单明细不能为空");
+ }
+ Set assetIds = new HashSet<>();
+ ReturnOriginGroup originGroup = new ReturnOriginGroup();
+ for (AmsReturnOrderItem item : items)
+ {
+ AmsAsset asset = lockReturnableAsset(item.getAssetId());
+ if (!assetIds.add(asset.getAssetId()))
+ {
+ throw new ServiceException("同一退库单不能重复选择资产");
+ }
+ validateNotOccupied(asset, order.getOrderId());
+ originGroup.accept(asset, fillOriginReference(item));
+ validateBeforeSnapshot(item, asset);
+ fillTargetSnapshots(item, asset, warehouse);
+ }
+ }
+
+ private AmsAsset lockReturnableAsset(Long assetId)
+ {
+ if (StringUtils.isNull(assetId))
+ {
+ throw new ServiceException("退库资产不能为空");
+ }
+ AmsAsset asset = amsAssetMapper.selectAmsAssetByAssetIdForUpdate(assetId);
+ if (StringUtils.isNull(asset))
+ {
+ throw new ServiceException("退库资产不存在或已删除");
+ }
+ if (!StringUtils.equals(AssetStatus.IN_USE, asset.getAssetStatus()))
+ {
+ throw new ServiceException(StringUtils.format("资产【{}】当前状态不允许退库", asset.getAssetCode()));
+ }
+ if (StringUtils.isNull(asset.getUseDeptId()) || StringUtils.isNull(asset.getUseUserId())
+ || StringUtils.isEmpty(asset.getUseDeptName()) || StringUtils.isEmpty(asset.getUseUserName()))
+ {
+ throw new ServiceException(StringUtils.format("在用资产【{}】缺少当前使用部门或使用人", asset.getAssetCode()));
+ }
+ return asset;
+ }
+
+ private void validateNotOccupied(AmsAsset asset, Long currentOrderId)
+ {
+ if (amsReturnOrderMapper.countOtherActiveReturnOrderByAssetId(asset.getAssetId(), currentOrderId,
+ ReturnOrderStatus.DRAFT, ReturnOrderStatus.PENDING_CONFIRM) > 0)
+ {
+ throw new ServiceException(StringUtils.format("资产【{}】已被其他有效退库单占用", asset.getAssetCode()));
+ }
+ }
+
+ private void fillAssetSnapshots(AmsReturnOrderItem item, AmsAsset asset)
+ {
+ item.setAssetCode(asset.getAssetCode());
+ item.setAssetName(asset.getAssetName());
+ item.setCategoryId(asset.getCategoryId());
+ item.setCategoryCode(asset.getCategoryCode());
+ item.setCategoryName(asset.getCategoryName());
+ item.setSpecModel(asset.getSpecModel());
+ item.setBrand(asset.getBrand());
+ item.setAssetStatus(asset.getAssetStatus());
+ item.setBeforeDeptId(asset.getUseDeptId());
+ item.setBeforeDeptName(asset.getUseDeptName());
+ item.setBeforeUserId(asset.getUseUserId());
+ item.setBeforeUserName(asset.getUseUserName());
+ }
+
+ /** 回填最近一次已完成领用的原仓位，供页面默认带出和后端单仓库规则校验。 */
+ private AmsReturnAssetCandidate fillOriginReference(AmsReturnOrderItem item)
+ {
+ AmsReturnAssetCandidate candidate = amsReturnOrderMapper.selectReturnAssetCandidateByAssetId(item.getAssetId());
+ item.setOriginWarehouseId(candidate == null ? null : candidate.getOriginWarehouseId());
+ item.setOriginWarehouseCode(candidate == null ? null : candidate.getOriginWarehouseCode());
+ item.setOriginWarehouseName(candidate == null ? null : candidate.getOriginWarehouseName());
+ item.setOriginWarehouseEnabled(candidate == null ? null : candidate.getOriginWarehouseEnabled());
+ item.setOriginLocationId(candidate == null ? null : candidate.getOriginLocationId());
+ item.setOriginLocationCode(candidate == null ? null : candidate.getOriginLocationCode());
+ item.setOriginLocationName(candidate == null ? null : candidate.getOriginLocationName());
+ item.setOriginLocationEnabled(candidate == null ? null : candidate.getOriginLocationEnabled());
+ return candidate;
+ }
+
+ private void fillOriginReferences(AmsReturnOrder order)
+ {
+ if (order == null || order.getAmsReturnOrderItemList() == null)
+ {
+ return;
+ }
+ for (AmsReturnOrderItem item : order.getAmsReturnOrderItemList())
+ {
+ fillOriginReference(item);
+ }
+ }
+
+ private void fillTargetSnapshots(AmsReturnOrderItem item, AmsAsset asset, AmsWarehouse warehouse)
+ {
+ AmsAssetLocation location = requireEnabledLocation(item.getAfterLocationId());
+ if (!Objects.equals(warehouse.getWarehouseId(), location.getWarehouseId()))
+ {
+ throw new ServiceException(StringUtils.format("资产【{}】的退库位置不属于接收仓库", asset.getAssetCode()));
+ }
+ item.setAfterWarehouseId(warehouse.getWarehouseId());
+ item.setAfterWarehouseCode(warehouse.getWarehouseCode());
+ item.setAfterWarehouseName(warehouse.getWarehouseName());
+ item.setAfterLocationCode(location.getLocationCode());
+ item.setAfterLocationName(location.getLocationName());
+ }
+
+ private void validateBeforeSnapshot(AmsReturnOrderItem item, AmsAsset asset)
+ {
+ if (!Objects.equals(item.getBeforeDeptId(), asset.getUseDeptId())
+ || !Objects.equals(item.getBeforeUserId(), asset.getUseUserId()))
+ {
+ throw new ServiceException(StringUtils.format("资产【{}】当前使用归属已变化，请重新编辑并提交退库单",
+ asset.getAssetCode()));
+ }
+ }
+
+ private AmsWarehouse requireEnabledWarehouse(Long warehouseId)
+ {
+ if (StringUtils.isNull(warehouseId))
+ {
+ throw new ServiceException("接收仓库不能为空");
+ }
+ AmsWarehouse warehouse = amsWarehouseService.selectAmsWarehouseByWarehouseId(warehouseId);
+ if (StringUtils.isNull(warehouse) || !StringUtils.equals(ENABLED_YES, warehouse.getEnabled()))
+ {
+ throw new ServiceException("接收仓库不存在或已停用");
+ }
+ return warehouse;
+ }
+
+ private AmsAssetLocation requireEnabledLocation(Long locationId)
+ {
+ if (StringUtils.isNull(locationId))
+ {
+ throw new ServiceException("退库位置不能为空");
+ }
+ AmsAssetLocation location = amsAssetLocationService.selectAmsAssetLocationByLocationId(locationId);
+ if (StringUtils.isNull(location) || !StringUtils.equals(ENABLED_YES, location.getEnabled()))
+ {
+ throw new ServiceException("退库位置不存在或已停用");
+ }
+ return location;
+ }
+
+ private SysDept requireNormalDept(Long deptId, String fieldName)
+ {
+ if (StringUtils.isNull(deptId))
+ {
+ throw new ServiceException(fieldName + "不能为空");
+ }
+ SysDept dept = sysDeptService.selectDeptById(deptId);
+ if (StringUtils.isNull(dept)
+ || !StringUtils.equals(UserConstants.DEPT_NORMAL, dept.getStatus())
+ || !StringUtils.equals(DEL_FLAG_NORMAL, dept.getDelFlag()))
+ {
+ throw new ServiceException(fieldName + "不存在或已停用");
+ }
+ return dept;
+ }
+
+ private SysUser requireNormalUser(Long userId, String fieldName)
+ {
+ if (StringUtils.isNull(userId))
+ {
+ throw new ServiceException(fieldName + "不能为空");
+ }
+ SysUser user = sysUserService.selectUserById(userId);
+ if (StringUtils.isNull(user)
+ || !StringUtils.equals(UserConstants.NORMAL, user.getStatus())
+ || !StringUtils.equals(DEL_FLAG_NORMAL, user.getDelFlag()))
+ {
+ throw new ServiceException(fieldName + "不存在或已停用");
+ }
+ return user;
+ }
+
+ private AmsReturnOrder requireOrderForUpdate(Long orderId, String requiredStatus, String message)
+ {
+ if (StringUtils.isNull(orderId))
+ {
+ throw new ServiceException("退库单ID不能为空");
+ }
+ AmsReturnOrder order = amsReturnOrderMapper.selectAmsReturnOrderByOrderIdForUpdate(orderId);
+ if (StringUtils.isNull(order))
+ {
+ throw new ServiceException("退库单不存在或已删除");
+ }
+ if (!StringUtils.equals(requiredStatus, order.getOrderStatus()))
+ {
+ throw new ServiceException(message);
+ }
+ return order;
+ }
+
+ private void requireDraft(AmsReturnOrder order)
+ {
+ if (!StringUtils.equals(ReturnOrderStatus.DRAFT, order.getOrderStatus()))
+ {
+ throw new ServiceException("仅草稿退库单允许删除");
+ }
+ }
+
+ /**
+ * 按资产ID升序对明细进行排序。
+ *
+ * 避坑考量：
+ * 这是典型的防死锁（Deadlock Prevention）设计。
+ * 当多个并发事务同时操作包含多个资产的生命周期单据时，若获取行锁（`FOR UPDATE`）的顺序不一致：
+ * 例如事务A先锁资产1再锁资产2，而事务B并发先锁资产2再锁资产1，就极易引发数据库死锁。
+ * 通过在应用层使用此方法统一按资产 ID 升序排序，使所有涉及批量资产锁定的逻辑（保存、提交、确认）
+ * 拥有全局一致的锁定顺序，从根本上消除了并发死锁的风险。
+ *
+ */
+ private List sortedItems(AmsReturnOrder order)
+ {
+ if (order.getAmsReturnOrderItemList() == null)
+ {
+ return new ArrayList<>();
+ }
+ List items = new ArrayList<>(order.getAmsReturnOrderItemList());
+ items.sort(Comparator.comparing(AmsReturnOrderItem::getAssetId,
+ Comparator.nullsFirst(Long::compareTo)));
+ return items;
+ }
+
+ private void insertReturnOrderItems(AmsReturnOrder order)
+ {
+ List items = new ArrayList<>();
+ Date now = DateUtils.getNowDate();
+ for (AmsReturnOrderItem item : order.getAmsReturnOrderItemList())
+ {
+ item.setItemId(null);
+ item.setOrderId(order.getOrderId());
+ item.setCreateBy(StringUtils.isNotEmpty(order.getCreateBy()) ? order.getCreateBy() : order.getUpdateBy());
+ item.setCreateTime(now);
+ item.setUpdateBy(null);
+ item.setUpdateTime(null);
+ items.add(item);
+ }
+ if (amsReturnOrderMapper.batchAmsReturnOrderItem(items) != items.size())
+ {
+ throw new ServiceException("退库单明细保存失败");
+ }
+ }
+
+ private void validateOperator(Long userId, String userName, String fieldName)
+ {
+ if (StringUtils.isNull(userId) || StringUtils.isEmpty(StringUtils.trim(userName)))
+ {
+ throw new ServiceException(fieldName + "ID和名称不能为空");
+ }
+ validateLength(StringUtils.trim(userName), 100, fieldName + "名称");
+ }
+
+ private void validateLoginName(String loginName)
+ {
+ if (StringUtils.isEmpty(StringUtils.trim(loginName)))
+ {
+ throw new ServiceException("操作登录账号不能为空");
+ }
+ validateLength(StringUtils.trim(loginName), 64, "操作登录账号");
+ }
+
+ private void validateLength(String value, int maxLength, String fieldName)
+ {
+ if (StringUtils.isNotEmpty(value) && value.length() > maxLength)
+ {
+ throw new ServiceException(fieldName + "长度不能超过" + maxLength + "个字符");
+ }
+ }
+
+ /**
+ * 退库单原仓库一致性校验分组辅助类。
+ *
+ * 业务意图与管控：
+ * 1. “一单一仓库原则”：在一张退库单中，原则上不允许将来自不同领用仓库（即不同的 `originWarehouseId`）的资产混在一起退库。
+ * 因为现场交接和收料一般发生在特定的仓库，混杂多个原仓库会增加清点和确认流程的混乱度。
+ * 2. 来源可追溯性一致：系统严格限制“可追溯领用来源资产”（曾经过领用单流程）与“无明确来源资产”混单提交。
+ * 无来源资产由于没有历史领用仓位记录，其退库不具备自动原仓对齐校验。
+ *
+ */
+ private static class ReturnOriginGroup
+ {
+ private boolean initialized;
+
+ private boolean traceable;
+
+ private Long originWarehouseId;
+
+ /**
+ * 接收并核对资产的来源一致性。
+ *
+ * @param asset 待核查资产
+ * @param candidate 来源资产候选快照
+ * @throws ServiceException 若来源仓库类型或仓库 ID 不一致时，直接抛出业务异常阻断
+ */
+ void accept(AmsAsset asset, AmsReturnAssetCandidate candidate)
+ {
+ boolean currentTraceable = candidate != null && candidate.isOriginTraceable();
+ Long currentWarehouseId = currentTraceable ? candidate.getOriginWarehouseId() : null;
+ if (!initialized)
+ {
+ initialized = true;
+ traceable = currentTraceable;
+ originWarehouseId = currentWarehouseId;
+ return;
+ }
+ if (traceable != currentTraceable)
+ {
+ throw new ServiceException(StringUtils.format(
+ "资产【{}】与当前退库单的原领用仓位来源类型不一致", asset.getAssetCode()));
+ }
+ if (traceable && !Objects.equals(originWarehouseId, currentWarehouseId))
+ {
+ throw new ServiceException(StringUtils.format(
+ "资产【{}】的原领用仓库与当前退库单不一致", asset.getAssetCode()));
+ }
+ }
+ }
+}
diff --git a/ruoyi-asset/src/main/resources/mapper/asset/AmsReturnOrderMapper.xml b/ruoyi-asset/src/main/resources/mapper/asset/AmsReturnOrderMapper.xml
new file mode 100644
index 0000000..862cb58
--- /dev/null
+++ b/ruoyi-asset/src/main/resources/mapper/asset/AmsReturnOrderMapper.xml
@@ -0,0 +1,389 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ select order_id, return_no, applicant_id, applicant_name, apply_dept_id, apply_dept_name,
+ receive_warehouse_id, receive_warehouse_code, receive_warehouse_name,
+ confirm_user_id, confirm_user_name, confirm_time, order_status,
+ create_by, create_time, update_by, update_time, remark, del_flag
+ from ams_return_order
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ insert into ams_return_order (
+ return_no, applicant_id, applicant_name, apply_dept_id, apply_dept_name,
+ receive_warehouse_id, receive_warehouse_code, receive_warehouse_name,
+ order_status, create_by, create_time, remark, del_flag
+ ) values (
+ #{returnNo}, #{applicantId}, #{applicantName}, #{applyDeptId}, #{applyDeptName},
+ #{receiveWarehouseId}, #{receiveWarehouseCode}, #{receiveWarehouseName},
+ #{orderStatus}, #{createBy}, #{createTime}, #{remark}, #{delFlag}
+ )
+
+
+
+ update ams_return_order
+ set receive_warehouse_id = #{receiveWarehouseId},
+ receive_warehouse_code = #{receiveWarehouseCode},
+ receive_warehouse_name = #{receiveWarehouseName},
+ update_by = #{updateBy},
+ update_time = #{updateTime},
+ remark = #{remark}
+ where order_id = #{orderId} and del_flag = '0' and order_status = 'DRAFT'
+
+
+
+ update ams_return_order
+ set order_status = #{orderStatus},
+ update_by = #{updateBy},
+ update_time = #{updateTime}
+ where order_id = #{orderId} and del_flag = '0' and order_status = 'DRAFT'
+
+
+
+ update ams_return_order
+ set order_status = #{orderStatus},
+ confirm_user_id = #{confirmUserId},
+ confirm_user_name = #{confirmUserName},
+ confirm_time = #{confirmTime},
+ update_by = #{updateBy},
+ update_time = #{updateTime}
+ where order_id = #{orderId} and del_flag = '0' and order_status = 'PENDING_CONFIRM'
+
+
+
+ update ams_return_order
+ set del_flag = '1'
+ where order_id = #{orderId} and del_flag = '0' and order_status = 'DRAFT'
+
+
+
+ update ams_return_order
+ set del_flag = '1'
+ where order_id in
+
+ #{orderId}
+
+ and del_flag = '0' and order_status = 'DRAFT'
+
+
+
+ update ams_return_order_item
+ set del_flag = '1'
+ where order_id in
+
+ #{orderId}
+
+ and del_flag = '0'
+
+
+
+ update ams_return_order_item
+ set del_flag = '1'
+ where order_id = #{orderId} and del_flag = '0'
+
+
+
+ insert into ams_return_order_item (
+ order_id, return_no, asset_id, asset_code, asset_name, category_id, category_code,
+ category_name, spec_model, brand, before_user_id, before_user_name, before_dept_id,
+ before_dept_name, after_warehouse_id, after_warehouse_code, after_warehouse_name,
+ after_location_id, after_location_code, after_location_name,
+ create_by, create_time, remark, del_flag
+ ) values
+
+ (
+ #{item.orderId}, #{item.returnNo}, #{item.assetId}, #{item.assetCode},
+ #{item.assetName}, #{item.categoryId}, #{item.categoryCode}, #{item.categoryName},
+ #{item.specModel}, #{item.brand}, #{item.beforeUserId}, #{item.beforeUserName},
+ #{item.beforeDeptId}, #{item.beforeDeptName}, #{item.afterWarehouseId},
+ #{item.afterWarehouseCode}, #{item.afterWarehouseName}, #{item.afterLocationId},
+ #{item.afterLocationCode}, #{item.afterLocationName}, #{item.createBy},
+ #{item.createTime}, #{item.remark}, #{item.delFlag}
+ )
+
+
+
+
diff --git a/ruoyi-asset/src/main/resources/templates/asset/return/add.html b/ruoyi-asset/src/main/resources/templates/asset/return/add.html
new file mode 100644
index 0000000..c21165d
--- /dev/null
+++ b/ruoyi-asset/src/main/resources/templates/asset/return/add.html
@@ -0,0 +1,229 @@
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ruoyi-asset/src/main/resources/templates/asset/return/edit.html b/ruoyi-asset/src/main/resources/templates/asset/return/edit.html
new file mode 100644
index 0000000..18c1790
--- /dev/null
+++ b/ruoyi-asset/src/main/resources/templates/asset/return/edit.html
@@ -0,0 +1,244 @@
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ruoyi-asset/src/main/resources/templates/asset/return/return.html b/ruoyi-asset/src/main/resources/templates/asset/return/return.html
new file mode 100644
index 0000000..ff5daa9
--- /dev/null
+++ b/ruoyi-asset/src/main/resources/templates/asset/return/return.html
@@ -0,0 +1,115 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ruoyi-asset/src/main/resources/templates/asset/return/selectAsset.html b/ruoyi-asset/src/main/resources/templates/asset/return/selectAsset.html
new file mode 100644
index 0000000..f2fc0c2
--- /dev/null
+++ b/ruoyi-asset/src/main/resources/templates/asset/return/selectAsset.html
@@ -0,0 +1,72 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ruoyi-asset/src/main/resources/templates/asset/return/view.html b/ruoyi-asset/src/main/resources/templates/asset/return/view.html
new file mode 100644
index 0000000..d38c240
--- /dev/null
+++ b/ruoyi-asset/src/main/resources/templates/asset/return/view.html
@@ -0,0 +1,49 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/ruoyi-asset/src/test/java/com/ruoyi/asset/service/impl/AmsReturnOrderServiceImplTest.java b/ruoyi-asset/src/test/java/com/ruoyi/asset/service/impl/AmsReturnOrderServiceImplTest.java
new file mode 100644
index 0000000..ed675bd
--- /dev/null
+++ b/ruoyi-asset/src/test/java/com/ruoyi/asset/service/impl/AmsReturnOrderServiceImplTest.java
@@ -0,0 +1,376 @@
+package com.ruoyi.asset.service.impl;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Collections;
+import java.util.Arrays;
+import java.util.List;
+import com.ruoyi.asset.constant.AssetStatus;
+import com.ruoyi.asset.constant.ReturnOrderStatus;
+import com.ruoyi.asset.domain.AmsAsset;
+import com.ruoyi.asset.domain.AmsAssetLocation;
+import com.ruoyi.asset.domain.AmsReturnAssetCandidate;
+import com.ruoyi.asset.domain.AmsReturnOrder;
+import com.ruoyi.asset.domain.AmsReturnOrderItem;
+import com.ruoyi.asset.domain.AmsWarehouse;
+import com.ruoyi.asset.domain.AssetTransitionContext;
+import com.ruoyi.asset.mapper.AmsAssetMapper;
+import com.ruoyi.asset.mapper.AmsReturnOrderMapper;
+import com.ruoyi.asset.service.IAmsAssetLocationService;
+import com.ruoyi.asset.service.IAmsWarehouseService;
+import com.ruoyi.asset.service.IAssetStatusTransitionService;
+import com.ruoyi.common.core.domain.entity.SysDept;
+import com.ruoyi.common.core.domain.entity.SysUser;
+import com.ruoyi.common.exception.ServiceException;
+import com.ruoyi.system.service.ISysCodeRuleService;
+import com.ruoyi.system.service.ISysDeptService;
+import com.ruoyi.system.service.ISysUserService;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class AmsReturnOrderServiceImplTest
+{
+ @Mock
+ private AmsReturnOrderMapper amsReturnOrderMapper;
+
+ @Mock
+ private AmsAssetMapper amsAssetMapper;
+
+ @Mock
+ private ISysCodeRuleService sysCodeRuleService;
+
+ @Mock
+ private IAmsWarehouseService amsWarehouseService;
+
+ @Mock
+ private IAmsAssetLocationService amsAssetLocationService;
+
+ @Mock
+ private ISysDeptService sysDeptService;
+
+ @Mock
+ private ISysUserService sysUserService;
+
+ @Mock
+ private IAssetStatusTransitionService assetStatusTransitionService;
+
+ @InjectMocks
+ private AmsReturnOrderServiceImpl service;
+
+ /** 新增退库草稿应生成单号，并使用台账及主数据回填快照。 */
+ @Test
+ void insertShouldGenerateCodeAndFillSnapshots()
+ {
+ AmsReturnOrder order = buildRequest();
+ stubApplicant();
+ stubInUseAsset();
+ stubTargetWarehouseLocation();
+ when(sysCodeRuleService.nextCode("RETURN_ORDER")).thenReturn("TK202606150001");
+ doAnswer(invocation -> {
+ AmsReturnOrder inserted = invocation.getArgument(0);
+ inserted.setOrderId(100L);
+ return 1;
+ }).when(amsReturnOrderMapper).insertAmsReturnOrder(any(AmsReturnOrder.class));
+ when(amsReturnOrderMapper.batchAmsReturnOrderItem(anyList()))
+ .thenAnswer(invocation -> ((List) invocation.getArgument(0)).size());
+
+ assertEquals(1, service.insertAmsReturnOrder(order, 1L, "管理员", 103L));
+
+ AmsReturnOrderItem item = order.getAmsReturnOrderItemList().get(0);
+ assertEquals("TK202606150001", order.getReturnNo());
+ assertEquals(ReturnOrderStatus.DRAFT, order.getOrderStatus());
+ assertEquals("研发部门", order.getApplyDeptName());
+ assertEquals("二号仓", order.getReceiveWarehouseName());
+ assertEquals("测试部门", item.getBeforeDeptName());
+ assertEquals("测试用户", item.getBeforeUserName());
+ assertEquals("二号仓A区", item.getAfterLocationName());
+ assertEquals(100L, item.getOrderId());
+ assertNotNull(item.getCreateTime());
+ }
+
+ /** 退库位置必须属于主表所选接收仓库。 */
+ @Test
+ void insertShouldRejectLocationOutsideWarehouse()
+ {
+ AmsReturnOrder order = buildRequest();
+ stubApplicant();
+ stubInUseAsset();
+ stubTargetWarehouseLocation();
+ when(sysCodeRuleService.nextCode("RETURN_ORDER")).thenReturn("TK202606150001");
+ AmsAssetLocation location = new AmsAssetLocation();
+ location.setLocationId(20L);
+ location.setWarehouseId(99L);
+ location.setEnabled("Y");
+ when(amsAssetLocationService.selectAmsAssetLocationByLocationId(20L)).thenReturn(location);
+
+ ServiceException exception = assertThrows(ServiceException.class,
+ () -> service.insertAmsReturnOrder(order, 1L, "管理员", 103L));
+
+ assertTrue(exception.getMessage().contains("不属于接收仓库"));
+ verify(amsReturnOrderMapper, never()).insertAmsReturnOrder(any(AmsReturnOrder.class));
+ }
+
+ /** 被其他草稿或待确认退库单占用的资产不得再次加入退库单。 */
+ @Test
+ void insertShouldRejectAssetOccupiedByOtherActiveReturn()
+ {
+ AmsReturnOrder order = buildRequest();
+ stubApplicant();
+ stubInUseAsset();
+ stubTargetWarehouse();
+ when(sysCodeRuleService.nextCode("RETURN_ORDER")).thenReturn("TK202606150001");
+ when(amsReturnOrderMapper.countOtherActiveReturnOrderByAssetId(1L, null,
+ ReturnOrderStatus.DRAFT, ReturnOrderStatus.PENDING_CONFIRM)).thenReturn(1);
+
+ ServiceException exception = assertThrows(ServiceException.class,
+ () -> service.insertAmsReturnOrder(order, 1L, "管理员", 103L));
+
+ assertTrue(exception.getMessage().contains("其他有效退库单"));
+ verify(amsReturnOrderMapper, never()).insertAmsReturnOrder(any(AmsReturnOrder.class));
+ }
+
+ /** 同一退库单中的可追溯资产必须来自同一领用前仓库。 */
+ @Test
+ void insertShouldRejectAssetsFromDifferentOriginWarehouses()
+ {
+ AmsReturnOrder order = buildRequestWithAssets(1L, 2L);
+ stubApplicant();
+ stubInUseAsset(1L);
+ stubInUseAsset(2L);
+ stubTargetWarehouseLocation();
+ when(sysCodeRuleService.nextCode("RETURN_ORDER")).thenReturn("TK202606150001");
+ when(amsReturnOrderMapper.selectReturnAssetCandidateByAssetId(1L))
+ .thenReturn(buildCandidate(1L, 10L));
+ when(amsReturnOrderMapper.selectReturnAssetCandidateByAssetId(2L))
+ .thenReturn(buildCandidate(2L, 20L));
+
+ ServiceException exception = assertThrows(ServiceException.class,
+ () -> service.insertAmsReturnOrder(order, 1L, "管理员", 103L));
+
+ assertTrue(exception.getMessage().contains("原领用仓库"));
+ verify(amsReturnOrderMapper, never()).insertAmsReturnOrder(any(AmsReturnOrder.class));
+ }
+
+ /** 缺少领用来源的资产不能与可追溯资产混在同一退库单。 */
+ @Test
+ void insertShouldRejectMixedTraceableAndMissingOrigin()
+ {
+ AmsReturnOrder order = buildRequestWithAssets(1L, 2L);
+ stubApplicant();
+ stubInUseAsset(1L);
+ stubInUseAsset(2L);
+ stubTargetWarehouseLocation();
+ when(sysCodeRuleService.nextCode("RETURN_ORDER")).thenReturn("TK202606150001");
+ when(amsReturnOrderMapper.selectReturnAssetCandidateByAssetId(1L))
+ .thenReturn(buildCandidate(1L, 10L));
+
+ ServiceException exception = assertThrows(ServiceException.class,
+ () -> service.insertAmsReturnOrder(order, 1L, "管理员", 103L));
+
+ assertTrue(exception.getMessage().contains("来源类型不一致"));
+ verify(amsReturnOrderMapper, never()).insertAmsReturnOrder(any(AmsReturnOrder.class));
+ }
+
+ /** 草稿提交前校验资产仍在用且使用归属未变化。 */
+ @Test
+ void submitShouldMoveToPendingConfirm()
+ {
+ AmsReturnOrder order = buildPersistedOrder(ReturnOrderStatus.DRAFT);
+ when(amsReturnOrderMapper.selectAmsReturnOrderByOrderIdForUpdate(100L)).thenReturn(order);
+ stubInUseAsset();
+ stubTargetWarehouseLocation();
+ when(amsReturnOrderMapper.submitAmsReturnOrder(any(AmsReturnOrder.class))).thenReturn(1);
+
+ assertEquals(1, service.submitReturn(100L, "admin"));
+
+ assertEquals(ReturnOrderStatus.PENDING_CONFIRM, order.getOrderStatus());
+ verify(amsReturnOrderMapper).submitAmsReturnOrder(order);
+ }
+
+ /** 确认退库应委托公共流转服务，并记录确认信息。 */
+ @Test
+ void confirmShouldDelegateTransitionAndCompleteOrder()
+ {
+ AmsReturnOrder order = buildPersistedOrder(ReturnOrderStatus.PENDING_CONFIRM);
+ when(amsReturnOrderMapper.selectAmsReturnOrderByOrderIdForUpdate(100L)).thenReturn(order);
+ stubInUseAsset();
+ stubTargetWarehouseLocation();
+ when(amsReturnOrderMapper.confirmAmsReturnOrder(any(AmsReturnOrder.class))).thenReturn(1);
+
+ assertEquals(1, service.confirmReturn(100L, 1L, "管理员", "admin"));
+
+ ArgumentCaptor contextCaptor = ArgumentCaptor.forClass(AssetTransitionContext.class);
+ verify(assetStatusTransitionService).confirmReturn(
+ org.mockito.ArgumentMatchers.eq(1L),
+ org.mockito.ArgumentMatchers.eq(2L),
+ org.mockito.ArgumentMatchers.eq(20L),
+ contextCaptor.capture());
+ assertEquals(100L, contextCaptor.getValue().getSourceOrderId());
+ assertEquals(101L, contextCaptor.getValue().getSourceItemId());
+ assertEquals(ReturnOrderStatus.RETURNED, order.getOrderStatus());
+ assertEquals("管理员", order.getConfirmUserName());
+ assertNotNull(order.getConfirmTime());
+ }
+
+ /** 草稿保存后使用人发生变化时，提交必须阻断。 */
+ @Test
+ void submitShouldRejectStaleUseOwnership()
+ {
+ AmsReturnOrder order = buildPersistedOrder(ReturnOrderStatus.DRAFT);
+ order.getAmsReturnOrderItemList().get(0).setBeforeUserId(99L);
+ when(amsReturnOrderMapper.selectAmsReturnOrderByOrderIdForUpdate(100L)).thenReturn(order);
+ stubInUseAsset();
+ stubTargetWarehouse();
+
+ ServiceException exception = assertThrows(ServiceException.class,
+ () -> service.submitReturn(100L, "admin"));
+
+ assertTrue(exception.getMessage().contains("当前使用归属已变化"));
+ verify(amsReturnOrderMapper, never()).submitAmsReturnOrder(any(AmsReturnOrder.class));
+ }
+
+ /** 非草稿退库单不得删除。 */
+ @Test
+ void deleteShouldRejectNonDraftOrder()
+ {
+ AmsReturnOrder order = new AmsReturnOrder();
+ order.setOrderId(100L);
+ order.setOrderStatus(ReturnOrderStatus.PENDING_CONFIRM);
+ when(amsReturnOrderMapper.selectAmsReturnOrderByOrderIdForUpdate(100L)).thenReturn(order);
+
+ ServiceException exception = assertThrows(ServiceException.class,
+ () -> service.deleteAmsReturnOrderByOrderId(100L));
+
+ assertTrue(exception.getMessage().contains("仅草稿"));
+ verify(amsReturnOrderMapper, never()).deleteAmsReturnOrderByOrderId(100L);
+ }
+
+ private AmsReturnOrder buildRequest()
+ {
+ AmsReturnOrder order = new AmsReturnOrder();
+ order.setCreateBy("admin");
+ order.setReceiveWarehouseId(2L);
+ AmsReturnOrderItem item = new AmsReturnOrderItem();
+ item.setAssetId(1L);
+ item.setAfterLocationId(20L);
+ order.setAmsReturnOrderItemList(Collections.singletonList(item));
+ return order;
+ }
+
+ private AmsReturnOrder buildRequestWithAssets(Long... assetIds)
+ {
+ AmsReturnOrder order = new AmsReturnOrder();
+ order.setCreateBy("admin");
+ order.setReceiveWarehouseId(2L);
+ order.setAmsReturnOrderItemList(Arrays.stream(assetIds).map(assetId -> {
+ AmsReturnOrderItem item = new AmsReturnOrderItem();
+ item.setAssetId(assetId);
+ item.setAfterLocationId(20L);
+ return item;
+ }).toList());
+ return order;
+ }
+
+ private AmsReturnOrder buildPersistedOrder(String status)
+ {
+ AmsReturnOrder order = buildRequest();
+ order.setOrderId(100L);
+ order.setReturnNo("TK202606150001");
+ order.setOrderStatus(status);
+ AmsReturnOrderItem item = order.getAmsReturnOrderItemList().get(0);
+ item.setItemId(101L);
+ item.setBeforeDeptId(105L);
+ item.setBeforeUserId(2L);
+ item.setAfterWarehouseId(2L);
+ return order;
+ }
+
+ private void stubApplicant()
+ {
+ SysDept dept = new SysDept();
+ dept.setDeptId(103L);
+ dept.setDeptName("研发部门");
+ dept.setStatus("0");
+ dept.setDelFlag("0");
+ when(sysDeptService.selectDeptById(103L)).thenReturn(dept);
+
+ SysUser user = new SysUser();
+ user.setUserId(1L);
+ user.setUserName("管理员");
+ user.setDeptId(103L);
+ user.setStatus("0");
+ user.setDelFlag("0");
+ when(sysUserService.selectUserById(1L)).thenReturn(user);
+ }
+
+ private void stubInUseAsset()
+ {
+ stubInUseAsset(1L);
+ }
+
+ private void stubInUseAsset(Long assetId)
+ {
+ AmsAsset asset = new AmsAsset();
+ asset.setAssetId(assetId);
+ asset.setAssetCode("ASSET-" + assetId);
+ asset.setAssetName("测试资产");
+ asset.setCategoryId(3L);
+ asset.setCategoryCode("CAT-003");
+ asset.setCategoryName("测试类别");
+ asset.setAssetStatus(AssetStatus.IN_USE);
+ asset.setUseDeptId(105L);
+ asset.setUseDeptName("测试部门");
+ asset.setUseUserId(2L);
+ asset.setUseUserName("测试用户");
+ when(amsAssetMapper.selectAmsAssetByAssetIdForUpdate(assetId)).thenReturn(asset);
+ }
+
+ private AmsReturnAssetCandidate buildCandidate(Long warehouseId, Long locationId)
+ {
+ AmsReturnAssetCandidate candidate = new AmsReturnAssetCandidate();
+ candidate.setOriginWarehouseId(warehouseId);
+ candidate.setOriginWarehouseName("原仓库" + warehouseId);
+ candidate.setOriginWarehouseEnabled("Y");
+ candidate.setOriginLocationId(locationId);
+ candidate.setOriginLocationName("原位置" + locationId);
+ candidate.setOriginLocationEnabled("Y");
+ return candidate;
+ }
+
+ private void stubTargetWarehouseLocation()
+ {
+ stubTargetWarehouse();
+
+ AmsAssetLocation location = new AmsAssetLocation();
+ location.setLocationId(20L);
+ location.setLocationCode("LOC-020");
+ location.setLocationName("二号仓A区");
+ location.setWarehouseId(2L);
+ location.setEnabled("Y");
+ when(amsAssetLocationService.selectAmsAssetLocationByLocationId(20L)).thenReturn(location);
+ }
+
+ private void stubTargetWarehouse()
+ {
+ AmsWarehouse warehouse = new AmsWarehouse();
+ warehouse.setWarehouseId(2L);
+ warehouse.setWarehouseCode("WH-002");
+ warehouse.setWarehouseName("二号仓");
+ warehouse.setEnabled("Y");
+ when(amsWarehouseService.selectAmsWarehouseByWarehouseId(2L)).thenReturn(warehouse);
+ }
+}