MODTLR-98 Support for intermediate request

descriptors/ModuleDescriptor-template.json

@@ -28,7 +28,9 @@
             "users.collection.get",
             "users.item.post",
             "inventory-storage.service-points.item.get",
-            "inventory-storage.service-points.collection.get"
+            "inventory-storage.service-points.collection.get",
+            "inventory-storage.service-points.item.post",
+            "user-tenants.collection.get"
           ]
         },
         {

src/main/java/org/folio/domain/entity/EcsTlrEntity.java

@@ -40,4 +40,8 @@ public class EcsTlrEntity {
   private UUID secondaryRequestId;
   private String secondaryRequestTenantId;
   private UUID secondaryRequestDcbTransactionId;
+  private UUID intermediateRequestId;
+  private String intermediateRequestTenantId;
+  private UUID intermediateRequestDcbTransactionId;
+
 }

src/main/java/org/folio/service/DcbService.java

@@ -8,8 +8,11 @@
 import org.folio.domain.entity.EcsTlrEntity;
 
 public interface DcbService {
+  void createTransactions(EcsTlrEntity ecsTlr, Request secondaryRequest);
   void createLendingTransaction(EcsTlrEntity ecsTlr);
-  void createBorrowingTransaction(EcsTlrEntity ecsTlr, Request request);
+  void createBorrowerTransaction(EcsTlrEntity ecsTlr, Request request);
+  void createBorrowingPickupTransaction(EcsTlrEntity ecsTlr, Request request);
+  void createPickupTransaction(EcsTlrEntity ecsTlr, Request request);
   TransactionStatusResponse getTransactionStatus(UUID transactionId, String tenantId);
   TransactionStatusResponse updateTransactionStatus(UUID transactionId,
     TransactionStatus.StatusEnum newStatus, String tenantId);

src/main/java/org/folio/service/RequestService.java

@@ -9,25 +9,24 @@
 import org.folio.domain.dto.InventoryItem;
 import org.folio.domain.dto.ReorderQueue;
 import org.folio.domain.dto.Request;
-import org.folio.domain.entity.EcsTlrEntity;
 import org.folio.support.CqlQuery;
 
 public interface RequestService {
-  RequestWrapper createPrimaryRequest(Request request, String borrowingTenantId);
+  RequestWrapper createPrimaryRequest(Request request, String primaryRequestTenantId,
+    String secondaryRequestTenantId);
 
-  RequestWrapper createSecondaryRequest(Request request, String borrowingTenantId,
-    Collection<String> lendingTenantIds);
+  RequestWrapper createSecondaryRequest(Request request, String primaryRequestTenantId,
+    Collection<String> secondaryRequestTenantIds);
 
-  CirculationItem createCirculationItem(EcsTlrEntity ecsTlr, Request secondaryRequest,
-    String borrowingTenantId, String lendingTenantId);
+  RequestWrapper createIntermediateRequest(Request intermediateRequest,
+    String primaryRequestTenantId, String intermediateRequestTenantId,
+    String secondaryRequestTenantId);
 
   CirculationItem updateCirculationItemOnRequestCreation(CirculationItem circulationItem,
     Request secondaryRequest);
 
   InventoryItem getItemFromStorage(String itemId, String tenantId);
-
   InventoryInstance getInstanceFromStorage(String instanceId, String tenantId);
-
   Request getRequestFromStorage(String requestId, String tenantId);
   Request getRequestFromStorage(String requestId);
   Collection<Request> getRequestsFromStorage(CqlQuery query, String idIndex, Collection<String> ids);

src/main/java/org/folio/service/TenantService.java

@@ -5,7 +5,7 @@
 import org.folio.domain.entity.EcsTlrEntity;
 
 public interface TenantService {
-  String getBorrowingTenant(EcsTlrEntity ecsTlr);
+  String getPrimaryRequestTenantId(EcsTlrEntity ecsTlr);
 
-  List<String> getLendingTenants(EcsTlrEntity ecsTlr);
+  List<String> getSecondaryRequestTenants(EcsTlrEntity ecsTlr);
 }

src/main/java/org/folio/service/impl/AllowedServicePointsServiceImpl.java

@@ -62,8 +62,6 @@ private AllowedServicePointsResponse getForCreate(AllowedServicePointsRequest re
     Map<String, AllowedServicePointsInner> recall = new HashMap<>();
     for (String tenantId : getLendingTenants(request)) {
       var servicePoints = getAllowedServicePointsFromTenant(request, patronGroupId, tenantId);
-      log.info("getForCreate:: service points from {}: {}", tenantId, servicePoints);
-
       combineAndFilterDuplicates(page, servicePoints.getPage());
       combineAndFilterDuplicates(hold, servicePoints.getHold());
       combineAndFilterDuplicates(recall, servicePoints.getRecall());

src/main/java/org/folio/service/impl/DcbServiceImpl.java

@@ -1,14 +1,17 @@
 package org.folio.service.impl;
 
 import static org.folio.domain.dto.DcbTransaction.RoleEnum.BORROWER;
+import static org.folio.domain.dto.DcbTransaction.RoleEnum.BORROWING_PICKUP;
 import static org.folio.domain.dto.DcbTransaction.RoleEnum.LENDER;
+import static org.folio.domain.dto.DcbTransaction.RoleEnum.PICKUP;
 
 import java.util.UUID;
 
 import org.folio.client.feign.DcbEcsTransactionClient;
 import org.folio.client.feign.DcbTransactionClient;
 import org.folio.domain.dto.DcbItem;
 import org.folio.domain.dto.DcbTransaction;
+import org.folio.domain.dto.DcbTransaction.RoleEnum;
 import org.folio.domain.dto.Request;
 import org.folio.domain.dto.TransactionStatus;
 import org.folio.domain.dto.TransactionStatusResponse;
@@ -43,27 +46,53 @@ public void createLendingTransaction(EcsTlrEntity ecsTlr) {
     DcbTransaction transaction = new DcbTransaction()
       .requestId(ecsTlr.getSecondaryRequestId().toString())
       .role(LENDER);
-    final UUID lendingTransactionId = createTransaction(transaction, ecsTlr.getSecondaryRequestTenantId());
-    ecsTlr.setSecondaryRequestDcbTransactionId(lendingTransactionId);
+    final UUID transactionId = createTransaction(transaction, ecsTlr.getSecondaryRequestTenantId());
+    ecsTlr.setSecondaryRequestDcbTransactionId(transactionId);
     log.info("createTransactions:: lending transaction {} for ECS TLR {} created",
-      () -> lendingTransactionId, ecsTlr::getId);
+      () -> transactionId, ecsTlr::getId);
   }
 
   @Override
-  public void createBorrowingTransaction(EcsTlrEntity ecsTlr, Request request) {
-    log.info("createBorrowingTransaction:: creating borrowing transaction for ECS TLR {}", ecsTlr::getId);
+  public void createBorrowerTransaction(EcsTlrEntity ecsTlr, Request request) {
+    log.info("createBorrowerTransaction:: creating borrower transaction for ECS TLR {}", ecsTlr::getId);
+    DcbTransaction transaction = buildTransaction(request, BORROWER, ecsTlr.getIntermediateRequestId());
+    final UUID transactionId = createTransaction(transaction, ecsTlr.getIntermediateRequestTenantId());
+    ecsTlr.setIntermediateRequestDcbTransactionId(transactionId);
+    log.info("createBorrowerTransaction:: borrower transaction {} for ECS TLR {} created",
+      () -> transactionId, ecsTlr::getId);
+  }
+
+  @Override
+  public void createBorrowingPickupTransaction(EcsTlrEntity ecsTlr, Request request) {
+    log.info("createBorrowingPickupTransaction:: creating borrowing-pickup transaction for ECS TLR {}",
+      ecsTlr::getId);
+    DcbTransaction transaction = buildTransaction(request, BORROWING_PICKUP, ecsTlr.getPrimaryRequestId());
+    final UUID transactionId = createTransaction(transaction, ecsTlr.getPrimaryRequestTenantId());
+    ecsTlr.setPrimaryRequestDcbTransactionId(transactionId);
+    log.info("createBorrowingPickupTransaction:: borrowing-pickup transaction {} for ECS TLR {} created",
+      () -> transactionId, ecsTlr::getId);
+  }
+
+  @Override
+  public void createPickupTransaction(EcsTlrEntity ecsTlr, Request request) {
+    log.info("createPickupTransaction:: creating pickup transaction for ECS TLR {}", ecsTlr.getId());
+    DcbTransaction transaction = buildTransaction(request, PICKUP, ecsTlr.getPrimaryRequestId());
+    final UUID transactionId = createTransaction(transaction, ecsTlr.getPrimaryRequestTenantId());
+    ecsTlr.setPrimaryRequestDcbTransactionId(transactionId);
+    log.info("createPickupTransaction:: pickup transaction {} for ECS TLR {} created",
+      () -> transactionId, ecsTlr::getId);
+  }
+
+  private DcbTransaction buildTransaction(Request request, RoleEnum role, UUID requestId) {
     DcbItem dcbItem = new DcbItem()
       .id(request.getItemId())
       .title(request.getInstance().getTitle())
       .barcode(request.getItem().getBarcode());
-    DcbTransaction transaction = new DcbTransaction()
-      .requestId(ecsTlr.getPrimaryRequestId().toString())
+
+    return new DcbTransaction()
+      .requestId(requestId.toString())
       .item(dcbItem)
-      .role(BORROWER);
-    final UUID borrowingTransactionId = createTransaction(transaction, ecsTlr.getPrimaryRequestTenantId());
-    ecsTlr.setPrimaryRequestDcbTransactionId(borrowingTransactionId);
-    log.info("createBorrowingTransaction:: borrowing transaction {} for ECS TLR {} created",
-      () -> borrowingTransactionId, ecsTlr::getId);
+      .role(role);
   }
 
   private UUID createTransaction(DcbTransaction transaction, String tenantId) {
@@ -97,4 +126,21 @@ public TransactionStatusResponse updateTransactionStatus(UUID transactionId,
         transactionId.toString(), new TransactionStatus().status(newStatus)));
   }
 
+  @Override
+  public void createTransactions(EcsTlrEntity ecsTlr, Request secondaryRequest) {
+    log.info("createTransactions:: creating transactions for ECS TLR {}", ecsTlr::getId);
+    if (secondaryRequest.getItemId() == null) {
+      log.info("createDcbTransactions:: secondary request has no item ID");
+      return;
+    }
+    createLendingTransaction(ecsTlr);
+    log.info("createTransactions:: intermediate request ID: {}", ecsTlr::getIntermediateRequestId);
+    if (ecsTlr.getIntermediateRequestId() == null) {
+      createBorrowingPickupTransaction(ecsTlr, secondaryRequest);
+    } else {
+      createBorrowerTransaction(ecsTlr, secondaryRequest);
+      createPickupTransaction(ecsTlr, secondaryRequest);
+    }
+  }
+
 }

src/main/java/org/folio/service/impl/EcsTlrServiceImpl.java

@@ -1,14 +1,19 @@
 package org.folio.service.impl;
 
+import static java.util.Optional.of;
+import static org.folio.domain.dto.Request.EcsRequestPhaseEnum.INTERMEDIATE;
+import static org.folio.domain.dto.Request.EcsRequestPhaseEnum.PRIMARY;
+
 import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 import org.folio.domain.RequestWrapper;
-import org.folio.domain.dto.CirculationItem;
 import org.folio.domain.dto.EcsTlr;
 import org.folio.domain.dto.Request;
+import org.folio.domain.dto.Request.EcsRequestPhaseEnum;
 import org.folio.domain.entity.EcsTlrEntity;
 import org.folio.domain.mapper.EcsTlrMapper;
 import org.folio.exception.TenantPickingException;
@@ -17,6 +22,7 @@
 import org.folio.service.EcsTlrService;
 import org.folio.service.RequestService;
 import org.folio.service.TenantService;
+import org.folio.service.UserTenantsService;
 import org.springframework.stereotype.Service;
 
 import lombok.RequiredArgsConstructor;
@@ -32,6 +38,7 @@ public class EcsTlrServiceImpl implements EcsTlrService {
   private final TenantService tenantService;
   private final RequestService requestService;
   private final DcbService dcbService;
+  private final UserTenantsService userTenantsService;
 
   @Override
   public Optional<EcsTlr> get(UUID id) {
@@ -47,23 +54,35 @@ public EcsTlr create(EcsTlr ecsTlrDto) {
       ecsTlrDto.getInstanceId(), ecsTlrDto.getItemId(), ecsTlrDto.getRequesterId());
 
     final EcsTlrEntity ecsTlr = requestsMapper.mapDtoToEntity(ecsTlrDto);
-    String borrowingTenantId = getBorrowingTenant(ecsTlr);
-    Collection<String> lendingTenantIds = getLendingTenants(ecsTlr);
-    RequestWrapper secondaryRequest = requestService.createSecondaryRequest(
-      buildSecondaryRequest(ecsTlr), borrowingTenantId, lendingTenantIds);
-
-    log.info("create:: Creating circulation item for ECS TLR (ILR) {}", ecsTlrDto.getId());
-    CirculationItem circulationItem = requestService.createCirculationItem(ecsTlr,
-      secondaryRequest.request(), borrowingTenantId, secondaryRequest.tenantId());
+    String primaryRequestTenantId = getPrimaryRequestTenant(ecsTlr);
+    Collection<String> secondaryRequestsTenantIds = getSecondaryRequestTenants(ecsTlr).stream()
+      .filter(tenantId -> !tenantId.equals(primaryRequestTenantId))
+      .collect(Collectors.toList());
 
-    RequestWrapper primaryRequest = requestService.createPrimaryRequest(
-      buildPrimaryRequest(secondaryRequest.request()), borrowingTenantId);
+    log.info("create:: Creating secondary request for ECS TLR (ILR), instance {}, item {}, requester {}",
+      ecsTlrDto.getInstanceId(), ecsTlrDto.getItemId(), ecsTlrDto.getRequesterId());
+    RequestWrapper secondaryRequestWrapper = requestService.createSecondaryRequest(
+      buildSecondaryRequest(ecsTlr), primaryRequestTenantId, secondaryRequestsTenantIds);
+    Request secondaryRequest = secondaryRequestWrapper.request();
+    String secondaryRequestTenantId = secondaryRequestWrapper.tenantId();
 
-    requestService.updateCirculationItemOnRequestCreation(circulationItem,
-      secondaryRequest.request());
+    log.info("create:: Creating primary request for ECS TLR (ILR), instance {}, item {}, requester {}",
+      ecsTlrDto.getInstanceId(), ecsTlrDto.getItemId(), ecsTlrDto.getRequesterId());
+    RequestWrapper primaryRequestWrapper = requestService.createPrimaryRequest(
+      buildPrimaryRequest(secondaryRequest), primaryRequestTenantId, secondaryRequestTenantId);
+
+    updateEcsTlr(ecsTlr, primaryRequestWrapper, secondaryRequestWrapper);
+
+    var centralTenantId = userTenantsService.getCentralTenantId();
+    if (!primaryRequestTenantId.equals(centralTenantId)) {
+      log.info("create:: Primary request tenant is not central, creating intermediate request");
+      RequestWrapper intermediateRequest = requestService.createIntermediateRequest(
+        buildIntermediateRequest(secondaryRequest), primaryRequestTenantId, centralTenantId,
+        secondaryRequestTenantId);
+      updateEcsTlrWithIntermediateRequest(ecsTlr, intermediateRequest);
+    }
 
-    updateEcsTlr(ecsTlr, primaryRequest, secondaryRequest);
-    createDcbTransactions(ecsTlr, secondaryRequest.request());
+    dcbService.createTransactions(ecsTlr, secondaryRequest);
 
     return requestsMapper.mapEntityToDto(save(ecsTlr));
   }
@@ -90,28 +109,28 @@ public boolean delete(UUID requestId) {
     return false;
   }
 
-  private String getBorrowingTenant(EcsTlrEntity ecsTlr) {
-    log.info("getBorrowingTenant:: getting borrowing tenant");
-    final String borrowingTenantId = tenantService.getBorrowingTenant(ecsTlr);
-    log.info("getBorrowingTenant:: borrowing tenant: {}", borrowingTenantId);
+  private String getPrimaryRequestTenant(EcsTlrEntity ecsTlr) {
+    log.info("getPrimaryRequestTenant:: getting primary request tenant");
+    final String primaryRequestTenantId = tenantService.getPrimaryRequestTenantId(ecsTlr);
+    log.info("getPrimaryRequestTenant:: primary request tenant: {}", primaryRequestTenantId);
 
-    if (borrowingTenantId == null) {
-      throw new TenantPickingException("Failed to get borrowing tenant");
+    if (primaryRequestTenantId == null) {
+      throw new TenantPickingException("Failed to get primary request tenant");
     }
 
-    return borrowingTenantId;
+    return primaryRequestTenantId;
   }
 
-  private Collection<String> getLendingTenants(EcsTlrEntity ecsTlr) {
+  private Collection<String> getSecondaryRequestTenants(EcsTlrEntity ecsTlr) {
     final String instanceId = ecsTlr.getInstanceId().toString();
-    log.info("getLendingTenants:: looking for lending tenants for instance {}", instanceId);
-    List<String> tenantIds = tenantService.getLendingTenants(ecsTlr);
+    log.info("getSecondaryRequestTenants:: looking for secondary request tenants for instance {}", instanceId);
+    List<String> tenantIds = tenantService.getSecondaryRequestTenants(ecsTlr);
     if (tenantIds.isEmpty()) {
-      log.error("getLendingTenants:: failed to find lending tenants for instance: {}", instanceId);
-      throw new TenantPickingException("Failed to find lending tenants for instance " + instanceId);
+      log.error("getSecondaryRequestTenants:: failed to find lending tenants for instance: {}", instanceId);
+      throw new TenantPickingException("Failed to find secondary request tenants for instance " + instanceId);
     }
 
-    log.info("getLendingTenants:: lending tenants found: {}", tenantIds);
+    log.info("getSecondaryRequestTenants:: secondary request tenants found: {}", tenantIds);
     return tenantIds;
   }
 
@@ -125,6 +144,14 @@ private EcsTlrEntity save(EcsTlrEntity ecsTlr) {
   }
 
   private static Request buildPrimaryRequest(Request secondaryRequest) {
+    return buildRequest(secondaryRequest, PRIMARY);
+  }
+
+  private static Request buildIntermediateRequest(Request secondaryRequest) {
+    return buildRequest(secondaryRequest, INTERMEDIATE);
+  }
+
+  private static Request buildRequest(Request secondaryRequest, EcsRequestPhaseEnum ecsRequestPhase) {
     return new Request()
       .id(secondaryRequest.getId())
       .instanceId(secondaryRequest.getInstanceId())
@@ -134,14 +161,14 @@ private static Request buildPrimaryRequest(Request secondaryRequest) {
       .requestDate(secondaryRequest.getRequestDate())
       .requestLevel(secondaryRequest.getRequestLevel())
       .requestType(secondaryRequest.getRequestType())
-      .ecsRequestPhase(Request.EcsRequestPhaseEnum.PRIMARY)
+      .ecsRequestPhase(ecsRequestPhase)
       .fulfillmentPreference(secondaryRequest.getFulfillmentPreference())
       .pickupServicePointId(secondaryRequest.getPickupServicePointId());
   }
 
   private Request buildSecondaryRequest(EcsTlrEntity ecsTlr) {
     return requestsMapper.mapEntityToRequest(ecsTlr)
-      .ecsRequestPhase(Request.EcsRequestPhaseEnum.SECONDARY);
+      .ecsRequestPhase(EcsRequestPhaseEnum.SECONDARY);
   }
 
   private static void updateEcsTlr(EcsTlrEntity ecsTlr, RequestWrapper primaryRequest,
@@ -153,7 +180,7 @@ private static void updateEcsTlr(EcsTlrEntity ecsTlr, RequestWrapper primaryRequ
     ecsTlr.setPrimaryRequestId(UUID.fromString(primaryRequest.request().getId()));
     ecsTlr.setSecondaryRequestId(UUID.fromString(secondaryRequest.request().getId()));
 
-    Optional.of(secondaryRequest.request())
+    of(secondaryRequest.request())
       .map(Request::getItemId)
       .map(UUID::fromString)
       .ifPresent(ecsTlr::setItemId);
@@ -162,13 +189,15 @@ private static void updateEcsTlr(EcsTlrEntity ecsTlr, RequestWrapper primaryRequ
     log.debug("updateEcsTlr:: ECS TLR: {}", () -> ecsTlr);
   }
 
-  private void createDcbTransactions(EcsTlrEntity ecsTlr, Request secondaryRequest) {
-    if (secondaryRequest.getItemId() == null) {
-      log.info("createDcbTransactions:: secondary request has no item ID");
-      return;
-    }
-    dcbService.createBorrowingTransaction(ecsTlr, secondaryRequest);
-    dcbService.createLendingTransaction(ecsTlr);
+  private static void updateEcsTlrWithIntermediateRequest(EcsTlrEntity ecsTlr,
+    RequestWrapper intermediateRequest) {
+
+    log.info("updateEcsTlrWithIntermediateRequest:: updating ECS TLR in memory");
+    ecsTlr.setIntermediateRequestTenantId(intermediateRequest.tenantId());
+    ecsTlr.setIntermediateRequestId(UUID.fromString(intermediateRequest.request().getId()));
+
+    log.info("updateEcsTlrWithIntermediateRequest:: ECS TLR updated in memory");
+    log.debug("updateEcsTlrWithIntermediateRequest:: ECS TLR: {}", () -> ecsTlr);
   }
 
 }