@Override public Object evaluateGroovyExpression(final String expression, final ActivityInstanceUUID activityUUID, final Map<String, Object> context, final boolean useActivityScope, final boolean propagate) throws InstanceNotFoundException, ActivityNotFoundException, GroovyException { return GroovyUtil.evaluate(expression, context, activityUUID, useActivityScope, propagate); }
private static String evaluate(final List<String> expressions, final Binding binding) throws GroovyException { final StringBuilder builder = new StringBuilder(); int i = 0; while (i < expressions.size()) { String expression = expressions.get(i); if (expression.equals(START_DELIMITER)) { expression = expressions.get(++i); builder.append(evaluateGroovyExpression(expression, binding)); } else { builder.append(expression); } i++; } return builder.toString(); }
private static String getMessage(final ActivityInstanceUUID activityUUID, final ProcessInstanceUUID instanceUUID, final ProcessDefinitionUUID processDefUUID, final String message) { final String partialMessage = getMessage(activityUUID, instanceUUID, message); final StringBuilder stb = new StringBuilder(partialMessage); if (processDefUUID != null) { stb.append(" ProcessDefinitionUUID: '").append(processDefUUID).append("'."); } return stb.toString(); }
public static Object evaluate(final String expression, final Binding binding) throws GroovyException, NotSerializableException, ActivityDefNotFoundException, DataFieldNotFoundException, ProcessNotFoundException, IOException, ClassNotFoundException { String workingExpression = expression; Object result = null; if (Misc.isJustAGroovyExpression(workingExpression)) { workingExpression = workingExpression.substring(START_DELIMITER.length()); workingExpression = workingExpression.substring(0, workingExpression.lastIndexOf(END_DELIMITER)); if (Misc.isJavaIdentifier(workingExpression) && binding.getVariables().containsKey(workingExpression)) { result = binding.getVariable(workingExpression); } else { result = evaluateGroovyExpression(workingExpression, binding); } } else { result = evaluate(getExpressions(workingExpression), binding); } return result; }
final String message = getMessage(activityUUID, instanceUUID, processDefinitionUUID, "The expression is null or empty."); throw new GroovyException(message); final int end = expression.indexOf(END_DELIMITER); if (begin >= end) { final String message = getMessage(activityUUID, instanceUUID, processDefinitionUUID, "The expression is not a Groovy one: " + expression + "."); throw new GroovyException(message); final Object result = evaluate(expression, binding); if (propagateWhenInJournal && instanceUUID != null) { propagateVariables(((PropagateBinding) binding).getVariablesToPropagate(), activityUUID, instanceUUID); final String message = getMessage(activityUUID, instanceUUID, processDefinitionUUID, "Exception while evaluating expression."); throw new GroovyException(message, e);
private void propagateVariablesIfNecessary(final ActivityInstanceUUID activityUUID, final ProcessInstanceUUID instanceUUID, final boolean propagate, final Binding binding) throws GroovyException { if (propagate) { try { GroovyUtil.propagateVariables(((PropagateBinding) binding).getVariablesToPropagate(), activityUUID, instanceUUID); } catch (final Exception e) { throw new GroovyException("Exception while propagating variables", e); } } }
@Override public Object evaluateGroovyExpression(final String expression, final ProcessInstanceUUID instanceUUID, final Map<String, Object> context, final boolean useInitialVariableValues, final boolean propagate) throws InstanceNotFoundException, GroovyException { return GroovyUtil.evaluate(expression, context, instanceUUID, useInitialVariableValues, propagate); }
public static void propagateVariables(final Map<String, Object> variables, final ActivityInstanceUUID activityUUID, final ProcessInstanceUUID instanceUUID) throws GroovyException { final StandardAPIAccessorImpl accessor = new StandardAPIAccessorImpl(); final RuntimeAPI runtime = accessor.getRuntimeAPI(); if (variables != null) { for (final Entry<String, Object> variable : variables.entrySet()) { try { if (activityUUID != null) { runtime.setVariable(activityUUID, variable.getKey(), variable.getValue()); } else { runtime.setProcessInstanceVariable(instanceUUID, variable.getKey(), variable.getValue()); } } catch (final BonitaException e) { final String message = getMessage(activityUUID, instanceUUID, "Error while propagating variables."); throw new GroovyException(message, e); } } } }
@Override public Object evaluateGroovyExpression(final String expression, final ProcessDefinitionUUID processDefinitionUUID, final Map<String, Object> context) throws ProcessNotFoundException, GroovyException { return GroovyUtil.evaluate(expression, context, processDefinitionUUID, false); }
@Override public Object evaluateGroovyExpression(final String expression, final ProcessInstanceUUID instanceUUID, final Map<String, Object> context, final boolean propagate) throws InstanceNotFoundException, GroovyException { return GroovyUtil.evaluate(expression, context, instanceUUID, false, propagate); }
public static Object evaluate(final String expression, final Map<String, Object> variables, final ClassLoader classLoader) throws GroovyException { return evaluate(expression, variables, null, null, null, false, false, false, classLoader); }
public static Object evaluate(final String expression, final Map<String, Object> variables) throws GroovyException { return evaluate(expression, variables, null, null, null, false, false, false, null); }
private Map<String, Object> evaluateGroovyExpressions(final Map<String, String> expressions, final Binding binding) throws GroovyException, NotSerializableException, ActivityDefNotFoundException, DataFieldNotFoundException, ProcessNotFoundException, IOException, ClassNotFoundException { final Map<String, Object> results = new HashMap<String, Object>(); for (final Entry<String, String> expr : expressions.entrySet()) { final String expressionName = expr.getKey(); final Object result = GroovyUtil.evaluate(expr.getValue(), binding); results.put(expressionName, result); } return results; }
public static String getEvaluatedCorrelationKey(final ProcessInstanceUUID processInstanceUUID, final String correlationKeyName, final String correlationKeyExpression) { if (correlationKeyExpression != null) { try { final String expression = GroovyUtil.evaluate(correlationKeyExpression, null, processInstanceUUID, false, false).toString(); return correlationKeyName.concat("||||").concat(expression); } catch (final GroovyException e) { throw new BonitaRuntimeException(e); } } return null; }
public static String getEvaluatedCorrelationKey(final ProcessDefinitionUUID definitionUUID, final String correlationKeyName, final String correlationKeyExpression) { if (correlationKeyExpression != null) { try { final String expression = GroovyUtil.evaluate(correlationKeyExpression, null, definitionUUID, false).toString(); return correlationKeyName.concat("||||").concat(expression); } catch (final GroovyException e) { throw new BonitaRuntimeException(e); } } return null; }
public static String getEvaluatedCorrelationKey(final ActivityInstanceUUID activityUUID, final String correlationKeyName, final String correlationKeyExpression) { if (correlationKeyExpression != null) { try { final String expression = GroovyUtil.evaluate(correlationKeyExpression, null, activityUUID, false, false) .toString(); return correlationKeyName.concat("||||").concat(expression); } catch (final GroovyException e) { throw new BonitaRuntimeException(e); } } return null; }
private static Object getEvaluatedExpression(final Binding binding, final Object parameterMethod, final Object connector) { if (parameterMethod instanceof String) { final String expression = (String) parameterMethod; if (GroovyExpression.isGroovyExpression(expression)) { try { return GroovyUtil.evaluate(expression, binding); } catch (final Exception e) { final StringBuilder stb = new StringBuilder("Error while executing connector: '"); stb.append(connector.getClass().getName()); stb.append("'. "); throw new BonitaRuntimeException(stb.toString(), e); } } } return parameterMethod; }
private static Map<String, Object> getProcessVariables(final Map<String, Object[]> outputs, final Object connector, final ProcessDefinitionUUID processDefinitionUUID) throws BonitaException { final Map<String, Object> newVariableValues = new HashMap<String, Object>(); if (connector instanceof Connector) { final Map<String, Object> values = getGetterValues((Connector) connector); for (final Entry<String, Object[]> output : outputs.entrySet()) { final String expression = (String) output.getValue()[0]; final String variableName = output.getKey(); final Object variableValue = GroovyUtil.evaluate(expression, values, processDefinitionUUID, false); final Object newValue = convertIfPossible(variableValue, getDataTypeClassName(variableName, processDefinitionUUID)); newVariableValues.put(variableName, newValue); } } return newVariableValues; }
private static Object evaluateInitialValue(final ProcessInstanceUUID instanceUUID, final DataFieldDefinition df, Object value, final Map<String, Object> context) { if (value == null) { final String script = df.getScriptingValue(); if (script != null) { try { if (instanceUUID != null) { value = GroovyUtil.evaluate(script, context, instanceUUID, false, false); } else { value = GroovyUtil.evaluate(script, context, df.getProcessDefinitionUUID(), false); } if (df.getDataTypeClassName().equals(Document.class.getName()) && value instanceof String) { value = Misc.generateDocument((String) value); } } catch (final Exception e) { try { value = GroovyUtil.evaluate(script, context); } catch (final GroovyException e1) { final StringBuilder stb = new StringBuilder("Error while initializing variable: '"); stb.append(df.getName()); stb.append("'. "); throw new BonitaRuntimeException(stb.toString(), e); } } } } return value; }
Object value = null; if (activityUUID != null) { value = GroovyUtil.evaluate(condition, null, activityUUID, false, false); } else { final Map<String, Object> context = new HashMap<String, Object>(); context.put(BonitaConstants.TIMER_LAST_EXECUTION, lastTime); value = GroovyUtil.evaluate(condition, context, definitionUUID, false);