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); } } }
protected void executeActions(final RuntimeAPI runtimeAPI) throws Exception { if (scriptsToExecute != null && !scriptsToExecute.isEmpty() ) { Map<String,String> scriptsToExecuteInASingleCall = new HashMap<String, String>(scriptsToExecute.size()); for (String scriptToExecute : scriptsToExecute) { scriptsToExecuteInASingleCall.put(String.valueOf(scriptsToExecuteInASingleCall.size()), scriptToExecute); } try { runtimeAPI.evaluateGroovyExpressions(scriptsToExecuteInASingleCall, processDefinitionUUID, scriptContext); } catch (GroovyException e) { if (LOG.isLoggable(Level.SEVERE)) { LOG.log(Level.SEVERE, "Error while executing action. unable to evaluate the groovy expression", e); } throw new GroovyException(e.getMessage() ,e); } } }
eventService.storeJob(timer); } catch (final GroovyException e) { throw new DeploymentRuntimeException(e.getMessage(), e.getCause());
eventService.storeJob(timer); } catch (final GroovyException e) { throw new DeploymentRuntimeException(e.getMessage(), e.getCause());
private void updateContext(final Map<String, Object> output, final ProcessDefinitionUUID parentProcessDefinitionUUID, final String fieldNameExpression, final Object evaluatedFieldValue) throws GroovyException, Exception { String fieldName = fieldNameExpression; Object newValue = evaluatedFieldValue; if (fieldNameExpression.contains(BonitaConstants.XPATH_VAR_SEPARATOR) || fieldNameExpression.contains(BonitaConstants.JAVA_VAR_SEPARATOR)) { fieldName = Misc.getVariableName(fieldNameExpression); final Object currentValue = output.get(fieldName); if (currentValue == null) { throw new GroovyException("The variable '" + fieldName + "' was not found in the context map or it's null"); } if (fieldNameExpression.contains(BonitaConstants.XPATH_VAR_SEPARATOR)) { if (currentValue instanceof Document) { newValue = getXMLValueXPath(fieldNameExpression, evaluatedFieldValue, (Document) currentValue); } else { throw new GroovyException("The variable '" + fieldName + "' is not a Document"); } } else if (fieldNameExpression.contains(BonitaConstants.JAVA_VAR_SEPARATOR)) { newValue = getModifiedJavaObject(parentProcessDefinitionUUID, fieldNameExpression, currentValue, evaluatedFieldValue); } } output.put(fieldName, newValue); }
protected void executeActions(final RuntimeAPI runtimeAPI) throws Exception { if (scriptsToExecute != null && !scriptsToExecute.isEmpty() ) { Map<String,String> scriptsToExecuteInASingleCall = new HashMap<String, String>(scriptsToExecute.size()); for (String scriptToExecute : scriptsToExecute) { scriptsToExecuteInASingleCall.put(String.valueOf(scriptsToExecuteInASingleCall.size()), scriptToExecute); } try { runtimeAPI.evaluateGroovyExpressions(scriptsToExecuteInASingleCall, processDefinitionUUID, scriptContext); } catch (GroovyException e) { if (LOG.isLoggable(Level.SEVERE)) { LOG.log(Level.SEVERE, "Error while executing action. unable to evaluate the groovy expression", e); } throw new GroovyException(e.getMessage() ,e); } } }
private static Object evaluateGroovyExpression(final String script, final Binding binding) throws GroovyException { final ClassLoader scriptClassLoader = Thread.currentThread().getContextClassLoader(); final Script groovyScript = GroovyScriptBuilder.getScript(script, scriptClassLoader); groovyScript.setBinding(binding); Object result = null; try { result = groovyScript.run(); } catch (final MissingPropertyException e) { final String lineSeparator = System.getProperty("line.separator", "\n"); final StringBuilder stb = new StringBuilder(); stb.append("Error in Groovy script: unable to use element \"" + e.getProperty() + "\""); stb.append(lineSeparator); stb.append(lineSeparator); stb.append("Possible cause:"); stb.append(lineSeparator); stb.append("- missing import"); stb.append(lineSeparator); stb.append("- variable not found (wrong name, undefined)"); stb.append(lineSeparator); stb.append("- ..."); stb.append(lineSeparator); stb.append(lineSeparator); stb.append("Script:"); stb.append(lineSeparator); stb.append("\"" + script + "\""); stb.append(lineSeparator); throw new GroovyException(stb.toString(), e); } return result; }
@Override public Map<String, Object> evaluateGroovyExpressions(final Map<String, String> expressions, final ProcessDefinitionUUID processDefinitionUUID, final Map<String, Object> context) throws ProcessNotFoundException, GroovyException { Misc.checkArgsNotNull(processDefinitionUUID); if (expressions == null || expressions.isEmpty()) { return Collections.emptyMap(); } final ClassLoader ori = Thread.currentThread().getContextClassLoader(); try { final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processDefinitionUUID); Thread.currentThread().setContextClassLoader(processClassLoader); final Binding simpleBinding = GroovyBindingBuilder.getSimpleBinding(processDefinitionUUID, null, null, context, true, true); return evaluateGroovyExpressions(expressions, simpleBinding); } catch (final Exception e) { throw new GroovyException("Exception while getting binding. ProcessDefinitionUUID: " + processDefinitionUUID, e); } finally { if (ori != null && ori != Thread.currentThread().getContextClassLoader()) { Thread.currentThread().setContextClassLoader(ori); } } }
private Binding getBinding(final ProcessDefinitionUUID processUUID, final ProcessInstanceUUID instanceUUID, final ActivityInstanceUUID activityUUID, final Map<String, Object> context, final boolean useActiveScope, final boolean useInitialVariableValues, final boolean propagate) throws GroovyException { Binding binding = null; try { if (propagate) { binding = GroovyBindingBuilder.getPropagateBinding(processUUID, instanceUUID, activityUUID, context, useActiveScope, useInitialVariableValues); } else { binding = GroovyBindingBuilder.getSimpleBinding(processUUID, instanceUUID, activityUUID, context, useActiveScope, useInitialVariableValues); } } catch (final Exception e) { throw new GroovyException("Exception while getting binding", e); } return binding; }
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); } } } }
stb.append("' "); throw new GroovyException(stb.toString(), e);
@Override public Map<String, Object> evaluateGroovyExpressions(final Map<String, String> expressions, final ProcessInstanceUUID processInstanceUUID, final Map<String, Object> context, final boolean useInitialVariableValues, final boolean propagate) throws InstanceNotFoundException, GroovyException { Misc.checkArgsNotNull(processInstanceUUID); if (expressions == null || expressions.isEmpty()) { return Collections.emptyMap(); } final ClassLoader ori = Thread.currentThread().getContextClassLoader(); try { final InternalProcessInstance instance = EnvTool.getAllQueriers().getProcessInstance(processInstanceUUID); final ProcessDefinitionUUID definitionUUID = instance.getProcessDefinitionUUID(); final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(definitionUUID); Thread.currentThread().setContextClassLoader(processClassLoader); final Binding binding = getBinding(definitionUUID, processInstanceUUID, null, context, false, useInitialVariableValues, propagate); final Map<String, Object> results = evaluateGroovyExpressions(expressions, binding); propagateVariablesIfNecessary(null, processInstanceUUID, propagate, binding); return results; } catch (final Exception e) { throw new GroovyException("Exception while evaluating expression. ProcessInstanceUUID: " + processInstanceUUID, e); } finally { if (ori != null && ori != Thread.currentThread().getContextClassLoader()) { Thread.currentThread().setContextClassLoader(ori); } } }
@Override public Map<String, Object> evaluateGroovyExpressions(final Map<String, String> expressions, final ActivityInstanceUUID activityUUID, final Map<String, Object> context, final boolean useActivityScope, final boolean propagate) throws InstanceNotFoundException, ActivityNotFoundException, GroovyException { Misc.checkArgsNotNull(activityUUID); if (expressions == null || expressions.isEmpty()) { return Collections.emptyMap(); } final ClassLoader ori = Thread.currentThread().getContextClassLoader(); try { final InternalActivityInstance activityInstance = EnvTool.getAllQueriers().getActivityInstance(activityUUID); final ProcessDefinitionUUID definitionUUID = activityInstance.getProcessDefinitionUUID(); final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(definitionUUID); Thread.currentThread().setContextClassLoader(processClassLoader); final Binding binding = getBinding(definitionUUID, activityInstance.getProcessInstanceUUID(), activityUUID, context, useActivityScope, false, propagate); final Map<String, Object> results = evaluateGroovyExpressions(expressions, binding); propagateVariablesIfNecessary(activityUUID, null, propagate, binding); return results; } catch (final Exception e) { throw new GroovyException("Exception while evaluating expression. ActivityInstanceUUID: " + activityUUID, e); } finally { if (ori != null && ori != Thread.currentThread().getContextClassLoader()) { Thread.currentThread().setContextClassLoader(ori); } } }
final String message = getMessage(activityUUID, instanceUUID, processDefinitionUUID, "The expression is null or empty."); throw new GroovyException(message); } else { final int begin = expression.indexOf(START_DELIMITER); final String message = getMessage(activityUUID, instanceUUID, processDefinitionUUID, "The expression is not a Groovy one: " + expression + "."); throw new GroovyException(message); final String message = getMessage(activityUUID, instanceUUID, processDefinitionUUID, "Exception while evaluating expression."); throw new GroovyException(message, e); } finally { if (ori != null && ori != Thread.currentThread().getContextClassLoader()) {