public boolean allowStage(Conditional[] conditionalClasses, ConditionalMatchType conditionalMatchType, Method method, MongoParameterAccessor mongoParameterAccessor, ConvertingParameterAccessor convertingParameterAccessor) { boolean shouldProcess = true; try { for (Conditional conditional : conditionalClasses) { List<Object> parameterValues = getParameterValues(method, mongoParameterAccessor, convertingParameterAccessor); ConditionalAnnotationMetadata metadata = new ConditionalAnnotationMetadata(conditional); AggregateQueryMethodConditionContext context = new AggregateQueryMethodConditionContext(method, parameterValues); Condition condition = conditional.condition().newInstance(); boolean isTrue = condition.matches(context, metadata); if (conditionalMatchType == ConditionalMatchType.ANY && isTrue) { return true; } if(conditionalMatchType == ConditionalMatchType.ALL) { shouldProcess &= condition.matches(context, metadata); } } } catch (InstantiationException | IllegalAccessException e) { throw new IllegalStateException("Could not create an instance of the condition class", e); } return conditionalMatchType == ConditionalMatchType.ANY ? ArrayUtils.isEmpty(conditionalClasses) : shouldProcess; }
@PostConstruct public void setupAutoConfigurationReport() { ConditionEvaluationReport report = ConditionEvaluationReport .get(this.context.getBeanFactory()); report.recordConditionEvaluation("a", mock(Condition.class), mock(ConditionOutcome.class)); report.recordExclusions(Arrays.asList("com.foo.Bar")); }
public static boolean matches(ConditionContext context) { Class<AuthorizationServerEndpointsConfigurationBeanCondition> type = AuthorizationServerEndpointsConfigurationBeanCondition.class; Conditional conditional = AnnotationUtils.findAnnotation(type, Conditional.class); StandardAnnotationMetadata metadata = new StandardAnnotationMetadata(type); for (Class<? extends Condition> conditionType : conditional.value()) { Condition condition = BeanUtils.instantiateClass(conditionType); if (condition.matches(context, metadata)) { return true; } } return false; }
/** * Record the occurrence of condition evaluation. * @param source the source of the condition (class or method name) * @param condition the condition evaluated * @param outcome the condition outcome */ public void recordConditionEvaluation(String source, Condition condition, ConditionOutcome outcome) { Assert.notNull(source, "Source must not be null"); Assert.notNull(condition, "Condition must not be null"); Assert.notNull(outcome, "Outcome must not be null"); this.unconditionalClasses.remove(source); if (!this.outcomes.containsKey(source)) { this.outcomes.put(source, new ConditionAndOutcomes()); } this.outcomes.get(source).add(condition, outcome); this.addedAncestorOutcomes = false; }
private Map<AnnotationMetadata, List<Condition>> getMemberConditions( String[] members) { MultiValueMap<AnnotationMetadata, Condition> memberConditions = new LinkedMultiValueMap<AnnotationMetadata, Condition>(); for (String member : members) { AnnotationMetadata metadata = getMetadata(member); for (String[] conditionClasses : getConditionClasses(metadata)) { for (String conditionClass : conditionClasses) { Condition condition = getCondition(conditionClass); memberConditions.add(metadata, condition); } } } return Collections.unmodifiableMap(memberConditions); }
public List<ConditionOutcome> getMatchOutcomes() { List<ConditionOutcome> outcomes = new ArrayList<ConditionOutcome>(); for (Map.Entry<AnnotationMetadata, List<Condition>> entry : this.memberConditions .entrySet()) { AnnotationMetadata metadata = entry.getKey(); List<Condition> conditions = entry.getValue(); outcomes.add(new MemberOutcomes(this.context, metadata, conditions) .getUltimateOutcome()); } return Collections.unmodifiableList(outcomes); }
MemberOutcomes(ConditionContext context, AnnotationMetadata metadata, List<Condition> conditions) { this.context = context; this.metadata = metadata; this.outcomes = new ArrayList<ConditionOutcome>(conditions.size()); for (Condition condition : conditions) { this.outcomes.add(getConditionOutcome(metadata, condition)); } }
private ConditionOutcome getConditionOutcome(AnnotationMetadata metadata, Condition condition) { if (condition instanceof SpringBootCondition) { return ((SpringBootCondition) condition).getMatchOutcome(this.context, metadata); } return new ConditionOutcome(condition.matches(this.context, metadata), ConditionMessage.empty()); }
/** * Return true if any of the specified conditions match. * @param context the context * @param metadata the annotation meta-data * @param conditions conditions to test * @return {@code true} if any condition matches. */ protected final boolean anyMatches(ConditionContext context, AnnotatedTypeMetadata metadata, Condition... conditions) { for (Condition condition : conditions) { if (matches(context, metadata, condition)) { return true; } } return false; }
/** * Return true if any of the specified condition matches. * @param context the context * @param metadata the annotation meta-data * @param condition condition to test * @return {@code true} if the condition matches. */ protected final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata, Condition condition) { if (condition instanceof SpringBootCondition) { return ((SpringBootCondition) condition).getMatchOutcome(context, metadata) .isMatch(); } return condition.matches(context, metadata); }
public MessageAndCondition(ConditionAndOutcome conditionAndOutcome) { Condition condition = conditionAndOutcome.getCondition(); ConditionOutcome outcome = conditionAndOutcome.getOutcome(); this.condition = ClassUtils.getShortName(condition.getClass()); if (StringUtils.hasLength(outcome.getMessage())) { this.message = outcome.getMessage(); } else { this.message = (outcome.isMatch() ? "matched" : "did not match"); } }
public List<ConditionOutcome> getMatchOutcomes() { List<ConditionOutcome> outcomes = new ArrayList<ConditionOutcome>(); for (Map.Entry<AnnotationMetadata, List<Condition>> entry : this.memberConditions .entrySet()) { AnnotationMetadata metadata = entry.getKey(); for (Condition condition : entry.getValue()) { outcomes.add(getConditionOutcome(metadata, condition)); } } return Collections.unmodifiableList(outcomes); }
private ConditionOutcome getConditionOutcome(AnnotationMetadata metadata, Condition condition) { String messagePrefix = "member condition on " + metadata.getClassName(); if (condition instanceof SpringBootCondition) { ConditionOutcome outcome = ((SpringBootCondition) condition) .getMatchOutcome(this.context, metadata); String message = outcome.getMessage(); return new ConditionOutcome(outcome.isMatch(), messagePrefix + (StringUtils.hasLength(message) ? " : " + message : "")); } boolean matches = condition.matches(this.context, metadata); return new ConditionOutcome(matches, messagePrefix); }
public void add(Condition condition, ConditionOutcome outcome) { this.outcomes.add(new ConditionAndOutcome(condition, outcome)); }
public ConditionAndOutcome(Condition condition, ConditionOutcome outcome) { this.condition = condition; this.outcome = outcome; }
public Condition getCondition() { return this.condition; }
private Condition getCondition(String conditionClassName) { Class<?> conditionClass = ClassUtils.resolveClassName(conditionClassName, this.context.getClassLoader()); return (Condition) BeanUtils.instantiateClass(conditionClass); }