From 63ffeabe62db1714dc012e39e7d5a52638443812 Mon Sep 17 00:00:00 2001 From: Thomas Georgios Giannos Date: Thu, 21 Dec 2023 18:45:49 +0200 Subject: [PATCH] Implementing validators for Description related persist models, action confirmation and dmp clone persist (in progress) --- .../commons/validation/BaseValidator.java | 8 ++ .../persist/ActionConfirmationPersist.java | 111 ++++++++++++--- .../eudat/model/persist/CloneDmpPersist.java | 66 +++++++-- .../model/persist/DescriptionPersist.java | 131 ++++++++++++++--- .../persist/DescriptionReferencePersist.java | 72 ++++++++-- .../eudat/model/persist/ReferencePersist.java | 133 +++++++++++++++--- .../DmpInvitationPersist.java | 113 ++++++++++----- .../EmailConfirmationPersist.java | 48 ++++++- .../descriptionproperties/FieldPersist.java | 78 +++++++--- .../PropertyDefinitionPersist.java | 68 +++++++-- .../DefinitionPersist.java | 51 +++++++ .../eu/eudat/service/dmp/DmpServiceImpl.java | 7 +- .../eudat/service/user/UserServiceImpl.java | 7 +- .../ValidatorRequestBodyAdvice.java | 11 +- .../controllers/v2/DescriptionController.java | 2 + .../eudat/controllers/v2/DmpController.java | 5 +- 16 files changed, 755 insertions(+), 156 deletions(-) diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/validation/BaseValidator.java b/dmp-backend/core/src/main/java/eu/eudat/commons/validation/BaseValidator.java index 829cfdd30..3ae8839fa 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/commons/validation/BaseValidator.java +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/validation/BaseValidator.java @@ -35,6 +35,14 @@ public abstract class BaseValidator extends AbstractValidator { protected Boolean isEmpty(String value) { return this.conventionService.isNullOrEmpty(value); } + protected Boolean isNull(Object value) { + return value == null; + } + + protected Boolean isNull(Collection value) { + return value == null; + } + protected Boolean lessEqual(String value, int size) { return value.length() <= size; } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/ActionConfirmationPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/ActionConfirmationPersist.java index b1993da53..08bf4058c 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/ActionConfirmationPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/ActionConfirmationPersist.java @@ -2,49 +2,60 @@ package eu.eudat.model.persist; import eu.eudat.commons.enums.ActionConfirmationStatus; import eu.eudat.commons.enums.ActionConfirmationType; -import eu.eudat.commons.validation.old.FieldNotNullIfOtherSet; -import eu.eudat.commons.validation.old.ValidEnum; -import eu.eudat.commons.validation.old.ValidId; +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.commons.validation.ValidatorFactory; +import eu.eudat.commons.validation.specification.Specification; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; import eu.eudat.model.persist.actionconfirmation.DmpInvitationPersist; import eu.eudat.model.persist.actionconfirmation.EmailConfirmationPersist; -import jakarta.validation.Valid; -import jakarta.validation.constraints.NotEmpty; -import jakarta.validation.constraints.NotNull; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.annotation.Scope; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; import java.time.Instant; +import java.util.Arrays; +import java.util.List; import java.util.UUID; -@FieldNotNullIfOtherSet(message = "{validation.hashempty}") public class ActionConfirmationPersist { - @ValidId(message = "{validation.invalidid}") + private UUID id; - @ValidEnum(message = "{validation.empty}") private ActionConfirmationType type; - @ValidEnum(message = "{validation.empty}") + private static final String _type = "type"; + private ActionConfirmationStatus status; - @NotNull(message = "{validation.empty}") - @NotEmpty(message = "{validation.empty}") + private static final String _status = "status"; + private String token; - @Valid + private static final String _token = "token"; + private DmpInvitationPersist dmpInvitation; - @Valid + private static final String _dmpInvitation = "dmpInvitation"; + private EmailConfirmationPersist emailConfirmation; - @NotNull(message = "{validation.empty}") - @Valid + private static final String _emailConfirmation = "emailConfirmation"; + private Instant expiresAt; - @NotNull(message = "{validation.empty}") - @Valid + private static final String _expiresAt = "expiresAt"; + private UUID createdById; + private static final String _createdById = "createdById"; + private String hash; + private static final String _hash = "hash"; + public UUID getId() { return id; } @@ -116,6 +127,70 @@ public class ActionConfirmationPersist { public void setHash(String hash) { this.hash = hash; } + + @Component(ActionConfirmationPersistValidator.ValidatorName) + @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public static class ActionConfirmationPersistValidator extends BaseValidator { + + public static final String ValidatorName = "ActionConfirmationPersistValidator"; + + private final MessageSource messageSource; + + private final ValidatorFactory validatorFactory; + + public ActionConfirmationPersistValidator(MessageSource messageSource, ConventionService conventionService, ErrorThesaurusProperties errors, ValidatorFactory validatorFactory) { + super(conventionService, errors); + this.messageSource = messageSource; + this.validatorFactory = validatorFactory; + } + + @Override + protected Class modelClass() { + return ActionConfirmationPersist.class; + } + + @Override + protected List specifications(ActionConfirmationPersist item) { + return Arrays.asList( + this.spec() + .iff(() -> this.isValidGuid(item.getId())) + .must(() -> this.isValidHash(item.getHash())) + .failOn(ActionConfirmationPersist._hash).failWith(messageSource.getMessage("Validation_Required", new Object[]{ActionConfirmationPersist._hash}, LocaleContextHolder.getLocale())), + this.spec() + .iff(() -> !this.isValidGuid(item.getId())) + .must(() -> !this.isValidHash(item.getHash())) + .failOn(ActionConfirmationPersist._hash).failWith(messageSource.getMessage("Validation_OverPosting", new Object[]{}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isNull(item.getType())) + .failOn(ActionConfirmationPersist._type).failWith(messageSource.getMessage("Validation_Required", new Object[]{ActionConfirmationPersist._type}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isNull(item.getStatus())) + .failOn(ActionConfirmationPersist._status).failWith(messageSource.getMessage("Validation_Required", new Object[]{ActionConfirmationPersist._status}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isEmpty(item.getToken())) + .failOn(ActionConfirmationPersist._token).failWith(messageSource.getMessage("Validation_Required", new Object[]{ActionConfirmationPersist._token}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isNull(item.getExpiresAt())) + .failOn(ActionConfirmationPersist._expiresAt).failWith(messageSource.getMessage("Validation_Required", new Object[]{ActionConfirmationPersist._expiresAt}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isNull(item.getCreatedById())) + .failOn(ActionConfirmationPersist._createdById).failWith(messageSource.getMessage("Validation_Required", new Object[]{ActionConfirmationPersist._createdById}, LocaleContextHolder.getLocale())), + + this.refSpec() + .iff(() -> !this.isNull(item.getDmpInvitation())) + .on(ActionConfirmationPersist._dmpInvitation) + .over(item.getDmpInvitation()) + .using(() -> this.validatorFactory.validator(DmpInvitationPersist.DmpInvitationPersistValidator.class)), + this.refSpec() + .iff(() -> !this.isNull(item.getEmailConfirmation())) + .on(ActionConfirmationPersist._emailConfirmation) + .over(item.getEmailConfirmation()) + .using(() -> this.validatorFactory.validator(EmailConfirmationPersist.EmailConfirmationPersistValidator.class)) + ); + } + + } + } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/CloneDmpPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/CloneDmpPersist.java index 3a4c80277..bf097fd00 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/CloneDmpPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/CloneDmpPersist.java @@ -1,30 +1,38 @@ package eu.eudat.model.persist; -import eu.eudat.commons.validation.old.ValidId; -import jakarta.validation.constraints.NotEmpty; -import jakarta.validation.constraints.NotNull; +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.commons.validation.specification.Specification; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; import org.apache.commons.compress.utils.Lists; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.annotation.Scope; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; +import java.util.Arrays; import java.util.List; import java.util.UUID; public class CloneDmpPersist { - @NotNull(message = "{validation.empty}") - @ValidId(message = "{validation.invalidid}") private UUID id = null; - @NotNull(message = "{validation.empty}") - @NotEmpty(message = "{validation.empty}") + public static final String _id = "id"; + private String label = null; - @NotNull(message = "{validation.empty}") - @NotEmpty(message = "{validation.empty}") + public static final String _label = "label"; + private String description = null; - @NotNull(message = "{validation.empty}") + public static final String _description = "description"; + private List descriptions = Lists.newArrayList(); + public static final String _descriptions = "descriptions"; + public UUID getId() { return id; } @@ -56,4 +64,42 @@ public class CloneDmpPersist { public void setDescriptions(List descriptions) { this.descriptions = descriptions; } + + @Component(CloneDmpPersistValidator.ValidatorName) + @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public static class CloneDmpPersistValidator extends BaseValidator { + + public static final String ValidatorName = "CloneDmpPersistValidator"; + + private final MessageSource messageSource; + + protected CloneDmpPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource) { + super(conventionService, errors); + this.messageSource = messageSource; + } + + @Override + protected Class modelClass() { + return CloneDmpPersist.class; + } + + @Override + protected List specifications(CloneDmpPersist item) { + return Arrays.asList( + this.spec() + .must(() -> this.isValidGuid(item.getId())) + .failOn(CloneDmpPersist._id).failWith(messageSource.getMessage("Validation_Required", new Object[]{CloneDmpPersist._id}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> this.isEmpty(item.getLabel())) + .failOn(CloneDmpPersist._label).failWith(messageSource.getMessage("Validation_Required", new Object[]{CloneDmpPersist._label}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> this.isEmpty(item.getDescription())) + .failOn(CloneDmpPersist._description).failWith(messageSource.getMessage("Validation_Required", new Object[]{CloneDmpPersist._description}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> this.isNull(item.getDescriptions())) + .failOn(CloneDmpPersist._descriptions).failWith(messageSource.getMessage("Validation_Required", new Object[]{CloneDmpPersist._descriptions}, LocaleContextHolder.getLocale())) + ); + } + } + } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java index 2332c235f..391d15023 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java @@ -1,61 +1,70 @@ package eu.eudat.model.persist; import eu.eudat.commons.enums.DescriptionStatus; +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.commons.validation.ValidatorFactory; import eu.eudat.commons.validation.old.FieldNotNullIfOtherSet; -import eu.eudat.commons.validation.old.ValidEnum; -import eu.eudat.commons.validation.old.ValidId; -import eu.eudat.data.DescriptionEntity; +import eu.eudat.commons.validation.specification.Specification; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; import eu.eudat.model.persist.descriptionproperties.PropertyDefinitionPersist; import jakarta.validation.Valid; -import jakarta.validation.constraints.NotEmpty; import jakarta.validation.constraints.NotNull; -import jakarta.validation.constraints.Size; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.annotation.Scope; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; +import java.util.Arrays; import java.util.List; import java.util.UUID; @FieldNotNullIfOtherSet(message = "{validation.hashempty}") public class DescriptionPersist { - @ValidId(message = "{validation.invalidid}") private UUID id; - @NotNull(message = "{validation.empty}") - @NotEmpty(message = "{validation.empty}") - @Size(max = DescriptionEntity._labelLength, message = "{validation.largerthanmax}") private String label; - @NotNull(message = "{validation.empty}") - @ValidId(message = "{validation.invalidid}") + public static final String _label = "label"; + + public static final int _labelLength = 250; + private UUID dmpId; - @NotNull(message = "{validation.empty}") - @ValidId(message = "{validation.invalidid}") + public static final String _dmpId = "dmpId"; + private UUID dmpDescriptionTemplateId; - @NotNull(message = "{validation.empty}") - @ValidId(message = "{validation.invalidid}") + public static final String _dmpDescriptionTemplateId = "dmpDescriptionTemplateId"; + private UUID descriptionTemplateId; - @ValidEnum(message = "{validation.empty}") + public static final String _descriptionTemplateId = "descriptionTemplateId"; + private DescriptionStatus status; + public static final String _status = "status"; + private String description; - @NotNull(message = "{validation.empty}") - @Valid private PropertyDefinitionPersist properties; - @NotNull(message = "{validation.empty}") - @Valid + public static final String _properties = "properties"; + private List tags; - @NotNull(message = "{validation.empty}") - @Valid + public static final String _tags = "tags"; + private List references; - + + public static final String _references = "references"; + private String hash; + public static final String _hash = "hash"; + public UUID getId() { return id; } @@ -143,4 +152,80 @@ public class DescriptionPersist { public void setDescriptionTemplateId(UUID descriptionTemplateId) { this.descriptionTemplateId = descriptionTemplateId; } + + @Component(DescriptionPersistValidator.ValidatorName) + @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public static class DescriptionPersistValidator extends BaseValidator { + + public static final String ValidatorName = "DescriptionPersistValidator"; + + private final MessageSource messageSource; + + private final ValidatorFactory validatorFactory; + + protected DescriptionPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource, ValidatorFactory validatorFactory) { + super(conventionService, errors); + this.messageSource = messageSource; + this.validatorFactory = validatorFactory; + } + + @Override + protected Class modelClass() { + return DescriptionPersist.class; + } + + @Override + protected List specifications(DescriptionPersist item) { + return Arrays.asList( + this.spec() + .iff(() -> this.isValidGuid(item.getId())) + .must(() -> this.isValidHash(item.getHash())) + .failOn(DescriptionPersist._hash).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionPersist._hash}, LocaleContextHolder.getLocale())), + this.spec() + .iff(() -> !this.isValidGuid(item.getId())) + .must(() -> !this.isValidHash(item.getHash())) + .failOn(DescriptionPersist._hash).failWith(messageSource.getMessage("Validation_OverPosting", new Object[]{}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isEmpty(item.getLabel())) + .failOn(DescriptionPersist._label).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionPersist._label}, LocaleContextHolder.getLocale())), + this.spec() + .iff(() -> !this.isEmpty(item.getLabel())) + .must(() -> this.lessEqual(item.getLabel(), DescriptionPersist._labelLength)) + .failOn(DescriptionPersist._label).failWith(messageSource.getMessage("Validation_MaxLength", new Object[]{DescriptionPersist._label}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> this.isValidGuid(item.getDmpId())) + .failOn(DescriptionPersist._dmpId).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionPersist._dmpId}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> this.isValidGuid(item.getDescriptionTemplateId())) + .failOn(DescriptionPersist._descriptionTemplateId).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionPersist._descriptionTemplateId}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> this.isValidGuid(item.getDmpDescriptionTemplateId())) + .failOn(DescriptionPersist._dmpDescriptionTemplateId).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionPersist._dmpDescriptionTemplateId}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isNull(item.getStatus())) + .failOn(DescriptionPersist._status).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionPersist._status}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isNull(item.getTags())) + .failOn(DescriptionPersist._tags).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionPersist._tags}, LocaleContextHolder.getLocale())), + + this.spec() + .must(() -> !this.isNull(item.getProperties())) + .failOn(DescriptionPersist._properties).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionPersist._properties}, LocaleContextHolder.getLocale())), + this.refSpec() + .iff(() -> !this.isNull(item.getProperties())) + .on(DescriptionPersist._properties) + .over(item.getProperties()) + .using(() -> this.validatorFactory.validator(PropertyDefinitionPersist.PropertyDefinitionPersistValidator.class)), + this.spec() + .must(() -> !this.isNull(item.getReferences())) + .failOn(DescriptionPersist._references).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionPersist._references}, LocaleContextHolder.getLocale())), + this.navSpec() + .iff(() -> !this.isNull(item.getReferences())) + .on(DescriptionPersist._references) + .over(item.getReferences()) + .using(() -> this.validatorFactory.validator(DescriptionReferencePersist.DescriptionReferencePersistValidator.class)) + ); + } + } + } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionReferencePersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionReferencePersist.java index 59ad3732b..147dc37ef 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionReferencePersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionReferencePersist.java @@ -1,24 +1,32 @@ package eu.eudat.model.persist; +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.commons.validation.ValidatorFactory; +import eu.eudat.commons.validation.specification.Specification; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.annotation.Scope; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; -import eu.eudat.commons.validation.old.FieldNotNullIfOtherSet; -import eu.eudat.commons.validation.old.ValidId; -import jakarta.validation.Valid; -import jakarta.validation.constraints.NotNull; - +import java.util.Arrays; +import java.util.List; import java.util.UUID; -@FieldNotNullIfOtherSet(message = "{validation.hashempty}") public class DescriptionReferencePersist { - @ValidId(message = "{validation.invalidid}") + private UUID id; - @NotNull(message = "{validation.empty}") - @Valid private ReferencePersist reference = null; + public static final String _reference = "reference"; + private String hash; + public static final String _hash = "hash"; + public UUID getId() { return id; } @@ -42,6 +50,52 @@ public class DescriptionReferencePersist { public void setHash(String hash) { this.hash = hash; } + + @Component(DescriptionReferencePersistValidator.ValidatorName) + @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public static class DescriptionReferencePersistValidator extends BaseValidator { + + public static final String ValidatorName = "DescriptionReferencePersistValidator"; + + private final MessageSource messageSource; + + private final ValidatorFactory validatorFactory; + + protected DescriptionReferencePersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource, ValidatorFactory validatorFactory) { + super(conventionService, errors); + this.messageSource = messageSource; + this.validatorFactory = validatorFactory; + } + + @Override + protected Class modelClass() { + return DescriptionReferencePersist.class; + } + + @Override + protected List specifications(DescriptionReferencePersist item) { + return Arrays.asList( + this.spec() + .iff(() -> this.isValidGuid(item.getId())) + .must(() -> this.isValidHash(item.getHash())) + .failOn(DescriptionReferencePersist._hash).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionReferencePersist._hash}, LocaleContextHolder.getLocale())), + this.spec() + .iff(() -> !this.isValidGuid(item.getId())) + .must(() -> !this.isValidHash(item.getHash())) + .failOn(DescriptionReferencePersist._hash).failWith(messageSource.getMessage("Validation_OverPosting", new Object[]{}, LocaleContextHolder.getLocale())), + + this.spec() + .must(() -> !this.isNull(item.getReference())) + .failOn(DescriptionReferencePersist._reference).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionReferencePersist._reference}, LocaleContextHolder.getLocale())), + this.refSpec() + .iff(() -> !this.isNull(item.getReference())) + .on(DescriptionReferencePersist._reference) + .over(item.getReference()) + .using(() -> this.validatorFactory.validator(ReferencePersist.ReferencePersistValidator.class)) + ); + } + } + } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/ReferencePersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/ReferencePersist.java index 694216cc5..9635ea972 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/ReferencePersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/ReferencePersist.java @@ -1,53 +1,74 @@ package eu.eudat.model.persist; -import eu.eudat.commons.enums.ReferenceType; import eu.eudat.commons.enums.ReferenceSourceType; -import eu.eudat.commons.validation.old.FieldNotNullIfOtherSet; +import eu.eudat.commons.enums.ReferenceType; +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.commons.validation.ValidatorFactory; import eu.eudat.commons.validation.old.ValidEnum; -import eu.eudat.commons.validation.old.ValidId; +import eu.eudat.commons.validation.specification.Specification; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; import eu.eudat.model.persist.referencedefinition.DefinitionPersist; -import jakarta.validation.Valid; -import jakarta.validation.constraints.NotEmpty; -import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.Size; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.annotation.Scope; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; +import java.util.Arrays; +import java.util.List; import java.util.UUID; -@FieldNotNullIfOtherSet(message = "{validation.hashempty}") public class ReferencePersist { - @ValidId(message = "{validation.invalidid}") private UUID id; - @NotNull(message = "{validation.empty}") - @NotEmpty(message = "{validation.empty}") - @Size(max = 250, message = "{validation.largerthanmax}") private String label; - @ValidEnum(message = "{validation.empty}") + public static final String _label = "label"; + + public static final int _labelLength = 250; + private ReferenceType type; + public static final String _type = "type"; + private String description; - @Valid private DefinitionPersist definition; - @NotNull(message = "{validation.empty}") - @NotEmpty(message = "{validation.empty}") - @Size(max = 1024, message = "{validation.largerthanmax}") + public static final String _definition = "definition"; + private String reference; + public static final String _reference = "reference"; + + public static final int _referenceLength = 1024; + @Size(max = 50, message = "{validation.largerthanmax}") private String abbreviation; + public static final String _abbreviation = "abbreviation"; + + public static final int _abbreviationLength = 50; + @Size(max = 1024, message = "{validation.largerthanmax}") private String source; + public static final String _source = "source"; + + public static final int _sourceLength = 1024; + @ValidEnum(message = "{validation.empty}") private ReferenceSourceType sourceType; + public static final String _sourceType = "sourceType"; + private String hash; + public static final String _hash = "hash"; + public UUID getId() { return id; } @@ -127,4 +148,84 @@ public class ReferencePersist { public void setHash(String hash) { this.hash = hash; } + + @Component(ReferencePersistValidator.ValidatorName) + @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public static class ReferencePersistValidator extends BaseValidator { + + public static final String ValidatorName = "ReferencePersistValidator"; + + private final MessageSource messageSource; + + private final ValidatorFactory validatorFactory; + + protected ReferencePersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource, ValidatorFactory validatorFactory) { + super(conventionService, errors); + this.messageSource = messageSource; + this.validatorFactory = validatorFactory; + } + + @Override + protected Class modelClass() { + return ReferencePersist.class; + } + + @Override + protected List specifications(ReferencePersist item) { + return Arrays.asList( + this.spec() + .iff(() -> this.isValidGuid(item.getId())) + .must(() -> this.isValidHash(item.getHash())) + .failOn(ReferencePersist._hash).failWith(messageSource.getMessage("Validation_Required", new Object[]{ReferencePersist._hash}, LocaleContextHolder.getLocale())), + this.spec() + .iff(() -> !this.isValidGuid(item.getId())) + .must(() -> !this.isValidHash(item.getHash())) + .failOn(ReferencePersist._hash).failWith(messageSource.getMessage("Validation_OverPosting", new Object[]{}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isEmpty(item.getLabel())) + .failOn(ReferencePersist._label).failWith(messageSource.getMessage("Validation_Required", new Object[]{ReferencePersist._label}, LocaleContextHolder.getLocale())), + this.spec() + .iff(() -> !this.isEmpty(item.getLabel())) + .must(() -> this.lessEqual(item.getLabel(), ReferencePersist._labelLength)) + .failOn(ReferencePersist._label).failWith(messageSource.getMessage("Validation_MaxLength", new Object[]{ReferencePersist._label}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isNull(item.getType())) + .failOn(ReferencePersist._type).failWith(messageSource.getMessage("Validation_Required", new Object[]{ReferencePersist._type}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isEmpty(item.getReference())) + .failOn(ReferencePersist._reference).failWith(messageSource.getMessage("Validation_Required", new Object[]{ReferencePersist._reference}, LocaleContextHolder.getLocale())), + this.spec() + .iff(() -> !this.isEmpty(item.getReference())) + .must(() -> this.lessEqual(item.getReference(), ReferencePersist._referenceLength)) + .failOn(ReferencePersist._reference).failWith(messageSource.getMessage("Validation_MaxLength", new Object[]{ReferencePersist._reference}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isEmpty(item.getAbbreviation())) + .failOn(ReferencePersist._abbreviation).failWith(messageSource.getMessage("Validation_Required", new Object[]{ReferencePersist._abbreviation}, LocaleContextHolder.getLocale())), + this.spec() + .iff(() -> !this.isEmpty(item.getAbbreviation())) + .must(() -> this.lessEqual(item.getAbbreviation(), ReferencePersist._abbreviationLength)) + .failOn(ReferencePersist._abbreviation).failWith(messageSource.getMessage("Validation_MaxLength", new Object[]{ReferencePersist._abbreviation}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isEmpty(item.getSource())) + .failOn(ReferencePersist._source).failWith(messageSource.getMessage("Validation_Required", new Object[]{ReferencePersist._source}, LocaleContextHolder.getLocale())), + this.spec() + .iff(() -> !this.isEmpty(item.getSource())) + .must(() -> this.lessEqual(item.getSource(), ReferencePersist._sourceLength)) + .failOn(ReferencePersist._source).failWith(messageSource.getMessage("Validation_MaxLength", new Object[]{ReferencePersist._source}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isNull(item.getSourceType())) + .failOn(ReferencePersist._sourceType).failWith(messageSource.getMessage("Validation_Required", new Object[]{ReferencePersist._sourceType}, LocaleContextHolder.getLocale())), + + this.spec() + .must(() -> !this.isNull(item.getDefinition())) + .failOn(ReferencePersist._definition).failWith(messageSource.getMessage("Validation_Required", new Object[]{ReferencePersist._definition}, LocaleContextHolder.getLocale())), + this.refSpec() + .iff(() -> !this.isNull(item.getDefinition())) + .on(ReferencePersist._definition) + .over(item.getDefinition()) + .using(() -> this.validatorFactory.validator(DefinitionPersist.DefinitionPersistValidator.class)) + ); + } + } + } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/actionconfirmation/DmpInvitationPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/actionconfirmation/DmpInvitationPersist.java index 4d1ef7688..ae03465f3 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/actionconfirmation/DmpInvitationPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/actionconfirmation/DmpInvitationPersist.java @@ -1,53 +1,96 @@ package eu.eudat.model.persist.actionconfirmation; import eu.eudat.commons.enums.DmpUserRole; -import eu.eudat.commons.validation.old.ValidEnum; -import jakarta.validation.Valid; -import jakarta.validation.constraints.NotEmpty; -import jakarta.validation.constraints.NotNull; +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.commons.validation.specification.Specification; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.annotation.Scope; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; +import java.util.Arrays; +import java.util.List; import java.util.UUID; public class DmpInvitationPersist { - @NotNull(message = "{validation.empty}") - @NotEmpty(message = "{validation.empty}") - private String email; + private String email; - @NotNull(message = "{validation.empty}") - @Valid - private UUID dmpId; + public static final String _email = "email"; - @ValidEnum(message = "{validation.empty}") - private DmpUserRole role; + private UUID dmpId; - public DmpInvitationPersist(String email, UUID dmpId, DmpUserRole role) { - this.email = email; - this.dmpId = dmpId; - this.role = role; - } + public static final String _dmpId = "dmpId"; - public String getEmail() { - return email; - } + private DmpUserRole role; - public void setEmail(String email) { - this.email = email; - } + public static final String _role = "role"; - public UUID getDmpId() { - return dmpId; - } + public DmpInvitationPersist(String email, UUID dmpId, DmpUserRole role) { + this.email = email; + this.dmpId = dmpId; + this.role = role; + } - public void setDmpId(UUID dmpId) { - this.dmpId = dmpId; - } + public String getEmail() { + return email; + } - public DmpUserRole getRole() { - return role; - } + public void setEmail(String email) { + this.email = email; + } + + public UUID getDmpId() { + return dmpId; + } + + public void setDmpId(UUID dmpId) { + this.dmpId = dmpId; + } + + public DmpUserRole getRole() { + return role; + } + + public void setRole(DmpUserRole role) { + this.role = role; + } + + @Component(DmpInvitationPersistValidator.ValidatorName) + @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public static class DmpInvitationPersistValidator extends BaseValidator { + + public static final String ValidatorName = "DmpInvitationPersistValidator"; + + private final MessageSource messageSource; + + protected DmpInvitationPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource) { + super(conventionService, errors); + this.messageSource = messageSource; + } + + @Override + protected Class modelClass() { + return DmpInvitationPersist.class; + } + + @Override + protected List specifications(DmpInvitationPersist item) { + return Arrays.asList( + this.spec() + .must(() -> !this.isEmpty(item.getEmail())) + .failOn(DmpInvitationPersist._email).failWith(messageSource.getMessage("Validation_Required", new Object[]{DmpInvitationPersist._email}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isNull(item.getDmpId())) + .failOn(DmpInvitationPersist._dmpId).failWith(messageSource.getMessage("Validation_Required", new Object[]{DmpInvitationPersist._dmpId}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isNull(item.getRole())) + .failOn(DmpInvitationPersist._role).failWith(messageSource.getMessage("Validation_Required", new Object[]{DmpInvitationPersist._role}, LocaleContextHolder.getLocale())) + ); + } + } - public void setRole(DmpUserRole role) { - this.role = role; - } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/actionconfirmation/EmailConfirmationPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/actionconfirmation/EmailConfirmationPersist.java index 948ddc6eb..302d5d256 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/actionconfirmation/EmailConfirmationPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/actionconfirmation/EmailConfirmationPersist.java @@ -1,16 +1,23 @@ package eu.eudat.model.persist.actionconfirmation; -import jakarta.validation.constraints.NotEmpty; -import jakarta.validation.constraints.NotNull; +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.commons.validation.specification.Specification; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.annotation.Scope; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; + +import java.util.Collections; +import java.util.List; public class EmailConfirmationPersist { - @NotNull(message = "{validation.empty}") - @NotEmpty(message = "{validation.empty}") private String email; - public EmailConfirmationPersist() { - } + public static final String _email = "email"; public EmailConfirmationPersist(String email) { this.email = email; @@ -23,4 +30,33 @@ public class EmailConfirmationPersist { public void setEmail(String email) { this.email = email; } + + @Component(EmailConfirmationPersistValidator.ValidatorName) + @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public static class EmailConfirmationPersistValidator extends BaseValidator { + + public static final String ValidatorName = "EmailConfirmationPersistValidator"; + + private final MessageSource messageSource; + + protected EmailConfirmationPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource) { + super(conventionService, errors); + this.messageSource = messageSource; + } + + @Override + protected Class modelClass() { + return EmailConfirmationPersist.class; + } + + @Override + protected List specifications(EmailConfirmationPersist item) { + return Collections.singletonList( + this.spec() + .must(() -> !this.isEmpty(item.getEmail())) + .failOn(EmailConfirmationPersist._email).failWith(messageSource.getMessage("Validation_Required", new Object[]{EmailConfirmationPersist._email}, LocaleContextHolder.getLocale())) + ); + } + } + } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/FieldPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/FieldPersist.java index d7dd2bf6b..6cc55c753 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/FieldPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/FieldPersist.java @@ -1,34 +1,72 @@ package eu.eudat.model.persist.descriptionproperties; +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.commons.validation.specification.Specification; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import org.springframework.context.MessageSource; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; -import jakarta.validation.constraints.NotEmpty; -import jakarta.validation.constraints.NotNull; +import java.util.Arrays; +import java.util.List; public class FieldPersist { - @NotNull(message = "{validation.empty}") - @NotEmpty(message = "{validation.empty}") - private String key; + private String key; - @NotNull(message = "{validation.empty}") - @NotEmpty(message = "{validation.empty}") - private String value; + public static final String _key = "key"; - public String getKey() { - return key; - } + private String value; - public void setKey(String key) { - this.key = key; - } + public static final String _value = "value"; - public String getValue() { - return value; - } + public String getKey() { + return key; + } + + public void setKey(String key) { + this.key = key; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + @Component(FieldPersistValidator.ValidatorName) + public static class FieldPersistValidator extends BaseValidator { + + public static final String ValidatorName = "Description.FieldPersistValidator"; + + private final MessageSource messageSource; + + protected FieldPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource) { + super(conventionService, errors); + this.messageSource = messageSource; + } + + @Override + protected Class modelClass() { + return FieldPersist.class; + } + + @Override + protected List specifications(FieldPersist item) { + return Arrays.asList( + this.spec() + .must(() -> !this.isEmpty(item.getKey())) + .failOn(FieldPersist._key).failWith(messageSource.getMessage("Validation_Required", new Object[]{FieldPersist._key}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isEmpty(item.getValue())) + .failOn(FieldPersist._value).failWith(messageSource.getMessage("Validation_Required", new Object[]{FieldPersist._value}, LocaleContextHolder.getLocale())) + ); + } + } - public void setValue(String value) { - this.value = value; - } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionPersist.java index bbf9d6c60..90f8664f2 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionPersist.java @@ -1,21 +1,67 @@ package eu.eudat.model.persist.descriptionproperties; -import jakarta.validation.Valid; -import jakarta.validation.constraints.NotNull; +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.commons.validation.ValidatorFactory; +import eu.eudat.commons.validation.specification.Specification; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.annotation.Scope; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; +import java.util.Arrays; import java.util.List; public class PropertyDefinitionPersist { - @NotNull(message = "{validation.empty}") - @Valid - private List fields; + private List fields; - public List getFields() { - return fields; - } + public static final String _fields = "fields"; + + public List getFields() { + return fields; + } + + public void setFields(List fields) { + this.fields = fields; + } + + @Component(PropertyDefinitionPersistValidator.ValidatorName) + @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public static class PropertyDefinitionPersistValidator extends BaseValidator { + + public static final String ValidatorName = "Description.PropertyDefinitionPersistValidator"; + + private final MessageSource messageSource; + + private final ValidatorFactory validatorFactory; + + protected PropertyDefinitionPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource, ValidatorFactory validatorFactory) { + super(conventionService, errors); + this.messageSource = messageSource; + this.validatorFactory = validatorFactory; + } + + @Override + protected Class modelClass() { + return PropertyDefinitionPersist.class; + } + + @Override + protected List specifications(PropertyDefinitionPersist item) { + return Arrays.asList( + this.spec() + .must(() -> !this.isNull(item.getFields())) + .failOn(PropertyDefinitionPersist._fields).failWith(messageSource.getMessage("Validation_Required", new Object[]{PropertyDefinitionPersist._fields}, LocaleContextHolder.getLocale())), + this.navSpec() + .iff(() -> !this.isNull(item.getFields())) + .on(PropertyDefinitionPersist._fields) + .over(item.getFields()) + .using(() -> this.validatorFactory.validator(FieldPersist.FieldPersistValidator.class)) + ); + } + } - public void setFields(List fields) { - this.fields = fields; - } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/DefinitionPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/DefinitionPersist.java index 60c8c6881..8d9b9ff51 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/DefinitionPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/DefinitionPersist.java @@ -1,8 +1,20 @@ package eu.eudat.model.persist.referencedefinition; +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.commons.validation.ValidatorFactory; +import eu.eudat.commons.validation.specification.Specification; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import eu.eudat.model.persist.descriptionproperties.PropertyDefinitionPersist; import jakarta.validation.Valid; import jakarta.validation.constraints.NotNull; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.annotation.Scope; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; +import java.util.Arrays; import java.util.List; public class DefinitionPersist { @@ -11,6 +23,8 @@ public class DefinitionPersist { @Valid private List fields = null; + public static final String _fields = "fields"; + public List getFields() { return fields; } @@ -18,4 +32,41 @@ public class DefinitionPersist { public void setFields(List fields) { this.fields = fields; } + + @Component(DefinitionPersistValidator.ValidatorName) + @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public static class DefinitionPersistValidator extends BaseValidator { + + public static final String ValidatorName = "Reference.DefinitionPersistValidator"; + + private final MessageSource messageSource; + + private final ValidatorFactory validatorFactory; + + protected DefinitionPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource, ValidatorFactory validatorFactory) { + super(conventionService, errors); + this.messageSource = messageSource; + this.validatorFactory = validatorFactory; + } + + @Override + protected Class modelClass() { + return DefinitionPersist.class; + } + + @Override + protected List specifications(DefinitionPersist item) { + return Arrays.asList( + this.spec() + .must(() -> !this.isNull(item.getFields())) + .failOn(DefinitionPersist._fields).failWith(messageSource.getMessage("Validation_Required", new Object[]{DefinitionPersist._fields}, LocaleContextHolder.getLocale())), + this.navSpec() + .iff(() -> !this.isNull(item.getFields())) + .on(DefinitionPersist._fields) + .over(item.getFields()) + .using(() -> null) //TODO + ); + } + } + } diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java index f48ccb161..63d8da359 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java @@ -15,6 +15,7 @@ import eu.eudat.commons.types.dmp.DmpPropertiesEntity; import eu.eudat.commons.types.notification.*; import eu.eudat.commons.types.reference.DefinitionEntity; import eu.eudat.commons.types.reference.FieldEntity; +import eu.eudat.commons.validation.ValidatorFactory; import eu.eudat.configurations.notification.NotificationProperties; import eu.eudat.convention.ConventionService; import eu.eudat.data.*; @@ -114,6 +115,8 @@ public class DmpServiceImpl implements DmpService { private final ActionConfirmationService actionConfirmationService; + private final ValidatorFactory validatorFactory; + @Autowired public DmpServiceImpl( EntityManager entityManager, @@ -126,7 +129,7 @@ public class DmpServiceImpl implements DmpService { MessageSource messageSource, XmlHandlingService xmlHandlingService, JsonHandlingService jsonHandlingService, - UserScope userScope, EventBroker eventBroker, DescriptionService descriptionService, NotificationIntegrationEventHandler eventHandler, NotificationProperties notificationProperties, ActionConfirmationService actionConfirmationService, FileTransformerService fileTransformerService) { + UserScope userScope, EventBroker eventBroker, DescriptionService descriptionService, NotificationIntegrationEventHandler eventHandler, NotificationProperties notificationProperties, ActionConfirmationService actionConfirmationService, FileTransformerService fileTransformerService, ValidatorFactory validatorFactory) { this.entityManager = entityManager; this.authorizationService = authorizationService; this.deleterFactory = deleterFactory; @@ -144,6 +147,7 @@ public class DmpServiceImpl implements DmpService { this.eventHandler = eventHandler; this.notificationProperties = notificationProperties; this.actionConfirmationService = actionConfirmationService; + this.validatorFactory = validatorFactory; } public Dmp persist(DmpPersist model, FieldSet fields) throws MyForbiddenException, MyValidationException, MyApplicationException, MyNotFoundException, InvalidApplicationException, JsonProcessingException { @@ -763,6 +767,7 @@ public class DmpServiceImpl implements DmpService { persist.setDmpInvitation(new DmpInvitationPersist(email, dmp.getId(), role)); persist.setCreatedById(this.userScope.getUserIdSafe()); persist.setExpiresAt(Instant.now().plusSeconds(Long.parseLong(this.notificationProperties.getEmailExpirationTimeSeconds()))); + validatorFactory.validator(ActionConfirmationPersist.ActionConfirmationPersistValidator.class).validateForce(persist); this.actionConfirmationService.persist(persist, null); return persist.getToken(); diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/user/UserServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/user/UserServiceImpl.java index 15951d035..33c7a69e3 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/user/UserServiceImpl.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/user/UserServiceImpl.java @@ -15,6 +15,7 @@ import eu.eudat.commons.scope.user.UserScope; import eu.eudat.commons.types.actionconfirmation.EmailConfirmationEntity; import eu.eudat.commons.types.notification.*; import eu.eudat.commons.types.user.AdditionalInfoEntity; +import eu.eudat.commons.validation.ValidatorFactory; import eu.eudat.configurations.notification.NotificationProperties; import eu.eudat.convention.ConventionService; import eu.eudat.data.*; @@ -98,6 +99,8 @@ public class UserServiceImpl implements UserService { private final NotificationProperties notificationProperties; private final NotificationIntegrationEventHandler eventHandler; + private final ValidatorFactory validatorFactory; + @Autowired public UserServiceImpl( EntityManager entityManager, @@ -110,7 +113,7 @@ public class UserServiceImpl implements UserService { EventBroker eventBroker, JsonHandlingService jsonHandlingService, XmlHandlingService xmlHandlingService, QueryFactory queryFactory, - UserScope userScope, KeycloakService keycloakService, ActionConfirmationService actionConfirmationService, NotificationProperties notificationProperties, NotificationIntegrationEventHandler eventHandler) { + UserScope userScope, KeycloakService keycloakService, ActionConfirmationService actionConfirmationService, NotificationProperties notificationProperties, NotificationIntegrationEventHandler eventHandler, ValidatorFactory validatorFactory) { this.entityManager = entityManager; this.authorizationService = authorizationService; this.deleterFactory = deleterFactory; @@ -127,6 +130,7 @@ public class UserServiceImpl implements UserService { this.actionConfirmationService = actionConfirmationService; this.notificationProperties = notificationProperties; this.eventHandler = eventHandler; + this.validatorFactory = validatorFactory; } //region persist @@ -401,6 +405,7 @@ public class UserServiceImpl implements UserService { persist.setEmailConfirmation(new EmailConfirmationPersist(email)); persist.setCreatedById(this.userScope.getUserIdSafe()); persist.setExpiresAt(Instant.now().plusSeconds(Long.parseLong(this.notificationProperties.getEmailExpirationTimeSeconds()))); + validatorFactory.validator(ActionConfirmationPersist.ActionConfirmationPersistValidator.class).validateForce(persist); this.actionConfirmationService.persist(persist, null); return persist.getToken(); diff --git a/dmp-backend/web/src/main/java/eu/eudat/controllers/controllerhandler/ValidatorRequestBodyAdvice.java b/dmp-backend/web/src/main/java/eu/eudat/controllers/controllerhandler/ValidatorRequestBodyAdvice.java index b8be7a9e9..703127b3d 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/controllers/controllerhandler/ValidatorRequestBodyAdvice.java +++ b/dmp-backend/web/src/main/java/eu/eudat/controllers/controllerhandler/ValidatorRequestBodyAdvice.java @@ -4,6 +4,7 @@ import eu.eudat.commons.validation.Validator; import eu.eudat.commons.validation.ValidatorFactory; import eu.eudat.commons.validation.ValidationFilterAnnotation; import gr.cite.tools.exception.MyApplicationException; +import org.jetbrains.annotations.NotNull; import org.springframework.core.MethodParameter; import org.springframework.http.HttpInputMessage; import org.springframework.http.converter.HttpMessageConverter; @@ -25,8 +26,8 @@ public class ValidatorRequestBodyAdvice implements RequestBodyAdvice { } @Override - public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, - Class> converterType) { + public @NotNull Object afterBodyRead(@NotNull Object body, @NotNull HttpInputMessage inputMessage, MethodParameter parameter, @NotNull Type targetType, + @NotNull Class> converterType) { if (parameter.getMethod() != null) { ValidationFilterAnnotation[] annotations = parameter.getMethod().getAnnotationsByType((ValidationFilterAnnotation.class)); @@ -44,17 +45,17 @@ public class ValidatorRequestBodyAdvice implements RequestBodyAdvice { } @Override - public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class> converterType) { + public Object handleEmptyBody(Object body, @NotNull HttpInputMessage inputMessage, @NotNull MethodParameter parameter, @NotNull Type targetType, @NotNull Class> converterType) { return body; } @Override - public boolean supports(MethodParameter parameter, Type targetType, Class> converterType) { + public boolean supports(MethodParameter parameter, @NotNull Type targetType, @NotNull Class> converterType) { return parameter.getMethod() != null && parameter.getMethod().isAnnotationPresent((ValidationFilterAnnotation.class)); } @Override - public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class> converterType) throws IOException { + public @NotNull HttpInputMessage beforeBodyRead(@NotNull HttpInputMessage inputMessage, @NotNull MethodParameter parameter, @NotNull Type targetType, @NotNull Class> converterType) throws IOException { return inputMessage; } } \ No newline at end of file diff --git a/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DescriptionController.java b/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DescriptionController.java index 37b3705c4..9946d880e 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DescriptionController.java +++ b/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DescriptionController.java @@ -6,6 +6,7 @@ import eu.eudat.authorization.AuthorizationFlags; import eu.eudat.commons.enums.DmpAccessType; import eu.eudat.commons.enums.DmpStatus; import eu.eudat.commons.enums.IsActive; +import eu.eudat.commons.validation.ValidationFilterAnnotation; import eu.eudat.file.transformer.model.file.FileFormat; import eu.eudat.model.Description; import eu.eudat.model.Dmp; @@ -153,6 +154,7 @@ public class DescriptionController { @PostMapping("persist") @Transactional + @ValidationFilterAnnotation(validator = DescriptionPersist.DescriptionPersistValidator.ValidatorName, argumentName = "model") public Description persist(@MyValidate @RequestBody DescriptionPersist model, FieldSet fieldSet) throws MyApplicationException, MyForbiddenException, MyNotFoundException, InvalidApplicationException, JsonProcessingException { logger.debug(new MapLogEntry("persisting" + Description.class.getSimpleName()).And("model", model).And("fieldSet", fieldSet)); Description persisted = this.descriptionService.persist(model, fieldSet); diff --git a/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DmpController.java b/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DmpController.java index 019ae50ba..316cd4678 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DmpController.java +++ b/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DmpController.java @@ -3,6 +3,7 @@ package eu.eudat.controllers.v2; import com.fasterxml.jackson.core.JsonProcessingException; import eu.eudat.audit.AuditableAction; import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.commons.validation.ValidationFilterAnnotation; import eu.eudat.data.DmpEntity; import eu.eudat.file.transformer.model.file.FileFormat; import eu.eudat.model.Dmp; @@ -143,7 +144,9 @@ public class DmpController { } @PostMapping("clone") - public Dmp buildClone(@MyValidate @RequestBody CloneDmpPersist model, FieldSet fieldSet) throws MyApplicationException, MyForbiddenException, MyNotFoundException { + @Transactional + @ValidationFilterAnnotation(validator = CloneDmpPersist.CloneDmpPersistValidator.ValidatorName, argumentName = "model") + public Dmp buildClone(@RequestBody CloneDmpPersist model, FieldSet fieldSet) throws MyApplicationException, MyForbiddenException, MyNotFoundException { logger.debug(new MapLogEntry("clone" + Dmp.class.getSimpleName()).And("model", model).And("fields", fieldSet)); this.censorFactory.censor(DmpCensor.class).censor(fieldSet, null);