Validator.java

  1. package no.nav.data.common.validator;

  3. import lombok.Getter;
  4. import lombok.extern.slf4j.Slf4j;
  5. import no.nav.data.common.exceptions.ValidationException;
  6. import no.nav.data.common.storage.StorageService;
  7. import no.nav.data.common.storage.domain.DomainObject;
  8. import no.nav.data.common.storage.domain.TypeRegistration;
  9. import org.apache.commons.lang3.StringUtils;
  10. import org.hibernate.validator.internal.constraintvalidators.hv.EmailValidator;
  11. import org.springframework.util.Assert;

  13. import java.time.LocalDate;
  14. import java.time.format.DateTimeParseException;
  15. import java.util.ArrayList;
  16. import java.util.Collection;
  17. import java.util.List;
  18. import java.util.UUID;
  19. import java.util.concurrent.atomic.AtomicInteger;
  20. import java.util.function.BiConsumer;
  21. import java.util.function.Consumer;
  22. import java.util.function.Function;
  23. import java.util.regex.Pattern;

  25. import static no.nav.data.common.utils.StreamUtils.nullToEmptyList;
  26. import static no.nav.data.common.utils.StreamUtils.safeStream;
  27. import static no.nav.data.common.utils.StringUtils.isUUID;

  29. @Slf4j
  30. public class Validator<T extends Validated> {

  32.     public static final Pattern NAV_IDENT_PATTERN = Pattern.compile("[A-Z][0-9]{6}");

  34.     public static final String DOES_NOT_EXIST = "doesNotExist";
  35.     public static final String ALREADY_EXISTS = "alreadyExist";
  36.     public static final String ILLEGAL_ARGUMENT = "illegalArgument";
  37.     private static final String ERROR_TYPE_MISSING = "fieldIsNullOrMissing";
  38.     private static final String ERROR_TYPE_PATTERN = "fieldWrongFormat";
  39.     private static final String ERROR_TYPE_ENUM = "fieldIsInvalidEnum";
  40.     private static final String ERROR_TYPE_DATE = "fieldIsInvalidDate";
  41.     private static final String ERROR_TYPE_UUID = "fieldIsInvalidUUID";
  42.     public static final String ERROR_MESSAGE_MISSING = "null or missing";
  43.     private static final String ERROR_MESSAGE_PATTERN = "%s is not valid for pattern '%s'";
  44.     private static final String ERROR_MESSAGE_ENUM = "%s was invalid for type %s";
  45.     private static final String ERROR_MESSAGE_DATE = "%s date is not a valid format";
  46.     private static final String ERROR_MESSAGE_UUID = "%s uuid is not a valid format";

  48.     private static final EmailValidator emailValidator = new EmailValidator();
  49.     private static final String EMAIL_DOMAIN = "@nav.no";

  51.     private final List<ValidationError> validationErrors = new ArrayList<>();
  52.     private final String parentField;
  53.     @Getter
  54.     private final T item;
  55.     private DomainObject domainItem;

  57.     public Validator(T item) {
  58.         this.parentField = "";
  59.         this.item = item;
  60.     }

  62.     public Validator(T item, String parentField) {
  63.         this.parentField = StringUtils.appendIfMissing(parentField, ".");
  64.         this.item = item;
  65.     }

  67.     public static <R extends RequestElement> Validator<R> validate(R item, StorageService storage) {
  68.         Validator<R> validator = validate(item);
  69.         UUID uuid = item.getIdAsUUID();
  70.         String typeOfRequest = TypeRegistration.typeOfRequest(item);
  71.         validator.domainItem = uuid != null && storage.exists(uuid, typeOfRequest) ? storage.get(uuid, typeOfRequest) : null;
  72.         validator.validateRepositoryValues(item, validator.domainItem != null);
  73.         return validator;
  74.     }

  76.     public static <R extends Validated> Validator<R> validate(R item) {
  77.         item.format();
  78.         RequestElement requestElement = item instanceof RequestElement re ? re : null;
  79.         if (requestElement != null) {
  80.             Assert.isTrue(requestElement.getUpdate() != null, "request not initialized");
  81.         }
  82.         Validator<R> validator = new Validator<>(item);
  83.         item.validateFieldValues(validator);
  84.         return validator;
  85.     }

  87.     @SuppressWarnings("unchecked")
  88.     public <D extends DomainObject> D getDomainItem() {
  89.         return (D) domainItem;
  90.     }

  92.     @SuppressWarnings("unchecked")
  93.     public <D extends DomainObject> D getDomainItem(Class<D> type) {
  94.         return (D) domainItem;
  95.     }

  97.     public void checkExists(String id, StorageService storage, Class<? extends DomainObject> aClass) {
  98.         if (isUUID(id) && !storage.exists(UUID.fromString(id), aClass)) {
  99.             String type = TypeRegistration.typeOf(aClass);
  100.             addError(type, Validator.DOES_NOT_EXIST, type + " " + id + " does not exist");
  101.         }
  102.     }

  104.     public boolean checkBlank(String fieldName, String fieldValue) {
  105.         if (StringUtils.isBlank(fieldValue)) {
  106.             validationErrors.add(new ValidationError(getFieldName(fieldName), ERROR_TYPE_MISSING, ERROR_MESSAGE_MISSING));
  107.             return true;
  108.         }
  109.         return false;
  110.     }

  112.     public void checkNull(String fieldName, Object fieldValue) {
  113.         if (fieldValue == null) {
  114.             validationErrors.add(new ValidationError(getFieldName(fieldName), ERROR_TYPE_MISSING, ERROR_MESSAGE_MISSING));
  115.         }
  116.     }

  118.     public void checkPatternRequired(String fieldName, String value, Pattern pattern) {
  119.         if (checkBlank(fieldName, value)) {
  120.             return;
  121.         }
  122.         checkPattern(fieldName, value, pattern);
  123.     }

  125.     public void checkPattern(String fieldName, String value, Pattern pattern) {
  126.         if (StringUtils.isBlank(value)) {
  127.             return;
  128.         }
  129.         if (!pattern.matcher(value).matches()) {
  130.             validationErrors.add(new ValidationError(getFieldName(fieldName), ERROR_TYPE_PATTERN, String.format(ERROR_MESSAGE_PATTERN, value, pattern)));
  131.         }
  132.     }

  134.     public <E extends Enum<E>> void checkRequiredEnum(String fieldName, String fieldValue, Class<E> type) {
  135.         if (checkBlank(fieldName, fieldValue)) {
  136.             return;
  137.         }
  138.         checkEnum(fieldName, fieldValue, type);
  139.     }

  141.     public <E extends Enum<E>> void checkEnum(String fieldName, String fieldValue, Class<E> type) {
  142.         if (StringUtils.isBlank(fieldValue)) {
  143.             return;
  144.         }
  145.         try {
  146.             Enum.valueOf(type, fieldValue);
  147.         } catch (IllegalArgumentException e) {
  148.             validationErrors.add(new ValidationError(getFieldName(fieldName), ERROR_TYPE_ENUM, String.format(ERROR_MESSAGE_ENUM, fieldValue, type.getSimpleName())));
  149.         }
  150.     }

  152.     public void checkDate(String fieldName, String fieldValue) {
  153.         if (StringUtils.isBlank(fieldValue)) {
  154.             return;
  155.         }
  156.         try {
  157.             LocalDate.parse(fieldValue);
  158.         } catch (DateTimeParseException e) {
  159.             validationErrors.add(new ValidationError(getFieldName(fieldName), ERROR_TYPE_DATE, String.format(ERROR_MESSAGE_DATE, fieldValue)));
  160.         }
  161.     }

  163.     public void checkUUID(String fieldName, String fieldValue) {
  164.         if (StringUtils.isBlank(fieldValue)) {
  165.             return;
  166.         }
  167.         try {
  168.             //noinspection ResultOfMethodCallIgnored
  169.             UUID.fromString(fieldValue);
  170.         } catch (Exception e) {
  171.             validationErrors.add(new ValidationError(getFieldName(fieldName), ERROR_TYPE_UUID, String.format(ERROR_MESSAGE_UUID, fieldValue)));
  172.         }
  173.     }

  175.     public void checkEmail(String fieldName, String fieldValue) {
  176.         if (!emailValidator.isValid(fieldValue, null)) {
  177.             validationErrors.add(new ValidationError(getFieldName(fieldName), "invalidEmail", "%s is an invalid email".formatted(fieldValue)));
  178.         } else if (!StringUtils.endsWithIgnoreCase(fieldValue, EMAIL_DOMAIN)) {
  179.             validationErrors.add(new ValidationError(getFieldName(fieldName), "invalidEmail", "%s is not an @nav.no email".formatted(fieldValue)));
  180.         }
  181.     }


  184.     public void addError(String fieldName, String errorType, String errorMessage) {
  185.         validationErrors.add(new ValidationError(getFieldName(fieldName), errorType, errorMessage));
  186.     }

  188.     public void checkId(RequestElement request) {
  189.         boolean nullId = request.getId() == null;
  190.         boolean update = request.isUpdate();
  191.         if (update && nullId) {
  192.             validationErrors
  193.                     .add(new ValidationError(getFieldName("id"), "missingIdForUpdate", "Request is missing ID for update"));
  194.         } else if (!update && !nullId) {
  195.             validationErrors.add(new ValidationError(getFieldName("id"), "idForCreate", "Request has ID for create"));
  196.         }
  197.     }

  199.     private String getFieldName(String fieldName) {
  200.         return parentField + fieldName;
  201.     }

  203.     public void validateType(String fieldName, Collection<? extends Validated> fieldValues) {
  204.         AtomicInteger i = new AtomicInteger(0);
  205.         safeStream(fieldValues).forEach(fieldValue -> validateType(String.format("%s[%d]", fieldName, i.getAndIncrement()), fieldValue));
  206.     }

  208.     public void validateType(String fieldName, Validated fieldValue) {
  209.         Validator<Validated> validator = new Validator<>(fieldValue, parentField + fieldName);
  210.         fieldValue.format();
  211.         fieldValue.validateFieldValues(validator);
  212.         validationErrors.addAll(validator.getErrors());
  213.     }

  215.     void validateRepositoryValues(RequestElement request, boolean existInRepository) {
  216.         if (creatingExistingElement(request.isUpdate(), existInRepository)) {
  217.             validationErrors.add(new ValidationError(getFieldName("id"), "creatingExisting",
  218.                     String.format("The %s %s already exists and therefore cannot be created", request.getRequestType(), request.getId())));
  219.         }

  221.         if (updatingNonExistingElement(request.isUpdate(), existInRepository)) {
  222.             validationErrors.add(new ValidationError(getFieldName("id"), "updatingNonExisting",
  223.                     String.format("The %s %s does not exist and therefore cannot be updated", request.getRequestType(), request.getId())));
  224.         }
  225.     }

  227.     private boolean creatingExistingElement(boolean isUpdate, boolean existInRepository) {
  228.         return !isUpdate && existInRepository;
  229.     }

  231.     private boolean updatingNonExistingElement(boolean isUpdate, boolean existInRepository) {
  232.         return isUpdate && !existInRepository;
  233.     }

  235.     public void ifErrorsThrowValidationException() {
  236.         if (!validationErrors.isEmpty()) {
  237.             log.warn("The request was not accepted. The following errors occurred during validation:{}", validationErrors);
  238.             throw new ValidationException(validationErrors, "The request was not accepted. The following errors occurred during validation:");
  239.         }
  240.     }

  242.     public final <R> Validator<T> addValidations(Function<? super T, Collection<R>> extractor, BiConsumer<Validator<T>, R> consumer) {
  243.         Collection<R> subItems = extractor.apply(item);
  244.         nullToEmptyList(subItems).forEach(it -> consumer.accept(this, it));
  245.         return this;
  246.     }

  248.     public final <R> Validator<T> addValidation(Function<? super T, R> extractor, BiConsumer<Validator<T>, R> consumer) {
  249.         R subItem = extractor.apply(item);
  250.         consumer.accept(this, subItem);
  251.         return this;
  252.     }

  254.     public final Validator<T> addValidations(Consumer<Validator<T>> consumer) {
  255.         consumer.accept(this);
  256.         return this;
  257.     }

  259.     public List<ValidationError> getErrors() {
  260.         return validationErrors;
  261.     }
  262. }
Created with JaCoCo 0.8.12.202403310830