MODORDERS -1087 Delete received pieces in bulk

ramls/pieces.raml

@@ -6,7 +6,7 @@ protocols: [ HTTP, HTTPS ]
 
 documentation:
   - title: Orders Business Logic API
-    content: <b>API for managing pieces</b>
+    content: <b>API for managing pieces including batch operations for deletion.</b>
 
 types:
   piece: !include acq-models/mod-orders-storage/schemas/piece.json
@@ -47,6 +47,40 @@ resourceTypes:
         example: true
         required: false
         default: false
+  /batch:
+    delete:
+      description: Batch delete pieces
+      body:
+        application/json:
+          type: piece-collection
+          example: !include acq-models/mod-orders-storage/examples/piece_collection.sample
+      responses:
+              204:
+                description: "Batch delete of pieces successfully completed"
+                body:
+                  application/json:
+                    example: "All pieces successfully deleted."
+              400:
+                description: "Bad request, e.g., malformed JSON or validation failed"
+                body:
+                  application/json:
+                    type: errors
+                  text/plain:
+                    example: "Bad request - malformed JSON or validation failed."
+              404:
+                description: "One or more pieces not found"
+                body:
+                  application/json:
+                    type: errors
+                  text/plain:
+                    example: "Error - one or more pieces not found."
+              500:
+                description: "Internal server error, e.g. due to misconfiguration"
+                body:
+                  application/json:
+                    type: errors
+                  text/plain:
+                    example: "Internal server error - due to misconfiguration."
   /{id}:
     uriParameters:
       id:

src/main/java/org/folio/orders/utils/ResourcePathResolver.java

@@ -23,6 +23,7 @@ private ResourcePathResolver() {
   public static final String REPORTING_CODES = "reportingCodes";
   public static final String PURCHASE_ORDER_STORAGE = "purchaseOrder";
   public static final String PIECES_STORAGE = "pieces";
+  public static final String PIECES_COLLECTION_STORAGE = "PiecesCollection";
   public static final String RECEIVING_HISTORY = "receiving-history";
   public static final String RECEIPT_STATUS = "receiptStatus";
   public static final String PAYMENT_STATUS = "paymentStatus";
@@ -94,6 +95,7 @@ private ResourcePathResolver() {
     apis.put(USERS, "/users");
     apis.put(ORDER_SETTINGS, "/orders-storage/settings");
     apis.put(ROUTING_LISTS, "/orders-storage/routing-lists");
+    apis.put(PIECES_COLLECTION_STORAGE, "/orders-storage/pieces-collecton");
 
     SUB_OBJECT_COLLECTION_APIS = Collections.unmodifiableMap(apis);
     SUB_OBJECT_ITEM_APIS = Collections.unmodifiableMap(

src/main/java/org/folio/rest/impl/PiecesAPI.java

@@ -2,16 +2,21 @@
 
 import static io.vertx.core.Future.succeededFuture;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 import javax.ws.rs.core.Response;
 
+import io.vertx.core.CompositeFuture;
+import io.vertx.core.Future;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.folio.rest.annotations.Validate;
 import org.folio.rest.core.models.RequestContext;
 import org.folio.rest.jaxrs.model.Piece;
+import org.folio.rest.jaxrs.model.PieceCollection;
 import org.folio.rest.jaxrs.resource.OrdersPieces;
 import org.folio.service.pieces.PieceStorageService;
 import org.folio.service.pieces.flows.create.PieceCreateFlowManager;
@@ -38,6 +43,7 @@ public class PiecesAPI extends BaseApi implements OrdersPieces {
   @Autowired
   private PieceUpdateFlowManager pieceUpdateFlowManager;
 
+
   public PiecesAPI() {
     SpringContextUtil.autowireDependencies(this, Vertx.currentContext());
   }
@@ -66,6 +72,8 @@ public void postOrdersPieces(boolean createItem, Piece entity, Map<String, Strin
       .onFailure(t -> handleErrorResponse(asyncResultHandler, t));
   }
 
+
+
   @Override
   @Validate
   public void getOrdersPiecesById(String id, Map<String, String> okapiHeaders,
@@ -91,9 +99,21 @@ public void putOrdersPiecesById(String pieceId, boolean createItem, boolean dele
   @Override
   @Validate
   public void deleteOrdersPiecesById(String pieceId, boolean deleteHolding, Map<String, String> okapiHeaders,
-      Handler<AsyncResult<Response>> asyncResultHandler, Context vertxContext) {
+                                             Handler<AsyncResult<Response>> asyncResultHandler, Context vertxContext) {
     pieceDeleteFlowManager.deletePiece(pieceId, deleteHolding, new RequestContext(vertxContext, okapiHeaders))
       .onSuccess(ok -> asyncResultHandler.handle(succeededFuture(buildNoContentResponse())))
       .onFailure(fail -> handleErrorResponse(asyncResultHandler, fail));
+
+  }
+
+  @Override
+  @Validate
+  public void deleteOrdersPiecesBatch(PieceCollection entity, Map<String, String> okapiHeaders, Handler<AsyncResult<Response>> asyncResultHandler, Context vertxContext) {
+    List<String> pieceIds = new ArrayList<>();
+    for (Piece piece : entity.getPieces()) {
+      pieceIds.add(piece.getId());
+    }
+    pieceDeleteFlowManager.batchDeletePiece(pieceIds, new RequestContext(vertxContext, okapiHeaders));
   }
 }
+

src/main/java/org/folio/service/pieces/PieceStorageService.java

@@ -27,7 +27,6 @@
 
 public class PieceStorageService {
   private static final Logger logger = LogManager.getLogger(PieceStorageService.class);
-
   private static final String PIECES_BY_POL_ID_AND_STATUS_QUERY = "poLineId==%s and receivingStatus==%s";
   private static final String PIECES_BY_HOLDING_ID_QUERY = "holdingId==%s";
   private static final String PIECE_STORAGE_ENDPOINT = resourcesPath(PIECES_STORAGE);

src/main/java/org/folio/service/pieces/flows/delete/PieceDeleteFlowManager.java

@@ -7,7 +7,9 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
+import io.vertx.core.CompositeFuture;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;
@@ -54,6 +56,7 @@ public PieceDeleteFlowManager(PieceStorageService pieceStorageService, Protectio
 
   public Future<Void> deletePiece(String pieceId, boolean deleteHolding, RequestContext requestContext) {
     PieceDeletionHolder holder = new PieceDeletionHolder().withDeleteHolding(deleteHolding);
+
     return pieceStorageService.getPieceById(pieceId, requestContext)
       .map(pieceToDelete -> {
         holder.withPieceToDelete(pieceToDelete); return null;
@@ -140,4 +143,26 @@ private Future<JsonObject> getOnOrderItemForPiece(Piece piece, RequestContext re
       return Future.succeededFuture();
     }
   }
+
+ public Future<Void> batchDeletePiece(List<String> ids, RequestContext requestContext) {
+   PieceDeletionHolder holder = new PieceDeletionHolder().withDeleteHolding(false);
+
+   List<Future> deleteFutures = ids.stream()
+     .map(id -> pieceStorageService.getPieceById(id, requestContext)
+       .map(pieceToDelete -> {
+         holder.withPieceToDelete(pieceToDelete);
+         return null;
+       })
+       .compose(aHolder -> basePieceFlowHolderBuilder.updateHolderWithOrderInformation(holder, requestContext))
+       .compose(aHolder -> basePieceFlowHolderBuilder.updateHolderWithTitleInformation(holder, requestContext))
+       .compose(aVoid -> protectionService.isOperationRestricted(holder.getTitle().getAcqUnitIds(), DELETE, requestContext))
+       .compose(aVoid -> isDeletePieceRequestValid(holder, requestContext))
+       .compose(aVoid -> processInventory(holder, requestContext))
+       .compose(pair -> updatePoLine(holder, requestContext))
+       .compose(aVoid -> pieceStorageService.deletePiece(holder.getPieceToDelete().getId(), true, requestContext))
+     )
+     .collect(Collectors.toList());
+
+   return CompositeFuture.all(deleteFutures).mapEmpty();
+ }
 }

src/test/java/org/folio/RestTestUtils.java

@@ -18,10 +18,12 @@
 
 import java.util.Map;
 
+import jakarta.validation.Payload;
 import org.apache.commons.lang3.StringUtils;
 import org.folio.orders.events.handlers.HandlersTestHelper;
 import org.folio.rest.jaxrs.model.Error;
 import org.folio.rest.jaxrs.model.Errors;
+import org.folio.rest.jaxrs.model.PieceCollection;
 import org.folio.rest.tools.parser.JsonPathParser;
 import org.hamcrest.Matchers;
 
@@ -171,6 +173,25 @@ public static Response verifyDeleteResponse(String url, Headers headers, String
     return response;
   }
 
+  public static Response verifyBatchDeleteResponse(String url, String body, Headers headers, String expectedContentType, int expectedCode) {
+    Response response = RestAssured
+            .with()
+            .header(X_OKAPI_URL)
+            .header(X_OKAPI_TOKEN)
+            .headers(headers)
+            .contentType(APPLICATION_JSON)
+            .body(body)
+            .when()
+            .delete(url)
+            .then()
+            .statusCode(expectedCode)
+            .contentType(expectedContentType)
+            .extract()
+            .response();
+    HandlersTestHelper.verifyOrderStatusUpdateEvent(0);
+    return response;
+  }
+
   public static void checkPreventProtectedFieldsModificationRule(String path, JsonObject compPO, Map<String, Object> updatedFields) {
     JsonObject compPOJson = JsonObject.mapFrom(compPO);
     JsonPathParser compPOParser = new JsonPathParser(compPOJson);

src/test/java/org/folio/rest/impl/PieceApiTest.java

@@ -1,11 +1,14 @@
 package org.folio.rest.impl;
 
+import static io.restassured.RestAssured.given;
 import static javax.ws.rs.core.MediaType.APPLICATION_JSON;
 import static javax.ws.rs.core.MediaType.TEXT_PLAIN;
 import static org.folio.RestTestUtils.prepareHeaders;
+import static org.folio.RestTestUtils.verifyBatchDeleteResponse;
 import static org.folio.RestTestUtils.verifyDeleteResponse;
 import static org.folio.RestTestUtils.verifyPostResponse;
 import static org.folio.RestTestUtils.verifyPut;
+import static org.folio.TestConfig.X_OKAPI_URL;
 import static org.folio.TestConfig.clearServiceInteractions;
 import static org.folio.TestConfig.initSpringContext;
 import static org.folio.TestConfig.isVerticleNotDeployed;
@@ -15,9 +18,12 @@
 import static org.folio.TestConstants.ID_DOES_NOT_EXIST;
 import static org.folio.TestConstants.ID_FOR_INTERNAL_SERVER_ERROR;
 import static org.folio.TestConstants.X_ECHO_STATUS;
+import static org.folio.TestConstants.X_OKAPI_TOKEN;
 import static org.folio.TestConstants.X_OKAPI_USER_ID;
+import static org.folio.TestConstants.X_OKAPI_USER_ID_WITH_ACQ_UNITS;
 import static org.folio.TestUtils.getMockAsJson;
 import static org.folio.TestUtils.getMockData;
+import static org.folio.orders.utils.ResourcePathResolver.PIECES_COLLECTION_STORAGE;
 import static org.folio.orders.utils.ResourcePathResolver.PIECES_STORAGE;
 import static org.folio.orders.utils.ResourcePathResolver.PO_LINES_STORAGE;
 import static org.folio.orders.utils.ResourcePathResolver.PURCHASE_ORDER_STORAGE;
@@ -31,15 +37,20 @@
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.notNullValue;
 import static org.hamcrest.Matchers.nullValue;
+import static org.junit.Assert.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
+import javax.ws.rs.core.Response;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeoutException;
 
 import io.restassured.http.Header;
+import io.restassured.http.Headers;
 import io.vertx.core.json.JsonObject;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -55,12 +66,15 @@
 import org.folio.rest.jaxrs.model.Location;
 import org.folio.rest.jaxrs.model.Physical;
 import org.folio.rest.jaxrs.model.Piece;
+import org.folio.rest.jaxrs.model.PieceCollection;
 import org.folio.rest.jaxrs.model.PurchaseOrder;
 import org.folio.rest.jaxrs.model.Title;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.testcontainers.shaded.com.fasterxml.jackson.core.JsonProcessingException;
 
 public class PieceApiTest {
 
@@ -69,6 +83,7 @@ public class PieceApiTest {
   public static final String PIECES_ENDPOINT = "/orders/pieces";
   private static final String PIECES_ID_PATH = PIECES_ENDPOINT + "/%s";
   static final String CONSISTENT_RECEIVED_STATUS_PIECE_UUID = "7d0aa803-a659-49f0-8a95-968f277c87d7";
+  private static final String PIECES_BATCH_PATH = PIECES_ENDPOINT+"/batch";
   private JsonObject pieceJsonReqData = getMockAsJson(PIECE_RECORDS_MOCK_DATA_PATH + "pieceRecord.json");
 
   private static boolean runningOnOwn;
@@ -356,4 +371,32 @@ void deletePieceInternalErrorOnStorageTest() {
     logger.info("=== Test delete piece by id - internal error from storage 500 ===");
     verifyDeleteResponse(String.format(PIECES_ID_PATH, ID_FOR_INTERNAL_SERVER_ERROR), APPLICATION_JSON, 500);
   }
+
+  @Test
+  @Timeout(5)
+  void deletePiecesByBatchWithItemDeletionTest() throws JsonProcessingException {
+    logger.info("=== Test delete pieces in batch - items deleted ===");
+    Piece postPieceRq = pieceJsonReqData.mapTo(Piece.class);
+    postPieceRq.withId("2bafc9e1-9dd3-4ede-9f23-c4a03f8bb205");
+    postPieceRq.setPoLineId("2bafc9e1-9dd3-4ede-9f23-c4a03f8bb2d5");
+    postPieceRq.setReceiptDate(null);
+    String orderId = UUID.randomUUID().toString();
+    CompositePurchaseOrder order = new CompositePurchaseOrder().withId(orderId);
+    verifyPostResponse(PIECES_ENDPOINT, JsonObject.mapFrom(postPieceRq).encode(),
+      prepareHeaders(EXIST_CONFIG_X_OKAPI_TENANT_LIMIT_10, X_OKAPI_USER_ID, X_OKAPI_USER_ID_WITH_ACQ_UNITS), APPLICATION_JSON, 201).as(Piece.class);
+
+    List<Piece> pieces = new ArrayList<>();
+    pieces.add(postPieceRq);
+    PieceCollection pieceCollection = new PieceCollection().withPieces(pieces);
+    MockServer.addMockEntry(PO_LINES_STORAGE, JsonObject.mapFrom(postPieceRq));
+    MockServer.addMockEntry(PURCHASE_ORDER_STORAGE, JsonObject.mapFrom(order));
+    JsonObject jsonPieceCollection = JsonObject.mapFrom(pieceCollection);
+    MockServer.addMockEntry(PIECES_STORAGE, JsonObject.mapFrom(postPieceRq));
+    MockServer.addMockEntry(PIECES_COLLECTION_STORAGE,JsonObject.mapFrom(pieceCollection));
+    int status204 = HttpStatus.HTTP_NO_CONTENT.toInt();
+
+    verifyBatchDeleteResponse(PIECES_BATCH_PATH, jsonPieceCollection.encode(),
+      prepareHeaders(EXIST_CONFIG_X_OKAPI_TENANT_LIMIT_10,X_OKAPI_USER_ID_WITH_ACQ_UNITS ,X_OKAPI_TOKEN,  X_OKAPI_USER_ID), APPLICATION_JSON,204);
+  }
+
 }

src/test/java/org/folio/service/pieces/flows/delete/PieceDeleteFlowManagerTest.java

@@ -356,6 +356,68 @@ void shouldUpdateLineQuantityIfPoLineIsNotPackageAndManualPieceCreateFalseAndInv
     verify(basePieceFlowHolderBuilder).updateHolderWithOrderInformation(holder, requestContext);
   }
 
+  @Test
+  void shouldUpdateLineQuantityIfPoLineIsNotPackageAndManualPieceCreateFalseAndInventoryInstanceVsHoldingAndDeleteHoldingAndPieceInBatch()  {
+    String orderId = UUID.randomUUID().toString();
+    String holdingId = UUID.randomUUID().toString();
+    String lineId = UUID.randomUUID().toString();
+    String itemId = UUID.randomUUID().toString();
+    String locationId = UUID.randomUUID().toString();
+    String titleId = UUID.randomUUID().toString();
+    JsonObject holding = new JsonObject();
+    holding.put(ID, holdingId);
+    holding.put(HOLDING_PERMANENT_LOCATION_ID, locationId);
+    JsonObject item = new JsonObject().put(ID, itemId);
+    item.put(ITEM_STATUS, new JsonObject().put(ITEM_STATUS_NAME, ItemStatus.ON_ORDER.value()));
+    Piece piece = new Piece().withId(UUID.randomUUID().toString()).withPoLineId(lineId)
+      .withHoldingId(holdingId).withFormat(Piece.Format.ELECTRONIC);
+    Location loc = new Location().withHoldingId(holdingId).withQuantityElectronic(1).withQuantity(1);
+    Cost cost = new Cost().withQuantityElectronic(1)
+      .withListUnitPriceElectronic(1d).withExchangeRate(1d).withCurrency("USD")
+      .withPoLineEstimatedPrice(1d);
+    PoLine poLine = new PoLine().withIsPackage(false).withCheckinItems(false).withOrderFormat(PoLine.OrderFormat.ELECTRONIC_RESOURCE)
+      .withEresource(new Eresource().withCreateInventory(Eresource.CreateInventory.INSTANCE_HOLDING))
+      .withPurchaseOrderId(orderId).withId(lineId).withLocations(List.of(loc)).withCost(cost);
+    PurchaseOrder purchaseOrder = new PurchaseOrder().withId(orderId).withWorkflowStatus(PurchaseOrder.WorkflowStatus.OPEN);
+    Title title = new Title().withId(titleId);
+    List<String> ids = new ArrayList<>();
+    ids.add(piece.getId());
+
+    doReturn(succeededFuture(piece)).when(pieceStorageService).getPieceById(piece.getId(), requestContext);
+    doReturn(succeededFuture(null)).when(protectionService).isOperationRestricted(any(), any(ProtectedOperationType.class), eq(requestContext));
+    doReturn(succeededFuture(null)).when(pieceStorageService).deletePiece(eq(piece.getId()), eq(true), eq(requestContext));
+    doReturn(succeededFuture(null)).when(inventoryItemManager).getNumberOfRequestsByItemId(eq(piece.getItemId()), eq(requestContext));
+    doReturn(succeededFuture(holding)).when(inventoryHoldingManager).getHoldingById(holdingId, false, requestContext);
+    doReturn(succeededFuture(null)).when(inventoryItemManager).getItemsByHoldingId(holdingId, requestContext);
+    doReturn(succeededFuture(null)).when(inventoryHoldingManager).deleteHoldingById(piece.getHoldingId(), true, requestContext);
+    doReturn(succeededFuture(null)).when(inventoryItemManager).getItemRecordById(itemId, true, requestContext);
+    doReturn(succeededFuture(null)).when(inventoryItemManager).deleteItem(itemId, true, requestContext);
+    doReturn(succeededFuture(holding)).when(inventoryHoldingManager).getHoldingById(holdingId, true, requestContext);
+    doReturn(succeededFuture(null)).when(pieceUpdateInventoryService).deleteHoldingConnectedToPiece(piece, requestContext);
+    doReturn(succeededFuture(new ArrayList<JsonObject>())).when(inventoryItemManager).getItemsByHoldingId(holdingId,  requestContext);
+    final ArgumentCaptor<PieceDeletionHolder> PieceDeletionHolderCapture = ArgumentCaptor.forClass(PieceDeletionHolder.class);
+    doAnswer((Answer<Future<Void>>) invocation -> {
+      PieceDeletionHolder answerHolder = invocation.getArgument(0);
+      answerHolder.withOrderInformation(purchaseOrder, poLine);
+      return succeededFuture(null);
+    }).when(basePieceFlowHolderBuilder).updateHolderWithOrderInformation(PieceDeletionHolderCapture.capture(), eq(requestContext));
+    doAnswer((Answer<Future<Void>>) invocation -> {
+      PieceDeletionHolder answerHolder = invocation.getArgument(0);
+      answerHolder.withTitleInformation(title);
+      return succeededFuture(null);
+    }).when(basePieceFlowHolderBuilder).updateHolderWithTitleInformation(PieceDeletionHolderCapture.capture(), eq(requestContext));
+
+    final ArgumentCaptor<PieceDeletionHolder> pieceDeletionHolderCapture = ArgumentCaptor.forClass(PieceDeletionHolder.class);
+    doReturn(succeededFuture(null)).when(pieceDeleteFlowPoLineService).updatePoLine(pieceDeletionHolderCapture.capture(), eq(requestContext));
+    //When
+   pieceDeleteFlowManager.batchDeletePiece(ids, requestContext).result();
+    verify(pieceStorageService).deletePiece(eq(piece.getId()), eq(true), eq(requestContext));
+    verify(inventoryItemManager, times(0)).deleteItem(itemId, true, requestContext);
+    verify(pieceStorageService, times(1)).deletePiece(eq(piece.getId()), eq(true), eq(requestContext));
+    verify(pieceDeleteFlowPoLineService).updatePoLine(pieceDeletionHolderCapture.capture(), eq(requestContext));
+
+  }
+
   private static class ContextConfiguration {
     @Bean PieceStorageService pieceStorageService() {
       return mock(PieceStorageService.class);