CIRC-2099 POST Api implementation

descriptors/ModuleDescriptor-template.json

@@ -737,6 +737,22 @@
         }
       ]
     },
+    {
+      "id": "print-events",
+      "version": "1.0",
+      "handlers": [
+        {
+          "methods": ["POST"],
+          "pathPattern": "/circulation/print-events-entry",
+          "permissionsRequired": [
+            "circulation.print-events-entry.item.post"
+          ],
+          "modulePermissions": [
+            "print-events-storage.print-events-entry.item.post"
+          ]
+        }
+      ]
+    },
     {
       "id": "_timer",
       "version": "1.0",
@@ -1318,6 +1334,10 @@
     {
       "id": "circulation-settings-storage",
       "version": "1.0"
+    },
+    {
+      "id": "print-events-storage",
+      "version": "1.0"
     }
   ],
   "optional": [
@@ -1327,6 +1347,11 @@
     }
   ],
   "permissionSets": [
+    {
+      "permissionName": "circulation.print-events-entry.item.post",
+      "displayName": "circulation - create print events",
+      "description": "create print event logs"
+    },
     {
       "permissionName": "circulation.requests.queue.reorder.collection.post",
       "displayName": "circulation - reorder queue for an item",

ramls/examples/print-events-request.json

@@ -0,0 +1,9 @@
+{
+  "requestIds": [
+    "059e54bb-53e5-4039-a2fb-b34358e88b0a",
+    "e70dcbae-30c6-47ac-94f8-4ffefd44a935"
+  ],
+  "requesterId": "d51470ea-5daa-480b-a4aa-09c8c6d9940e",
+  "requesterName": "requester",
+  "printEventDate": "2024-06-25T20:00:00+05:30"
+}

src/main/java/org/folio/circulation/CirculationVerticle.java

@@ -31,6 +31,7 @@
 import org.folio.circulation.resources.OverdueFineCirculationRulesEngineResource;
 import org.folio.circulation.resources.OverdueFineScheduledNoticeProcessingResource;
 import org.folio.circulation.resources.PickSlipsResource;
+import org.folio.circulation.resources.PrintEventsResource;
 import org.folio.circulation.resources.RequestByInstanceIdResource;
 import org.folio.circulation.resources.RequestCirculationRulesEngineResource;
 import org.folio.circulation.resources.RequestCollectionResource;
@@ -152,6 +153,7 @@ public void start(Promise<Void> startFuture) {
     new LoanRelatedFeeFineClosedHandlerResource(client).register(router);
     new FeeFineBalanceChangedHandlerResource(client).register(router);
     new CirculationSettingsResource(client).register(router);
+    new PrintEventsResource(client).register(router);
 
     server.requestHandler(router)
       .listen(config().getInteger("port"), result -> {

src/main/java/org/folio/circulation/domain/CirculationSetting.java

@@ -39,6 +39,7 @@ public class CirculationSetting {
   private final JsonObject value;
 
   public static CirculationSetting from(JsonObject representation) {
+    log.info("from {}", representation);
     final var id = getProperty(representation, ID_FIELD);
     final var name = getProperty(representation, NAME_FIELD);
     final var value = getObjectProperty(representation, VALUE_FIELD);

src/main/java/org/folio/circulation/domain/PrintEventRequest.java

@@ -0,0 +1,59 @@
+package org.folio.circulation.domain;
+
+import io.vertx.core.json.JsonObject;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.ToString;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.lang.invoke.MethodHandles;
+import java.util.List;
+import java.util.Set;
+
+import static lombok.AccessLevel.PRIVATE;
+import static org.folio.circulation.support.json.JsonPropertyFetcher.getArrayProperty;
+import static org.folio.circulation.support.json.JsonPropertyFetcher.getProperty;
+
+@AllArgsConstructor(access = PRIVATE)
+@ToString(onlyExplicitlyIncluded = true)
+public class PrintEventRequest {
+  private static final Logger log = LogManager.getLogger(MethodHandles.lookup().lookupClass());
+  public static final String REQUEST_IDS_FIELD = "requestIds";
+  public static final String REQUESTER_ID_FIELD = "requesterId";
+  public static final String REQUESTER_NAME_FIELD = "requesterName";
+  public static final String PRINT_DATE_FIELD = "printEventDate";
+
+  @ToString.Include
+  @Getter
+  private final JsonObject representation;
+
+  @Getter
+  private final List<String> requestIds;
+  @Getter
+  private final String requesterId;
+  @Getter
+  private final String requesterName;
+  @Getter
+  private final String printEventDate;
+
+  public static PrintEventRequest from(JsonObject representation) {
+    final var requestIds = getArrayProperty(representation, REQUEST_IDS_FIELD).stream()
+      .map(String.class::cast)
+      .toList();
+    final var requesterId = getProperty(representation, REQUESTER_ID_FIELD);
+    final var requesterName = getProperty(representation, REQUESTER_NAME_FIELD);
+    final var printEventDate = getProperty(representation, PRINT_DATE_FIELD);
+
+    if (requestIds.isEmpty() || null == requesterId || null == requesterName || null == printEventDate || !containsOnlyKnownFields(representation)) {
+      log.info("from:: Print Event Request JSON is invalid: {},{},{},{},{}", representation, requestIds, requesterName, requesterId, printEventDate);
+      return null;
+    }
+    return new PrintEventRequest(representation, requestIds, requesterId, requesterName, printEventDate);
+  }
+
+  private static boolean containsOnlyKnownFields(JsonObject representation) {
+    return Set.of(REQUEST_IDS_FIELD, REQUESTER_ID_FIELD, REQUESTER_NAME_FIELD, PRINT_DATE_FIELD)
+      .containsAll(representation.fieldNames());
+  }
+}

src/main/java/org/folio/circulation/infrastructure/storage/CirculationSettingsRepository.java

@@ -40,8 +40,13 @@ public CompletableFuture<Result<CirculationSetting>> getById(String id) {
 
   public CompletableFuture<Result<MultipleRecords<CirculationSetting>>> findBy(String query) {
     return circulationSettingsStorageClient.getManyWithRawQueryStringParameters(query)
-      .thenApply(flatMapResult(response ->
-        MultipleRecords.from(response, CirculationSetting::from, RECORDS_PROPERTY_NAME)));
+      .thenApply(flatMapResult(response -> {
+        log.info("************* {}", response);
+        log.info(MultipleRecords.from(response, CirculationSetting::from, RECORDS_PROPERTY_NAME).value().getRecords());
+        return MultipleRecords.from(response, CirculationSetting::from, RECORDS_PROPERTY_NAME);
+        }
+        ));
+
   }
 
   public CompletableFuture<Result<CirculationSetting>> create(

src/main/java/org/folio/circulation/infrastructure/storage/PrintEventsRepository.java

@@ -0,0 +1,35 @@
+package org.folio.circulation.infrastructure.storage;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.folio.circulation.domain.PrintEventRequest;
+import org.folio.circulation.support.Clients;
+import org.folio.circulation.support.CollectionResourceClient;
+import org.folio.circulation.support.http.client.ResponseInterpreter;
+import org.folio.circulation.support.results.Result;
+
+import java.lang.invoke.MethodHandles;
+import java.util.concurrent.CompletableFuture;
+
+import static org.folio.circulation.support.http.ResponseMapping.forwardOnFailure;
+import static org.folio.circulation.support.results.Result.succeeded;
+
+public class PrintEventsRepository {
+  private static final Logger log = LogManager.getLogger(MethodHandles.lookup().lookupClass());
+
+  private final CollectionResourceClient printEventsStorageClient;
+
+  public PrintEventsRepository(Clients clients) {
+    printEventsStorageClient = clients.printEventsStorageClient();
+  }
+
+  public CompletableFuture<Result<Void>> create(PrintEventRequest printEventRequest) {
+    log.info("create:: parameters printEvent: {}", printEventRequest);
+    final var storagePrintEventRequest = printEventRequest.getRepresentation();
+    final ResponseInterpreter<Void> interpreter = new ResponseInterpreter<Void>()
+      .on(201, succeeded(null))
+      .otherwise(forwardOnFailure());
+    return printEventsStorageClient.post(storagePrintEventRequest).thenApply(interpreter::flatMap);
+  }
+
+}

src/main/java/org/folio/circulation/resources/PrintEventsResource.java

@@ -0,0 +1,128 @@
+package org.folio.circulation.resources;
+
+import io.vertx.core.http.HttpClient;
+import io.vertx.ext.web.Router;
+import io.vertx.ext.web.RoutingContext;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.folio.circulation.domain.CirculationSetting;
+import org.folio.circulation.domain.MultipleRecords;
+import org.folio.circulation.domain.PrintEventRequest;
+import org.folio.circulation.infrastructure.storage.CirculationSettingsRepository;
+import org.folio.circulation.infrastructure.storage.PrintEventsRepository;
+import org.folio.circulation.infrastructure.storage.requests.RequestRepository;
+import org.folio.circulation.support.Clients;
+import org.folio.circulation.support.RouteRegistration;
+import org.folio.circulation.support.http.server.JsonHttpResponse;
+import org.folio.circulation.support.http.server.WebContext;
+import org.folio.circulation.support.results.Result;
+
+import java.lang.invoke.MethodHandles;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+
+import static org.folio.circulation.support.ValidationErrorFailure.singleValidationError;
+import static org.folio.circulation.support.json.JsonPropertyFetcher.getProperty;
+import static org.folio.circulation.support.results.Result.ofAsync;
+import static org.folio.circulation.support.results.Result.succeeded;
+
+public class PrintEventsResource extends Resource {
+  private static final Logger log = LogManager.getLogger(MethodHandles.lookup().lookupClass());
+  private static final String PRINT_EVENT_FLAG_QUERY = "query=name=Enable print event log";
+  private static final String PRINT_EVENT_FEATURE_DISABLED_ERROR = "print event feature is disabled for this tenant";
+  private static final String NO_CONFIG_FOUND_ERROR = "No configuration found for print event feature";
+  private static final String MULTIPLE_CONFIGS_ERROR = "Multiple configurations found for print event feature";
+  private static final String PRINT_EVENT_FLAG_PROPERTY_NAME = "Enable Print Event";
+
+  public PrintEventsResource(HttpClient client) {
+    super(client);
+  }
+
+  @Override
+  public void register(Router router) {
+    new RouteRegistration("/circulation/print-events-entry", router)
+      .create(this::create);
+  }
+
+  void create(RoutingContext routingContext) {
+    final var context = new WebContext(routingContext);
+    final var clients = Clients.create(context, client);
+    final var printEventsRepository = new PrintEventsRepository(clients);
+    final var circulationSettingsRepository = new CirculationSettingsRepository(clients);
+    final var requestRepository = new RequestRepository(clients);
+    final var incomingRepresentation = routingContext.body().asJsonObject();
+    final var printEventRequest = PrintEventRequest.from(incomingRepresentation);
+
+    log.info("create:: Creating print event: {}", printEventRequest);
+
+    ofAsync(printEventRequest)
+      .thenApply(refuseWhenPrintEventRequestIsInvalid())
+      .thenCompose(r -> r.after(validatePrintEventFeatureFlag(circulationSettingsRepository)))
+      .thenCompose(r -> r.after(validateRequests(requestRepository)))
+      .thenCompose(r -> r.after(printEventsRepository::create))
+      .thenApply(r -> r.map(response -> {
+        assert printEventRequest != null;
+        return JsonHttpResponse.created(printEventRequest.getRepresentation(), null);
+      }))
+      .thenAccept(context::writeResultToHttpResponse);
+  }
+
+  private static Function<PrintEventRequest, CompletableFuture<Result<PrintEventRequest>>>
+  validateRequests(RequestRepository requestRepository) {
+    return printRequest -> requestRepository.fetchRequests(printRequest.getRequestIds())
+      .thenApply(printRequestList -> printRequestList.map(Collection::size)).thenApply(size -> {
+        if (size.value() != printRequest.getRequestIds().size()) {
+          return Result.failed(singleValidationError("invalid request found", "", ""));
+        }
+        return succeeded(printRequest);
+      });
+  }
+
+  private static Function<Result<PrintEventRequest>, Result<PrintEventRequest>>
+  refuseWhenPrintEventRequestIsInvalid() {
+    return r -> r.failWhen(printEventRequest -> succeeded(printEventRequest == null),
+      circulationSetting -> singleValidationError("Print Event Request  JSON is invalid", "", ""));
+  }
+
+  private static Function<PrintEventRequest, CompletableFuture<Result<PrintEventRequest>>> validatePrintEventFeatureFlag(
+    CirculationSettingsRepository circulationSettingsRepository) {
+    return printEventRequest -> circulationSettingsRepository.findBy(formatString(PRINT_EVENT_FLAG_QUERY))
+      .thenApply(result -> {
+        log.info("validatePrintEventFeatureFlag:: result value {}", result.value());
+        log.info("validatePrintEventFeatureFlag:: result value {}", result.value().getRecords());
+        return handleCirculationSettingResult(result.map(MultipleRecords::getRecords), printEventRequest);
+      });
+  }
+
+  private static Result<PrintEventRequest> handleCirculationSettingResult(Result<Collection<CirculationSetting>> result,
+                                                                          PrintEventRequest printEventRequest) {
+
+    int size = result.value().size();
+    if (size == 0) {
+      return Result.failed(singleValidationError(NO_CONFIG_FOUND_ERROR, "", ""));
+    } else if (size > 1) {
+      return Result.failed(singleValidationError(MULTIPLE_CONFIGS_ERROR, "", ""));
+    }
+    boolean isEnabled = result.value().stream()
+      .map(x -> Boolean.valueOf(getProperty(x.getValue(), PRINT_EVENT_FLAG_PROPERTY_NAME))).findFirst().orElse(true);
+
+    if (!isEnabled) {
+      return Result.failed(singleValidationError(PRINT_EVENT_FEATURE_DISABLED_ERROR, "", ""));
+    }
+    return succeeded(printEventRequest);
+  }
+
+  public static String formatString(String input) {
+    String[] parts = input.split("=", 2);
+    if (parts.length != 2) {
+      return input;
+    }
+    String encodedKey = URLEncoder.encode(parts[0], StandardCharsets.UTF_8);
+    String encodedValue = URLEncoder.encode(parts[1], StandardCharsets.UTF_8);
+    return encodedKey + "=" + encodedValue.replace("+", "%20");
+  }
+
+}

src/main/java/org/folio/circulation/support/Clients.java

@@ -70,6 +70,8 @@ public class Clients {
   private final CollectionResourceClient circulationItemClient;
   private final GetManyRecordsClient settingsStorageClient;
   private final CollectionResourceClient circulationSettingsStorageClient;
+  private final CollectionResourceClient printEventsStorageClient;
+
 
   public static Clients create(WebContext context, HttpClient httpClient) {
     return new Clients(context.createHttpClient(httpClient), context);
@@ -138,6 +140,8 @@ private Clients(OkapiHttpClient client, WebContext context) {
       settingsStorageClient = createSettingsStorageClient(client, context);
       circulationItemClient = createCirculationItemClient(client, context);
       circulationSettingsStorageClient = createCirculationSettingsStorageClient(client, context);
+      printEventsStorageClient = createPrintEventsStorageClient(client, context);
+
     }
     catch(MalformedURLException e) {
       throw new InvalidOkapiLocationException(context.getOkapiLocation(), e);
@@ -380,6 +384,10 @@ public CollectionResourceClient circulationSettingsStorageClient() {
     return circulationSettingsStorageClient;
   }
 
+  public CollectionResourceClient printEventsStorageClient() {
+    return printEventsStorageClient;
+  }
+
   private static CollectionResourceClient getCollectionResourceClient(
     OkapiHttpClient client, WebContext context,
     String path)
@@ -814,6 +822,13 @@ private CollectionResourceClient createCirculationSettingsStorageClient(
       "/circulation-settings-storage/circulation-settings");
   }
 
+  private CollectionResourceClient createPrintEventsStorageClient(
+    OkapiHttpClient client, WebContext context) throws MalformedURLException {
+
+    return  getCollectionResourceClient(client, context,
+      "/print-events-storage/print-events-entry");
+  }
+
   private GetManyRecordsClient createSettingsStorageClient(
     OkapiHttpClient client, WebContext context)
     throws MalformedURLException {