@Override public void delete(Stream<Entity> entities) { delegate() .delete( defaultValueReferenceValidator.validateEntitiesNotReferenced( entities, getEntityType())); }
private void initRequiredValueValidation(ValidationResource validationResource) { if (!getCapabilities().contains(VALIDATE_NOTNULL_CONSTRAINT)) { List<Attribute> requiredValueAttrs = stream(getEntityType().getAtomicAttributes().spliterator(), false) .filter(attr -> !attr.isNillable() && attr.getExpression() == null) .collect(toList()); validationResource.setRequiredValueAttrs(requiredValueAttrs); } }
private void initValidation( ValidationResource validationResource, ValidationMode validationMode) { initRequiredValueValidation(validationResource); initReferenceValidation(validationResource); initUniqueValidation(validationResource); if (validationMode == ValidationMode.UPDATE) { initReadonlyValidation(validationResource); } }
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()); } }
private void initReferenceValidation(ValidationResource validationResource) { if (!getCapabilities().contains(VALIDATE_REFERENCE_CONSTRAINT)) { stream(getEntityType().getAtomicAttributes().spliterator(), false) .filter(attr -> isReferenceType(attr) && attr.getExpression() == null) .collect(toList()); String backend = dataService.getMeta().getBackend(getEntityType()).getName(); refAttrs = stream(getEntityType().getAtomicAttributes().spliterator(), false) .filter( attr -> isReferenceType(attr) && attr.getExpression() == null && isDifferentBackend(backend, attr)) .collect(toList()); refAttrs .stream() .anyMatch(refAttr -> refAttr.getRefEntity().getId().equals(getEntityType().getId()))); validationResource.setRefAttrs(refAttrs);
private void initUniqueValidation(ValidationResource validationResource) { if (!getCapabilities().contains(VALIDATE_UNIQUE_CONSTRAINT)) { stream(getEntityType().getAtomicAttributes().spliterator(), false) .filter(attr -> attr.isUnique() && attr.getExpression() == null) .collect(toList()); delegate() .findAll(q) .forEach(
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; }); }
Entity entityToUpdate = findOneById(entity.getIdValue()); validationResource .getReadonlyAttrs() format( "The attribute '%s' of entity '%s' can not be changed it is readonly.", readonlyAttr.getName(), getName()), (long) validationResource.getRow()));
private void validateEntityValueRequired(Entity entity, ValidationResource validationResource) { validationResource .getRequiredValueAttrs() .forEach( nonNillableAttr -> { Object value = entity.get(nonNillableAttr.getName()); if (value == null || (isMultipleReferenceType(nonNillableAttr) && !entity.getEntities(nonNillableAttr.getName()).iterator().hasNext())) { ConstraintViolation constraintViolation = new ConstraintViolation( format( "The attribute '%s' of entity '%s' can not be null.", nonNillableAttr.getName(), getName()), (long) validationResource.getRow()); validationResource.addViolation(constraintViolation); } }); }
public ValidationProfile invoke() { validateRequired = !getCapabilities().contains(VALIDATE_NOTNULL_CONSTRAINT); validateUniqueness = !getCapabilities().contains(VALIDATE_UNIQUE_CONSTRAINT); validateReadonly = !getCapabilities().contains(VALIDATE_READONLY_CONSTRAINT); return this; } }
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); }
format( "Duplicate value '%s' for unique attribute '%s' from entity '%s'", attrValue, uniqueAttr.getName(), getName()), (long) validationResource.getRow()); validationResource.addViolation(constraintViolation);
@Override public void deleteAll() { defaultValueReferenceValidator.validateEntityTypeNotReferenced(getEntityType()); delegate().deleteAll(); }
private void initReadonlyValidation(ValidationResource validationResource) { if (!getCapabilities().contains(VALIDATE_READONLY_CONSTRAINT)) { String idAttrName = getEntityType().getIdAttribute().getName(); List<Attribute> readonlyAttrs = stream(getEntityType().getAtomicAttributes().spliterator(), false) .filter( attr -> attr.isReadOnly() && attr.getExpression() == null && !attr.isMappedBy() && !attr.getName().equals(idAttrName)) .collect(toList()); validationResource.setReadonlyAttrs(readonlyAttrs); } }
@Override public void deleteById(Object id) { defaultValueReferenceValidator.validateEntityNotReferencedById(id, getEntityType()); delegate().deleteById(id); }