/** * 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 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 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 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 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 Expression getObject() throws Exception { Language languageImpl = validateLanguage(); return languageImpl.createExpression(getExpression()); } }
String path = getPathPart(); try { exp = expLang.createExpression(resolveScript(scheme + ":" + path)); } catch (IOException e) { throw new IllegalStateException( exp = expLang.createExpression(getExpressionPart());
@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; }