/** * Asserts that the given language name and expression evaluates to the * given value on a specific exchange */ protected void assertExpression(Exchange exchange, String languageName, String expressionText, Object expectedValue) { Language language = assertResolveLanguage(languageName); Expression expression = language.createExpression(expressionText); assertNotNull("No Expression could be created for text: " + expressionText + " language: " + language, expression); assertExpression(expression, exchange, expectedValue); }
/** * Asserts that the given language name and predicate expression evaluates * to the expected value on the message exchange */ protected void assertPredicate(String languageName, String expressionText, Exchange exchange, boolean expected) { Language language = assertResolveLanguage(languageName); Predicate predicate = language.createPredicate(expressionText); assertNotNull("No Predicate could be created for text: " + expressionText + " language: " + language, predicate); assertPredicate(predicate, exchange, expected); }
/** * Asserts that the expression evaluates to one of the two given values */ protected void assertExpression(String expressionText, String expectedValue, String orThisExpectedValue) { Language language = assertResolveLanguage(getLanguageName()); Expression expression = language.createExpression(expressionText); assertNotNull("No Expression could be created for text: " + expressionText + " language: " + language, expression); Object value; if (expectedValue != null) { value = expression.evaluate(exchange, expectedValue.getClass()); } else { value = expression.evaluate(exchange, Object.class); } log.debug("Evaluated expression: {} on exchange: {} result: {}", expression, exchange, value); assertTrue("Expression: " + expression + " on Exchange: " + exchange, expectedValue.equals(value) || orThisExpectedValue.equals(value)); }
protected Predicate getMandatoryPredicate(Step step, String expression, String language) { Objects.requireNonNull(expression, "No expression specified for step " + step); Language jsonpath = getLanguage(language); Predicate answer = jsonpath.createPredicate(expression); Objects.requireNonNull(answer, "No predicate created from: " + expression); return answer; }
public static Expression getMandatoryExpression(CamelContext context, Step step, String expression) { Objects.requireNonNull(expression, "No expression specified for step " + step); Language jsonpath = getLanguage(context); Expression answer = jsonpath.createExpression(expression); Objects.requireNonNull(answer, "No expression created from: " + expression); return answer; }
public JsonSimplePredicate(String expression, CamelContext context) { Language language = ObjectHelper.notNull(context.resolveLanguage("simple"), "simple language"); String ognlExpression = convertSimpleToOGNLForMaps(expression); this.predicate = language.createPredicate(expression); this.ognlPredicate = language.createPredicate(ognlExpression); }
protected Expression getMandatoryExpression(Step step, String expression, String language) { Objects.requireNonNull(expression, "No expression specified for step " + step); Language jsonpath = getLanguage(language); Expression answer = jsonpath.createExpression(expression); Objects.requireNonNull(answer, "No expression created from: " + expression); return answer; }
public JsonSimplePredicate(final String expression, final CamelContext context) { final Language language = ObjectHelper.notNull(context.resolveLanguage("simple"), "simple language"); final String ognlExpression = convertSimpleToOGNLForMaps(expression); predicate = language.createPredicate(expression); ognlPredicate = language.createPredicate(ognlExpression); final Registry registry = context.getRegistry(); final Set<ObjectMapper> mappers = registry.findByType(ObjectMapper.class); if (mappers.size() != 1) { mapper = MAPPER; } else { mapper = mappers.iterator().next(); } }
public static Expression getMandatoryExpression(CamelContext context, Step step, String expression) { Objects.requireNonNull(expression, "No expression specified for step " + step); Language jsonpath = getLanguage(context); Expression answer = jsonpath.createExpression(expression); Objects.requireNonNull(answer, "No expression created from: " + expression); return answer; }
@Override public Predicate getObject() throws Exception { Language languageImpl = validateLanguage(); return languageImpl.createPredicate(getExpression()); }
@Override public Expression getObject() throws Exception { Language languageImpl = validateLanguage(); return languageImpl.createExpression(getExpression()); } }
/** * Parses a string of the form "languageName.remaining = expression" returning the Predicate and the remaining text */ protected Pair<Predicate, String> parsePredicateAndRemaining(CamelContextService camelContextService, String key, String expression) { // lets assume no dots in language names int idx = key.indexOf('.'); if (idx > 0) { String languageName = key.substring(0, idx); String remaining = key.substring(idx + 1); Language language = camelContextService.getCamelContext().resolveLanguage(languageName); if (languageName == null) { LOG.error("Could not resolve language '" + languageName + "' with expression '" + expression + "'"); } else { try { Predicate predicate = language.createPredicate(expression); if (predicate == null) { LOG.error("Could not create predicate for language " + language + " and expression '" + expression + "'"); } else { return new Pair<Predicate, String>(predicate, remaining); } } catch (Exception e) { LOG.error("Failed to parse " + language + " expression '" + expression + "'. Reason: " + e); } } } return null; }
String path = getPathPart(); try { exp = expLang.createExpression(resolveScript(scheme + ":" + path)); } catch (IOException e) { throw new IllegalStateException( exp = expLang.createExpression(getExpressionPart());
@Override public boolean matches(Exchange exchange) { Object msgBody = exchange.getIn().getBody(); // TODO: Maybe check for content-type, too ? // String contentType = exchange.getIn().getHeader(Exchange.CONTENT_TYPE, String.class); // if ("application/json".equals(contentType)) { ... } // ??? if (!(msgBody instanceof String)) { return language.createPredicate(expression).matches(exchange); } Exchange exchangeToCheck = exchange; // If it is a json document , suppose that this is a document which needs to be parsed as JSON // Therefor we set a map instead of the string Map jsonDocument = jsonStringAsMap((String) msgBody, exchange); if (jsonDocument != null) { // Clone the exchange and set the JSON message converted to a Map / List as in message. // The intention is that only this predicate acts on the converted value, // but the original in-message still continues to carry the same format // The predicated is supposed to be read only with respect to the incoming messaeg. exchangeToCheck = ExchangeHelper.createCopy(exchange, true); exchangeToCheck.getIn().setBody(jsonDocument); } return language.createPredicate(convertSimpleToOGNLForMaps(expression)).matches(exchangeToCheck); }
@Override public Optional<ProcessorDefinition> handle(SplitInline step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { String languageName = step.getLanguage(); String expressionDefinition = step.getExpression(); if (ObjectHelper.isEmpty(languageName) && ObjectHelper.isEmpty(expressionDefinition)) { return Optional.of(route.split(Builder.body())); } else { Objects.requireNonNull(languageName, "Expression language should not be null"); Objects.requireNonNull(expressionDefinition, "Expression should not be null"); // A small hack until https://issues.apache.org/jira/browse/CAMEL-12079 // gets fixed so we can support the 'bean::method' annotation as done by // Function step definition if ("bean".equals(languageName)) { if (expressionDefinition.contains("::")) { expressionDefinition = expressionDefinition.replace("::", "?method="); } } final CamelContext context = routeBuilder.getContext(); final Language language = context.resolveLanguage(languageName); final Expression expression = language.createExpression(expressionDefinition); final ProcessorDefinition split = route.split(expression); return Optional.of(split); } } }
final Expression expression = language.createExpression(expressionDefinition);
final Expression expression = language.createExpression(expressionDefinition);
Object answer; if (path == null) { Expression exp = exchange.getContext().resolveLanguage("simple").createExpression(expression); String text = exp.evaluate(exchange, String.class); JsonPath path = JsonPath.compile(text);
@Lazy @Bean(name = ServiceCallDefinitionConstants.DEFAULT_SERVICE_CALL_CONFIG_ID) @ConditionalOnMissingBean(name = ServiceCallDefinitionConstants.DEFAULT_SERVICE_CALL_CONFIG_ID) public ServiceCallConfigurationDefinition serviceCallConfiguration() throws Exception { final ServiceCallConfigurationDefinition definition = new ServiceCallConfigurationDefinition(); final CamelCloudConfigurationProperties.ServiceCall serviceCall = configurationProperties.getServiceCall(); ObjectHelper.ifNotEmpty(serviceCall.getComponent(), definition::setComponent); ObjectHelper.ifNotEmpty(serviceCall.getUri(), definition::setUri); ObjectHelper.ifNotEmpty(serviceCall.getServiceDiscovery(), definition::setServiceDiscoveryRef); ObjectHelper.ifNotEmpty(serviceCall.getServiceFilter(), definition::setServiceFilterRef); ObjectHelper.ifNotEmpty(serviceCall.getServiceChooser(), definition::setServiceChooserRef); ObjectHelper.ifNotEmpty(serviceCall.getLoadBalancer(), definition::setLoadBalancerRef); if (serviceCall.getLoadBalancer() == null && serviceCall.isDefaultLoadBalancer()) { definition.defaultLoadBalancer(); } final String expression = serviceCall.getExpression(); final String expressionLanguage = serviceCall.getExpressionLanguage(); if (ObjectHelper.isNotEmpty(expression) && ObjectHelper.isNotEmpty(expressionLanguage)) { Language language = camelContext.resolveLanguage(expressionLanguage); if (language == null) { throw new IllegalArgumentException("Unable to resolve language: " + expressionLanguage); } definition.setExpression(language.createExpression(expression)); } return definition; }