Examples with ReceivingCollection org.folio.rest.jaxrs.model.ReceivingCollection used on opensource projects

Example 1 with ReceivingCollection

use of org.folio.rest.jaxrs.model.ReceivingCollection in project mod-orders by folio-org.

the class ReceivingCheckinProtectionTest method getReceivingCollection.

private static ReceivingCollection getReceivingCollection(List<String> units) {
    CompositePurchaseOrder order = getMinimalContentCompositePurchaseOrder().withAcqUnitIds(units).withId(getRandomId());
    addMockEntry(PURCHASE_ORDER_STORAGE, JsonObject.mapFrom(order));
    CompositePoLine poLine = getMinimalContentCompositePoLine(order.getId()).withId(EXPECTED_FLOW_PO_LINE_ID);
    addMockEntry(PO_LINES_STORAGE, JsonObject.mapFrom(poLine));
    MockServer.addMockTitles(Collections.singletonList(poLine));
    ReceivingCollection toBeReceivedRq = new ReceivingCollection();
    List<ToBeReceived> toBeReceivedList = new ArrayList<>(Arrays.asList(getToBeReceived(poLine.getId(), EXPECTED_FLOW_PIECE_ID_1), getToBeReceived(poLine.getId(), EXPECTED_FLOW_PIECE_ID_2)));
    toBeReceivedRq.setToBeReceived(toBeReceivedList);
    toBeReceivedRq.setTotalRecords(toBeReceivedList.size());
    return toBeReceivedRq;
}

Example 2 with ReceivingCollection

use of org.folio.rest.jaxrs.model.ReceivingCollection in project mod-orders by folio-org.

the class ReceivingCheckinProtectionTest method testReceivingCompositeFlow.

@Test
void testReceivingCompositeFlow() {
    addMockEntry(PURCHASE_ORDER_STORAGE, JsonObject.mapFrom(getMinimalContentCompositePurchaseOrder().withAcqUnitIds(NOT_PROTECTED_UNITS).withId(ORDER_WITH_NOT_PROTECTED_UNITS_ID)));
    addMockEntry(PURCHASE_ORDER_STORAGE, JsonObject.mapFrom(getMinimalContentCompositePurchaseOrder().withAcqUnitIds(PROTECTED_UNITS).withId(ORDER_WITH_PROTECTED_UNITS_ID)));
    List<CompositePoLine> poLines = new ArrayList<>();
    poLines.add(getMinimalContentCompositePoLine(ORDER_WITH_NOT_PROTECTED_UNITS_ID).withId(EXPECTED_FLOW_PO_LINE_ID));
    poLines.add(getMinimalContentCompositePoLine(ORDER_WITH_NOT_PROTECTED_UNITS_ID).withId(RANDOM_PO_LINE_ID_1));
    poLines.add(getMinimalContentCompositePoLine(ORDER_WITH_PROTECTED_UNITS_ID).withId(RANDOM_PO_LINE_ID_2));
    poLines.forEach(line -> addMockEntry(PO_LINES_STORAGE, JsonObject.mapFrom(line)));
    MockServer.addMockTitles(poLines);
    ReceivingCollection toBeReceivedRq = new ReceivingCollection();
    List<ToBeReceived> toBeReceivedList = new ArrayList<>();
    toBeReceivedList.add(getToBeReceived(EXPECTED_FLOW_PO_LINE_ID, EXPECTED_FLOW_PIECE_ID_1));
    toBeReceivedList.add(getToBeReceived(RANDOM_PO_LINE_ID_1, getRandomId()));
    toBeReceivedList.add(getToBeReceived(RANDOM_PO_LINE_ID_2, getRandomId()));
    toBeReceivedList.add(getToBeReceived(EXPECTED_FLOW_PO_LINE_ID, getRandomId()));
    toBeReceivedRq.setToBeReceived(toBeReceivedList);
    toBeReceivedRq.setTotalRecords(toBeReceivedList.size());
    ReceivingResults results = verifyPostResponse(Entities.RECEIVING.getEndpoint(), JsonObject.mapFrom(toBeReceivedRq).encode(), prepareHeaders(EXIST_CONFIG_X_OKAPI_TENANT_LIMIT_10, X_OKAPI_USER_WITH_UNITS_NOT_ASSIGNED_TO_ORDER), APPLICATION_JSON, HttpStatus.HTTP_OK.toInt()).as(ReceivingResults.class);
    List<ProcessingStatus> result = results.getReceivingResults().stream().flatMap(r -> r.getReceivingItemResults().stream().map(ReceivingItemResult::getProcessingStatus)).filter(s -> Objects.isNull(s.getError())).collect(Collectors.toList());
    assertThat(result, hasSize(1));
    List<Error> errors = results.getReceivingResults().stream().flatMap(r -> r.getReceivingItemResults().stream().map(e -> e.getProcessingStatus().getError())).filter(Objects::nonNull).collect(Collectors.toList());
    assertThat(errors, hasSize(toBeReceivedList.size() - 1));
    assertThat(errors.stream().filter(e -> e.getCode().equals(PIECE_NOT_FOUND.getCode())).count(), is(2L));
    assertThat(errors.stream().filter(e -> e.getCode().equals(USER_HAS_NO_PERMISSIONS.getCode())).count(), is(1L));
}

Example 3 with ReceivingCollection

use of org.folio.rest.jaxrs.model.ReceivingCollection in project mod-orders by folio-org.

the class CheckinReceivingApiTest method testReceiveOngoingOrder.

@Test
void testReceiveOngoingOrder() {
    logger.info("=== Test POST Receive - Ongoing PO Lines");
    CompositePoLine poLines = getMockAsJson(POLINES_COLLECTION).getJsonArray("poLines").getJsonObject(9).mapTo(CompositePoLine.class);
    MockServer.addMockTitles(Collections.singletonList(poLines));
    ReceivingCollection receivingRq = getMockAsJson(RECEIVING_RQ_MOCK_DATA_PATH + "receive-physical-ongoing.json").mapTo(ReceivingCollection.class);
    receivingRq.getToBeReceived().get(0).setPoLineId(COMPOSITE_POLINE_ONGOING_ID);
    ReceivingResults results = verifyPostResponse(ORDERS_RECEIVING_ENDPOINT, JsonObject.mapFrom(receivingRq).encode(), prepareHeaders(EXIST_CONFIG_X_OKAPI_TENANT_LIMIT_10), APPLICATION_JSON, 200).as(ReceivingResults.class);
    assertThat(results.getTotalRecords(), equalTo(receivingRq.getTotalRecords()));
    Map<String, Set<String>> pieceIdsByPol = verifyReceivingSuccessRs(results);
    List<JsonObject> pieceSearches = getPieceSearches();
    List<JsonObject> pieceUpdates = getPieceUpdates();
    List<JsonObject> polSearches = getPoLineSearches();
    List<JsonObject> polUpdates = getPoLineUpdates();
    assertThat(pieceSearches, not(nullValue()));
    assertThat(pieceUpdates, not(nullValue()));
    assertThat(polSearches, not(nullValue()));
    int expectedSearchRqQty = Math.floorDiv(receivingRq.getTotalRecords(), MAX_IDS_FOR_GET_RQ) + 1;
    // The piece searches should be made 1 time: 1st time to get all required piece records
    assertThat(pieceSearches, hasSize(expectedSearchRqQty));
    assertThat(pieceUpdates, hasSize(receivingRq.getTotalRecords()));
    assertThat(polSearches, hasSize(pieceIdsByPol.size()));
    // check no status updates were performed
    assertThat(polUpdates, nullValue());
    // Verify no status updated for ongoing order
    verifyOrderStatusUpdateEvent(0);
}

Example 4 with ReceivingCollection

use of org.folio.rest.jaxrs.model.ReceivingCollection in project mod-orders by folio-org.

the class CheckinReceivingApiTest method testPostReceivingPhysicalWithErrors.

@Test
void testPostReceivingPhysicalWithErrors() throws IOException {
    logger.info("=== Test POST Receiving - Receive physical resources with different errors");
    ReceivingCollection receivingRq = getMockAsJson(RECEIVING_RQ_MOCK_DATA_PATH + "receive-physical-resources-6-of-10-with-errors.json").mapTo(ReceivingCollection.class);
    CompositePoLine poLines = getMockAsJson(POLINES_COLLECTION).getJsonArray("poLines").getJsonObject(3).mapTo(CompositePoLine.class);
    MockServer.addMockTitles(Collections.singletonList(poLines));
    ReceivingResults results = verifyPostResponse(ORDERS_RECEIVING_ENDPOINT, JsonObject.mapFrom(receivingRq).encode(), prepareHeaders(EXIST_CONFIG_X_OKAPI_TENANT_LIMIT_10), APPLICATION_JSON, 200).as(ReceivingResults.class);
    assertThat(results.getTotalRecords(), is(receivingRq.getTotalRecords()));
    assertThat(results.getReceivingResults(), hasSize(1));
    ReceivingResult receivingResult = results.getReceivingResults().get(0);
    assertThat(receivingResult.getPoLineId(), not(is(emptyString())));
    assertThat(receivingResult.getProcessedSuccessfully(), is(5));
    assertThat(receivingResult.getProcessedWithError(), is(5));
    Set<String> errorCodes = new HashSet<>();
    for (ReceivingItemResult receivingItemResult : receivingResult.getReceivingItemResults()) {
        assertThat(receivingItemResult.getPieceId(), not(is(emptyString())));
        assertThat(receivingItemResult.getProcessingStatus(), not(nullValue()));
        if (receivingItemResult.getProcessingStatus().getType() == SUCCESS) {
            assertThat(receivingItemResult.getProcessingStatus().getError(), nullValue());
        } else {
            assertThat(receivingItemResult.getProcessingStatus().getError(), not(nullValue()));
            errorCodes.add(receivingItemResult.getProcessingStatus().getError().getCode());
        }
    }
    assertThat(errorCodes, containsInAnyOrder(PIECE_ALREADY_RECEIVED.getCode(), PIECE_POL_MISMATCH.getCode(), PIECE_NOT_FOUND.getCode(), ITEM_UPDATE_FAILED.getCode(), PIECE_UPDATE_FAILED.getCode()));
    List<JsonObject> itemUpdates = getItemUpdates();
    List<JsonObject> polUpdates = getPoLineUpdates();
    assertThat(getPoLineSearches(), hasSize(1));
    assertThat(polUpdates, hasSize(1));
    assertThat(itemUpdates, hasSize(6));
    itemUpdates.forEach(item -> {
        assertThat(item.getJsonObject(ITEM_STATUS), notNullValue());
        assertThat(item.getJsonObject(ITEM_STATUS).getString(ITEM_STATUS_NAME), equalTo(ReceivedItem.ItemStatus.IN_PROCESS.value()));
    });
    polUpdates.forEach(pol -> {
        PoLine poLine = pol.mapTo(PoLine.class);
        assertThat(poLine.getReceiptStatus(), is(PoLine.ReceiptStatus.PARTIALLY_RECEIVED));
        assertThat(poLine.getReceiptDate(), is(nullValue()));
    });
    verifyProperQuantityOfHoldingsCreated(receivingRq);
    // Verify messages sent via event bus
    verifyOrderStatusUpdateEvent(1);
}

Example 5 with ReceivingCollection

use of org.folio.rest.jaxrs.model.ReceivingCollection in project mod-orders by folio-org.

the class CheckinReceivingApiTest method testPostReceivingRevertElectronicResource.

@Test
void testPostReceivingRevertElectronicResource() {
    logger.info("=== Test POST Receiving - Revert received electronic resource");
    CompositePoLine poLines = getMockAsJson(POLINES_COLLECTION).getJsonArray("poLines").getJsonObject(6).mapTo(CompositePoLine.class);
    MockServer.addMockTitles(Collections.singletonList(poLines));
    ReceivingCollection receivingRq = getMockAsJson(RECEIVING_RQ_MOCK_DATA_PATH + "revert-electronic-1-of-1-resource.json").mapTo(ReceivingCollection.class);
    ReceivingResults results = verifyPostResponse(ORDERS_RECEIVING_ENDPOINT, JsonObject.mapFrom(receivingRq).encode(), prepareHeaders(EXIST_CONFIG_X_OKAPI_TENANT_LIMIT_10), APPLICATION_JSON, 200).as(ReceivingResults.class);
    assertThat(results.getTotalRecords(), equalTo(receivingRq.getTotalRecords()));
    verifyReceivingSuccessRs(results);
    List<JsonObject> pieceSearches = getPieceSearches();
    List<JsonObject> pieceUpdates = getPieceUpdates();
    List<JsonObject> itemsSearches = getItemsSearches();
    List<JsonObject> itemUpdates = getItemUpdates();
    List<JsonObject> polSearches = getPoLineSearches();
    List<JsonObject> polUpdates = getPoLineUpdates();
    assertThat(pieceSearches, not(nullValue()));
    assertThat(pieceUpdates, not(nullValue()));
    assertThat(itemsSearches, not(nullValue()));
    assertThat(itemUpdates, not(nullValue()));
    assertThat(polSearches, not(nullValue()));
    assertThat(polUpdates, not(nullValue()));
    // The piece searches should be made 3 times: 1st time to get piece record, 2nd and 3rd times to calculate expected PO Line status
    assertThat(pieceSearches, hasSize(3));
    assertThat(pieceUpdates, hasSize(1));
    assertThat(itemsSearches, hasSize(1));
    assertThat(itemUpdates, hasSize(1));
    assertThat(polSearches, hasSize(1));
    assertThat(polUpdates, hasSize(1));
    itemUpdates.forEach(item -> {
        assertThat(item.getJsonObject(ITEM_STATUS), notNullValue());
        assertThat(item.getString(ITEM_LEVEL_CALL_NUMBER), is(nullValue()));
        assertThat(item.getJsonObject(ITEM_STATUS).getString(ITEM_STATUS_NAME), equalTo(ReceivedItem.ItemStatus.ON_ORDER.value()));
    });
    polUpdates.forEach(pol -> {
        PoLine poLine = pol.mapTo(PoLine.class);
        assertThat(poLine.getReceiptStatus(), is(PoLine.ReceiptStatus.AWAITING_RECEIPT));
        assertThat(poLine.getReceiptDate(), is(nullValue()));
    });
    // Verify messages sent via event bus
    verifyOrderStatusUpdateEvent(1);
}