MODORDERS-1254. BE - Allow user to view PO value for any related fiscal year (#1170)

* MODORDERS-1254. BE - Allow user to view PO value for any related fiscal year

* MODORDERS-1254. Code review improvements

* MODORDERS-1254. Fix sonar complains

* MODORDERS-1254. Fix sonar complains

Author: SerhiiNosko

descriptors/ModuleDescriptor-template.json

@@ -135,6 +135,21 @@
             "finance-storage.ledgers.collection.get",
             "inventory-storage.holdings.collection.get"
           ]
+        },
+        {
+          "methods": [
+            "GET"
+          ],
+          "pathPattern": "/orders/composite-orders/{id}/fiscal-years",
+          "permissionsRequired": [
+            "orders.fiscal-years.collection.get"
+          ],
+          "modulePermissions": [
+            "finance.transactions.collection.get",
+            "finance.fiscal-years.collection.get",
+            "finance.fiscal-years.item.get",
+            "mod-settings.global.read.stripes-core.prefs.manage"
+          ]
         }
       ]
     },
@@ -1561,6 +1576,11 @@
       "displayName": "orders - re-encumber an order",
       "description": "Re-encumber an order"
     },
+    {
+      "permissionName": "orders.fiscal-years.collection.get",
+      "displayName": "orders - get available fiscal years",
+      "description": "Get available fiscal years for an order"
+    },
     {
       "permissionName": "orders.po-lines.collection.get",
       "displayName": "Orders - get collection of PO lines",
@@ -2170,6 +2190,7 @@
         "orders.configuration.prefixes.all",
         "orders.configuration.suffixes.all",
         "orders.re-encumber.item.post",
+        "orders.fiscal-years.collection.get",
         "orders.rollover.item.post",
         "orders.holding-summary.collection.get",
         "orders.acquisition-methods.all",

ramls/order.raml

@@ -12,6 +12,7 @@ types:
   composite-purchase-order: !include acq-models/mod-orders/schemas/composite_purchase_order.json
   purchase-order-collection: !include acq-models/mod-orders-storage/schemas/purchase_order_collection.json
   purchase_order: !include acq-models/mod-orders-storage/schemas/purchase_order.json
+  fiscal-year-collection: !include acq-models/mod-finance/schemas/fiscal_year_collection.json
   errors: !include raml-util/schemas/errors.schema
 
   UUID:
@@ -54,6 +55,12 @@ resourceTypes:
       is: [validate]
       get:
         description: Return a purchase order with given {id}
+        queryParameters:
+          fiscalYearId:
+            displayName: Fiscal Year ID
+            type: UUID
+            required: false
+            description: Filter order by fiscal year ID
       put:
         description: |
           Update a purchase order with given {id}
@@ -102,4 +109,42 @@ resourceTypes:
                     value: !include raml-util/examples/errors.sample
                 text/plain:
                   example: "Internal server error, contact administrator"
-
+      /fiscal-years:
+        get:
+          description: Get available fiscal years for a purchase order
+          responses:
+            200:
+              description: "Fiscal years retrieved successfully"
+              body:
+                application/json:
+                  type: fiscal-year-collection
+                  example:
+                    strict: false
+                    value: !include acq-models/mod-finance/examples/fiscal_year_collection.sample
+            400:
+              description: "Bad request"
+              body:
+                application/json:
+                  example:
+                    strict: false
+                    value: !include raml-util/examples/errors.sample
+                text/plain:
+                  example: "Bad request"
+            404:
+              description: "Order not found"
+              body:
+                application/json:
+                  example:
+                    strict: false
+                    value: !include raml-util/examples/errors.sample
+                text/plain:
+                  example: "Order not found"
+            500:
+              description: "Internal server error"
+              body:
+                application/json:
+                  example:
+                    strict: false
+                    value: !include raml-util/examples/errors.sample
+                text/plain:
+                  example: "Internal server error, contact administrator"

src/main/java/org/folio/config/ApplicationConfig.java

@@ -81,6 +81,7 @@
 import org.folio.service.orders.PurchaseOrderStorageService;
 import org.folio.service.orders.ReEncumbranceHoldersBuilder;
 import org.folio.service.orders.CompositeOrderTotalFieldsPopulateService;
+import org.folio.service.orders.OrderFiscalYearService;
 import org.folio.service.orders.flows.update.open.OpenCompositeOrderFlowValidator;
 import org.folio.service.orders.flows.update.open.OpenCompositeOrderHolderBuilder;
 import org.folio.service.orders.flows.update.open.OpenCompositeOrderInventoryService;
@@ -877,4 +878,9 @@ CirculationRequestsRetriever circulationRequestsRetriever(PieceStorageService pi
   SettingsRetriever settingsRetriever(RestClient restClient) {
     return new SettingsRetriever(restClient);
   }
+
+  @Bean
+  OrderFiscalYearService orderFiscalYearService(TransactionService transactionService, FiscalYearService fiscalYearService) {
+    return new OrderFiscalYearService(transactionService, fiscalYearService);
+  }
 }

src/main/java/org/folio/helper/PurchaseOrderHelper.java

@@ -388,10 +388,11 @@ public Future<Void> deleteOrder(String orderId, RequestContext requestContext) {
   /**
    * Gets purchase order by id
    *
-   * @param orderId purchase order uuid
+   * @param orderId      purchase order uuid
+   * @param fiscalYearId fiscal year id for fetching totals
    * @return completable future with {@link CompositePurchaseOrder} on success or an exception if processing fails
    */
-  public Future<CompositePurchaseOrder> getCompositeOrder(String orderId, RequestContext requestContext) {
+  public Future<CompositePurchaseOrder> getCompositeOrder(String orderId, String fiscalYearId, RequestContext requestContext) {
     Promise<CompositePurchaseOrder> promise = Promise.promise();
     purchaseOrderStorageService.getPurchaseOrderByIdAsJson(orderId, requestContext)
       .map(HelperUtils::convertToCompositePurchaseOrder)
@@ -407,7 +408,8 @@ public Future<CompositePurchaseOrder> getCompositeOrder(String orderId, RequestC
             populateInstanceId(linesIdTitles, compPO.getPoLines());
             return null;
           })
-          .compose(po -> combinedPopulateService.populate(new CompositeOrderRetrieveHolder(compPO), requestContext)))
+          .compose(po -> combinedPopulateService.populate(new CompositeOrderRetrieveHolder(compPO)
+            .withFiscalYearId(fiscalYearId), requestContext)))
         .map(CompositeOrderRetrieveHolder::getOrder))
       .onSuccess(promise::complete)
       .onFailure(t -> {

src/main/java/org/folio/models/CompositeOrderRetrieveHolder.java

@@ -1,39 +1,32 @@
 package org.folio.models;
 
-import java.util.Optional;
-
-import org.folio.rest.acq.model.finance.FiscalYear;
+import lombok.Data;
 import org.folio.rest.jaxrs.model.CompositePurchaseOrder;
 
+@Data
 public class CompositeOrderRetrieveHolder {
     private CompositePurchaseOrder order;
-    private FiscalYear fiscalYear;
+    private String fiscalYearId;
+    private String fiscalYearCurrency;
 
     public CompositeOrderRetrieveHolder(CompositePurchaseOrder order) {
         this.order = order;
     }
 
-    public FiscalYear getFiscalYear() {
-        return fiscalYear;
-    }
-
-    public CompositeOrderRetrieveHolder withFiscalYear(FiscalYear fiscalYear) {
-        this.fiscalYear = fiscalYear;
+    public CompositeOrderRetrieveHolder withFiscalYearId(String fiscalYearId) {
+        this.fiscalYearId = fiscalYearId;
         return this;
     }
 
-    public CompositePurchaseOrder getOrder() {
-        return order;
+    public CompositeOrderRetrieveHolder withFiscalYearCurrency(String currency) {
+      this.fiscalYearCurrency = currency;
+      return this;
     }
 
     public String getOrderId() {
         return order.getId();
     }
 
-    public String getFiscalYearId() {
-        return Optional.ofNullable(fiscalYear).map(FiscalYear::getId).orElse(null);
-    }
-
     public CompositeOrderRetrieveHolder withTotalEncumbered(double transactionsTotal) {
         order.setTotalEncumbered(transactionsTotal);
         return this;

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

@@ -16,6 +16,7 @@
 import org.folio.rest.jaxrs.model.LedgerFiscalYearRollover;
 import org.folio.rest.jaxrs.resource.OrdersCompositeOrders;
 import org.folio.rest.jaxrs.resource.OrdersRollover;
+import org.folio.service.orders.OrderFiscalYearService;
 import org.folio.service.orders.OrderReEncumberService;
 import org.folio.service.orders.OrderRolloverService;
 import org.folio.spring.SpringContextUtil;
@@ -34,6 +35,8 @@ public class OrdersApi extends BaseApi implements OrdersCompositeOrders, OrdersR
   private OrderReEncumberService orderReEncumberService;
   @Autowired
   private PurchaseOrderHelper purchaseOrderHelper;
+  @Autowired
+  private OrderFiscalYearService orderFiscalYearService;
 
   public OrdersApi(Vertx vertx, String tenantId) {
     SpringContextUtil.autowireDependencies(this, Vertx.currentContext());
@@ -51,10 +54,10 @@ public void deleteOrdersCompositeOrdersById(String id, Map<String, String> okapi
 
   @Override
   @Validate
-  public void getOrdersCompositeOrdersById(String id, Map<String, String> okapiHeaders,
+  public void getOrdersCompositeOrdersById(String id, String fiscalYearId, Map<String, String> okapiHeaders,
       Handler<AsyncResult<Response>> asyncResultHandler, Context vertxContext) {
 
-    purchaseOrderHelper.getCompositeOrder(id, new RequestContext(vertxContext, okapiHeaders))
+    purchaseOrderHelper.getCompositeOrder(id, fiscalYearId, new RequestContext(vertxContext, okapiHeaders))
       .onSuccess(order -> asyncResultHandler.handle(succeededFuture(buildOkResponse(order))))
       .onFailure(t -> handleErrorResponse(asyncResultHandler, t));
   }
@@ -109,4 +112,12 @@ public void postOrdersRollover(LedgerFiscalYearRollover ledgerFYRollover, Map<St
       .onSuccess(v -> asyncResultHandler.handle(succeededFuture(buildNoContentResponse())))
       .onFailure(fail -> handleErrorResponse(asyncResultHandler, fail));
   }
+
+  @Override
+  @Validate
+  public void getOrdersCompositeOrdersFiscalYearsById(String id, Map<String, String> okapiHeaders, Handler<AsyncResult<Response>> asyncResultHandler, Context vertxContext) {
+    orderFiscalYearService.getAvailableFiscalYears(id, new RequestContext(vertxContext, okapiHeaders))
+      .onSuccess(fiscalYears -> asyncResultHandler.handle(succeededFuture(buildOkResponse(fiscalYears))))
+      .onFailure(t -> handleErrorResponse(asyncResultHandler, t));
+  }
 }

src/main/java/org/folio/service/finance/FiscalYearService.java

@@ -1,19 +1,28 @@
 package org.folio.service.finance;
 
+import static one.util.streamex.StreamEx.ofSubLists;
 import static org.folio.orders.utils.CacheUtils.buildAsyncCache;
+import static org.folio.orders.utils.HelperUtils.collectResultsOnSuccess;
+import static org.folio.orders.utils.QueryUtils.convertIdsToCqlQuery;
 import static org.folio.orders.utils.ResourcePathResolver.FISCAL_YEARS;
 import static org.folio.orders.utils.ResourcePathResolver.LEDGER_CURRENT_FISCAL_YEAR;
 import static org.folio.orders.utils.ResourcePathResolver.resourceByIdPath;
 import static org.folio.orders.utils.ResourcePathResolver.resourcesPath;
+import static org.folio.rest.RestConstants.MAX_IDS_FOR_GET_RQ_15;
 import static org.folio.rest.core.exceptions.ErrorCodes.CURRENT_FISCAL_YEAR_NOT_FOUND;
 
 import java.time.Instant;
 import java.time.ZoneId;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 import java.util.concurrent.CompletionException;
+import java.util.stream.Collectors;
 
 import com.github.benmanes.caffeine.cache.AsyncCache;
 import io.vertx.core.Vertx;
@@ -103,12 +112,32 @@ private Future<String> getSeriesByFiscalYearId(String fiscalYearId, RequestConte
         .toCompletionStage().toCompletableFuture()));
   }
 
-  private Future<FiscalYear> getFiscalYearById(String fiscalYearId, RequestContext requestContext) {
+  public Future<FiscalYear> getFiscalYearById(String fiscalYearId, RequestContext requestContext) {
     var requestEntry = new RequestEntry(FISCAL_YEAR_BY_ID_ENDPOINT).withId(fiscalYearId);
     return restClient.get(requestEntry, FiscalYear.class, requestContext)
       .onFailure(t -> log.error("Unable to fetch fiscal year by id: {}", fiscalYearId, t));
   }
 
+  public Future<List<FiscalYear>> getAllFiscalYears(Collection<String> fiscalYearIds, RequestContext requestContext) {
+    Set<String> uniqueFiscalYearIds = new LinkedHashSet<>(fiscalYearIds);
+    return collectResultsOnSuccess(
+      ofSubLists(new ArrayList<>(uniqueFiscalYearIds), MAX_IDS_FOR_GET_RQ_15)
+        .map(ids-> getAllFiscalYearsByIds(ids, requestContext))
+        .toList())
+      .map(lists -> lists.stream()
+        .flatMap(Collection::stream)
+        .toList());
+  }
+
+  private Future<List<FiscalYear>> getAllFiscalYearsByIds(Collection<String> ids, RequestContext requestContext) {
+    String query = convertIdsToCqlQuery(ids);
+    RequestEntry requestEntry = new RequestEntry(FISCAL_YEARS_ENDPOINT).withQuery(query)
+      .withLimit(MAX_IDS_FOR_GET_RQ_15)
+      .withOffset(0);
+    return restClient.get(requestEntry, FiscalYearCollection.class, requestContext)
+      .map(FiscalYearCollection::getFiscalYears);
+  }
+
   private Future<String> getCurrentFiscalYearForSeries(String series, RequestContext requestContext) {
     var cacheKey = CACHE_KEY_TEMPLATE.formatted(series, TenantTool.tenantId(requestContext.getHeaders()));
     return Future.fromCompletionStage(currentFiscalYearCacheBySeries.get(cacheKey, (key, executor) ->

src/main/java/org/folio/service/orders/CompositeOrderRetrieveHolderBuilder.java

@@ -1,9 +1,11 @@
 package org.folio.service.orders;
 
 import java.util.Objects;
-import java.util.concurrent.CompletionException;
 
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.folio.models.CompositeOrderRetrieveHolder;
+import org.folio.rest.acq.model.finance.FiscalYear;
 import org.folio.rest.core.exceptions.HttpException;
 import org.folio.rest.core.models.RequestContext;
 import org.folio.rest.jaxrs.model.FundDistribution;
@@ -19,24 +21,45 @@ public CompositeOrderRetrieveHolderBuilder(FiscalYearService fiscalYearService)
   }
 
   public Future<CompositeOrderRetrieveHolder> withCurrentFiscalYear(CompositeOrderRetrieveHolder holder,
-      RequestContext requestContext) {
+                                                                    RequestContext requestContext) {
+    return getFiscalYear(holder, requestContext)
+      .map(fiscalYear -> {
+        if (fiscalYear != null) {
+          holder.withFiscalYearId(fiscalYear.getId());
+          holder.withFiscalYearCurrency(fiscalYear.getCurrency());
+        }
+        return holder;
+      })
+      .otherwise(t -> handleFiscalYearError(holder, t));
+  }
+
+  private Future<FiscalYear> getFiscalYear(CompositeOrderRetrieveHolder holder, RequestContext requestContext) {
+    if (StringUtils.isNotBlank(holder.getFiscalYearId())) {
+      return fiscalYearService.getFiscalYearById(holder.getFiscalYearId(), requestContext);
+    }
+
+    if (holder.getOrder() == null || CollectionUtils.isEmpty(holder.getOrder().getPoLines())) {
+      return Future.succeededFuture(null);
+    }
+
     return holder.getOrder()
       .getPoLines()
       .stream()
-      .flatMap(poLine -> poLine.getFundDistribution()
-        .stream())
+      .flatMap(poLine ->  poLine.getFundDistribution().stream())
+      .filter(Objects::nonNull)
       .map(FundDistribution::getFundId)
+      .filter(StringUtils::isNotBlank)
       .findFirst()
-      .map(fundId -> fiscalYearService.getCurrentFiscalYearByFundId(fundId, requestContext)
-        .map(holder::withFiscalYear)
-         .otherwise(t -> {
-          Throwable cause = Objects.nonNull(t.getCause()) ? t.getCause() : t;
-          if (cause instanceof HttpException && ((HttpException) cause).getCode() == 404) {
-            return holder;
-          }
-          throw new CompletionException(cause);
-        }))
-      .orElseGet(() ->  Future.succeededFuture(holder));
+      .map(fundId -> fiscalYearService.getCurrentFiscalYearByFundId(fundId, requestContext))
+      .orElseGet(() -> Future.succeededFuture(null));
+  }
+
+  private CompositeOrderRetrieveHolder handleFiscalYearError(CompositeOrderRetrieveHolder holder, Throwable t) {
+    Throwable cause = Objects.nonNull(t.getCause()) ? t.getCause() : t;
+    if (cause instanceof HttpException && ((HttpException) cause).getCode() == 404) {
+      return holder;
+    }
+    throw new HttpException(500, cause.getMessage(), cause);
   }
 
 }