private void initValidation( ValidationResource validationResource, ValidationMode validationMode) { initRequiredValueValidation(validationResource); initReferenceValidation(validationResource); initUniqueValidation(validationResource); if (validationMode == ValidationMode.UPDATE) { initReadonlyValidation(validationResource); } }
@Override public void validateEntityNotReferencedById(Object entityId, EntityType entityType) { validateEntityNotReferenced(entityId, entityType, getDefaultValueMap(entityType)); }
private void validate( Entity entity, ValidationResource validationResource, ValidationMode validationMode, ValidationProfile validationProfile) { validationResource.incrementRow(); validateEntityValueTypes(entity, validationResource); // other validation steps might not be able to handle invalid data types, stop here if (validationResource.hasViolations()) { throw new MolgenisValidationException(validationResource.getViolations()); } if (validationProfile.isValidateRequired()) { validateEntityValueRequired(entity, validationResource); } if (validationProfile.isValidateUniqueness()) { validateEntityValueUniqueness(entity, validationResource, validationMode); } validateEntityValueReferences(entity, validationResource); if (validationProfile.isValidateReadonly() && validationMode == ValidationMode.UPDATE) { validateEntityValueReadOnly(entity, validationResource); } if (validationResource.hasViolations()) { throw new MolgenisValidationException(validationResource.getViolations()); } }
@Override public void add(Entity entity) { try (ValidationResource validationResource = new ValidationResource()) { validate(entity, validationResource, ValidationMode.ADD); } delegate().add(entity); }
private Stream<Entity> validate( Stream<Entity> entities, ValidationResource validationResource, ValidationMode validationMode) { // prepare validation initValidation(validationResource, validationMode); ValidationProfile validationProfile = new ValidationProfile().invoke(); // add validation operation to stream return entities.filter( entity -> { validate(entity, validationResource, validationMode, validationProfile); return true; }); }
@Override public void delete(Stream<Entity> entities) { delegate() .delete( defaultValueReferenceValidator.validateEntitiesNotReferenced( entities, getEntityType())); }
@Override public void deleteAll() { defaultValueReferenceValidator.validateEntityTypeNotReferenced(getEntityType()); delegate().deleteAll(); }
@Override public void deleteById(Object id) { defaultValueReferenceValidator.validateEntityNotReferencedById(id, getEntityType()); delegate().deleteById(id); }
@Override public void deleteAll(Stream<Object> ids) { delegate() .deleteAll( defaultValueReferenceValidator.validateEntitiesNotReferencedById(ids, getEntityType())); }
@Override public long count(Query<E> q) { queryValidator.validate(q, getEntityType()); return super.count(q); }
private void validateEntityValueTypes(Entity entity, ValidationResource validationResource) { // entity attributes validation Set<ConstraintViolation> attrViolations = entityAttributesValidator.validate(entity, getEntityType()); if (attrViolations != null && !attrViolations.isEmpty()) { attrViolations.forEach(validationResource::addViolation); } }
@Override public void delete(Entity entity) { defaultValueReferenceValidator.validateEntityNotReferenced(entity); delegate().delete(entity); }
public ValidationProfile invoke() { validateRequired = !getCapabilities().contains(VALIDATE_NOTNULL_CONSTRAINT); validateUniqueness = !getCapabilities().contains(VALIDATE_UNIQUE_CONSTRAINT); validateReadonly = !getCapabilities().contains(VALIDATE_READONLY_CONSTRAINT); return this; } }
@Override public void validateEntityNotReferenced(Entity entity) { validateEntityNotReferencedById(entity.getIdValue(), entity.getEntityType()); }
@Override public void update(Entity entity) { try (ValidationResource validationResource = new ValidationResource()) { validate(entity, validationResource, ValidationMode.UPDATE); } delegate().update(entity); }
@Override public Stream<E> findAll(Query<E> q) { queryValidator.validate(q, getEntityType()); return super.findAll(q); }
@Override public Stream<Object> validateEntitiesNotReferencedById( Stream<Object> entityIdStream, EntityType entityType) { Multimap<String, Attribute> defaultValueMap = getDefaultValueMap(entityType); return entityIdStream.filter( entityId -> { validateEntityNotReferenced(entityId, entityType, defaultValueMap); return true; }); }
@Override public void update(Stream<Entity> entities) { try (ValidationResource validationResource = new ValidationResource()) { entities = validate(entities, validationResource, ValidationMode.UPDATE); delegate().update(entities); } }
@Override public E findOne(Query<E> q) { queryValidator.validate(q, getEntityType()); return super.findOne(q); } }
@Override public Integer add(Stream<Entity> entities) { try (ValidationResource validationResource = new ValidationResource()) { entities = validate(entities, validationResource, ValidationMode.ADD); return delegate().add(entities); } }