private Expression parseFieldExpression(String field, boolean useResultTypeHint) { FluentParserContext parserContext = new FluentParserContext().evaluate(boundObject.getClass()); if (useResultTypeHint) { parserContext.expectResult(String.class); } return expressionParser.parseExpression(field, parserContext); }
public View getView(RequestContext context) { String viewId = (String) this.viewId.getValue(context); return new MockView(viewId, context); } }
private Object getFormattedValue(String field) { Expression fieldExpression = parseFieldExpression(field, true); Class<?> valueType = fieldExpression.getValueType(boundObject); if (isCustomConverterConfigured(field) || avoidConversion(valueType)) { fieldExpression = parseFieldExpression(fieldExpression.getExpressionString(), false); } Object value = fieldExpression.getValue(boundObject); if ((value instanceof String) == false) { if (avoidConversion(valueType) == false) { PropertyEditor editor = findSpringConvertingPropertyEditor(field, valueType); if (editor != null) { editor.setValue(value); value = editor.getAsText(); } } } return value; }
public boolean test(MappingResult result) { if (property.equals(result.getMapping().getTargetExpression().getExpressionString())) { return true; } else { return false; } } }
public Class<?> getFieldType(String field) { return parseFieldExpression(fixedField(field), false).getValueType(boundObject); }
/** * Hook method subclasses can override to return a specialized expression evaluating transition criteria * implementation. * @param encodedCriteria the encoded transition criteria expression * @param parser the parser that should parse the expression * @return the transition criteria object * @throws ConversionExecutionException when something goes wrong */ protected TransitionCriteria createBooleanExpressionTransitionCriteria(String encodedCriteria, ExpressionParser parser) throws ConversionExecutionException { Expression expression = parser.parseExpression(encodedCriteria, new FluentParserContext().template().evaluate(RequestContext.class)); return new DefaultTransitionCriteria(expression); } }
private Object getModelObject() { Expression model = getModelExpression(); if (model != null) { try { return model.getValue(requestContext); } catch (EvaluationException e) { return null; } } else { return null; } }
protected Event doExecute(RequestContext context) throws Exception { Object result = expression.getValue(context); if (result instanceof Action) { return ActionExecutor.execute((Action) result, context); } else { if (resultExpression != null) { resultExpression.setValue(context, result); } return resultEventFactory.createResultEvent(this, result, context); } }
public boolean test(MappingResult result) { if (result.isError() && field.equals(result.getMapping().getTargetExpression().getExpressionString())) { return true; } else { return false; } } }
public Object convertSourceToTargetClass(Object source, Class<?> targetClass) throws Exception { String targetStateId = (String) source; if (!StringUtils.hasText(targetStateId)) { return null; } ExpressionParser parser = flowBuilderContext.getExpressionParser(); Expression expression = parser.parseExpression(targetStateId, new FluentParserContext().template().evaluate(RequestContext.class).expectResult(String.class)); return new DefaultTargetStateResolver(expression); } }
public Object getValue(Object context) throws EvaluationException { String subflowId = (String) this.subflowId.getValue(context); return flowDefinitionLocator.getFlowDefinition(subflowId); }
private void validate(Object model, TransitionDefinition transition) { if (logger.isDebugEnabled()) { logger.debug("Validating model"); } ValidationHelper helper = new ValidationHelper(model, requestContext, eventId, getModelExpression() .getExpressionString(), expressionParser, messageCodesResolver, mappingResults, validationHintResolver); helper.setValidator(this.validator); helper.validate(); }
private Expression parseSubflowExpression(String subflow) { Expression subflowId = getLocalContext().getExpressionParser().parseExpression(subflow, new FluentParserContext().template().evaluate(RequestContext.class).expectResult(String.class)); return new SubflowExpression(subflowId, getLocalContext().getFlowDefinitionLocator()); }
public Object getRawFieldValue(String field) { return parseFieldExpression(fixedField(field), false).getValue(boundObject); }
private void exposeBindingModel(Map<String, Object> model) { Object modelObject = getModelObject(); if (modelObject != null) { BindingModel bindingModel = new BindingModel(getModelExpression().getExpressionString(), modelObject, expressionParser, conversionService, requestContext.getMessageContext()); bindingModel.setBinderConfiguration(binderConfiguration); bindingModel.setMappingResults(mappingResults); model.put(BindingResult.MODEL_KEY_PREFIX + getModelExpression().getExpressionString(), bindingModel); } }
public boolean test(RequestContext context) { Object result = expression.getValue(context); if (result == null) { return false; } else if (result instanceof Boolean) { return (Boolean) result; } else { String eventId = String.valueOf(result); return context.getCurrentEvent().getId().equals(eventId); } }
public State resolveTargetState(Transition transition, State sourceState, RequestContext context) { String targetStateId = (String) targetStateIdExpression.getValue(context); if (targetStateId != null) { return ((Flow) context.getActiveFlow()).getStateInstance(targetStateId); } else { return null; } }
protected Event doExecute(RequestContext context) throws Exception { String resourceUri = (String) this.resourceUri.getValue(context); context.getExternalContext().requestExternalRedirect(resourceUri); return success(); }
protected Event doExecute(RequestContext context) throws Exception { String[] fragments = new String[fragmentExpressions.length]; for (int i = 0; i < fragmentExpressions.length; i++) { Expression exp = fragmentExpressions[i]; fragments[i] = (String) exp.getValue(context); } context.getFlashScope().put(View.RENDER_FRAGMENTS_ATTRIBUTE, fragments); return success(); }