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); }
/** * Adds a {@link DefaultMapping} between the given request parameter name and a matching model field. * * @param mapper the mapper to add the mapping to * @param parameter the request parameter name * @param model the model */ protected void addDefaultMapping(DefaultMapper mapper, String parameter, Object model) { Expression source = new RequestParameterExpression(parameter); ParserContext parserContext = new SimpleParserContext(model.getClass()); if (expressionParser instanceof BeanWrapperExpressionParser || checkModelProperty(parameter, model)) { Expression target = expressionParser.parseExpression(parameter, parserContext); DefaultMapping mapping = new DefaultMapping(source, target); if (logger.isDebugEnabled()) { logger.debug("Adding default mapping for parameter '" + parameter + "'"); } mapper.addMapping(mapping); } }
/** * Adds a special {@link DefaultMapping} that results in setting the target field on the model to an empty value * (typically null). * * @param mapper the mapper to add the mapping to * @param field the field for which a mapping is to be added * @param model the model */ protected void addEmptyValueMapping(DefaultMapper mapper, String field, Object model) { ParserContext parserContext = new SimpleParserContext(model.getClass()); Expression target = emptyValueExpressionParser.parseExpression(field, parserContext); try { Class<?> propertyType = target.getValueType(model); Expression source = new StaticExpression(getEmptyValue(propertyType)); DefaultMapping mapping = new DefaultMapping(source, target); if (logger.isDebugEnabled()) { logger.debug("Adding empty value mapping for parameter '" + field + "'"); } mapper.addMapping(mapping); } catch (EvaluationException e) { } }
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); } }
/** * 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 DefaultMapping parseSubflowInputMapping(InputModel input) { ExpressionParser parser = getLocalContext().getExpressionParser(); String name = input.getName(); String value = null; if (StringUtils.hasText(input.getValue())) { value = input.getValue(); } else { value = name; } Expression source = parser.parseExpression(value, new FluentParserContext().evaluate(RequestContext.class)); Expression target = parser.parseExpression(name, new FluentParserContext().evaluate(MutableAttributeMap.class)); DefaultMapping mapping = new DefaultMapping(source, target); parseAndSetMappingConversionExecutor(input, mapping); parseAndSetMappingRequired(input, mapping); return mapping; }
private DefaultMapping parseFlowInputMapping(InputModel input) { ExpressionParser parser = getLocalContext().getExpressionParser(); String name = input.getName(); String value = null; if (StringUtils.hasText(input.getValue())) { value = input.getValue(); } else { value = "flowScope." + name; } Expression source = parser.parseExpression(name, new FluentParserContext().evaluate(MutableAttributeMap.class)); Expression target = parser.parseExpression(value, new FluentParserContext().evaluate(RequestContext.class)); DefaultMapping mapping = new DefaultMapping(source, target); parseAndSetMappingConversionExecutor(input, mapping); parseAndSetMappingRequired(input, mapping); return mapping; }
private DefaultMapping parseFlowOutputMapping(OutputModel output) { ExpressionParser parser = getLocalContext().getExpressionParser(); String name = output.getName(); String value = null; if (StringUtils.hasText(output.getValue())) { value = output.getValue(); } else { value = name; } Expression source = parser.parseExpression(value, new FluentParserContext().evaluate(RequestContext.class)); Expression target = parser.parseExpression(name, new FluentParserContext().evaluate(MutableAttributeMap.class)); DefaultMapping mapping = new DefaultMapping(source, target); parseAndSetMappingConversionExecutor(output, mapping); parseAndSetMappingRequired(output, mapping); return mapping; }
private DefaultMapping parseSubflowOutputMapping(OutputModel output) { ExpressionParser parser = getLocalContext().getExpressionParser(); String name = output.getName(); String value = null; if (StringUtils.hasText(output.getValue())) { value = output.getValue(); } else { value = "flowScope." + name; } Expression source = parser.parseExpression(name, new FluentParserContext().evaluate(MutableAttributeMap.class)); Expression target = parser.parseExpression(value, new FluentParserContext().evaluate(RequestContext.class)); DefaultMapping mapping = new DefaultMapping(source, target); parseAndSetMappingConversionExecutor(output, mapping); parseAndSetMappingRequired(output, mapping); return mapping; }
private Action parseEvaluateAction(EvaluateModel evaluate) { FluentParserContext evaluateExpressionParserContext = new FluentParserContext().evaluate(RequestContext.class); if (StringUtils.hasText(evaluate.getResultType())) { evaluateExpressionParserContext.expectResult(toClass(evaluate.getResultType())); } Expression evaluateExpression = getLocalContext().getExpressionParser().parseExpression( evaluate.getExpression(), evaluateExpressionParserContext); Expression resultExpression = null; if (StringUtils.hasText(evaluate.getResult())) { resultExpression = getLocalContext().getExpressionParser().parseExpression(evaluate.getResult(), new FluentParserContext().evaluate(RequestContext.class)); } return new EvaluateAction(evaluateExpression, resultExpression); }
private Action parseSetAction(SetModel set) { Expression nameExpression = getLocalContext().getExpressionParser().parseExpression(set.getName(), new FluentParserContext().evaluate(RequestContext.class)); FluentParserContext valueParserContext = new FluentParserContext().evaluate(RequestContext.class); if (StringUtils.hasText(set.getType())) { valueParserContext.expectResult(toClass(set.getType())); } Expression valueExpression = getLocalContext().getExpressionParser().parseExpression(set.getValue(), valueParserContext); return new SetAction(nameExpression, valueExpression); }
private Action parseRenderAction(RenderModel render) { String[] fragmentExpressionStrings = StringUtils.commaDelimitedListToStringArray(render.getFragments()); fragmentExpressionStrings = StringUtils.trimArrayElements(fragmentExpressionStrings); ParserContext context = new FluentParserContext().template().evaluate(RequestContext.class) .expectResult(String.class); Expression[] fragments = new Expression[fragmentExpressionStrings.length]; for (int i = 0; i < fragmentExpressionStrings.length; i++) { String fragment = fragmentExpressionStrings[i]; fragments[i] = getLocalContext().getExpressionParser().parseExpression(fragment, context); } return new RenderAction(fragments); }
private ViewFactory parseViewFactory(String view, String stateId, boolean endState, BinderModel binderModel) { if (!StringUtils.hasText(view)) { if (endState) { return null; } else { view = getLocalContext().getViewFactoryCreator().getViewIdByConvention(stateId); Expression viewId = getLocalContext().getExpressionParser().parseExpression(view, new FluentParserContext().template().evaluate(RequestContext.class).expectResult(String.class)); return createViewFactory(viewId, binderModel); } } else if (view.startsWith("externalRedirect:")) { String encodedUrl = view.substring("externalRedirect:".length()); Expression externalUrl = getLocalContext().getExpressionParser().parseExpression(encodedUrl, new FluentParserContext().template().evaluate(RequestContext.class).expectResult(String.class)); return new ActionExecutingViewFactory(new ExternalRedirectAction(externalUrl)); } else if (view.startsWith("flowRedirect:")) { String flowRedirect = view.substring("flowRedirect:".length()); Expression expression = getLocalContext().getExpressionParser().parseExpression(flowRedirect, new FluentParserContext().template().evaluate(RequestContext.class).expectResult(String.class)); return new ActionExecutingViewFactory(new FlowDefinitionRedirectAction(expression)); } else { Expression viewId = getLocalContext().getExpressionParser().parseExpression(view, new FluentParserContext().template().evaluate(RequestContext.class).expectResult(String.class)); return createViewFactory(viewId, binderModel); } }
Expression source = new RequestParameterExpression(binding.getProperty()); ParserContext parserContext = new SimpleParserContext(model.getClass()); Expression target = expressionParser.parseExpression(binding.getProperty(), parserContext); DefaultMapping mapping = new DefaultMapping(source, target); mapping.setRequired(binding.getRequired());
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()); }
private Transition parseThen(IfModel ifModel) { Expression test = getLocalContext().getExpressionParser().parseExpression(ifModel.getTest(), new FluentParserContext().evaluate(RequestContext.class).expectResult(Boolean.class)); TransitionCriteria matchingCriteria = new DefaultTransitionCriteria(test); TargetStateResolver targetStateResolver = (TargetStateResolver) fromStringTo(TargetStateResolver.class) .execute(ifModel.getThen()); return getLocalContext().getFlowArtifactFactory().createTransition(targetStateResolver, matchingCriteria, null, null); }
private Transition parseTransition(TransitionModel transition) { TransitionCriteria matchingCriteria = (TransitionCriteria) fromStringTo(TransitionCriteria.class).execute( transition.getOn()); TargetStateResolver stateResolver = (TargetStateResolver) fromStringTo(TargetStateResolver.class).execute( transition.getTo()); TransitionCriteria executionCriteria = TransitionCriteriaChain.criteriaChainFor(parseActions(transition .getActions())); MutableAttributeMap<Object> attributes = parseMetaAttributes(transition.getAttributes()); if (StringUtils.hasText(transition.getBind())) { attributes.put("bind", fromStringTo(Boolean.class).execute(transition.getBind())); } if (StringUtils.hasText(transition.getValidate())) { attributes.put("validate", fromStringTo(Boolean.class).execute(transition.getValidate())); } if (StringUtils.hasText(transition.getValidationHints())) { attributes.put("validationHints", getLocalContext().getExpressionParser().parseExpression(transition.getValidationHints(), new FluentParserContext().evaluate(RequestContext.class))); } if (StringUtils.hasText(transition.getHistory())) { attributes.put("history", fromStringTo(History.class).execute(transition.getHistory().toUpperCase())); } parseAndPutSecured(transition.getSecured(), attributes); return getLocalContext().getFlowArtifactFactory().createTransition(stateResolver, matchingCriteria, executionCriteria, attributes); }
private void parseAndAddViewState(ViewStateModel state, Flow flow) { ViewFactory viewFactory = parseViewFactory(state.getView(), state.getId(), false, state.getBinder()); Boolean redirect = null; if (StringUtils.hasText(state.getRedirect())) { redirect = (Boolean) fromStringTo(Boolean.class).execute(state.getRedirect()); } boolean popup = false; if (StringUtils.hasText(state.getPopup())) { popup = ((Boolean) fromStringTo(Boolean.class).execute(state.getPopup())); } MutableAttributeMap<Object> attributes = parseMetaAttributes(state.getAttributes()); if (state.getModel() != null) { attributes.put( "model", getLocalContext().getExpressionParser().parseExpression(state.getModel(), new FluentParserContext().evaluate(RequestContext.class))); } if (state.getValidationHints() != null) { attributes.put("validationHints", getLocalContext().getExpressionParser().parseExpression(state.getValidationHints(), new FluentParserContext().evaluate(RequestContext.class))); } parseAndPutSecured(state.getSecured(), attributes); getLocalContext().getFlowArtifactFactory().createViewState(state.getId(), flow, parseViewVariables(state.getVars()), parseActions(state.getOnEntryActions()), viewFactory, redirect, popup, parseActions(state.getOnRenderActions()), parseTransitions(state.getTransitions()), parseExceptionHandlers(state.getExceptionHandlers(), state.getTransitions()), parseActions(state.getOnExitActions()), attributes); }
private Transition parseThen(Element element) { Expression expression = getLocalFlowServiceLocator().getExpressionParser().parseExpression( element.getAttribute(TEST_ATTRIBUTE)); TransitionCriteria matchingCriteria = new BooleanExpressionTransitionCriteria(expression); TargetStateResolver targetStateResolver = (TargetStateResolver) fromStringTo(TargetStateResolver.class) .execute(element.getAttribute(THEN_ATTRIBUTE)); return getFlowArtifactFactory().createTransition(targetStateResolver, matchingCriteria, null, null); }
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()); }