MODLD-582: LCCN Validation | Ensure uniquely assigned

MODLD-582: Change lccn value in test

MODLD-582: Additional verification for searchClient invocation

MODLD-582: Review/Sonar fixes

MODLD-582: Review/Sonar fixes

MODLD-582: Handle failed dependency

MODLD-582: Review/Sonar fixes

MODLD-582: Review/Sonar fixes

MODLD-582: Rework exception handling in search service

MODLD-582 Review fixes

MODLD-582 Review fixes

descriptors/ModuleDescriptor-template.json

@@ -22,6 +22,7 @@
             "inventory-storage.preceding-succeeding-titles.item.post",
             "inventory-storage.preceding-succeeding-titles.item.put",
             "inventory-storage.preceding-succeeding-titles.item.delete",
+            "search.instances.collection.get",
             "source-storage.snapshots.post",
             "source-storage.records.formatted.item.get",
             "source-storage.records.post",
@@ -62,6 +63,7 @@
             "inventory-storage.preceding-succeeding-titles.item.post",
             "inventory-storage.preceding-succeeding-titles.item.put",
             "inventory-storage.preceding-succeeding-titles.item.delete",
+            "search.instances.collection.get",
             "source-storage.snapshots.post",
             "source-storage.records.formatted.item.get",
             "source-storage.records.post",
@@ -172,6 +174,10 @@
     {
       "id": "source-storage-records",
       "version": "3.2 3.3"
+    },
+    {
+      "id": "search",
+      "version": "1.3"
     }
   ],
   "permissionSets": [

src/main/java/org/folio/linked/data/client/SearchClient.java

@@ -0,0 +1,14 @@
+package org.folio.linked.data.client;
+
+import org.folio.linked.data.domain.dto.SearchResponseTotalOnly;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+
+@FeignClient(name = "search")
+public interface SearchClient {
+
+  @GetMapping("/instances")
+  ResponseEntity<SearchResponseTotalOnly> searchInstances(@RequestParam("query") String query);
+}

src/main/java/org/folio/linked/data/configuration/ErrorResponseConfig.java

@@ -21,6 +21,7 @@ public class ErrorResponseConfig {
   private ErrorResponseConfig.Error genericBadRequest;
   private ErrorResponseConfig.Error validation;
   private ErrorResponseConfig.Error genericServer;
+  private ErrorResponseConfig.Error failedDependency;
 
   public record Error(int status, String code, List<String> parameters, String message) {
   }

src/main/java/org/folio/linked/data/controller/ResourceController.java

@@ -1,7 +1,10 @@
 package org.folio.linked.data.controller;
 
+import static java.util.Optional.ofNullable;
+import static org.springframework.http.HttpMethod.PUT;
 import static org.springframework.http.HttpStatus.CREATED;
 
+import jakarta.servlet.http.HttpServletRequest;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.folio.linked.data.domain.dto.ResourceIdDto;
@@ -12,6 +15,8 @@
 import org.folio.linked.data.service.resource.ResourceMarcBibService;
 import org.folio.linked.data.service.resource.ResourceService;
 import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.WebDataBinder;
+import org.springframework.web.bind.annotation.InitBinder;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
@@ -70,4 +75,22 @@ public ResponseEntity<ResourceMarcViewDto> getResourceMarcViewById(Long id, Stri
     return ResponseEntity.ok(resourceMarcService.getResourceMarcView(id));
   }
 
+  @InitBinder
+  public void bindIdForResourcePutRequest(WebDataBinder binder, HttpServletRequest request) {
+    var target = binder.getTarget();
+    if (target instanceof ResourceRequestDto dto && isPutRequest(request)) {
+      dto.setId(idFromUri(request.getRequestURI()));
+    }
+  }
+
+  private boolean isPutRequest(HttpServletRequest request) {
+    return ofNullable(request)
+      .map(r -> PUT.name().equalsIgnoreCase(r.getMethod()))
+      .orElse(false);
+  }
+
+  private Long idFromUri(String path) {
+    String[] parts = path.split("/");
+    return Long.parseLong(parts[parts.length - 1]);
+  }
 }

src/main/java/org/folio/linked/data/controller/advice/ApiExceptionHandler.java

@@ -2,6 +2,7 @@
 
 import jakarta.persistence.EntityNotFoundException;
 import jakarta.validation.ConstraintViolationException;
+import jakarta.validation.ValidationException;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;
 import org.apache.logging.log4j.Level;
@@ -88,6 +89,18 @@ public ResponseEntity<ErrorResponse> handleMissingServletRequestParameterExcepti
     return genericBadRequestMapper.errorResponseEntity(e);
   }
 
+  @ExceptionHandler(ValidationException.class)
+  public ResponseEntity<ErrorResponse> handleValidationException(ValidationException exception) {
+    return handleValidationExceptionCause(exception);
+  }
+
+  private ResponseEntity<ErrorResponse> handleValidationExceptionCause(ValidationException exception) {
+    if (exception.getCause() instanceof RequestProcessingException e) {
+      return handleRequestProcessingException(e);
+    }
+    return handleAllOtherExceptions(exception);
+  }
+
   @ExceptionHandler(Exception.class)
   public ResponseEntity<ErrorResponse> handleAllOtherExceptions(Exception exception) {
     logException(exception);

src/main/java/org/folio/linked/data/exception/RequestProcessingExceptionBuilder.java

@@ -49,6 +49,10 @@ public RequestProcessingException notFoundSourceRecordException(String idType, S
     return requestProcessingException(notFoundError, "Source Record", idType, idValue, "Source Record storage");
   }
 
+  public RequestProcessingException failedDependencyException(String message, String reason) {
+    return requestProcessingException(errorResponseConfig.getFailedDependency(), message, reason);
+  }
+
   private RequestProcessingException requestProcessingException(ErrorResponseConfig.Error error, String... arguments) {
     var parameters = new HashMap<String, String>();
     for (int i = 0; i < arguments.length; i++) {

src/main/java/org/folio/linked/data/exception/SearchException.java

@@ -0,0 +1,8 @@
+package org.folio.linked.data.exception;
+
+public class SearchException extends RuntimeException {
+
+  public SearchException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/org/folio/linked/data/repo/FolioMetadataRepository.java

@@ -14,7 +14,13 @@ public interface FolioMetadataRepository extends JpaRepository<FolioMetadata, Lo
 
   Optional<FolioMetadata> findByInventoryId(String inventoryId);
 
+  Optional<InventoryIdOnly> findInventoryIdById(Long id);
+
   interface IdOnly {
     Long getId();
   }
+
+  interface InventoryIdOnly {
+    String getInventoryId();
+  }
 }

src/main/java/org/folio/linked/data/service/search/InstanceSearchService.java

@@ -0,0 +1,11 @@
+package org.folio.linked.data.service.search;
+
+import java.util.Collection;
+import org.folio.linked.data.domain.dto.SearchResponseTotalOnly;
+
+public interface InstanceSearchService {
+
+  SearchResponseTotalOnly searchByLccn(Collection<String> lccn);
+
+  SearchResponseTotalOnly searchByLccnExcludingId(Collection<String> lccn, String instanceId);
+}

src/main/java/org/folio/linked/data/service/search/InstanceSearchServiceImpl.java

@@ -0,0 +1,48 @@
+package org.folio.linked.data.service.search;
+
+import static java.lang.String.format;
+import static java.util.Objects.isNull;
+import static java.util.stream.Collectors.joining;
+
+import java.util.Collection;
+import java.util.Objects;
+import lombok.RequiredArgsConstructor;
+import org.folio.linked.data.client.SearchClient;
+import org.folio.linked.data.domain.dto.SearchResponseTotalOnly;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class InstanceSearchServiceImpl implements InstanceSearchService {
+
+  private static final String EXCLUDE_SUPPRESSED = "staffSuppress <> \"true\" and discoverySuppress <> \"true\"";
+  private static final String ID_NOT_EQUALS = "id <> \"%s\"";
+  private static final String LCCN_EQUALS = "lccn==\"%s\"";
+
+  private final SearchClient searchClient;
+
+  @Override
+  public SearchResponseTotalOnly searchByLccn(Collection<String> lccn) {
+    return search(getLccnQuery(lccn));
+  }
+
+  @Override
+  public SearchResponseTotalOnly searchByLccnExcludingId(Collection<String> lccn, String instanceId) {
+    if (isNull(instanceId)) {
+      return searchByLccn(lccn);
+    }
+    return search(format("%s and %s", getLccnQuery(lccn), format(ID_NOT_EQUALS, instanceId)));
+  }
+
+  private SearchResponseTotalOnly search(String query) {
+    return searchClient.searchInstances(query).getBody();
+  }
+
+  private String getLccnQuery(Collection<String> lccnCol) {
+    var orLccnQuery = lccnCol.stream()
+      .filter(Objects::nonNull)
+      .map(lccn -> format(LCCN_EQUALS, lccn))
+      .collect(joining(" or "));
+    return format("(%s) and (%s)", orLccnQuery, EXCLUDE_SUPPRESSED);
+  }
+}

src/main/java/org/folio/linked/data/util/LccnUtils.java

@@ -0,0 +1,17 @@
+package org.folio.linked.data.util;
+
+import static org.apache.commons.collections4.CollectionUtils.isEmpty;
+
+import lombok.experimental.UtilityClass;
+import org.folio.linked.data.domain.dto.LccnRequest;
+
+@UtilityClass
+public class LccnUtils {
+
+  public static boolean isCurrent(LccnRequest lccnRequest) {
+    return isEmpty(lccnRequest.getStatus()) || lccnRequest.getStatus()
+      .stream()
+      .flatMap(status -> status.getLink().stream())
+      .anyMatch(link -> link.endsWith("current"));
+  }
+}

src/main/java/org/folio/linked/data/validation/LccnUniqueConstraint.java

@@ -0,0 +1,25 @@
+package org.folio.linked.data.validation;
+
+import jakarta.validation.Constraint;
+import jakarta.validation.Payload;
+import jakarta.validation.Valid;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import org.folio.linked.data.validation.dto.LccnUniquenessValidator;
+
+@Documented
+@Constraint(validatedBy = LccnUniquenessValidator.class)
+@Target({ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER})
+@Retention(RetentionPolicy.RUNTIME)
+@Valid
+public @interface LccnUniqueConstraint {
+
+  String message() default "{lccnUniqueConstraint.message}";
+
+  Class<?>[] groups() default {};
+
+  Class<? extends Payload>[] payload() default {};
+}

src/main/java/org/folio/linked/data/validation/dto/LccnPatternValidator.java

@@ -1,6 +1,6 @@
 package org.folio.linked.data.validation.dto;
 
-import static org.apache.commons.collections4.CollectionUtils.isEmpty;
+import static org.folio.linked.data.util.LccnUtils.isCurrent;
 
 import jakarta.validation.ConstraintValidator;
 import jakarta.validation.ConstraintValidatorContext;
@@ -24,13 +24,6 @@ public boolean isValid(LccnRequest lccnRequest, ConstraintValidatorContext const
     }
   }
 
-  private boolean isCurrent(LccnRequest lccnRequest) {
-    return isEmpty(lccnRequest.getStatus()) || lccnRequest.getStatus()
-      .stream()
-      .flatMap(status -> status.getLink().stream())
-      .anyMatch(link -> link.endsWith("current"));
-  }
-
   private boolean hasValidPattern(String lccnValue) {
     return LCCN_STRUCTURE_A_PATTERN.matcher(lccnValue).matches()
       || LCCN_STRUCTURE_B_PATTERN.matcher(lccnValue).matches();

src/main/java/org/folio/linked/data/validation/dto/LccnUniquenessValidator.java

@@ -0,0 +1,87 @@
+package org.folio.linked.data.validation.dto;
+
+import static java.util.Optional.ofNullable;
+
+import jakarta.validation.ConstraintValidator;
+import jakarta.validation.ConstraintValidatorContext;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Stream;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.log4j.Log4j2;
+import org.folio.linked.data.domain.dto.InstanceField;
+import org.folio.linked.data.domain.dto.LccnField;
+import org.folio.linked.data.domain.dto.LccnRequest;
+import org.folio.linked.data.domain.dto.ResourceRequestDto;
+import org.folio.linked.data.domain.dto.SearchResponseTotalOnly;
+import org.folio.linked.data.exception.RequestProcessingExceptionBuilder;
+import org.folio.linked.data.repo.FolioMetadataRepository;
+import org.folio.linked.data.service.search.InstanceSearchService;
+import org.folio.linked.data.util.LccnUtils;
+import org.folio.linked.data.validation.LccnUniqueConstraint;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+@Log4j2
+public class LccnUniquenessValidator implements ConstraintValidator<LccnUniqueConstraint, ResourceRequestDto> {
+
+  private final InstanceSearchService instanceSearchService;
+  private final FolioMetadataRepository folioMetadataRepository;
+  private final RequestProcessingExceptionBuilder exceptionBuilder;
+
+  @Override
+  public boolean isValid(ResourceRequestDto resourceRequestDto, ConstraintValidatorContext constraintValidatorContext) {
+    var resource = resourceRequestDto.getResource();
+    if (resource instanceof InstanceField instance && hasCurrentLccn(instance)) {
+      var inventoryId = findInventoryId(resourceRequestDto);
+      return isUnique(getLccnValues(instance), inventoryId);
+    }
+    return true;
+  }
+
+  private String findInventoryId(ResourceRequestDto resourceRequestDto) {
+    return ofNullable(resourceRequestDto.getId())
+      .flatMap(folioMetadataRepository::findInventoryIdById)
+      .map(FolioMetadataRepository.InventoryIdOnly::getInventoryId)
+      .orElse(null);
+  }
+
+  private boolean isUnique(List<String> lccn, String inventoryId) {
+    return ofNullable(findInstanceWithLccn(lccn, inventoryId))
+      .map(SearchResponseTotalOnly::getTotalRecords)
+      .map(count -> count == 0)
+      .orElse(false);
+  }
+
+  private SearchResponseTotalOnly findInstanceWithLccn(List<String> lccn, String inventoryId) {
+    try {
+      return instanceSearchService.searchByLccnExcludingId(lccn, inventoryId);
+    } catch (Exception e) {
+      log.error(e);
+      throw exceptionBuilder.failedDependencyException(
+        "Could not validate LCCN for duplicate", "Unable to reach search service");
+    }
+  }
+
+  private boolean hasCurrentLccn(InstanceField instance) {
+    return getLccnRequest(instance).anyMatch(LccnUtils::isCurrent);
+  }
+
+  private List<String> getLccnValues(InstanceField instance) {
+    return getLccnRequest(instance)
+      .filter(LccnUtils::isCurrent)
+      .map(LccnRequest::getValue)
+      .flatMap(Collection::stream)
+      .toList();
+  }
+
+  private Stream<LccnRequest> getLccnRequest(InstanceField instance) {
+    return instance.getInstance()
+      .getMap()
+      .stream()
+      .filter(LccnField.class::isInstance)
+      .map(i -> (LccnField) i)
+      .map(LccnField::getLccn);
+  }
+}

src/main/resources/ValidationMessages.properties

@@ -1,2 +1,3 @@
 primaryTitleConstraint.message=required_primary_main_title
 lccnPatternConstraint.message=lccn_does_not_match_pattern
+lccnUniqueConstraint.message=lccn_not_unique

src/main/resources/errors.yml

@@ -37,3 +37,8 @@ genericServer:
   code: server
   parameters: exception, message
   message: 'Server error: [%s] with message [%s]'
+failedDependency:
+  status: 424
+  code: failed_dependency
+  parameters: message, reason
+  message: '[%s] - reason: [%s]. Please try later.'

src/main/resources/swagger.api/folio-modules.yaml

@@ -12,6 +12,8 @@ components:
       $ref: folio-modules/search/resourceIndexEvent.json
     resourceIndexEventType:
       $ref: folio-modules/search/resourceIndexEventType.json
+    searchResponseTotalOnly:
+      $ref: folio-modules/search/searchResponseTotalOnly.json
     linkedDataInstance:
       $ref: folio-modules/search/linkedDataInstance.json
     linkedDataWork: