diff --git a/src/main/java/org/folio/helper/CheckinHelper.java b/src/main/java/org/folio/helper/CheckinHelper.java index 71c1cf640..b81bf4c9b 100644 --- a/src/main/java/org/folio/helper/CheckinHelper.java +++ b/src/main/java/org/folio/helper/CheckinHelper.java @@ -12,6 +12,7 @@ import org.apache.commons.lang3.tuple.Pair; import org.folio.models.pieces.PiecesHolder; import org.folio.orders.events.handlers.MessageAddress; +import org.folio.orders.utils.HelperUtils; import org.folio.orders.utils.PoLineCommonUtil; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.CheckInPiece; @@ -95,8 +96,11 @@ private Future>> createItemsWithPieceUpdate(CheckinColle if (checkInPiece.getId().equals(piece.getId()) && Boolean.TRUE.equals(checkInPiece.getCreateItem())) { pieceFutures.add(purchaseOrderLineService.getOrderLineById(poLineId, requestContext) .map(PoLineCommonUtil::convertToCompositePoLine) - .compose(compPol -> pieceCreateFlowInventoryManager.processInventory(compPol, piece, checkInPiece.getCreateItem(), requestContext)) - .map(voidResult -> new PiecesHolder.PiecePoLineDto(poLineId, piece))); + .compose(compPol -> purchaseOrderStorageService.getPurchaseOrderByIdAsJson(compPol.getPurchaseOrderId(), requestContext) + .map(HelperUtils::convertToCompositePurchaseOrder) + .compose(purchaseOrder -> pieceCreateFlowInventoryManager.processInventory(purchaseOrder, compPol, piece, + checkInPiece.getCreateItem(), requestContext)) + .map(voidResult -> new PiecesHolder.PiecePoLineDto(poLineId, piece)))); } else if (checkInPiece.getId().equals(piece.getId()) && InventoryUtils.allowItemRecreate(srcTenantId, dstTenantId) && Objects.nonNull(piece.getItemId())) { pieceFutures.add(purchaseOrderLineService.getOrderLineById(poLineId, requestContext) .map(PoLineCommonUtil::convertToCompositePoLine) diff --git a/src/main/java/org/folio/helper/CheckinReceivePiecesHelper.java b/src/main/java/org/folio/helper/CheckinReceivePiecesHelper.java index e8c14c72a..ca546224a 100644 --- a/src/main/java/org/folio/helper/CheckinReceivePiecesHelper.java +++ b/src/main/java/org/folio/helper/CheckinReceivePiecesHelper.java @@ -19,6 +19,7 @@ import org.folio.rest.core.RestClient; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Eresource; import org.folio.rest.jaxrs.model.Error; import org.folio.rest.jaxrs.model.Location; @@ -40,6 +41,7 @@ import org.folio.service.inventory.InventoryItemManager; import org.folio.service.inventory.InventoryUtils; import org.folio.service.orders.PurchaseOrderLineService; +import org.folio.service.orders.PurchaseOrderStorageService; import org.folio.service.pieces.ItemRecreateInventoryService; import org.folio.service.pieces.PieceStorageService; import org.folio.service.pieces.flows.create.PieceCreateFlowInventoryManager; @@ -121,6 +123,9 @@ public abstract class CheckinReceivePiecesHelper extends BaseHelper { protected PieceUpdateFlowPoLineService pieceUpdateFlowPoLineService; @Autowired private ItemRecreateInventoryService itemRecreateInventoryService; + @Autowired + protected PurchaseOrderStorageService purchaseOrderStorageService; + private final RestClient restClient; private List poLineList; @@ -501,26 +506,50 @@ protected Future recreateItemRecords(Map> piecesGroupe if (Objects.isNull(holder.getItemsToRecreate()) || holder.getItemsToRecreate().isEmpty()) { return Future.succeededFuture(); } - var futures = new ArrayList>(); - piecesGroupedByPoLine.keySet().stream() - .map(poLineId -> holder.getItemsToRecreate().get(poLineId)) - .forEach(itemToRecreateList -> - itemToRecreateList.forEach(itemToRecreate -> { - var piece = itemToRecreate.getPieceFromStorage(); - var checkInPiece = itemToRecreate.getCheckInPiece(); - var srcConfig = InventoryUtils.constructItemRecreateConfig(piece.getReceivingTenantId(), requestContext, true); - var dstConfig = InventoryUtils.constructItemRecreateConfig(checkInPiece.getReceivingTenantId(), requestContext, false); - if (InventoryUtils.allowItemRecreate(srcConfig.tenantId(), dstConfig.tenantId())) { - logger.info("recreateItemRecords:: recreating item by id '{}', srcTenantId: '{}', dstTenantId: '{}'", piece.getItemId(), srcConfig.tenantId(), dstConfig.tenantId()); - futures.add(itemRecreateInventoryService.recreateItemInDestinationTenant(itemToRecreate.getCompositePoLine(), piece, srcConfig.context(), dstConfig.context())); - } - })); - return collectResultsOnSuccess(futures) - .map(itemIdsRecreated -> { - itemIdsRecreated.forEach(itemIdRecreated -> logger.info("recreateItemRecords:: recreated item by id '{}'", itemIdRecreated)); - return null; - }) - .compose(v -> Future.succeededFuture()); + + Map> purchaseOrderFutures = piecesGroupedByPoLine.keySet().stream() + .collect(Collectors.toMap( + poLineId -> poLineId, + poLineId -> purchaseOrderStorageService.getCompositeOrderByPoLineId(poLineId, requestContext) + .recover(throwable -> { + logger.warn("recreateItemRecords:: Composite Purchase order can't be found for poLine: {}", poLineId); + return Future.succeededFuture(null); + }) + )); + + return GenericCompositeFuture.join(new ArrayList<>(purchaseOrderFutures.values())).compose(purchaseOrdersFuture -> { + Map purchaseOrderMap = purchaseOrderFutures.entrySet().stream() + .collect(Collectors.toMap( + Map.Entry::getKey, + entry -> entry.getValue().result() + )); + + List> futures = new ArrayList<>(); + piecesGroupedByPoLine.keySet().stream() + .map(poLineId -> holder.getItemsToRecreate().get(poLineId)) + .forEach(itemToRecreateList -> + itemToRecreateList.forEach(itemToRecreate -> { + var piece = itemToRecreate.getPieceFromStorage(); + var checkInPiece = itemToRecreate.getCheckInPiece(); + var srcConfig = InventoryUtils.constructItemRecreateConfig(piece.getReceivingTenantId(), requestContext, true); + var dstConfig = InventoryUtils.constructItemRecreateConfig(checkInPiece.getReceivingTenantId(), requestContext, false); + if (InventoryUtils.allowItemRecreate(srcConfig.tenantId(), dstConfig.tenantId())) { + logger.info("recreateItemRecords:: recreating item by id '{}', srcTenantId: '{}', dstTenantId: '{}'", piece.getItemId(), srcConfig.tenantId(), dstConfig.tenantId()); + var compPO = purchaseOrderMap.get(itemToRecreate.getPoLineId()); + var itemIdFuture = itemRecreateInventoryService.recreateItemInDestinationTenant(compPO, itemToRecreate.getCompositePoLine(), + piece, srcConfig.context(), dstConfig.context()); + futures.add(itemIdFuture); + } + })); + + return collectResultsOnSuccess(futures) + .map(itemIdsRecreated -> { + itemIdsRecreated.forEach(itemIdRecreated -> + logger.info("recreateItemRecords:: recreated item by id '{}'", itemIdRecreated)); + return null; + }) + .compose(v -> Future.succeededFuture()); + }); } /** diff --git a/src/main/java/org/folio/orders/utils/PoLineCommonUtil.java b/src/main/java/org/folio/orders/utils/PoLineCommonUtil.java index 69650f045..b14bbbb81 100644 --- a/src/main/java/org/folio/orders/utils/PoLineCommonUtil.java +++ b/src/main/java/org/folio/orders/utils/PoLineCommonUtil.java @@ -290,4 +290,5 @@ private static void checkFieldsChanged(JsonPathParser oldObject, JsonPathParser throw new HttpException(400, error, parameters); } } + } diff --git a/src/main/java/org/folio/service/inventory/InventoryItemManager.java b/src/main/java/org/folio/service/inventory/InventoryItemManager.java index d3e7f68dc..2de5d2005 100644 --- a/src/main/java/org/folio/service/inventory/InventoryItemManager.java +++ b/src/main/java/org/folio/service/inventory/InventoryItemManager.java @@ -17,10 +17,10 @@ import org.folio.rest.core.models.RequestEntry; import org.folio.rest.jaxrs.model.BindItem; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Location; import org.folio.rest.jaxrs.model.Parameter; import org.folio.rest.jaxrs.model.Piece; -import org.folio.rest.jaxrs.model.PurchaseOrder; import org.folio.rest.jaxrs.model.ReceivedItem; import org.folio.service.caches.ConfigurationEntriesCache; import org.folio.service.caches.InventoryCache; @@ -175,7 +175,8 @@ public Future> deleteItems(List itemIds, boolean skipNotFound * @param location list of location holdingId is associated with * @return future with list of piece objects */ - public Future> handleItemRecords(CompositePoLine compPOL, Location location, RequestContext requestContext) { + public Future> handleItemRecords(CompositePurchaseOrder comPO, CompositePoLine compPOL, + Location location, RequestContext requestContext) { Map piecesWithItemsQuantities = HelperUtils.calculatePiecesWithItemIdQuantity(compPOL, List.of(location)); int piecesWithItemsQty = IntStreamEx.of(piecesWithItemsQuantities.values()).sum(); String polId = compPOL.getId(); @@ -205,11 +206,13 @@ public Future> handleItemRecords(CompositePoLine compPOL, Location l List existingItemIds; if (pieceFormat == Piece.Format.ELECTRONIC) { existingItemIds = getElectronicItemIds(compPOL, existingItems); - return createMissingElectronicItems(compPOL, pieceWithHoldingId, expectedQuantity - existingItemIds.size(), updatedRequestContext) + return createMissingElectronicItems(comPO, compPOL, pieceWithHoldingId, + expectedQuantity - existingItemIds.size(), updatedRequestContext) .map(createdItemIds -> buildPieces(location, polId, pieceFormat, createdItemIds, existingItemIds)); } else { existingItemIds = getPhysicalItemIds(compPOL, existingItems); - return createMissingPhysicalItems(compPOL, pieceWithHoldingId, expectedQuantity - existingItemIds.size(), updatedRequestContext) + return createMissingPhysicalItems(comPO, compPOL, pieceWithHoldingId, + expectedQuantity - existingItemIds.size(), updatedRequestContext) .map(createdItemIds -> buildPieces(location, polId, pieceFormat, createdItemIds, existingItemIds)); } }); @@ -306,18 +309,19 @@ public Future> getItemsByHoldingId(String holdingId, RequestCon }); } - public Future openOrderCreateItemRecord(CompositePoLine compPOL, String holdingId, RequestContext requestContext) { + public Future openOrderCreateItemRecord(CompositePurchaseOrder compPO, CompositePoLine compPOL, + String holdingId, RequestContext requestContext) { final int ITEM_QUANTITY = 1; logger.debug("Handling {} items for PO Line and holdings with id={}", ITEM_QUANTITY, holdingId); Promise itemFuture = Promise.promise(); try { Piece pieceWithHoldingId = new Piece().withHoldingId(holdingId); if (compPOL.getOrderFormat() == ELECTRONIC_RESOURCE) { - createMissingElectronicItems(compPOL, pieceWithHoldingId, ITEM_QUANTITY, requestContext) + createMissingElectronicItems(compPO, compPOL, pieceWithHoldingId, ITEM_QUANTITY, requestContext) .onSuccess(idS -> itemFuture.complete(idS.get(0))) .onFailure(itemFuture::fail); } else { - createMissingPhysicalItems(compPOL, pieceWithHoldingId, ITEM_QUANTITY, requestContext) + createMissingPhysicalItems(compPO, compPOL, pieceWithHoldingId, ITEM_QUANTITY, requestContext) .onSuccess(idS -> itemFuture.complete(idS.get(0))) .onFailure(itemFuture::fail); } @@ -336,12 +340,13 @@ public Future openOrderCreateItemRecord(CompositePoLine compPOL, String * @param quantity expected number of items to create * @return id of newly created Instance Record */ - public Future> createMissingElectronicItems(CompositePoLine compPOL, Piece piece, int quantity, RequestContext requestContext) { + public Future> createMissingElectronicItems(CompositePurchaseOrder compPO, CompositePoLine compPOL, + Piece piece, int quantity, RequestContext requestContext) { if (quantity <= 0) { return Future.succeededFuture(List.of()); } String holdingId = piece.getHoldingId(); - return buildElectronicItemRecordJsonObject(compPOL, holdingId, requestContext) + return buildElectronicItemRecordJsonObject(compPO, compPOL, holdingId, requestContext) .compose(item -> { InventoryUtils.updateItemWithPieceFields(item, piece); item.put(ID, piece.getItemId()); @@ -350,8 +355,9 @@ public Future> createMissingElectronicItems(CompositePoLine compPOL }); } - private Future buildElectronicItemRecordJsonObject(CompositePoLine compPOL, String holdingId, RequestContext requestContext) { - return buildBaseItemRecordJsonObject(compPOL, holdingId, requestContext) + private Future buildElectronicItemRecordJsonObject(CompositePurchaseOrder compPO, CompositePoLine compPOL, + String holdingId, RequestContext requestContext) { + return buildBaseItemRecordJsonObject(compPO, compPOL, holdingId, requestContext) .map(itemRecord -> itemRecord.put(ITEM_MATERIAL_TYPE_ID, compPOL.getEresource().getMaterialType())); } @@ -364,13 +370,14 @@ private Future buildElectronicItemRecordJsonObject(CompositePoLine c * @param quantity expected number of items to create * @return id of newly created Instance Record */ - public Future> createMissingPhysicalItems(CompositePoLine compPOL, Piece piece, int quantity, + public Future> createMissingPhysicalItems(CompositePurchaseOrder compPO, CompositePoLine compPOL, + Piece piece, int quantity, RequestContext requestContext) { if (quantity <= 0) { return Future.succeededFuture(List.of()); } String holdingId = piece.getHoldingId(); - return buildPhysicalItemRecordJsonObject(compPOL, holdingId, requestContext) + return buildPhysicalItemRecordJsonObject(compPO, compPOL, holdingId, requestContext) .compose(item -> { InventoryUtils.updateItemWithPieceFields(item, piece); item.put(ID, piece.getItemId()); @@ -379,33 +386,26 @@ public Future> createMissingPhysicalItems(CompositePoLine compPOL, }); } - private Future buildPhysicalItemRecordJsonObject(CompositePoLine compPOL, String holdingId, RequestContext requestContext) { - return buildBaseItemRecordJsonObject(compPOL, holdingId, requestContext) + private Future buildPhysicalItemRecordJsonObject(CompositePurchaseOrder compPO, CompositePoLine compPOL, + String holdingId, RequestContext requestContext) { + return buildBaseItemRecordJsonObject(compPO, compPOL, holdingId, requestContext) .map(itemRecord -> itemRecord.put(ITEM_MATERIAL_TYPE_ID, compPOL.getPhysical().getMaterialType())); } - private Future buildBaseItemRecordJsonObject(CompositePoLine compPOL, String holdingId, RequestContext requestContext) { + private Future buildBaseItemRecordJsonObject(CompositePurchaseOrder compPO, CompositePoLine compPOL, + String holdingId, RequestContext requestContext) { + String itemStatus = compPO.getWorkflowStatus().equals(CompositePurchaseOrder.WorkflowStatus.CLOSED) + ? ReceivedItem.ItemStatus.ORDER_CLOSED.value() + : ReceivedItem.ItemStatus.ON_ORDER.value(); return InventoryUtils.getLoanTypeId(configurationEntriesCache, inventoryCache, requestContext) .map(loanTypeId -> { JsonObject itemRecord = new JsonObject(); itemRecord.put(ITEM_HOLDINGS_RECORD_ID, holdingId); itemRecord.put(ITEM_PERMANENT_LOAN_TYPE_ID, loanTypeId); itemRecord.put(ITEM_PURCHASE_ORDER_LINE_IDENTIFIER, compPOL.getId()); + itemRecord.put(ITEM_STATUS, new JsonObject().put(ITEM_STATUS_NAME, itemStatus)); return itemRecord; - }) - .compose(itemRecord -> setItemStatus(compPOL, itemRecord, requestContext)); - } - - private Future setItemStatus(CompositePoLine compPOL, JsonObject itemRecord, RequestContext requestContext) { - return purchaseOrderStorageService.getPurchaseOrderById(compPOL.getPurchaseOrderId(), requestContext) - .map(compPO -> { - String itemStatus = compPO.getWorkflowStatus().equals(PurchaseOrder.WorkflowStatus.CLOSED) - ? ReceivedItem.ItemStatus.ORDER_CLOSED.value() - : ReceivedItem.ItemStatus.ON_ORDER.value(); - itemRecord.put(ITEM_STATUS, new JsonObject().put(ITEM_STATUS_NAME, itemStatus)); - return itemRecord; - } - ); + }); } public Future createBindItem(CompositePoLine compPOL, String holdingId, BindItem bindItem, RequestContext locationContext) { diff --git a/src/main/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderInventoryService.java b/src/main/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderInventoryService.java index 39e644be8..4b7d6bbfa 100644 --- a/src/main/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderInventoryService.java +++ b/src/main/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderInventoryService.java @@ -59,7 +59,7 @@ public Future processInventory(Map> lineIdsTitles, Com List> futures = new ArrayList<>(); for (CompositePoLine poLine : compPO.getCompositePoLines()) { semaphore.acquire(() -> { - Future future = processInventory(poLine, getFirstTitleIdIfExist(lineIdsTitles, poLine), isInstanceMatchingDisabled, requestContext) + Future future = processInventory(compPO, poLine, getFirstTitleIdIfExist(lineIdsTitles, poLine), isInstanceMatchingDisabled, requestContext) .onComplete(asyncResult -> semaphore.release()); futures.add(future); if (futures.size() == compPO.getCompositePoLines().size()) { @@ -72,14 +72,12 @@ public Future processInventory(Map> lineIdsTitles, Com .mapEmpty()); } - public Future processInventory(CompositePoLine compPOL, String titleId, boolean isInstanceMatchingDisabled, - RequestContext requestContext) { - - if (logger.isDebugEnabled()) { - logger.debug("Executing a strategy for: {}", compPOL.getOrderFormat().value()); - } - return processInventoryStrategyResolver.getHoldingAndItemStrategy(compPOL.getOrderFormat().value()) - .processInventory(compPOL, titleId, isInstanceMatchingDisabled, + public Future processInventory(CompositePurchaseOrder compPO, CompositePoLine compPOL, String titleId, + boolean isInstanceMatchingDisabled, RequestContext requestContext) { + logger.debug("processInventory:: Executing a strategy for: {}", compPOL.getOrderFormat().value()); + return processInventoryStrategyResolver + .getHoldingAndItemStrategy(compPOL.getOrderFormat().value()) + .processInventory(compPO, compPOL, titleId, isInstanceMatchingDisabled, inventoryItemManager, inventoryHoldingManager, inventoryInstanceManager, openCompositeOrderPieceService, restClient, requestContext); } diff --git a/src/main/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderPieceService.java b/src/main/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderPieceService.java index 84adfc51f..e0a697006 100644 --- a/src/main/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderPieceService.java +++ b/src/main/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderPieceService.java @@ -23,6 +23,7 @@ import org.folio.rest.core.exceptions.InventoryException; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Piece; import org.folio.rest.jaxrs.model.Title; import org.folio.service.ProtectionService; @@ -119,7 +120,7 @@ public Future createPiece(Piece piece, boolean isInstanceMatchingDisabled .compose(order -> titlesService.getTitleById(piece.getTitleId(), requestContext) .compose(title -> protectionService.isOperationRestricted(title.getAcqUnitIds(), ProtectedOperationType.CREATE, requestContext) .map(v -> order))) - .compose(order -> openOrderUpdateInventory(order.getCompositePoLines().get(0), piece, isInstanceMatchingDisabled, requestContext)) + .compose(order -> openOrderUpdateInventory(order, order.getCompositePoLines().get(0), piece, isInstanceMatchingDisabled, requestContext)) .compose(v -> pieceStorageService.insertPiece(piece, requestContext)); } @@ -162,7 +163,8 @@ public Future updatePieceRecord(Piece piece, RequestContext requestContext * @param compPOL Composite PO line to update Inventory for * @return CompletableFuture with void. */ - public Future openOrderUpdateInventory(CompositePoLine compPOL, Piece piece, boolean isInstanceMatchingDisabled, RequestContext requestContext) { + public Future openOrderUpdateInventory(CompositePurchaseOrder compPO, CompositePoLine compPOL, + Piece piece, boolean isInstanceMatchingDisabled, RequestContext requestContext) { if (!Boolean.TRUE.equals(compPOL.getIsPackage())) { return inventoryItemManager.updateItemWithPieceFields(piece, requestContext); } @@ -170,7 +172,7 @@ public Future openOrderUpdateInventory(CompositePoLine compPOL, Piece piec return titlesService.getTitleById(piece.getTitleId(), requestContext) .compose(title -> titlesService.updateTitleWithInstance(title, isInstanceMatchingDisabled, locationContext, requestContext).map(title::withInstanceId)) .compose(title -> getOrCreateHolding(compPOL, piece, title, locationContext)) - .compose(holdingId -> updateItemsIfNeeded(compPOL, holdingId, locationContext)) + .compose(holdingId -> updateItemsIfNeeded(compPO, compPOL, holdingId, locationContext)) .map(itemId -> Optional.ofNullable(itemId).map(piece::withItemId)) .mapEmpty(); } @@ -183,9 +185,10 @@ private Future getOrCreateHolding(CompositePoLine compPOL, Piece piece, .map(holdingId -> piece.withLocationId(null).withHoldingId(holdingId).getHoldingId()); } - private Future updateItemsIfNeeded(CompositePoLine compPOL, String holdingId, RequestContext locationContext) { + private Future updateItemsIfNeeded(CompositePurchaseOrder compPO, CompositePoLine compPOL, + String holdingId, RequestContext locationContext) { return PoLineCommonUtil.isItemsUpdateRequired(compPOL) - ? inventoryItemManager.openOrderCreateItemRecord(compPOL, holdingId, locationContext) + ? inventoryItemManager.openOrderCreateItemRecord(compPO, compPOL, holdingId, locationContext) : Future.succeededFuture(); } diff --git a/src/main/java/org/folio/service/pieces/ItemRecreateInventoryService.java b/src/main/java/org/folio/service/pieces/ItemRecreateInventoryService.java index 83da13296..082c62854 100644 --- a/src/main/java/org/folio/service/pieces/ItemRecreateInventoryService.java +++ b/src/main/java/org/folio/service/pieces/ItemRecreateInventoryService.java @@ -14,6 +14,7 @@ import org.folio.models.ItemStatus; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Piece; import org.folio.service.inventory.InventoryItemManager; import org.folio.service.pieces.flows.DefaultPieceFlowsValidator; @@ -30,7 +31,8 @@ public ItemRecreateInventoryService(InventoryItemManager inventoryItemManager) { } // Return an Id of the recreated Item - public Future recreateItemInDestinationTenant(CompositePoLine compPol, Piece piece, RequestContext srcLocCtx, RequestContext dstLocCtx) { + public Future recreateItemInDestinationTenant(CompositePurchaseOrder compPO, CompositePoLine compPol, + Piece piece, RequestContext srcLocCtx, RequestContext dstLocCtx) { // Example Case: Member Tenant 1 (University) -> Member Tenant 2 (College) // Create Item in Member Tenant 2 with the same Item Id // Delete Item in Member Tenant 1 by Item Id @@ -38,9 +40,9 @@ public Future recreateItemInDestinationTenant(CompositePoLine compPol, P Future> itemFuture; if (piece.getFormat() == Piece.Format.ELECTRONIC && DefaultPieceFlowsValidator.isCreateItemForElectronicPiecePossible(piece, compPol)) { - itemFuture = inventoryItemManager.createMissingElectronicItems(compPol, piece, ITEM_QUANTITY, dstLocCtx); + itemFuture = inventoryItemManager.createMissingElectronicItems(compPO, compPol, piece, ITEM_QUANTITY, dstLocCtx); } else if (DefaultPieceFlowsValidator.isCreateItemForNonElectronicPiecePossible(piece, compPol)) { - itemFuture = inventoryItemManager.createMissingPhysicalItems(compPol, piece, ITEM_QUANTITY, dstLocCtx); + itemFuture = inventoryItemManager.createMissingPhysicalItems(compPO, compPol, piece, ITEM_QUANTITY, dstLocCtx); } else { itemFuture = Future.succeededFuture(List.of()); } diff --git a/src/main/java/org/folio/service/pieces/PieceUpdateInventoryService.java b/src/main/java/org/folio/service/pieces/PieceUpdateInventoryService.java index 1f8847952..90a2c0be1 100644 --- a/src/main/java/org/folio/service/pieces/PieceUpdateInventoryService.java +++ b/src/main/java/org/folio/service/pieces/PieceUpdateInventoryService.java @@ -12,6 +12,7 @@ import org.apache.logging.log4j.Logger; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Piece; import org.folio.service.inventory.InventoryHoldingManager; import org.folio.service.inventory.InventoryItemManager; @@ -39,24 +40,28 @@ public PieceUpdateInventoryService(InventoryItemManager inventoryItemManager, /** * Return id of created Item */ - public Future manualPieceFlowCreateItemRecord(Piece piece, CompositePoLine compPOL, RequestContext requestContext) { + public Future manualPieceFlowCreateItemRecord(Piece piece, CompositePurchaseOrder compPO, + CompositePoLine compPOL, RequestContext requestContext) { final int ITEM_QUANTITY = 1; Promise itemFuture = Promise.promise(); try { - logger.debug("Handling {} items for PO Line and holdings with id={}", ITEM_QUANTITY, piece.getHoldingId()); - if (piece.getFormat() == Piece.Format.ELECTRONIC && DefaultPieceFlowsValidator.isCreateItemForElectronicPiecePossible(piece, compPOL)) { - inventoryItemManager.createMissingElectronicItems(compPOL, piece, ITEM_QUANTITY, requestContext) - .onSuccess(idS -> itemFuture.complete(idS.get(0))) - .onFailure(itemFuture::fail); - } else if (DefaultPieceFlowsValidator.isCreateItemForNonElectronicPiecePossible(piece, compPOL)) { - inventoryItemManager.createMissingPhysicalItems(compPOL, piece, ITEM_QUANTITY, requestContext) - .onSuccess(idS -> itemFuture.complete(idS.get(0))) - .onFailure(itemFuture::fail); - } - else { + logger.debug("manualPieceFlowCreateItemRecord:: Handling {} items for PO Line and holdings with id={}", + ITEM_QUANTITY, piece.getHoldingId()); + if (piece.getFormat() == Piece.Format.ELECTRONIC && DefaultPieceFlowsValidator.isCreateItemForElectronicPiecePossible(piece, compPOL)) { + inventoryItemManager.createMissingElectronicItems(compPO, compPOL, piece, ITEM_QUANTITY, requestContext) + .onSuccess(idS -> itemFuture.complete(idS.get(0))) + .onFailure(itemFuture::fail); + } else if (DefaultPieceFlowsValidator.isCreateItemForNonElectronicPiecePossible(piece, compPOL)) { + inventoryItemManager.createMissingPhysicalItems(compPO, compPOL, piece, ITEM_QUANTITY, requestContext) + .onSuccess(idS -> itemFuture.complete(idS.get(0))) + .onFailure(itemFuture::fail); + } else { + logger.warn("manualPieceFlowCreateItemRecord:: Creating Item is not possible for piece: {}, poLine: {}", + piece.getId(), compPOL.getId()); itemFuture.complete(null); } } catch (Exception e) { + logger.error("Error while creating item for piece:{} and comPOL: {}", piece.getId(), compPOL.getId(), e); itemFuture.fail(e); } return itemFuture.future(); diff --git a/src/main/java/org/folio/service/pieces/flows/create/PieceCreateFlowInventoryManager.java b/src/main/java/org/folio/service/pieces/flows/create/PieceCreateFlowInventoryManager.java index ba651b742..2e5430296 100644 --- a/src/main/java/org/folio/service/pieces/flows/create/PieceCreateFlowInventoryManager.java +++ b/src/main/java/org/folio/service/pieces/flows/create/PieceCreateFlowInventoryManager.java @@ -1,21 +1,22 @@ package org.folio.service.pieces.flows.create; +import static org.folio.orders.utils.RequestContextUtil.createContextWithNewTenantId; + import java.util.Optional; +import io.vertx.core.Future; import org.folio.orders.utils.PoLineCommonUtil; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Location; import org.folio.rest.jaxrs.model.Piece; import org.folio.service.inventory.InventoryHoldingManager; +import org.folio.service.orders.PurchaseOrderStorageService; import org.folio.service.pieces.PieceUpdateInventoryService; import org.folio.service.pieces.flows.DefaultPieceFlowsValidator; import org.folio.service.titles.TitlesService; -import io.vertx.core.Future; - -import static org.folio.orders.utils.RequestContextUtil.createContextWithNewTenantId; - public class PieceCreateFlowInventoryManager { private final TitlesService titlesService; @@ -30,11 +31,12 @@ public PieceCreateFlowInventoryManager(TitlesService titlesService, this.inventoryHoldingManager = inventoryHoldingManager; } - public Future processInventory(CompositePoLine compPOL, Piece piece, boolean createItem, RequestContext requestContext) { + public Future processInventory(CompositePurchaseOrder compPO, CompositePoLine compPOL, + Piece piece, boolean createItem, RequestContext requestContext) { var locationContext = createContextWithNewTenantId(requestContext, piece.getReceivingTenantId()); return updateInventoryInstanceForPoLine(compPOL, piece, locationContext, requestContext) .compose(instanceId -> handleHolding(compPOL, piece, instanceId, locationContext)) - .compose(holdingId -> handleItem(compPOL, createItem, piece, locationContext)) + .compose(holdingId -> handleItem(compPO, compPOL, createItem, piece, locationContext)) .map(itemId -> Optional.ofNullable(itemId).map(piece::withItemId)) .mapEmpty(); } @@ -73,10 +75,11 @@ private Future handleHolding(CompositePoLine compPOL, Piece piece, Str }); } - private Future handleItem(CompositePoLine compPOL, boolean createItem, Piece piece, RequestContext requestContext) { + private Future handleItem(CompositePurchaseOrder compPO, CompositePoLine compPOL, boolean createItem, + Piece piece, RequestContext requestContext) { return piece.getItemId() != null || !createItem || piece.getHoldingId() == null ? Future.succeededFuture(piece.getItemId()) - : pieceUpdateInventoryService.manualPieceFlowCreateItemRecord(piece, compPOL, requestContext); + : pieceUpdateInventoryService.manualPieceFlowCreateItemRecord(piece, compPO, compPOL, requestContext); } } diff --git a/src/main/java/org/folio/service/pieces/flows/create/PieceCreateFlowManager.java b/src/main/java/org/folio/service/pieces/flows/create/PieceCreateFlowManager.java index b814713fa..c11247c37 100644 --- a/src/main/java/org/folio/service/pieces/flows/create/PieceCreateFlowManager.java +++ b/src/main/java/org/folio/service/pieces/flows/create/PieceCreateFlowManager.java @@ -41,7 +41,7 @@ public Future createPiece(Piece pieceToCreate, boolean createItem, Reques .compose(aHolder -> basePieceFlowHolderBuilder.updateHolderWithTitleInformation(holder, requestContext)) .map(v -> {defaultPieceFlowsValidator.isPieceRequestValid(pieceToCreate, holder.getOriginPoLine(), createItem); return null;}) .compose(order -> protectionService.isOperationRestricted(holder.getTitle().getAcqUnitIds(), ProtectedOperationType.CREATE, requestContext)) - .compose(v -> pieceCreateFlowInventoryManager.processInventory(holder.getOriginPoLine(), holder.getPieceToCreate(), holder.isCreateItem(), requestContext)) + .compose(v -> pieceCreateFlowInventoryManager.processInventory(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), holder.getPieceToCreate(), holder.isCreateItem(), requestContext)) .compose(compPoLine -> updatePoLine(holder, requestContext)) .compose(v -> pieceStorageService.insertPiece(pieceToCreate, requestContext)); } diff --git a/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryElectronicStrategy.java b/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryElectronicStrategy.java index 077762c05..2c3413b1e 100644 --- a/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryElectronicStrategy.java +++ b/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryElectronicStrategy.java @@ -10,6 +10,7 @@ import org.folio.rest.core.RestClient; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Piece; import org.folio.service.consortium.ConsortiumConfigurationService; import org.folio.service.inventory.InventoryHoldingManager; @@ -23,16 +24,17 @@ public ProcessInventoryElectronicStrategy(ConsortiumConfigurationService consort super(consortiumConfigurationService); } - public Future> handleHoldingsAndItemsRecords(CompositePoLine compPOL, - InventoryItemManager inventoryItemManager, - InventoryHoldingManager inventoryHoldingManager, - RestClient restClient, - RequestContext requestContext) { + public Future> handleHoldingsAndItemsRecords(CompositePurchaseOrder compPO, + CompositePoLine compPOL, + InventoryItemManager inventoryItemManager, + InventoryHoldingManager inventoryHoldingManager, + RestClient restClient, + RequestContext requestContext) { List>> itemsPerHolding = new ArrayList<>(); // Group all locations by location id because the holding should be unique for different locations if (PoLineCommonUtil.isHoldingUpdateRequiredForEresource(compPOL)) { - itemsPerHolding = updateHolding(compPOL, inventoryItemManager, inventoryHoldingManager, restClient, requestContext); + itemsPerHolding = updateHolding(compPO, compPOL, inventoryItemManager, inventoryHoldingManager, restClient, requestContext); } return collectResultsOnSuccess(itemsPerHolding) .map(itemCreated -> itemCreated.stream() diff --git a/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryMixedStrategy.java b/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryMixedStrategy.java index e8b7860d6..a2d64a0d1 100755 --- a/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryMixedStrategy.java +++ b/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryMixedStrategy.java @@ -15,6 +15,7 @@ import org.folio.rest.core.RestClient; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Location; import org.folio.rest.jaxrs.model.Piece; import org.folio.service.consortium.ConsortiumConfigurationService; @@ -30,7 +31,8 @@ public ProcessInventoryMixedStrategy(ConsortiumConfigurationService consortiumCo super(consortiumConfigurationService); } - public Future> handleHoldingsAndItemsRecords(CompositePoLine compPOL, + public Future> handleHoldingsAndItemsRecords(CompositePurchaseOrder compPO, + CompositePoLine compPOL, InventoryItemManager inventoryItemManager, InventoryHoldingManager inventoryHoldingManager, RestClient restClient, @@ -45,7 +47,7 @@ public Future> handleHoldingsAndItemsRecords(CompositePoLine compPOL List>> pieceFutures = new ArrayList<>(); if (PoLineCommonUtil.isItemsUpdateRequired(compPOL)) { for (Location location : compPOL.getLocations()) { - pieceFutures.add(inventoryItemManager.handleItemRecords(compPOL, location, requestContext)); + pieceFutures.add(inventoryItemManager.handleItemRecords(compPO, compPOL, location, requestContext)); } } else { pieceFutures.add(Future.succeededFuture(Collections.emptyList())); diff --git a/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryPhysicalStrategy.java b/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryPhysicalStrategy.java index 53bb4fdec..6ae6a5b9b 100644 --- a/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryPhysicalStrategy.java +++ b/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryPhysicalStrategy.java @@ -10,6 +10,7 @@ import org.folio.rest.core.RestClient; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Piece; import org.folio.service.consortium.ConsortiumConfigurationService; import org.folio.service.inventory.InventoryHoldingManager; @@ -23,7 +24,8 @@ public ProcessInventoryPhysicalStrategy(ConsortiumConfigurationService consortiu super(consortiumConfigurationService); } - public Future> handleHoldingsAndItemsRecords(CompositePoLine compPOL, + public Future> handleHoldingsAndItemsRecords(CompositePurchaseOrder compPO, + CompositePoLine compPOL, InventoryItemManager inventoryItemManager, InventoryHoldingManager inventoryHoldingManager, RestClient restClient, @@ -32,7 +34,7 @@ public Future> handleHoldingsAndItemsRecords(CompositePoLine compPOL // Group all locations by location id because the holding should be unique for different locations if (PoLineCommonUtil.isHoldingUpdateRequiredForPhysical(compPOL)) { - itemsPerHolding = updateHolding(compPOL, inventoryItemManager, inventoryHoldingManager, restClient, requestContext); + itemsPerHolding = updateHolding(compPO, compPOL, inventoryItemManager, inventoryHoldingManager, restClient, requestContext); } return collectResultsOnSuccess(itemsPerHolding) .map(itemCreated -> itemCreated.stream() diff --git a/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryStrategy.java b/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryStrategy.java index d2bc3b521..ff7dd592e 100644 --- a/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryStrategy.java +++ b/src/main/java/org/folio/service/pieces/flows/strategies/ProcessInventoryStrategy.java @@ -13,6 +13,7 @@ import org.folio.rest.core.models.RequestContext; import org.folio.rest.core.models.RequestEntry; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Location; import org.folio.rest.jaxrs.model.Piece; import org.folio.service.consortium.ConsortiumConfigurationService; @@ -45,7 +46,8 @@ protected ProcessInventoryStrategy(ConsortiumConfigurationService consortiumConf * @param compPOL PO line to retrieve/create Item Records for. At this step PO Line must contain instance Id * @return future with list of pieces with item and location id's */ - protected abstract Future> handleHoldingsAndItemsRecords(CompositePoLine compPOL, + protected abstract Future> handleHoldingsAndItemsRecords(CompositePurchaseOrder comPO, + CompositePoLine compPOL, InventoryItemManager inventoryItemManager, InventoryHoldingManager inventoryHoldingManager, RestClient restClient, @@ -57,7 +59,8 @@ protected abstract Future> handleHoldingsAndItemsRecords(CompositePo * @param compPOL Composite PO line to update Inventory for * @return CompletableFuture with void. */ - public Future processInventory(CompositePoLine compPOL, String titleId, + public Future processInventory(CompositePurchaseOrder compPO, + CompositePoLine compPOL, String titleId, boolean isInstanceMatchingDisabled, InventoryItemManager inventoryItemManager, InventoryHoldingManager inventoryHoldingManager, @@ -75,13 +78,14 @@ public Future processInventory(CompositePoLine compPOL, String titleId, } return inventoryInstanceManager.openOrderHandleInstance(compPOL, isInstanceMatchingDisabled, requestContext) - .compose(compPOLWithInstanceId -> handleHoldingsAndItemsRecords( - compPOLWithInstanceId, inventoryItemManager, inventoryHoldingManager, restClient, requestContext)) + .compose(compPOLWithInstanceId -> handleHoldingsAndItemsRecords(compPO, compPOLWithInstanceId, + inventoryItemManager, inventoryHoldingManager, restClient, requestContext)) .compose(piecesWithItemId -> handlePieces(compPOL, titleId, piecesWithItemId, isInstanceMatchingDisabled, requestContext, openCompositeOrderPieceService)); } - protected List>> updateHolding(CompositePoLine compPOL, + protected List>> updateHolding(CompositePurchaseOrder compPO, + CompositePoLine compPOL, InventoryItemManager inventoryItemManager, InventoryHoldingManager inventoryHoldingManager, RestClient restClient, @@ -97,7 +101,7 @@ protected List>> updateHolding(CompositePoLine compPOL, // Items are not going to be created when create inventory is "Instance, Holding" exchangeLocationIdWithHoldingId(location, holdingId); if (PoLineCommonUtil.isItemsUpdateRequired(compPOL)) { - return inventoryItemManager.handleItemRecords(compPOL, location, requestContext); + return inventoryItemManager.handleItemRecords(compPO, compPOL, location, requestContext); } else { return Future.succeededFuture(Collections.emptyList()); } diff --git a/src/main/java/org/folio/service/pieces/flows/update/PieceUpdateFlowInventoryManager.java b/src/main/java/org/folio/service/pieces/flows/update/PieceUpdateFlowInventoryManager.java index 8cf47b8b9..2ea953726 100644 --- a/src/main/java/org/folio/service/pieces/flows/update/PieceUpdateFlowInventoryManager.java +++ b/src/main/java/org/folio/service/pieces/flows/update/PieceUpdateFlowInventoryManager.java @@ -124,7 +124,8 @@ private Future handleItem(PieceUpdateHolder holder, RequestContext reque updateItemWithFields(jsonItem, poLineToSave, pieceToUpdate); if (InventoryUtils.allowItemRecreate(srcConfig.tenantId(), dstConfig.tenantId())) { logger.info("handleItem:: recreating item by id '{}', srcTenantId: '{}', dstTenantId: '{}'", itemId, srcConfig.tenantId(), dstConfig.tenantId()); - return itemRecreateInventoryService.recreateItemInDestinationTenant(holder.getPoLineToSave(), holder.getPieceToUpdate(), srcConfig.context(), dstConfig.context()); + return itemRecreateInventoryService.recreateItemInDestinationTenant(holder.getPurchaseOrderToSave(), + holder.getPoLineToSave(), holder.getPieceToUpdate(), srcConfig.context(), dstConfig.context()); } else { logger.info("handleItem:: updating item by id '{}'", itemId); return inventoryItemManager.updateItem(jsonItem, requestContext).map(v -> jsonItem.getString(ID)); @@ -132,7 +133,7 @@ private Future handleItem(PieceUpdateHolder holder, RequestContext reque } if (holder.isCreateItem() && pieceToUpdate.getHoldingId() != null) { logger.info("handleItem:: creating item by id '{}'", itemId); - return pieceUpdateInventoryService.manualPieceFlowCreateItemRecord(pieceToUpdate, poLineToSave, requestContext); + return pieceUpdateInventoryService.manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), poLineToSave, requestContext); } else { return Future.succeededFuture(); } diff --git a/src/test/java/org/folio/helper/CheckinHelperTest.java b/src/test/java/org/folio/helper/CheckinHelperTest.java index 9dcd20440..fe2913534 100644 --- a/src/test/java/org/folio/helper/CheckinHelperTest.java +++ b/src/test/java/org/folio/helper/CheckinHelperTest.java @@ -50,6 +50,7 @@ import org.folio.service.inventory.InventoryInstanceManager; import org.folio.service.inventory.InventoryItemManager; import org.folio.service.orders.PurchaseOrderLineService; +import org.folio.service.orders.PurchaseOrderStorageService; import org.folio.service.pieces.ItemRecreateInventoryService; import org.folio.service.pieces.PieceStorageService; import org.folio.service.pieces.flows.create.PieceCreateFlowInventoryManager; @@ -76,6 +77,8 @@ public class CheckinHelperTest { PieceUpdateFlowPoLineService pieceUpdateFlowPoLineService; @Autowired ItemRecreateInventoryService itemRecreateInventoryService; + @Autowired + PurchaseOrderStorageService purchaseOrderStorageService; private Map okapiHeadersMock; private RequestContext requestContext; @@ -338,5 +341,9 @@ PurchaseOrderLineService purchaseOrderLineService() { ItemRecreateInventoryService itemRecreateInventoryService() { return mock(ItemRecreateInventoryService.class); } + @Bean + PurchaseOrderStorageService purchaseOrderStorageService() { + return mock(PurchaseOrderStorageService.class); + } } } diff --git a/src/test/java/org/folio/rest/impl/CheckinReceivingApiTest.java b/src/test/java/org/folio/rest/impl/CheckinReceivingApiTest.java index 00300bf6c..ce3a12620 100644 --- a/src/test/java/org/folio/rest/impl/CheckinReceivingApiTest.java +++ b/src/test/java/org/folio/rest/impl/CheckinReceivingApiTest.java @@ -119,6 +119,7 @@ import static org.folio.rest.impl.MockServer.getPoLineBatchUpdates; import static org.folio.rest.impl.MockServer.getPoLineSearches; import static org.folio.rest.impl.MockServer.getPoLineUpdates; +import static org.folio.rest.impl.MockServer.getPurchaseOrderRetrievals; import static org.folio.rest.impl.MockServer.getUpdatedTitles; import static org.folio.rest.jaxrs.model.ProcessingStatus.Type.SUCCESS; import static org.folio.rest.jaxrs.model.ReceivedItem.ItemStatus.ON_ORDER; @@ -695,14 +696,15 @@ void testPostCheckInPhysicalFullyReceivedWithChangedLocation() { private static Stream testPostCheckInPhysicalFullyReceivedEcsArgs() { return Stream.of( - Arguments.of(12, "checkin-fully-receive-physical-resource-ecs-single.json", 1, 2), - Arguments.of(13, "checkin-fully-receive-physical-resource-ecs-multiple.json", 2, 3) + Arguments.of(12, "checkin-fully-receive-physical-resource-ecs-single.json", 1, 4, 1), + Arguments.of(13, "checkin-fully-receive-physical-resource-ecs-multiple.json", 2, 5, 1) ); } @ParameterizedTest @MethodSource("testPostCheckInPhysicalFullyReceivedEcsArgs") - void testPostCheckInPhysicalFullyReceivedEcs(int poLineIdx, String checkInCollectionPath, int processedSuccessfullyCount, int polSearchesCount) { + void testPostCheckInPhysicalFullyReceivedEcs(int poLineIdx, String checkInCollectionPath, + int processedSuccessfullyCount, int polSearchesCount, int purchaseOrderSearchesCount) { logger.info("=== Test POST check-in - Check-in Fully Received physical resource with changed affiliation in a ECS environment ==="); CompositePoLine compositePoLine = getMockAsJson(POLINES_COLLECTION).getJsonArray("poLines").getJsonObject(poLineIdx).mapTo(CompositePoLine.class); @@ -726,6 +728,7 @@ void testPostCheckInPhysicalFullyReceivedEcs(int poLineIdx, String checkInCollec List pieceSearches = getPieceSearches(); List pieceUpdates = getPieceUpdates(); List polSearches = getPoLineSearches(); + List purchaseOrderSearches = getPurchaseOrderRetrievals(); List polBatchUpdates = getPoLineBatchUpdates(); List itemsSearches = getItemsSearches(); List itemUpdates = getItemUpdates(); @@ -737,12 +740,12 @@ void testPostCheckInPhysicalFullyReceivedEcs(int poLineIdx, String checkInCollec assertThat(polSearches, not(nullValue())); int expectedSearchRqQty = Math.floorDiv(checkinCollection.getTotalRecords(), MAX_IDS_FOR_GET_RQ_15) + 1; - // The piece searches should be made 2 times: 1st time to get all required piece records, 2nd time to calculate expected PO Line status assertThat(pieceSearches, hasSize(expectedSearchRqQty + pieceIdsByPol.size())); assertThat(pieceUpdates, hasSize(checkinCollection.getTotalRecords())); // Should be >1 due to an extra call performed in CheckinHelper.createItemsWithPieceUpdate per CheckInPiece assertThat(polSearches, hasSize(polSearchesCount)); + assertThat(purchaseOrderSearches, hasSize(purchaseOrderSearchesCount)); assertThat(polBatchUpdates, hasSize(pieceIdsByPol.size())); JsonArray poLinesJson = polBatchUpdates.get(0).getJsonArray("poLines"); diff --git a/src/test/java/org/folio/service/inventory/InventoryManagerTest.java b/src/test/java/org/folio/service/inventory/InventoryManagerTest.java index ad1c27cbf..b7e40ad93 100644 --- a/src/test/java/org/folio/service/inventory/InventoryManagerTest.java +++ b/src/test/java/org/folio/service/inventory/InventoryManagerTest.java @@ -76,11 +76,11 @@ import org.folio.rest.core.models.RequestContext; import org.folio.rest.core.models.RequestEntry; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Eresource; import org.folio.rest.jaxrs.model.Error; import org.folio.rest.jaxrs.model.Location; import org.folio.rest.jaxrs.model.Piece; -import org.folio.rest.jaxrs.model.PurchaseOrder; import org.folio.rest.jaxrs.model.Title; import org.folio.service.caches.ConfigurationEntriesCache; import org.folio.service.caches.InventoryCache; @@ -316,6 +316,7 @@ void testShouldNotDeleteItemIfProvidedListEmpty() { @Test void testShouldNotHandleItemRecordsIfCheckinItemsIsTrue() { + CompositePurchaseOrder order = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); CompositePoLine reqData = getMockAsJson(COMP_PO_LINES_MOCK_DATA_PATH, "c2755a78-2f8d-47d0-a218-059a9b7391b4").mapTo(CompositePoLine.class); String poLineId = "c0d08448-347b-418a-8c2f-5fb50248d67e"; reqData.setId(poLineId); @@ -327,7 +328,7 @@ void testShouldNotHandleItemRecordsIfCheckinItemsIsTrue() { //When Location location = new Location().withLocationId("758258bc-ecc1-41b8-abca-f7b610822fff"); - List pieces = inventoryItemManager.handleItemRecords(reqData, location, requestContext).result(); + List pieces = inventoryItemManager.handleItemRecords(order, reqData, location, requestContext).result(); assertEquals(0, pieces.size()); } @@ -532,7 +533,7 @@ void testShouldNotCreateInstanceRecordIfInstancesFoundInDB() throws IOException @Test void testShouldCreateItemRecordForEresources() { - //given + CompositePurchaseOrder order = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); Eresource eresource = new Eresource().withMaterialType(line.getPhysical().getMaterialType()) .withCreateInventory(Eresource.CreateInventory.INSTANCE_HOLDING_ITEM); @@ -540,59 +541,53 @@ void testShouldCreateItemRecordForEresources() { line.setEresource(eresource); line.setOrderFormat(CompositePoLine.OrderFormat.ELECTRONIC_RESOURCE); String expItemId = UUID.randomUUID().toString(); + doReturn(succeededFuture(Collections.singletonList(expItemId))) - .when(inventoryItemManager).createMissingElectronicItems(any(CompositePoLine.class), any(Piece.class), eq(1), eq(requestContext)); - //When - Future result = inventoryItemManager.openOrderCreateItemRecord(line, HOLDING_ID, requestContext); + .when(inventoryItemManager).createMissingElectronicItems(any(CompositePurchaseOrder.class), any(CompositePoLine.class), + any(Piece.class), eq(1), eq(requestContext)); + + Future result = inventoryItemManager.openOrderCreateItemRecord(order, line, HOLDING_ID, requestContext); String actItemId = result.result(); - //Then - verify(inventoryItemManager).createMissingElectronicItems(any(CompositePoLine.class), any(Piece.class), eq(1), eq(requestContext)); + + verify(inventoryItemManager).createMissingElectronicItems(any(CompositePurchaseOrder.class), any(CompositePoLine.class), any(Piece.class), eq(1), eq(requestContext)); assertEquals(expItemId, actItemId); } @Test void testShouldProvideCorrectErrorCodeWhenItemCreatingFailed() { - //given - PurchaseOrder purchaseOrder = new PurchaseOrder() - .withId(UUID.randomUUID().toString()) - .withWorkflowStatus(PurchaseOrder.WorkflowStatus.CLOSED); + CompositePurchaseOrder order = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); + order.setWorkflowStatus(CompositePurchaseOrder.WorkflowStatus.CLOSED); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); - line.setPurchaseOrderId(purchaseOrder.getId()); + line.setPurchaseOrderId(order.getId()); Piece piece = getMockAsJson(PIECE_PATH,"pieceRecord").mapTo(Piece.class); doReturn(Future.failedFuture(new HttpException(500, "Something went wrong!"))) .when(restClient).postJsonObjectAndGetId(any(RequestEntry.class), any(JsonObject.class), any(RequestContext.class)); doReturn(Future.succeededFuture(new JsonObject())).when(configurationEntriesCache).loadConfiguration(ORDER_CONFIG_MODULE_NAME, requestContext); doReturn(Future.succeededFuture(new JsonObject())).when(inventoryCache).getEntryId(LOAN_TYPES, DEFAULT_LOAN_TYPE_NAME, requestContext); - doReturn(Future.succeededFuture(purchaseOrder)).when(purchaseOrderStorageService).getPurchaseOrderById(any(), any()); - //When - Future> result = inventoryItemManager.createMissingPhysicalItems(line, piece, 1, requestContext); + Future> result = inventoryItemManager.createMissingPhysicalItems(order, line, piece, 1, requestContext); HttpException cause = (HttpException) result.cause(); - //Then assertEquals(ITEM_CREATION_FAILED.getCode(), cause.getError().getCode()); assertEquals("Something went wrong!", cause.getError().getParameters().get(0).getValue()); } @Test void testShouldProvideCorrectBarcodeNotUniqueErrorCode() { - //given - PurchaseOrder purchaseOrder = new PurchaseOrder() - .withId(UUID.randomUUID().toString()) - .withWorkflowStatus(PurchaseOrder.WorkflowStatus.CLOSED); + CompositePurchaseOrder order = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); + order.setWorkflowStatus(CompositePurchaseOrder.WorkflowStatus.CLOSED); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); - line.setPurchaseOrderId(purchaseOrder.getId()); + line.setPurchaseOrderId(order.getId()); Piece piece = getMockAsJson(PIECE_PATH,"pieceRecord").mapTo(Piece.class); doReturn(Future.failedFuture(new HttpException(500, InventoryItemManager.BARCODE_ALREADY_EXIST_ERROR))) .when(restClient).postJsonObjectAndGetId(any(RequestEntry.class), any(JsonObject.class), any(RequestContext.class)); doReturn(Future.succeededFuture(new JsonObject())).when(configurationEntriesCache).loadConfiguration(ORDER_CONFIG_MODULE_NAME, requestContext); doReturn(Future.succeededFuture(new JsonObject())).when(inventoryCache).getEntryId(LOAN_TYPES, DEFAULT_LOAN_TYPE_NAME, requestContext); - doReturn(Future.succeededFuture(purchaseOrder)).when(purchaseOrderStorageService).getPurchaseOrderById(any(), any()); //When - Future> result = inventoryItemManager.createMissingPhysicalItems(line, piece, 1, requestContext); + Future> result = inventoryItemManager.createMissingPhysicalItems(order, line, piece, 1, requestContext); HttpException cause = (HttpException) result.cause(); //Then @@ -601,11 +596,10 @@ void testShouldProvideCorrectBarcodeNotUniqueErrorCode() { @Test void testShouldCreateItemWithClosedStatusWhenOrderClosed() { - PurchaseOrder purchaseOrder = new PurchaseOrder() - .withId(UUID.randomUUID().toString()) - .withWorkflowStatus(PurchaseOrder.WorkflowStatus.CLOSED); + CompositePurchaseOrder order = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); + order.setWorkflowStatus(CompositePurchaseOrder.WorkflowStatus.CLOSED); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); - line.setPurchaseOrderId(purchaseOrder.getId()); + line.setPurchaseOrderId(order.getId()); Piece piece = getMockAsJson(PIECE_PATH,"pieceRecord").mapTo(Piece.class); JsonObject itemRecord = getMockAsJson(ITEM_RECORD_PATH); String expItemId = itemRecord.getString("id"); @@ -614,33 +608,51 @@ void testShouldCreateItemWithClosedStatusWhenOrderClosed() { .when(restClient).postJsonObjectAndGetId(any(RequestEntry.class), eq(itemRecord), any(RequestContext.class)); doReturn(Future.succeededFuture(new JsonObject())).when(configurationEntriesCache).loadConfiguration(ORDER_CONFIG_MODULE_NAME, requestContext); doReturn(Future.succeededFuture(new JsonObject())).when(inventoryCache).getEntryId(LOAN_TYPES, DEFAULT_LOAN_TYPE_NAME, requestContext); - doReturn(Future.succeededFuture(purchaseOrder)).when(purchaseOrderStorageService).getPurchaseOrderById(any(), any()); - Future> result = inventoryItemManager.createMissingPhysicalItems(line, piece, 1, requestContext); + Future> result = inventoryItemManager.createMissingPhysicalItems(order, line, piece, 1, requestContext); + assertEquals(expItemId, result.result().get(0)); + } + + @Test + void testShouldCreateItemWithOnOrderStatusWhenOrderNotFoundInMemberTenant() { + CompositePurchaseOrder order = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); + order.setWorkflowStatus(CompositePurchaseOrder.WorkflowStatus.CLOSED); + CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); + line.setPurchaseOrderId(order.getId()); + Piece piece = getMockAsJson(PIECE_PATH,"pieceRecord").mapTo(Piece.class); + JsonObject itemRecord = getMockAsJson(ITEM_RECORD_PATH); + String expItemId = itemRecord.getString("id"); + + doReturn(Future.succeededFuture(expItemId)) + .when(restClient).postJsonObjectAndGetId(any(RequestEntry.class), eq(itemRecord), any(RequestContext.class)); + doReturn(Future.succeededFuture(new JsonObject())).when(configurationEntriesCache).loadConfiguration(ORDER_CONFIG_MODULE_NAME, requestContext); + doReturn(Future.succeededFuture(new JsonObject())).when(inventoryCache).getEntryId(LOAN_TYPES, DEFAULT_LOAN_TYPE_NAME, requestContext); + + Future> result = inventoryItemManager.createMissingPhysicalItems(order, line, piece, 1, requestContext); assertEquals(expItemId, result.result().get(0)); } @Test void testShouldCreateItemRecordForPhysical() { //given + CompositePurchaseOrder order = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); String expItemId = UUID.randomUUID().toString(); doReturn(succeededFuture(Collections.singletonList(expItemId))) - .when(inventoryItemManager).createMissingPhysicalItems(any(CompositePoLine.class), any(Piece.class), eq(1), eq(requestContext)); - //When - Future result = inventoryItemManager.openOrderCreateItemRecord(line, HOLDING_ID, requestContext); + .when(inventoryItemManager).createMissingPhysicalItems(any(CompositePurchaseOrder.class), any(CompositePoLine.class), any(Piece.class), eq(1), eq(requestContext)); + + Future result = inventoryItemManager.openOrderCreateItemRecord(order, line, HOLDING_ID, requestContext); String actItemId = result.result(); - //Then - verify(inventoryItemManager).createMissingPhysicalItems(any(CompositePoLine.class), any(Piece.class), eq(1), eq(requestContext)); + + verify(inventoryItemManager).createMissingPhysicalItems(any(CompositePurchaseOrder.class), any(CompositePoLine.class), any(Piece.class), eq(1), eq(requestContext)); assertEquals(expItemId, actItemId); } @Test void testUpdateInventoryNegativeCaseIfPOLIsNull() { - //When - Future result = inventoryItemManager.openOrderCreateItemRecord(null, UUID.randomUUID().toString(), requestContext); - //Then + Future result = inventoryItemManager.openOrderCreateItemRecord(null, null, UUID.randomUUID().toString(), requestContext); + assertTrue(result.failed()); } diff --git a/src/test/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderInventoryServiceTest.java b/src/test/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderInventoryServiceTest.java index f21d4ebcc..8eea94c12 100644 --- a/src/test/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderInventoryServiceTest.java +++ b/src/test/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderInventoryServiceTest.java @@ -10,6 +10,7 @@ import org.folio.rest.core.RestClient; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.CompositePoLine; +import org.folio.rest.jaxrs.model.CompositePurchaseOrder; import org.folio.rest.jaxrs.model.Location; import org.folio.service.consortium.ConsortiumConfigurationService; import org.folio.service.inventory.InventoryHoldingManager; @@ -55,6 +56,7 @@ import static org.folio.rest.impl.MockServer.BASE_MOCK_DATA_PATH; import static org.folio.rest.impl.MockServer.HOLDINGS_OLD_NEW_PATH; import static org.folio.rest.tools.utils.TenantTool.tenantId; +import static org.folio.service.inventory.InventoryManagerTest.ORDER_PATH; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.any; import static org.mockito.Mockito.anyBoolean; @@ -120,6 +122,7 @@ public static void after() { @Test void shouldFoundHoldingIdByLocationId() throws IOException { String titleId = UUID.randomUUID().toString(); + CompositePurchaseOrder purchaseOrder = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); JsonObject holdingsCollection = new JsonObject(getMockData(HOLDINGS_OLD_NEW_PATH)); @@ -127,7 +130,8 @@ void shouldFoundHoldingIdByLocationId() throws IOException { doReturn(succeededFuture(holdingsCollection)).when(restClient).getAsJsonObject(any(), eq(requestContext)); doReturn(succeededFuture(requestContext)).when(consortiumConfigurationService).cloneRequestContextIfNeeded(any(), any()); - openCompositeOrderInventoryService.processInventory(line, titleId, false, requestContext).result(); + openCompositeOrderInventoryService.processInventory(purchaseOrder, line, titleId, false, requestContext) + .result(); assertEquals(line.getLocations().get(0).getHoldingId(), "65cb2bf0-d4c2-4886-8ad0-b76f1ba75d63"); verify(processInventoryStrategyResolver, times(1)).getHoldingAndItemStrategy(any()); @@ -139,6 +143,7 @@ void shouldUseClonedRequestContextBasedOnLocationWhenTenantSpecified() throws IO String titleId = UUID.randomUUID().toString(); Location location = new Location().withLocationId(UUID.randomUUID().toString()).withTenantId(RandomStringUtils.random(4)); + CompositePurchaseOrder purchaseOrder = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); line.setLocations(Collections.singletonList(location)); RequestContext newContext = RequestContextUtil.createContextWithNewTenantId(requestContext, location.getTenantId()); @@ -149,7 +154,7 @@ void shouldUseClonedRequestContextBasedOnLocationWhenTenantSpecified() throws IO doReturn(succeededFuture(holdingsCollection)).when(restClient).getAsJsonObject(any(), requestContextCaptor.capture()); doReturn(succeededFuture(newContext)).when(consortiumConfigurationService).cloneRequestContextIfNeeded(any(), any()); - openCompositeOrderInventoryService.processInventory(line, titleId, false, requestContext).result(); + openCompositeOrderInventoryService.processInventory(purchaseOrder, line, titleId, false, requestContext).result(); RequestContext capturedRequestContext = requestContextCaptor.getValue(); assertEquals(location.getTenantId(), tenantId(capturedRequestContext.getHeaders())); @@ -161,6 +166,7 @@ void shouldNotUseClonedRequestContextBasedOnLocationWhenTenantNotSpecified() thr String titleId = UUID.randomUUID().toString(); Location location = new Location().withLocationId(UUID.randomUUID().toString()); + CompositePurchaseOrder purchaseOrder = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); line.setLocations(Collections.singletonList(location)); Optional configuration = Optional.of(new ConsortiumConfiguration(UUID.randomUUID().toString(), UUID.randomUUID().toString())); @@ -171,7 +177,7 @@ void shouldNotUseClonedRequestContextBasedOnLocationWhenTenantNotSpecified() thr doReturn(succeededFuture(holdingsCollection)).when(restClient).getAsJsonObject(any(), requestContextCaptor.capture()); doReturn(succeededFuture(requestContext)).when(consortiumConfigurationService).cloneRequestContextIfNeeded(any(), any()); - openCompositeOrderInventoryService.processInventory(line, titleId, false, requestContext).result(); + openCompositeOrderInventoryService.processInventory(purchaseOrder, line, titleId, false, requestContext).result(); RequestContext capturedRequestContext = requestContextCaptor.getValue(); assertEquals(tenantId(okapiHeadersMock), tenantId(capturedRequestContext.getHeaders())); diff --git a/src/test/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderPieceServiceTest.java b/src/test/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderPieceServiceTest.java index d52f7ae66..c8d95379d 100644 --- a/src/test/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderPieceServiceTest.java +++ b/src/test/java/org/folio/service/orders/flows/update/open/OpenCompositeOrderPieceServiceTest.java @@ -179,14 +179,15 @@ void testShouldUpdatePieceByInvokingMethodAndSentEventToUpdatePoLineIfReceivingS @Test void testUpdateInventoryPositiveCaseIfPOLIsTitle() { - //given + CompositePurchaseOrder order = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); Title title = getMockAsJson(TILES_PATH,"title").mapTo(Title.class); Piece piece = createPieceWithLocationId(line, title); + doReturn(succeededFuture(null)).when(inventoryItemManager).updateItemWithPieceFields(piece, requestContext); - //When - openCompositeOrderPieceService.openOrderUpdateInventory(line, piece, false, requestContext).result(); - //Then + + openCompositeOrderPieceService.openOrderUpdateInventory(order, line, piece, false, requestContext).result(); + assertEquals(title.getId(), piece.getTitleId()); } @@ -198,6 +199,7 @@ void testUpdateInventoryPositiveCaseIfPOLIsPackage() { String holdingId = UUID.randomUUID().toString(); String instanceId = UUID.randomUUID().toString(); + CompositePurchaseOrder order = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); line.setIsPackage(true); Title title = getMockAsJson(TILES_PATH,"title").mapTo(Title.class).withInstanceId(instanceId); @@ -211,11 +213,12 @@ void testUpdateInventoryPositiveCaseIfPOLIsPackage() { .when(inventoryInstanceManager).createShadowInstanceIfNeeded(eq(instanceId), eq(requestContext)); doReturn(succeededFuture(holdingId)) .when(inventoryHoldingManager).createHoldingAndReturnId(eq(title.getInstanceId()), eq(piece.getLocationId()), eq(requestContext)); - doReturn(succeededFuture(itemId)).when(inventoryItemManager).openOrderCreateItemRecord(any(CompositePoLine.class), eq(holdingId), eq(requestContext)); + doReturn(succeededFuture(itemId)).when(inventoryItemManager).openOrderCreateItemRecord(any(CompositePurchaseOrder.class), + any(CompositePoLine.class), eq(holdingId), eq(requestContext)); doReturn(succeededFuture(itemId)).when(inventoryInstanceManager).createInstanceRecord(eq(title), eq(requestContext)); //When - openCompositeOrderPieceService.openOrderUpdateInventory(line, piece, false, requestContext).result(); + openCompositeOrderPieceService.openOrderUpdateInventory(order, line, piece, false, requestContext).result(); //Then assertEquals(piece.getItemId(), itemId); @@ -230,6 +233,7 @@ void testShouldUpdateInventoryPositiveCaseIfLineIsPackageAndPieceContainsHolding String holdingId = UUID.randomUUID().toString(); String itemId = UUID.randomUUID().toString(); + CompositePurchaseOrder order = getMockAsJson(ORDER_PATH).mapTo(CompositePurchaseOrder.class); CompositePoLine line = getMockAsJson(COMPOSITE_LINES_PATH, LINE_ID).mapTo(CompositePoLine.class); line.getLocations().get(0).withLocationId(null).withHoldingId(holdingId); line.setIsPackage(true); @@ -237,11 +241,11 @@ void testShouldUpdateInventoryPositiveCaseIfLineIsPackageAndPieceContainsHolding Piece piece = createPieceWithHoldingId(line, title); doReturn(succeededFuture(title)).when(titlesService).getTitleById(piece.getTitleId(), requestContext); - doReturn(succeededFuture(itemId)).when(inventoryItemManager).openOrderCreateItemRecord(line, holdingId, requestContext); + doReturn(succeededFuture(itemId)).when(inventoryItemManager).openOrderCreateItemRecord(order, line, holdingId, requestContext); doReturn(succeededFuture(instanceId)).when(titlesService).updateTitleWithInstance(eq(title), anyBoolean(), eq(requestContext), eq(requestContext)); //When - openCompositeOrderPieceService.openOrderUpdateInventory(line, piece, false, requestContext).result(); + openCompositeOrderPieceService.openOrderUpdateInventory(order, line, piece, false, requestContext).result(); //Then assertEquals(holdingId, piece.getHoldingId()); @@ -268,7 +272,8 @@ void shouldCreatePieceWithLocationReferenceIfLineContainsLocationAndInventoryIsI CompositePurchaseOrder compOrder = new CompositePurchaseOrder().withCompositePoLines(List.of(line)); Title title = new Title().withId(titleId).withTitle("test title"); - doReturn(succeededFuture(null)).when(openCompositeOrderPieceService).openOrderUpdateInventory(any(CompositePoLine.class), any(Piece.class), any(Boolean.class), eq(requestContext)); + doReturn(succeededFuture(null)).when(openCompositeOrderPieceService).openOrderUpdateInventory(any(CompositePurchaseOrder.class), + any(CompositePoLine.class), any(Piece.class), any(Boolean.class), eq(requestContext)); doReturn(succeededFuture(Collections.emptyList())).when(pieceStorageService).getPiecesByPoLineId(line, requestContext); doReturn(succeededFuture(new Piece())).when(pieceStorageService).insertPiece(any(Piece.class), eq(requestContext)); doReturn(succeededFuture(null)).when(protectionService).isOperationRestricted(any(), any(ProtectedOperationType.class), eq(requestContext)); @@ -327,7 +332,8 @@ void shouldCreatePieceWithLocationReferenceIfElectronicLineContainsLocationAndIn Title title = new Title().withId(titleId).withTitle("test title"); - doReturn(succeededFuture(null)).when(openCompositeOrderPieceService).openOrderUpdateInventory(any(CompositePoLine.class), any(Piece.class), any(Boolean.class), eq(requestContext)); + doReturn(succeededFuture(null)).when(openCompositeOrderPieceService).openOrderUpdateInventory(any(CompositePurchaseOrder.class), + any(CompositePoLine.class), any(Piece.class), any(Boolean.class), eq(requestContext)); doReturn(succeededFuture(Collections.emptyList())).when(pieceStorageService).getPiecesByPoLineId(line, requestContext); doReturn(succeededFuture(new Piece())).when(pieceStorageService).insertPiece(any(Piece.class), eq(requestContext)); doReturn(succeededFuture(null)).when(protectionService).isOperationRestricted(any(), any(ProtectedOperationType.class), eq(requestContext)); @@ -387,7 +393,8 @@ void shouldCreatePieceWithLocationReferenceIfMixedLineContainsLocationAndInvento CompositePurchaseOrder compOrder = new CompositePurchaseOrder().withCompositePoLines(List.of(line)); Title title = new Title().withId(titleId).withTitle("test title"); - doReturn(succeededFuture(null)).when(openCompositeOrderPieceService).openOrderUpdateInventory(any(CompositePoLine.class), any(Piece.class), any(Boolean.class), eq(requestContext)); + doReturn(succeededFuture(null)).when(openCompositeOrderPieceService).openOrderUpdateInventory(any(CompositePurchaseOrder.class), + any(CompositePoLine.class), any(Piece.class), any(Boolean.class), eq(requestContext)); doReturn(succeededFuture(Collections.emptyList())).when(pieceStorageService).getPiecesByPoLineId(line, requestContext); doReturn(succeededFuture(new Piece())).when(pieceStorageService).insertPiece(any(Piece.class), eq(requestContext)); doReturn(succeededFuture(null)).when(protectionService).isOperationRestricted(any(), any(ProtectedOperationType.class), eq(requestContext)); @@ -446,7 +453,8 @@ void shouldCreatePieceWithLocationAndHoldingReferenceIfMixedLineContainsLocation CompositePurchaseOrder compOrder = new CompositePurchaseOrder().withCompositePoLines(List.of(line)); Title title = new Title().withId(titleId).withTitle("test title"); - doReturn(succeededFuture(null)).when(openCompositeOrderPieceService).openOrderUpdateInventory(any(CompositePoLine.class), any(Piece.class), any(Boolean.class), eq(requestContext)); + doReturn(succeededFuture(null)).when(openCompositeOrderPieceService).openOrderUpdateInventory(any(CompositePurchaseOrder.class), + any(CompositePoLine.class), any(Piece.class), any(Boolean.class), eq(requestContext)); doReturn(succeededFuture(Collections.emptyList())).when(pieceStorageService).getPiecesByPoLineId(line, requestContext); doReturn(succeededFuture(new Piece())).when(pieceStorageService).insertPiece(any(Piece.class), eq(requestContext)); doReturn(succeededFuture(null)).when(protectionService).isOperationRestricted(any(), any(ProtectedOperationType.class), eq(requestContext)); @@ -521,7 +529,8 @@ void shouldCreatePieceWithLocationAndHoldingReferenceIfMixedLineContainsLocation CompositePurchaseOrder compOrder = new CompositePurchaseOrder().withCompositePoLines(List.of(line)); Title title = new Title().withId(titleId).withTitle("test title"); - doReturn(succeededFuture(null)).when(openCompositeOrderPieceService).openOrderUpdateInventory(any(CompositePoLine.class), any(Piece.class), any(Boolean.class), eq(requestContext)); + doReturn(succeededFuture(null)).when(openCompositeOrderPieceService).openOrderUpdateInventory(any(CompositePurchaseOrder.class), + any(CompositePoLine.class), any(Piece.class), any(Boolean.class), eq(requestContext)); doReturn(succeededFuture(Collections.emptyList())).when(pieceStorageService).getPiecesByPoLineId(line, requestContext); doReturn(succeededFuture(new Piece())).when(pieceStorageService).insertPiece(any(Piece.class), eq(requestContext)); doReturn(succeededFuture(null)).when(protectionService).isOperationRestricted(any(), any(ProtectedOperationType.class), eq(requestContext)); diff --git a/src/test/java/org/folio/service/pieces/ItemRecreateInventoryServiceTest.java b/src/test/java/org/folio/service/pieces/ItemRecreateInventoryServiceTest.java index 14639ab96..a1ce525cf 100644 --- a/src/test/java/org/folio/service/pieces/ItemRecreateInventoryServiceTest.java +++ b/src/test/java/org/folio/service/pieces/ItemRecreateInventoryServiceTest.java @@ -27,6 +27,7 @@ import java.util.concurrent.TimeoutException; import org.folio.ApiTestSuite; import org.folio.models.pieces.PieceUpdateHolder; +import org.folio.orders.utils.HelperUtils; import org.folio.orders.utils.RequestContextUtil; import org.folio.rest.core.models.RequestContext; import org.folio.rest.jaxrs.model.Piece; @@ -98,6 +99,7 @@ void shouldRecreatePhysicalItem() throws IOException { var piece = new JsonObject(piecesMock).mapTo(Piece.class); var purchaseOrder = new JsonObject(purchaseOrderMock).mapTo(PurchaseOrder.class); + var compPO = HelperUtils.convertToCompositePurchaseOrder(new JsonObject(purchaseOrderMock)); var poLine = new JsonObject(poLineMock).mapTo(PoLine.class); var pieceHolder = (PieceUpdateHolder) new PieceUpdateHolder() @@ -107,10 +109,11 @@ void shouldRecreatePhysicalItem() throws IOException { var srcLocCtx = RequestContextUtil.createContextWithNewTenantId(requestContext, "tenant1"); var dstLocCtx = RequestContextUtil.createContextWithNewTenantId(requestContext, "tenant2"); - itemRecreateInventoryService.recreateItemInDestinationTenant(pieceHolder.getPoLineToSave(), pieceHolder.getPieceToUpdate(), srcLocCtx ,dstLocCtx).result(); + itemRecreateInventoryService.recreateItemInDestinationTenant(compPO, pieceHolder.getPoLineToSave(), + pieceHolder.getPieceToUpdate(), srcLocCtx ,dstLocCtx).result(); - verify(inventoryItemManager, times(1)) - .createMissingPhysicalItems(pieceHolder.getPoLineToSave(), pieceHolder.getPieceToUpdate(), ITEM_QUANTITY, dstLocCtx); + verify(inventoryItemManager, times(1)).createMissingPhysicalItems(compPO, + pieceHolder.getPoLineToSave(), pieceHolder.getPieceToUpdate(), ITEM_QUANTITY, dstLocCtx); } @Test @@ -121,6 +124,7 @@ void shouldRecreateElectronicItem() throws IOException { var piece = new JsonObject(piecesMock).mapTo(Piece.class); var purchaseOrder = new JsonObject(purchaseOrderMock).mapTo(PurchaseOrder.class); + var compPO = HelperUtils.convertToCompositePurchaseOrder(new JsonObject(purchaseOrderMock)); var poLine = new JsonObject(poLineMock).mapTo(PoLine.class); var pieceHolder = (PieceUpdateHolder) new PieceUpdateHolder() @@ -130,10 +134,11 @@ void shouldRecreateElectronicItem() throws IOException { var srcLocCtx = RequestContextUtil.createContextWithNewTenantId(requestContext, "tenant1"); var dstLocCtx = RequestContextUtil.createContextWithNewTenantId(requestContext, "tenant2"); - itemRecreateInventoryService.recreateItemInDestinationTenant(pieceHolder.getPoLineToSave(), pieceHolder.getPieceToUpdate(), srcLocCtx, dstLocCtx).result(); + itemRecreateInventoryService.recreateItemInDestinationTenant(compPO, pieceHolder.getPoLineToSave(), + pieceHolder.getPieceToUpdate(), srcLocCtx, dstLocCtx).result(); verify(inventoryItemManager, times(1)) - .createMissingElectronicItems(pieceHolder.getPoLineToSave(), pieceHolder.getPieceToUpdate(), ITEM_QUANTITY, dstLocCtx); + .createMissingElectronicItems(compPO, pieceHolder.getPoLineToSave(), pieceHolder.getPieceToUpdate(), ITEM_QUANTITY, dstLocCtx); } private static class ContextConfiguration { diff --git a/src/test/java/org/folio/service/pieces/flows/create/PieceCreateFlowInventoryManagerTest.java b/src/test/java/org/folio/service/pieces/flows/create/PieceCreateFlowInventoryManagerTest.java index f7a229bf4..ac1d4b83b 100644 --- a/src/test/java/org/folio/service/pieces/flows/create/PieceCreateFlowInventoryManagerTest.java +++ b/src/test/java/org/folio/service/pieces/flows/create/PieceCreateFlowInventoryManagerTest.java @@ -130,21 +130,21 @@ void testPieceCreateForPackagePoLineWithCreateInventoryInstanceHoldingItem() { doReturn(succeededFuture(piece)).when(pieceStorageService).getPieceById(pieceId, requestContext); doReturn(succeededFuture(List.of(piece))).when(pieceStorageService).getPiecesByHoldingId(piece.getId(), requestContext); doReturn(succeededFuture(instanceId)).when(titlesService).updateTitleWithInstance(eq(title.getId()), eq(requestContext), eq(requestContext)); - doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(piece, compPOL, requestContext); + doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(piece, compositePurchaseOrder, compPOL, requestContext); doReturn(succeededFuture(null)).when(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(piece, requestContext); PieceCreationHolder holder = new PieceCreationHolder().withPieceToCreate(piece).withCreateItem(true); holder.withOrderInformation(compositePurchaseOrder); holder.withTitleInformation(title); - pieceCreateFlowInventoryManager.processInventory(holder.getOriginPoLine(), holder.getPieceToCreate(), + pieceCreateFlowInventoryManager.processInventory(holder.getPurchaseOrderToSave(), holder.getOriginPoLine(), holder.getPieceToCreate(), holder.isCreateItem(), requestContext).result(); assertEquals(itemId, piece.getItemId()); assertEquals(holdingId, piece.getHoldingId()); verify(titlesService).updateTitleWithInstance(piece.getTitleId(), requestContext, requestContext); - verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(piece, compPOL, requestContext); + verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(piece, compositePurchaseOrder, compPOL, requestContext); } @Test @@ -176,7 +176,7 @@ void testShouldNotCreateHoldingPieceCreateForPackagePoLineWithCreateInventoryIns holder.withOrderInformation(compositePurchaseOrder); holder.withTitleInformation(title); - pieceCreateFlowInventoryManager.processInventory(holder.getOriginPoLine(), holder.getPieceToCreate(), + pieceCreateFlowInventoryManager.processInventory(holder.getPurchaseOrderToSave(), holder.getOriginPoLine(), holder.getPieceToCreate(), holder.isCreateItem(), requestContext).result(); assertNull(piece.getItemId()); @@ -184,7 +184,7 @@ void testShouldNotCreateHoldingPieceCreateForPackagePoLineWithCreateInventoryIns assertEquals(locationId, piece.getLocationId()); verify(titlesService).updateTitleWithInstance(piece.getTitleId(), requestContext, requestContext); - verify(pieceUpdateInventoryService, times(0)).manualPieceFlowCreateItemRecord(piece, compPOL, requestContext); + verify(pieceUpdateInventoryService, times(0)).manualPieceFlowCreateItemRecord(piece, compositePurchaseOrder, compPOL, requestContext); } @@ -216,7 +216,7 @@ void testShouldNotCreateHoldingPieceCreateForNonPackagePoLineWithCreateInventory holder.withOrderInformation(compositePurchaseOrder); holder.withTitleInformation(title); - pieceCreateFlowInventoryManager.processInventory(holder.getOriginPoLine(), holder.getPieceToCreate(), + pieceCreateFlowInventoryManager.processInventory(holder.getPurchaseOrderToSave(), holder.getOriginPoLine(), holder.getPieceToCreate(), holder.isCreateItem(), requestContext).result(); assertNull(piece.getItemId()); @@ -224,7 +224,7 @@ void testShouldNotCreateHoldingPieceCreateForNonPackagePoLineWithCreateInventory assertEquals(locationId, piece.getLocationId()); verify(titlesService).updateTitleWithInstance(piece.getTitleId(), requestContext, requestContext); - verify(pieceUpdateInventoryService, times(0)).manualPieceFlowCreateItemRecord(piece, compPOL, requestContext); + verify(pieceUpdateInventoryService, times(0)).manualPieceFlowCreateItemRecord(piece, compositePurchaseOrder, compPOL, requestContext); } private static class ContextConfiguration { diff --git a/src/test/java/org/folio/service/pieces/flows/update/PieceUpdateFlowInventoryManagerTest.java b/src/test/java/org/folio/service/pieces/flows/update/PieceUpdateFlowInventoryManagerTest.java index c317edd25..ade32fe18 100644 --- a/src/test/java/org/folio/service/pieces/flows/update/PieceUpdateFlowInventoryManagerTest.java +++ b/src/test/java/org/folio/service/pieces/flows/update/PieceUpdateFlowInventoryManagerTest.java @@ -148,12 +148,12 @@ void shouldDeleteHoldingWhenElecPieceUpdateForPackagePoLineWithCreateInventoryAl doReturn(succeededFuture(title)).when(titlesService).getTitleById(pieceToUpdate.getTitleId(), requestContext); doReturn(succeededFuture(new JsonObject())).when(inventoryItemManager).getItemRecordById(pieceToUpdate.getItemId(), true, requestContext); doReturn(succeededFuture(List.of(itemId))).when(inventoryItemManager) - .createMissingElectronicItems(holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); + .createMissingElectronicItems(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); doReturn(succeededFuture(null)).when(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); doReturn(succeededFuture(holding)).when(inventoryHoldingManager).getHoldingById(holder.getPieceFromStorage().getHoldingId(), true, requestContext); doReturn(succeededFuture(new ArrayList())).when(inventoryItemManager).getItemsByHoldingId(holder.getPieceFromStorage().getHoldingId(), requestContext); doReturn(succeededFuture(null)).when(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); - doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); doReturn(succeededFuture(instanceId)).when(titlesService).updateTitleWithInstance(eq(title.getId()), eq(requestContext), eq(requestContext)); pieceUpdateFlowInventoryManager.processInventory(holder, requestContext).result(); @@ -162,7 +162,7 @@ void shouldDeleteHoldingWhenElecPieceUpdateForPackagePoLineWithCreateInventoryAl verify(inventoryHoldingManager, times(0)).getOrCreateHoldingsRecord(eq(holder.getInstanceId()), any(Location.class), eq(requestContext)); verify(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); verify(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); - verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); } @Test @@ -197,12 +197,12 @@ void shouldDeleteHoldingWhenPhysPieceUpdateForPackagePoLineWithCreateInventoryAl doReturn(succeededFuture(title)).when(titlesService).getTitleById(pieceToUpdate.getTitleId(), requestContext); doReturn(succeededFuture(new JsonObject())).when(inventoryItemManager).getItemRecordById(pieceToUpdate.getItemId(), true, requestContext); doReturn(succeededFuture(List.of(itemId))).when(inventoryItemManager) - .createMissingPhysicalItems(holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); + .createMissingPhysicalItems(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); doReturn(succeededFuture(null)).when(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); doReturn(succeededFuture(holding)).when(inventoryHoldingManager).getHoldingById(holder.getPieceFromStorage().getHoldingId(), true, requestContext); doReturn(succeededFuture(new ArrayList())).when(inventoryItemManager).getItemsByHoldingId(holder.getPieceFromStorage().getHoldingId(), requestContext); doReturn(succeededFuture(null)).when(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); - doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); doReturn(succeededFuture(instanceId)).when(titlesService).updateTitleWithInstance(eq(title.getId()), eq(requestContext), eq(requestContext)); pieceUpdateFlowInventoryManager.processInventory(holder, requestContext).result(); @@ -211,7 +211,7 @@ void shouldDeleteHoldingWhenPhysPieceUpdateForPackagePoLineWithCreateInventoryAl verify(inventoryHoldingManager, times(0)).getOrCreateHoldingsRecord(eq(holder.getInstanceId()), any(Location.class), eq(requestContext)); verify(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); verify(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); - verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); } @Test @@ -247,12 +247,12 @@ void shouldDeleteHoldingWhenPhysPieceUpdateForPackagePoLineWithCreateInventoryAl doReturn(succeededFuture(new JsonObject())).when(inventoryItemManager).getItemRecordById(pieceToUpdate.getItemId(), true, requestContext); doReturn(succeededFuture(List.of(itemId))).when(inventoryItemManager) - .createMissingPhysicalItems(holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); + .createMissingPhysicalItems(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); doReturn(succeededFuture(null)).when(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); doReturn(succeededFuture(holding)).when(inventoryHoldingManager).getHoldingById(holder.getPieceFromStorage().getHoldingId(), true, requestContext); doReturn(succeededFuture(new ArrayList())).when(inventoryItemManager).getItemsByHoldingId(holder.getPieceFromStorage().getHoldingId(), requestContext); doReturn(succeededFuture(null)).when(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); - doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); doReturn(succeededFuture(instanceId)).when(titlesService).updateTitleWithInstance(eq(title.getId()), eq(requestContext), eq(requestContext)); pieceUpdateFlowInventoryManager.processInventory(holder, requestContext).result(); @@ -261,7 +261,7 @@ void shouldDeleteHoldingWhenPhysPieceUpdateForPackagePoLineWithCreateInventoryAl verify(inventoryHoldingManager, times(0)).getOrCreateHoldingsRecord(eq(holder.getInstanceId()), any(Location.class), eq(requestContext)); verify(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); verify(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); - verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); } @Test @@ -301,7 +301,7 @@ void shouldUpdateItemWithNewHoldingIdWhenPhysPieceUpdateForPackagePoLineWithCrea doReturn(succeededFuture(null)).when(inventoryItemManager).updateItem(item, requestContext); doReturn(succeededFuture(List.of(itemId))).when(inventoryItemManager) - .createMissingPhysicalItems(holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); + .createMissingPhysicalItems(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); doReturn(succeededFuture(null)).when(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); doReturn(succeededFuture(holding)).when(inventoryHoldingManager).getHoldingById(holder.getPieceFromStorage().getHoldingId(), true, requestContext); doReturn(succeededFuture(new ArrayList())).when(inventoryItemManager).getItemsByHoldingId(holder.getPieceFromStorage().getHoldingId(), requestContext); @@ -316,8 +316,8 @@ void shouldUpdateItemWithNewHoldingIdWhenPhysPieceUpdateForPackagePoLineWithCrea verify(inventoryHoldingManager, times(0)).getOrCreateHoldingsRecord(eq(holder.getInstanceId()), any(Location.class), eq(requestContext)); verify(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); verify(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); - verify(inventoryItemManager,times(0)).createMissingElectronicItems(holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); - verify(inventoryItemManager,times(0)).createMissingPhysicalItems(holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); + verify(inventoryItemManager,times(0)).createMissingElectronicItems(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); + verify(inventoryItemManager,times(0)).createMissingPhysicalItems(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); verify(inventoryItemManager).updateItem(item, requestContext); } @@ -354,12 +354,12 @@ void shouldDeleteHoldingWhenElecPieceUpdateForNonPackagePoLineWithCreateInventor doReturn(succeededFuture(title)).when(titlesService).getTitleById(pieceToUpdate.getTitleId(), requestContext); doReturn(succeededFuture(new JsonObject())).when(inventoryItemManager).getItemRecordById(pieceToUpdate.getItemId(), true, requestContext); doReturn(succeededFuture(List.of(itemId))).when(inventoryItemManager) - .createMissingElectronicItems(holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); + .createMissingElectronicItems(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); doReturn(succeededFuture(null)).when(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); doReturn(succeededFuture(holding)).when(inventoryHoldingManager).getHoldingById(holder.getPieceFromStorage().getHoldingId(), true, requestContext); doReturn(succeededFuture(new ArrayList())).when(inventoryItemManager).getItemsByHoldingId(holder.getPieceFromStorage().getHoldingId(), requestContext); doReturn(succeededFuture(null)).when(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); - doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); doReturn(succeededFuture(instanceId)).when(titlesService).updateTitleWithInstance(eq(title.getId()), eq(requestContext), eq(requestContext)); pieceUpdateFlowInventoryManager.processInventory(holder, requestContext).result(); @@ -368,7 +368,7 @@ void shouldDeleteHoldingWhenElecPieceUpdateForNonPackagePoLineWithCreateInventor verify(inventoryHoldingManager, times(0)).getOrCreateHoldingsRecord(eq(holder.getInstanceId()), any(Location.class), eq(requestContext)); verify(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); verify(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); - verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); } @Test @@ -403,12 +403,12 @@ void shouldDeleteHoldingWhenPhysPieceUpdateForNonPackagePoLineWithCreateInventor doReturn(succeededFuture(title)).when(titlesService).getTitleById(pieceToUpdate.getTitleId(), requestContext); doReturn(succeededFuture(new JsonObject())).when(inventoryItemManager).getItemRecordById(pieceToUpdate.getItemId(), true, requestContext); doReturn(succeededFuture(List.of(itemId))).when(inventoryItemManager) - .createMissingPhysicalItems(holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); + .createMissingPhysicalItems(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); doReturn(succeededFuture(null)).when(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); doReturn(succeededFuture(holding)).when(inventoryHoldingManager).getHoldingById(holder.getPieceFromStorage().getHoldingId(), true, requestContext); doReturn(succeededFuture(new ArrayList())).when(inventoryItemManager).getItemsByHoldingId(holder.getPieceFromStorage().getHoldingId(), requestContext); doReturn(succeededFuture(null)).when(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); - doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); doReturn(succeededFuture(instanceId)).when(titlesService).updateTitleWithInstance(eq(title.getId()), eq(requestContext), eq(requestContext)); pieceUpdateFlowInventoryManager.processInventory(holder, requestContext).result(); @@ -417,7 +417,7 @@ void shouldDeleteHoldingWhenPhysPieceUpdateForNonPackagePoLineWithCreateInventor verify(inventoryHoldingManager, times(0)).getOrCreateHoldingsRecord(eq(holder.getInstanceId()), any(Location.class), eq(requestContext)); verify(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); verify(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); - verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); } @Test @@ -451,12 +451,12 @@ void shouldDeleteHoldingWhenPhysPieceUpdateForNonPackagePoLineWithCreateInventor doReturn(succeededFuture(new JsonObject())).when(inventoryItemManager).getItemRecordById(pieceToUpdate.getItemId(), true, requestContext); doReturn(succeededFuture(List.of(itemId))).when(inventoryItemManager) - .createMissingPhysicalItems(holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); + .createMissingPhysicalItems(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); doReturn(succeededFuture(null)).when(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); doReturn(succeededFuture(holding)).when(inventoryHoldingManager).getHoldingById(holder.getPieceFromStorage().getHoldingId(), true, requestContext); doReturn(succeededFuture(new ArrayList())).when(inventoryItemManager).getItemsByHoldingId(holder.getPieceFromStorage().getHoldingId(), requestContext); doReturn(succeededFuture(null)).when(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); - doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + doReturn(succeededFuture(itemId)).when(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); pieceUpdateFlowInventoryManager.processInventory(holder, requestContext).result(); @@ -464,7 +464,7 @@ void shouldDeleteHoldingWhenPhysPieceUpdateForNonPackagePoLineWithCreateInventor verify(inventoryHoldingManager, times(0)).getOrCreateHoldingsRecord(eq(holder.getInstanceId()), any(Location.class), eq(requestContext)); verify(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); verify(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); - verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + verify(pieceUpdateInventoryService).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); } @Test @@ -503,7 +503,7 @@ void shouldUpdateItemWithNewHoldingIdWhenPhysPieceUpdateForNonPackagePoLineWithC doReturn(succeededFuture(null)).when(inventoryItemManager).updateItem(item, requestContext); doReturn(succeededFuture(List.of(itemId))).when(inventoryItemManager) - .createMissingPhysicalItems(holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); + .createMissingPhysicalItems(holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), pieceToUpdate, 1, requestContext); doReturn(succeededFuture(null)).when(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); doReturn(succeededFuture(holding)).when(inventoryHoldingManager).getHoldingById(holder.getPieceFromStorage().getHoldingId(), true, requestContext); doReturn(succeededFuture(new ArrayList())).when(inventoryItemManager).getItemsByHoldingId(holder.getPieceFromStorage().getHoldingId(), requestContext); @@ -517,7 +517,7 @@ void shouldUpdateItemWithNewHoldingIdWhenPhysPieceUpdateForNonPackagePoLineWithC verify(inventoryHoldingManager, times(0)).getOrCreateHoldingsRecord(eq(holder.getInstanceId()), any(Location.class), eq(requestContext)); verify(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(holder.getPieceFromStorage(), requestContext); verify(inventoryItemManager).updateItemWithPieceFields(holder.getPieceToUpdate(), requestContext); - verify(pieceUpdateInventoryService, times(0)).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + verify(pieceUpdateInventoryService, times(0)).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); verify(inventoryItemManager).updateItem(item, requestContext); } @@ -555,7 +555,7 @@ void shouldNotTryToUpdateItemWhenUpdatingPieceThatDoesNotHaveItem() pieceUpdateFlowInventoryManager.processInventory(holder, requestContext).result(); verify(inventoryItemManager, times(1)).getItemRecordById(null, true, requestContext); - verify(pieceUpdateInventoryService, times(0)).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPoLineToSave(), requestContext); + verify(pieceUpdateInventoryService, times(0)).manualPieceFlowCreateItemRecord(pieceToUpdate, holder.getPurchaseOrderToSave(), holder.getPoLineToSave(), requestContext); verify(inventoryItemManager, times(0)).updateItem(item, requestContext); }