private Collection<RuleViolation> evaluateNode(final Node node, final Node parent) { // Evaluate containment rules for this node. return violations.addViolations(evaluateContainment(ruleSet, graph, null != parent ? parent : graph, node)); } });
@Override @SuppressWarnings("unchecked") public void validate(final Graph graph, final Consumer<Collection<RuleViolation>> callback) { validate(graph, null, callback); }
protected AbstractDiagramValidator(final DefinitionManager definitionManager, final RuleManager ruleManager, final TreeWalkTraverseProcessor treeWalkTraverseProcessor, final ModelValidator modelValidator) { this.graphValidator = new GraphValidatorImpl(definitionManager, ruleManager, treeWalkTraverseProcessor); this.modelValidator = modelValidator; }
private BiConsumer<Element, Collection<RuleViolation>> consumeBeanAndViolations(final Supplier<List<DiagramElementViolation<RuleViolation>>> violations) { return (element, ruleViolations) -> { final Optional<Object> bean = getBean(element); if (bean.isPresent()) { // If the underlying bean is a Definition, it accomplishes JSR303 validations. modelValidator.validate(bean.get(), modelViolations -> violations.get().add(new ElementViolationImpl.Builder() .setUuid(element.getUUID()) .setGraphViolations(ruleViolations) .setModelViolations(modelViolations) .build())); } else { // Otherwise, no need not perform bean validation. violations.get().add(new ElementViolationImpl.Builder() .setUuid(element.getUUID()) .setGraphViolations(ruleViolations) .build()); } }; }
public ElementViolationImpl build() { if (Objects.isNull(type)) { setType(ValidationUtils.getMaxSeverity(new LinkedHashSet<org.kie.workbench.common.stunner.core.validation.Violation>() {{ Optional.ofNullable(graphViolations).ifPresent(v -> addAll(v)); Optional.ofNullable(modelViolations).ifPresent(v -> addAll(v)); Optional.ofNullable(domainViolations).ifPresent(v -> addAll(v)); }})); } return new ElementViolationImpl(uuid, graphViolations, modelViolations, domainViolations, type); } }
@Override @SuppressWarnings("unchecked") public void validate(final Diagram diagram, final Consumer<Collection<DiagramElementViolation<RuleViolation>>> resultConsumer) { final Graph graph = diagram.getGraph(); final List<DiagramElementViolation<RuleViolation>> violations = new LinkedList<>(); graphValidator.validate(graph, Optional.empty(), Optional.of((g, v) -> consumeBeanAndViolations(() -> violations).accept(g, v)), Optional.of((n, v) -> consumeBeanAndViolations(() -> violations).accept(n, v)), Optional.of((e, v) -> consumeBeanAndViolations(() -> violations).accept(e, v)), // At this point all violations have been already consumed, so no need // to use the resulting ones here. vs -> resultConsumer.accept(violations) ); }
public static ValidationFailedNotification build(final ClientTranslationService translationService, final NotificationContext context, final Collection<DiagramElementViolation<RuleViolation>> errors) { final Violation.Type type = ValidationUtils.getMaxSeverity(errors); return new ValidationFailedNotification(errors, context, CoreTranslationMessages.getDiagramValidationsErrorMessage( translationService, CoreTranslationMessages.VALIDATION_FAILED, errors ), getNotificationType(type)); }
private ModelBeanViolation buildViolation(final ConstraintViolation<?> rootViolation) { LOGGER.log(Level.INFO, "Bean constraint violation found with message [" + rootViolation.getMessage() + "]"); return ModelBeanViolationImpl.Builder.build(rootViolation); } }
@Test public void testValidateBean1Failed() { when(beanValidator.validate(eq(bean1))).thenReturn(Collections.singleton(violation1)); tested.validate(bean1, v -> assertViolation(v, violation1)); }
/** * Actually the different commands allows removing nodes that have * incoming or outgoing view connectors, as connectors can be re-attached to * a different node, but the graph structure is not considered valid, so the * diagram cannot be updated until fixing that connections. * So there exist no rule for empty connections, actually it's just a common validation. */ @SuppressWarnings("unchecked") private Optional<RuleViolation> evaluateNotEmptyConnections(final Graph<?, ? extends Node> graph, final Edge<? extends View<?>, ? extends Node> connector, final Optional<Node<? extends View<?>, ? extends Edge>> sourceNode, final Optional<Node<? extends View<?>, ? extends Edge>> targetNode) { log(" NOT_EMPTY_CONNECTIONS " + "[edge=" + connector + ",source=" + sourceNode.orElse(null) + ",target=" + targetNode.orElse(null) + "]"); if (!sourceNode.isPresent() || !targetNode.isPresent()) { return Optional.of(EmptyConnectionViolation.Builder.build(connector, sourceNode, targetNode)); } return Optional.empty(); }
public ElementViolationImpl createElementViolationImpl() { return new ElementViolationImpl(uuid, graphViolations, modelViolations, domainViolations, type); } }
public static ModelBeanViolationImpl build(final ConstraintViolation<?> root) { return new ModelBeanViolationImpl(root.getPropertyPath().toString(), root.getMessage(), Type.WARNING); } }
public Set<RuleViolation> addViolations(final RuleViolations items) { final Set<RuleViolation> result = new LinkedHashSet<>(); items.violations().forEach(v -> { result.add(v); ViolationsSet.this.add(v); }); return result; } }
@Override public boolean startNodeTraversal(final Node node) { super.startNodeTraversal(node); final Collection<RuleViolation> nodeViolations = evaluateNode(node, currentParents.isEmpty() ? null : currentParents.peek()); nodeValidatorConsumer.ifPresent(c -> c.accept(node, nodeViolations)); return true; }
@Override public void validate(final Graph graph, final RuleSet ruleSet, final Consumer<Collection<RuleViolation>> callback) { this.validate(graph, Optional.ofNullable(ruleSet), Optional.empty(), Optional.empty(), Optional.empty(), callback); }
@SuppressWarnings("unchecked") private RuleViolations evaluateCardinality(final RuleSet ruleSet, final Graph graph) { log(" CARDINALITY [graph=" + graph + "]"); return ruleManager .evaluate(ruleSet, RuleContextBuilder.GraphContexts.cardinality(graph, Optional.empty(), Optional.empty())); }
@Override public void startGraphTraversal(final org.kie.workbench.common.stunner.core.graph.Graph graph) { super.startGraphTraversal(graph); currentParents.clear(); // Evaluate the graph's cardinality rules. final Set<RuleViolation> graphCardinalityViolations = violations.addViolations(evaluateCardinality(ruleSet, graph)); graphValidatorConsumer.ifPresent(g -> g.accept(graph, graphCardinalityViolations)); }
@SuppressWarnings("unchecked") private RuleViolations evaluateContainment(final RuleSet ruleSet, final Graph graph, final Element<? extends Definition<?>> parent, final Node candidate) { log(" CONTAINMENT " + "[parent=" + parent + ",candidate=" + candidate + "]"); return ruleManager .evaluate(ruleSet, RuleContextBuilder.GraphContexts.containment(graph, parent, candidate)); }
@SuppressWarnings("unchecked") private RuleViolations evaluateOutgoingEdgeCardinality(final RuleSet ruleSet, final org.kie.workbench.common.stunner.core.graph.Graph graph, final Edge<? extends View, Node> edge) { log(" OUT-EDGE CARDINALITY [edge=" + edge + "]"); return ruleManager .evaluate(ruleSet, RuleContextBuilder.GraphContexts.edgeCardinality(graph, edge.getSourceNode(), (Edge<? extends View<?>, Node>) edge, EdgeCardinalityContext.Direction.OUTGOING, Optional.empty())); }