diff --git a/lombok.config b/lombok.config new file mode 100644 index 00000000..ea9a6ba1 --- /dev/null +++ b/lombok.config @@ -0,0 +1,756 @@ +## +## Key : config.stopBubbling +## Type: boolean +## +## Tell the configuration system it should stop looking for other configuration files (default: false). +## +## Examples: +# +# clear config.stopBubbling +config.stopBubbling=true + +## +## Key : lombok.accessors.chain +## Type: boolean +## +## Generate setters that return 'this' instead of 'void' (default: false). +## +## Examples: +# +# clear lombok.accessors.chain +# lombok.accessors.chain = [false | true] +# + +## +## Key : lombok.accessors.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Accessors is used. +## +## Examples: +# +# clear lombok.accessors.flagUsage +# lombok.accessors.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.accessors.fluent +## Type: boolean +## +## Generate getters and setters using only the field name (no get/set prefix) (default: false). +## +## Examples: +# +# clear lombok.accessors.fluent +# lombok.accessors.fluent = [false | true] +# + +## +## Key : lombok.accessors.prefix +## Type: list of string +## +## Strip this field prefix, like 'f' or 'm_', from the names of generated getters and setters. +## +## Examples: +# +# clear lombok.accessors.prefix +# lombok.accessors.prefix += +# lombok.accessors.prefix -= +# + +## +## Key : lombok.addGeneratedAnnotation +## Type: boolean +## +## Generate @javax.annotation.Generated on all generated code (default: false). Deprecated, use 'lombok.addJavaxGeneratedAnnotation' instead. +## +## Examples: +# +# clear lombok.addGeneratedAnnotation +# lombok.addGeneratedAnnotation = [false | true] +# + +## +## Key : lombok.addJavaxGeneratedAnnotation +## Type: boolean +## +## Generate @javax.annotation.Generated on all generated code (default: follow lombok.addGeneratedAnnotation). +## +## Examples: +# +# clear lombok.addJavaxGeneratedAnnotation +# lombok.addJavaxGeneratedAnnotation = [false | true] +# + +## +## Key : lombok.addLombokGeneratedAnnotation +## Type: boolean +## +## Generate @lombok.Generated on all generated code (default: false). +## +## Examples: +# +# clear lombok.addLombokGeneratedAnnotation +lombok.addLombokGeneratedAnnotation = true +# + +## +## Key : lombok.allArgsConstructor.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @AllArgsConstructor is used. +## +## Examples: +# +# clear lombok.allArgsConstructor.flagUsage +# lombok.allArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.anyConstructor.addConstructorProperties +## Type: boolean +## +## Generate @ConstructorProperties for generated constructors (default: false). +## +## Examples: +# +# clear lombok.anyConstructor.addConstructorProperties +lombok.anyConstructor.addConstructorProperties=true + +## +## Key : lombok.anyConstructor.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if any of the XxxArgsConstructor annotations are used. +## +## Examples: +# +# clear lombok.anyConstructor.flagUsage +# lombok.anyConstructor.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.anyConstructor.suppressConstructorProperties +## Type: boolean +## +## Suppress the generation of @ConstructorProperties for generated constructors (default: false). +## +## Examples: +# +# clear lombok.anyConstructor.suppressConstructorProperties +# lombok.anyConstructor.suppressConstructorProperties = [false | true] +# + +## +## Key : lombok.builder.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Builder is used. +## +## Examples: +# +# clear lombok.builder.flagUsage +# lombok.builder.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.cleanup.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Cleanup is used. +## +## Examples: +# +# clear lombok.cleanup.flagUsage +# lombok.cleanup.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.copyableAnnotations +## Type: list of type-name +## +## Copy these annotations to getters, setters, withers, builder-setters, etc. +## +## Examples: +# +# clear lombok.copyableAnnotations +# lombok.copyableAnnotations += +# lombok.copyableAnnotations -= +# + +## +## Key : lombok.data.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Data is used. +## +## Examples: +# +# clear lombok.data.flagUsage +# lombok.data.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.delegate.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Delegate is used. +## +## Examples: +# +# clear lombok.delegate.flagUsage +# lombok.delegate.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.equalsAndHashCode.callSuper +## Type: enum (lombok.core.configuration.CallSuperType) +## +## When generating equals and hashCode for classes that don't extend Object, either automatically take into account superclass implementation (call), or don't (skip), or warn and don't (warn). (default = warn). +## +## Examples: +# +# clear lombok.equalsAndHashCode.callSuper +# lombok.equalsAndHashCode.callSuper = [CALL | SKIP | WARN] +# + +## +## Key : lombok.equalsAndHashCode.doNotUseGetters +## Type: boolean +## +## Don't call the getters but use the fields directly in the generated equals and hashCode method (default = false). +## +## Examples: +# +# clear lombok.equalsAndHashCode.doNotUseGetters +# lombok.equalsAndHashCode.doNotUseGetters = [false | true] +# + +## +## Key : lombok.equalsAndHashCode.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @EqualsAndHashCode is used. +## +## Examples: +# +# clear lombok.equalsAndHashCode.flagUsage +# lombok.equalsAndHashCode.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.experimental.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if an experimental feature is used. +## +## Examples: +# +# clear lombok.experimental.flagUsage +# lombok.experimental.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.extensionMethod.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @ExtensionMethod is used. +## +## Examples: +# +# clear lombok.extensionMethod.flagUsage +# lombok.extensionMethod.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.extern.findbugs.addSuppressFBWarnings +## Type: boolean +## +## Generate @edu.umd.cs.findbugs.annotations.SuppressFBWArnings on all generated code (default: false). +## +## Examples: +# +# clear lombok.extern.findbugs.addSuppressFBWarnings +# lombok.extern.findbugs.addSuppressFBWarnings = [false | true] +# + +## +## Key : lombok.fieldDefaults.defaultFinal +## Type: boolean +## +## If true, fields, in any file (lombok annotated or not) are marked as final. Use @NonFinal to override this. +## +## Examples: +# +# clear lombok.fieldDefaults.defaultFinal +# lombok.fieldDefaults.defaultFinal = [false | true] +# + +## +## Key : lombok.fieldDefaults.defaultPrivate +## Type: boolean +## +## If true, fields without any access modifier, in any file (lombok annotated or not) are marked as private. Use @PackagePrivate or an explicit modifier to override this. +## +## Examples: +# +# clear lombok.fieldDefaults.defaultPrivate +# lombok.fieldDefaults.defaultPrivate = [false | true] +# + +## +## Key : lombok.fieldDefaults.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @FieldDefaults is used. +## +## Examples: +# +# clear lombok.fieldDefaults.flagUsage +# lombok.fieldDefaults.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.fieldNameConstants.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @FieldNameConstants is used. +## +## Examples: +# +# clear lombok.fieldNameConstants.flagUsage +# lombok.fieldNameConstants.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.fieldNameConstants.innerTypeName +## Type: string +## +## The default name of the inner type generated by @FieldNameConstants. (default: 'Fields'). +## +## Examples: +# +# clear lombok.fieldNameConstants.innerTypeName +# lombok.fieldNameConstants.innerTypeName = +# + +## +## Key : lombok.getter.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Getter is used. +## +## Examples: +# +# clear lombok.getter.flagUsage +# lombok.getter.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.getter.lazy.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Getter(lazy=true) is used. +## +## Examples: +# +# clear lombok.getter.lazy.flagUsage +# lombok.getter.lazy.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.getter.noIsPrefix +## Type: boolean +## +## If true, generate and use getFieldName() for boolean getters instead of isFieldName(). +## +## Examples: +# +# clear lombok.getter.noIsPrefix +# lombok.getter.noIsPrefix = [false | true] +# + +## +## Key : lombok.helper.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Helper is used. +## +## Examples: +# +# clear lombok.helper.flagUsage +# lombok.helper.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.log.apacheCommons.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @CommonsLog is used. +## +## Examples: +# +# clear lombok.log.apacheCommons.flagUsage +# lombok.log.apacheCommons.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.log.fieldIsStatic +## Type: boolean +## +## Make the generated logger fields static (default: true). +## +## Examples: +# +# clear lombok.log.fieldIsStatic +# lombok.log.fieldIsStatic = [false | true] +# + +## +## Key : lombok.log.fieldName +## Type: string +## +## Use this name for the generated logger fields (default: 'log'). +## +## Examples: +# +# clear lombok.log.fieldName +# lombok.log.fieldName = +# + +## +## Key : lombok.log.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if any of the log annotations is used. +## +## Examples: +# +# clear lombok.log.flagUsage +# lombok.log.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.log.flogger.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Flogger is used. +## +## Examples: +# +# clear lombok.log.flogger.flagUsage +# lombok.log.flogger.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.log.javaUtilLogging.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Log is used. +## +## Examples: +# +# clear lombok.log.javaUtilLogging.flagUsage +# lombok.log.javaUtilLogging.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.log.jbosslog.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @JBossLog is used. +## +## Examples: +# +# clear lombok.log.jbosslog.flagUsage +# lombok.log.jbosslog.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.log.log4j.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Log4j is used. +## +## Examples: +# +# clear lombok.log.log4j.flagUsage +# lombok.log.log4j.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.log.log4j2.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Log4j2 is used. +## +## Examples: +# +# clear lombok.log.log4j2.flagUsage +# lombok.log.log4j2.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.log.slf4j.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Slf4j is used. +## +## Examples: +# +# clear lombok.log.slf4j.flagUsage +# lombok.log.slf4j.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.log.xslf4j.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @XSlf4j is used. +## +## Examples: +# +# clear lombok.log.xslf4j.flagUsage +# lombok.log.xslf4j.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.noArgsConstructor.extraPrivate +## Type: boolean +## +## Generate a private no-ars constructor for @Data and @Value (default: true). +## +## Examples: +# +# clear lombok.noArgsConstructor.extraPrivate +# lombok.noArgsConstructor.extraPrivate = [false | true] +# + +## +## Key : lombok.noArgsConstructor.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @NoArgsConstructor is used. +## +## Examples: +# +# clear lombok.noArgsConstructor.flagUsage +# lombok.noArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.nonNull.exceptionType +## Type: enum (lombok.core.configuration.NullCheckExceptionType) +## +## The type of the exception to throw if a passed-in argument is null (Default: NullPointerException). +## +## Examples: +# +# clear lombok.nonNull.exceptionType +# lombok.nonNull.exceptionType = [NullPointerException | IllegalArgumentException] +# + +## +## Key : lombok.nonNull.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @NonNull is used. +## +## Examples: +# +# clear lombok.nonNull.flagUsage +# lombok.nonNull.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.onX.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if onX is used. +## +## Examples: +# +# clear lombok.onX.flagUsage +# lombok.onX.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.requiredArgsConstructor.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @RequiredArgsConstructor is used. +## +## Examples: +# +# clear lombok.requiredArgsConstructor.flagUsage +# lombok.requiredArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.setter.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Setter is used. +## +## Examples: +# +# clear lombok.setter.flagUsage +# lombok.setter.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.singular.auto +## Type: boolean +## +## If true (default): Automatically singularize the assumed-to-be-plural name of your variable/parameter when using {@code @Singular}. +## +## Examples: +# +# clear lombok.singular.auto +# lombok.singular.auto = [false | true] +# + +## +## Key : lombok.singular.useGuava +## Type: boolean +## +## Generate backing immutable implementations for @Singular on java.util.* types by using guava's ImmutableList, etc. Normally java.util's mutable types are used and wrapped to make them immutable. +## +## Examples: +# +# clear lombok.singular.useGuava +# lombok.singular.useGuava = [false | true] +# + +## +## Key : lombok.sneakyThrows.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @SneakyThrows is used. +## +## Examples: +# +# clear lombok.sneakyThrows.flagUsage +# lombok.sneakyThrows.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.superBuilder.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @SuperBuilder is used. +## +## Examples: +# +# clear lombok.superBuilder.flagUsage +# lombok.superBuilder.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.synchronized.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Synchronized is used. +## +## Examples: +# +# clear lombok.synchronized.flagUsage +# lombok.synchronized.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.toString.doNotUseGetters +## Type: boolean +## +## Don't call the getters but use the fields directly in the generated toString method (default = false). +## +## Examples: +# +# clear lombok.toString.doNotUseGetters +# lombok.toString.doNotUseGetters = [false | true] +# + +## +## Key : lombok.toString.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @ToString is used. +## +## Examples: +# +# clear lombok.toString.flagUsage +# lombok.toString.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.toString.includeFieldNames +## Type: boolean +## +## Include the field names in the generated toString method (default = true). +## +## Examples: +# +# clear lombok.toString.includeFieldNames +# lombok.toString.includeFieldNames = [false | true] +# + +## +## Key : lombok.utilityClass.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @UtilityClass is used. +## +## Examples: +# +# clear lombok.utilityClass.flagUsage +# lombok.utilityClass.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.val.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if 'val' is used. +## +## Examples: +# +# clear lombok.val.flagUsage +# lombok.val.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.value.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Value is used. +## +## Examples: +# +# clear lombok.value.flagUsage +# lombok.value.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.var.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if 'var' is used. +## +## Examples: +# +# clear lombok.var.flagUsage +# lombok.var.flagUsage = [WARNING | ERROR | ALLOW] +# + +## +## Key : lombok.wither.flagUsage +## Type: enum (lombok.core.configuration.FlagUsageType) +## +## Emit a warning or error if @Wither is used. +## +## Examples: +# +# clear lombok.wither.flagUsage +# lombok.wither.flagUsage = [WARNING | ERROR | ALLOW] +# + diff --git a/pom.xml b/pom.xml index 7394574d..1d586f40 100644 --- a/pom.xml +++ b/pom.xml @@ -15,12 +15,11 @@ UTF-8 - 1.7 - 1.7 24.0.0 ${basedir}/ramls types/**,raml-util/schemas 3.5.4 + 1.9.1 1.0.0 @@ -107,6 +106,12 @@ cloning 1.9.11 + + org.projectlombok + lombok + 1.18.8 + provided + junit junit @@ -187,7 +192,7 @@ org.apache.maven.plugins maven-compiler-plugin - 3.1 + 3.8.0 1.8 1.8 @@ -294,10 +299,10 @@ org.codehaus.mojo aspectj-maven-plugin - 1.9 + 1.11 true - false + true 1.8 true @@ -318,12 +323,12 @@ org.aspectj aspectjrt - 1.8.9 + ${aspectj.version} org.aspectj aspectjtools - 1.8.9 + ${aspectj.version} diff --git a/src/main/java/org/folio/links/NoteLinksRepository.java b/src/main/java/org/folio/links/NoteLinksRepository.java index bfb7c93e..16b636e4 100644 --- a/src/main/java/org/folio/links/NoteLinksRepository.java +++ b/src/main/java/org/folio/links/NoteLinksRepository.java @@ -4,18 +4,21 @@ import io.vertx.core.Future; +import org.folio.model.EntityLink; +import org.folio.model.Order; +import org.folio.model.OrderBy; +import org.folio.model.RowPortion; +import org.folio.model.Status; import org.folio.rest.jaxrs.model.Link; import org.folio.rest.jaxrs.model.NoteCollection; -import org.folio.rest.model.Order; -import org.folio.rest.model.OrderBy; -import org.folio.rest.model.Status; public interface NoteLinksRepository { Future updateNoteLinks(Link link, List assignNotes, List unAssignNotes, String tenantId); - Future findNotesByQuery(Status status, Order order, OrderBy orderBy, String domain, String title, - Link link, int limit, int offset, String tenantId); + Future findNotesByTitleAndStatus(EntityLink link, String title, Status status, + OrderBy orderBy, Order order, + RowPortion rowPortion, String tenantId); - Future countNotes(Status status, String domain, String title, Link link, String tenantId); + Future countNotesWithTitleAndStatus(EntityLink link, String title, Status status, String tenantId); } diff --git a/src/main/java/org/folio/links/NoteLinksRepositoryImpl.java b/src/main/java/org/folio/links/NoteLinksRepositoryImpl.java index 9fa41211..95f2dc74 100644 --- a/src/main/java/org/folio/links/NoteLinksRepositoryImpl.java +++ b/src/main/java/org/folio/links/NoteLinksRepositoryImpl.java @@ -35,12 +35,14 @@ import org.springframework.stereotype.Component; import org.folio.db.DbUtils; +import org.folio.model.EntityLink; +import org.folio.model.Order; +import org.folio.model.OrderBy; +import org.folio.model.RowPortion; +import org.folio.model.Status; import org.folio.rest.jaxrs.model.Link; import org.folio.rest.jaxrs.model.Note; import org.folio.rest.jaxrs.model.NoteCollection; -import org.folio.rest.model.Order; -import org.folio.rest.model.OrderBy; -import org.folio.rest.model.Status; import org.folio.rest.persist.PostgresClient; @Component @@ -70,21 +72,20 @@ public Future updateNoteLinks(Link link, List assignNotes, List findNotesByQuery(Status status, Order order, - OrderBy orderBy, String domain, String title, Link link, int limit, - int offset, String tenantId) { + public Future findNotesByTitleAndStatus(EntityLink link, String title, Status status, OrderBy orderBy, + Order order, RowPortion rowPortion, String tenantId) { JsonArray parameters = new JsonArray(); StringBuilder queryBuilder = new StringBuilder(); - addSelectClause(parameters, queryBuilder, domain, title, tenantId); + addSelectClause(parameters, queryBuilder, link.getDomain(), title, tenantId); - String jsonLink = Json.encode(link); + String jsonLink = Json.encode(toLink(link)); addWhereClause(parameters, queryBuilder, status, jsonLink); if (status == Status.ALL) { addOrderByClause(parameters, queryBuilder, order, orderBy, jsonLink); } - addLimitOffset(parameters, queryBuilder, limit, offset); + addLimitOffset(parameters, queryBuilder, rowPortion); Future future = Future.future(); pgClient(tenantId).select(queryBuilder.toString(), parameters, future); @@ -93,14 +94,13 @@ public Future findNotesByQuery(Status status, Order order, } @Override - public Future countNotes(Status status, String domain, String title, Link link, - String tenantId) { + public Future countNotesWithTitleAndStatus(EntityLink link, String title, Status status, String tenantId) { JsonArray parameters = new JsonArray(); StringBuilder queryBuilder = new StringBuilder(); - addSelectCountClause(parameters, queryBuilder, domain, title, tenantId); + addSelectCountClause(parameters, queryBuilder, link.getDomain(), title, tenantId); - String jsonLink = Json.encode(link); + String jsonLink = Json.encode(toLink(link)); addWhereClause(parameters, queryBuilder, status, jsonLink); Future future = Future.future(); @@ -205,6 +205,10 @@ private Future endTransaction(PostgresClient postgresClient, AsyncResult notesIds, Link link) { return parameters; } - private void addLimitOffset(JsonArray parameters, StringBuilder query, int limit, int offset) { + private void addLimitOffset(JsonArray parameters, StringBuilder query, RowPortion rowPortion) { query.append(LIMIT_OFFSET); parameters - .add(limit) - .add(offset); + .add(rowPortion.getLimit()) + .add(rowPortion.getOffset()); } private void addSelectClause(JsonArray parameters, StringBuilder query, String domain, String title, String tenantId) { diff --git a/src/main/java/org/folio/links/NoteLinksService.java b/src/main/java/org/folio/links/NoteLinksService.java index 83fc01d1..6c58bdc0 100644 --- a/src/main/java/org/folio/links/NoteLinksService.java +++ b/src/main/java/org/folio/links/NoteLinksService.java @@ -2,17 +2,20 @@ import io.vertx.core.Future; +import org.folio.model.EntityLink; +import org.folio.model.Order; +import org.folio.model.OrderBy; +import org.folio.model.RowPortion; +import org.folio.model.Status; import org.folio.rest.jaxrs.model.Link; import org.folio.rest.jaxrs.model.NoteCollection; import org.folio.rest.jaxrs.model.NoteLinksPut; -import org.folio.rest.model.Order; -import org.folio.rest.model.OrderBy; -import org.folio.rest.model.Status; public interface NoteLinksService { Future updateNoteLinks(NoteLinksPut entity, Link link, String tenantId); - Future findNotesByQuery(Status parsedStatus, Order parsedOrder, OrderBy parsedOrderBy, String domain, - String title, Link link, int limit, int offset, String tenantId); + Future findNotesByTitleAndStatus(EntityLink link, String title, Status status, + OrderBy orderBy, Order order, + RowPortion rowPortion, String tenantId); } diff --git a/src/main/java/org/folio/links/NoteLinksServiceImpl.java b/src/main/java/org/folio/links/NoteLinksServiceImpl.java index a4613627..46d4b278 100644 --- a/src/main/java/org/folio/links/NoteLinksServiceImpl.java +++ b/src/main/java/org/folio/links/NoteLinksServiceImpl.java @@ -8,13 +8,15 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; +import org.folio.model.EntityLink; +import org.folio.model.Order; +import org.folio.model.OrderBy; +import org.folio.model.RowPortion; +import org.folio.model.Status; import org.folio.rest.jaxrs.model.Link; import org.folio.rest.jaxrs.model.NoteCollection; import org.folio.rest.jaxrs.model.NoteLinkPut; import org.folio.rest.jaxrs.model.NoteLinksPut; -import org.folio.rest.model.Order; -import org.folio.rest.model.OrderBy; -import org.folio.rest.model.Status; @Component public class NoteLinksServiceImpl implements NoteLinksService { @@ -31,14 +33,15 @@ public Future updateNoteLinks(NoteLinksPut entity, Link link, String tenan } @Override - public Future findNotesByQuery(Status parsedStatus, Order parsedOrder, - OrderBy parsedOrderBy, String domain, String title, Link link, int limit, int offset, String tenantId) { + public Future findNotesByTitleAndStatus(EntityLink link, String title, Status status, + OrderBy orderBy, Order order, RowPortion rowPortion, String tenantId) { MutableObject mutableTotalRecords = new MutableObject<>(); - return noteLinksRepository.countNotes(parsedStatus, domain, title, link, tenantId) + + return noteLinksRepository.countNotesWithTitleAndStatus(link, title, status, tenantId) .compose(count -> { mutableTotalRecords.setValue(count); - return noteLinksRepository.findNotesByQuery(parsedStatus, parsedOrder, parsedOrderBy, - domain, title, link, limit, offset, tenantId); + return noteLinksRepository.findNotesByTitleAndStatus(link, title, status, orderBy, order, rowPortion, + tenantId); }) .map(notes -> { notes.setTotalRecords(mutableTotalRecords.getValue()); diff --git a/src/main/java/org/folio/model/EntityLink.java b/src/main/java/org/folio/model/EntityLink.java new file mode 100644 index 00000000..1879bdbe --- /dev/null +++ b/src/main/java/org/folio/model/EntityLink.java @@ -0,0 +1,12 @@ +package org.folio.model; + +import lombok.Value; + +@Value +public class EntityLink { + + private String domain; + private String type; + private String id; + +} diff --git a/src/main/java/org/folio/db/model/NoteView.java b/src/main/java/org/folio/model/NoteView.java similarity index 98% rename from src/main/java/org/folio/db/model/NoteView.java rename to src/main/java/org/folio/model/NoteView.java index 2770b553..0065f8fa 100644 --- a/src/main/java/org/folio/db/model/NoteView.java +++ b/src/main/java/org/folio/model/NoteView.java @@ -1,17 +1,17 @@ -package org.folio.db.model; +package org.folio.model; import java.util.ArrayList; import java.util.List; import javax.validation.constraints.NotNull; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + import org.folio.rest.jaxrs.model.Link; import org.folio.rest.jaxrs.model.Metadata; import org.folio.rest.jaxrs.model.UserDisplayInfo; -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonInclude; - /** * Database representation of a note */ diff --git a/src/main/java/org/folio/model/Order.java b/src/main/java/org/folio/model/Order.java new file mode 100644 index 00000000..bf2e58ec --- /dev/null +++ b/src/main/java/org/folio/model/Order.java @@ -0,0 +1,34 @@ +package org.folio.model; + +import static org.apache.commons.lang3.StringUtils.defaultString; + +import org.apache.commons.lang3.EnumUtils; + +public enum Order { + + ASC("asc"), DESC("desc"); + + private String value; + + + Order(String value) { + this.value = value; + } + + public String getValue() { + return value; + } + + @Override + public String toString() { + return value; + } + + public static boolean contains(String value) { + return EnumUtils.isValidEnum(Order.class, defaultString(value).toUpperCase()); + } + + public static Order enumOf(String value) { + return valueOf(defaultString(value).toUpperCase()); + } +} diff --git a/src/main/java/org/folio/model/OrderBy.java b/src/main/java/org/folio/model/OrderBy.java new file mode 100644 index 00000000..cad0531e --- /dev/null +++ b/src/main/java/org/folio/model/OrderBy.java @@ -0,0 +1,33 @@ +package org.folio.model; + +import static org.apache.commons.lang3.StringUtils.defaultString; + +import org.apache.commons.lang3.EnumUtils; + +public enum OrderBy { + + STATUS("status"), TITLE("title"); + + private String value; + + OrderBy(String value) { + this.value = value; + } + + public String getValue() { + return value; + } + + @Override + public String toString() { + return value; + } + + public static boolean contains(String value) { + return EnumUtils.isValidEnum(OrderBy.class, defaultString(value).toUpperCase()); + } + + public static OrderBy enumOf(String value) { + return valueOf(defaultString(value).toUpperCase()); + } +} diff --git a/src/main/java/org/folio/model/RowPortion.java b/src/main/java/org/folio/model/RowPortion.java new file mode 100644 index 00000000..5bb0814a --- /dev/null +++ b/src/main/java/org/folio/model/RowPortion.java @@ -0,0 +1,10 @@ +package org.folio.model; + +import lombok.Value; + +@Value +public class RowPortion { + + private int offset; + private int limit; +} diff --git a/src/main/java/org/folio/model/Status.java b/src/main/java/org/folio/model/Status.java new file mode 100644 index 00000000..8b80f262 --- /dev/null +++ b/src/main/java/org/folio/model/Status.java @@ -0,0 +1,21 @@ +package org.folio.model; + + +import static org.apache.commons.lang3.StringUtils.defaultString; + +import org.apache.commons.lang3.EnumUtils; + +public enum Status { + + ASSIGNED, + UNASSIGNED, + ALL; + + public static boolean contains(String value) { + return EnumUtils.isValidEnum(Status.class, defaultString(value).toUpperCase()); + } + + public static Status enumOf(String value) { + return valueOf(defaultString(value).toUpperCase()); + } +} diff --git a/src/main/java/org/folio/note/NoteRepositoryImpl.java b/src/main/java/org/folio/note/NoteRepositoryImpl.java index 7768a031..cb7c4ca9 100644 --- a/src/main/java/org/folio/note/NoteRepositoryImpl.java +++ b/src/main/java/org/folio/note/NoteRepositoryImpl.java @@ -15,7 +15,7 @@ import org.springframework.stereotype.Component; import org.folio.db.CqlQuery; -import org.folio.db.model.NoteView; +import org.folio.model.NoteView; import org.folio.rest.jaxrs.model.Note; import org.folio.rest.jaxrs.model.NoteCollection; import org.folio.rest.persist.PostgresClient; diff --git a/src/main/java/org/folio/rest/impl/NoteLinksImpl.java b/src/main/java/org/folio/rest/impl/NoteLinksImpl.java index b75bc996..f30e84e2 100644 --- a/src/main/java/org/folio/rest/impl/NoteLinksImpl.java +++ b/src/main/java/org/folio/rest/impl/NoteLinksImpl.java @@ -1,6 +1,11 @@ package org.folio.rest.impl; import static io.vertx.core.Future.succeededFuture; +import static org.apache.commons.lang3.EnumUtils.getEnumList; +import static org.apache.commons.lang3.EnumUtils.isValidEnum; +import static org.apache.commons.lang3.StringUtils.defaultString; +import static org.apache.commons.lang3.StringUtils.join; +import static org.apache.commons.lang3.Validate.isTrue; import java.util.Map; import java.util.function.Function; @@ -17,15 +22,17 @@ import org.folio.common.pf.PartialFunction; import org.folio.links.NoteLinksService; +import org.folio.model.EntityLink; +import org.folio.model.Order; +import org.folio.model.OrderBy; +import org.folio.model.RowPortion; +import org.folio.model.Status; import org.folio.rest.RestVerticle; import org.folio.rest.annotations.Validate; import org.folio.rest.jaxrs.model.Link; import org.folio.rest.jaxrs.model.NoteCollection; import org.folio.rest.jaxrs.model.NoteLinksPut; import org.folio.rest.jaxrs.resource.NoteLinks; -import org.folio.rest.model.Order; -import org.folio.rest.model.OrderBy; -import org.folio.rest.model.Status; import org.folio.rest.tools.utils.TenantTool; import org.folio.spring.SpringContextUtil; @@ -67,34 +74,32 @@ public void getNoteLinksDomainTypeIdByDomainAndTypeAndId(String domain, String t Handler> asyncResultHandler, Context vertxContext) { String tenantId = TenantTool.calculateTenantId(okapiHeaders.get(RestVerticle.OKAPI_HEADER_TENANT)); - Link link = new Link().withId(id).withType(type); try { validateParameters(status, order, orderBy); } catch (IllegalArgumentException e) { handleWithInvalidParameters(asyncResultHandler, e.getMessage()); } - Status parsedStatus = Status.valueOf(status.toUpperCase()); - Order parsedOrder = Order.valueOf(order.toUpperCase()); - OrderBy parsedOrderBy = OrderBy.valueOf(orderBy.toUpperCase()); - - Future notes = noteLinksService.findNotesByQuery(parsedStatus, parsedOrder, - parsedOrderBy, domain, title, link, limit, offset, tenantId); + Future notes = noteLinksService.findNotesByTitleAndStatus(new EntityLink(domain, type, id), + title, Status.enumOf(status), OrderBy.enumOf(orderBy), Order.enumOf(order), + new RowPortion(offset, limit), tenantId); respond(notes, GetNoteLinksDomainTypeIdByDomainAndTypeAndIdResponse::respond200WithApplicationJson, asyncResultHandler); } - private void validateParameters(String status, String order, String orderBy) throws IllegalArgumentException { - if (!Status.contains(status.toUpperCase())) { - throw new IllegalArgumentException("Status is incorrect. Possible values: \"ASSIGNED\",\"UNASSIGNED\",\"ALL\""); - } - if (!Order.contains(order.toUpperCase())) { - throw new IllegalArgumentException("Order is incorrect. Possible values: \"asc\",\"desc\""); - } - if (!OrderBy.contains(orderBy.toUpperCase())) { - throw new IllegalArgumentException("OrderBy is incorrect. Possible values: \"status\",\"title\""); - } + private void validateParameters(String status, String order, String orderBy) { + validateEnum(Status.class, status); + validateEnum(Order.class, order); + validateEnum(OrderBy.class, orderBy); + } + + private > void validateEnum(final Class enumClass, final String enumName) { + String normalized = defaultString(enumName).toUpperCase(); + + isTrue(isValidEnum(enumClass, normalized), + "%s is incorrect: %s. Possible values: %s", + enumClass.getSimpleName(), enumName, join(getEnumList(enumClass), ", ")); } private void handleSuccess(Handler> asyncResultHandler) { diff --git a/src/main/java/org/folio/rest/model/Order.java b/src/main/java/org/folio/rest/model/Order.java deleted file mode 100644 index 7270f28c..00000000 --- a/src/main/java/org/folio/rest/model/Order.java +++ /dev/null @@ -1,25 +0,0 @@ -package org.folio.rest.model; - -public enum Order { - - ASC("asc"), DESC("desc"); - - private String value; - - Order(String value) { - this.value = value; - } - - public String getValue() { - return value; - } - - public static boolean contains(String value) { - for (Order c : Order.values()) { - if (c.name().equals(value)) { - return true; - } - } - return false; - } -} diff --git a/src/main/java/org/folio/rest/model/OrderBy.java b/src/main/java/org/folio/rest/model/OrderBy.java deleted file mode 100644 index a3f79cd3..00000000 --- a/src/main/java/org/folio/rest/model/OrderBy.java +++ /dev/null @@ -1,25 +0,0 @@ -package org.folio.rest.model; - -public enum OrderBy { - - STATUS("status"), TITLE("title"); - - private String value; - - OrderBy(String value) { - this.value = value; - } - - public String getValue() { - return value; - } - - public static boolean contains(String value) { - for (OrderBy orderByValue : OrderBy.values()) { - if (orderByValue.name().equals(value)) { - return true; - } - } - return false; - } -} diff --git a/src/main/java/org/folio/rest/model/Status.java b/src/main/java/org/folio/rest/model/Status.java deleted file mode 100644 index c8638095..00000000 --- a/src/main/java/org/folio/rest/model/Status.java +++ /dev/null @@ -1,27 +0,0 @@ -package org.folio.rest.model; - -public enum Status { - - ASSIGNED("ASSIGNED"), - UNASSIGNED("UNASSIGNED"), - ALL("ALL"); - - private String value; - - Status(String value) { - this.value = value; - } - - public String getValue() { - return value; - } - - public static boolean contains(String value) { - for (Status c : Status.values()) { - if (c.name().equals(value)) { - return true; - } - } - return false; - } -}