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; }
for (final Entry<String, Object[]> parameter : parameters.entrySet()) { final String methodName = parameter.getKey(); final Object[] methodParameters = evaluateParametersWithGroovy(binding, parameter.getValue(), connector); final List<Setter> setters = ((Connector) connector).getSetters(); if (setters != null) { setter = getSetter(setters, methodName); if (setter != null) { final Object[] setterParameters = setter.getParameters(); final Class<?> methodParameterClass = methodParameters[i].getClass(); if (methodParameterClass.equals(BigDecimal.class) || methodParameterClass.equals(BigInteger.class)) { methodParameters[i] = convertIfPossible(methodParameters[i].toString(), setterParameterClass.getName()); } else if (methodParameterClass.equals(String.class)) { methodParameters[i] = convertIfPossible(methodParameters[i], setterParameterClass.getName());
public static void executeConnector(final Execution execution, final String activityName, final ConnectorDefinition connector) { executeConnector(execution, activityName, connector, null); }
public static void executeConnectors(final ActivityDefinition activityDef, final Execution execution, final Event event) { executeConnectors(activityDef, execution, event, null); }
ConnectorExecutor.executeConnector(internalExecution, activityId, deadline); ConnectorExecutor.executeConnectors(activity, execution, Event.onEvent, parameters); skip(internalExecution); } else if (EventConstants.CONNECTORS_AUTOMATIC_ON_ENTER_EXECUTED.equals(signal)) { ConnectorExecutor.executeConnectors(activity, execution, Event.automaticOnExit); end(internalExecution);
private Set<String> executeFilter(final String connectorClassName, final Map<String, Object[]> parameters, final Set<String> members, final ProcessDefinitionUUID definitionUUID, final ClassLoader classLoader) throws Exception { FacadeUtil.checkArgsNotNull(members); final ClassLoader baseClassLoader = Thread.currentThread().getContextClassLoader(); try { Filter connector = null; if (classLoader == null) { connector = (Filter) EnvTool.getClassDataLoader().getInstance(definitionUUID, connectorClassName); } else { Thread.currentThread().setContextClassLoader(classLoader); final Class<?> objectClass = Class.forName(connectorClassName, true, classLoader); connector = (Filter) objectClass.newInstance(); } return ConnectorExecutor.executeFilter(connector, parameters, members); } finally { Thread.currentThread().setContextClassLoader(baseClassLoader); } }
private Set<String> executeRoleResolver(final String connectorClassName, final Map<String, Object[]> parameters, final ProcessDefinitionUUID definitionUUID, final ClassLoader classLoader) throws Exception { final ClassLoader baseClassLoader = Thread.currentThread().getContextClassLoader(); try { RoleResolver connector = null; if (classLoader == null) { connector = (RoleResolver) EnvTool.getClassDataLoader().getInstance(definitionUUID, connectorClassName); } else { Thread.currentThread().setContextClassLoader(classLoader); final Class<?> objectClass = Class.forName(connectorClassName, true, classLoader); connector = (RoleResolver) objectClass.newInstance(); } return ConnectorExecutor.executeRoleResolver(connector, parameters); } finally { Thread.currentThread().setContextClassLoader(baseClassLoader); } }
private static Set<String> executeRoleMapper(final TaskInstance task, final Performer performer) { final ProcessDefinitionUUID processUUID = task.getProcessDefinitionUUID(); final RoleMapperDefinition rolemapperDef = performer.getRoleMapperDefinition(); final ClassLoader baseClassLoader = Thread.currentThread().getContextClassLoader(); try { final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); Thread.currentThread().setContextClassLoader(processClassLoader); if (rolemapperDef != null) { final RoleMapper roleMapper = EnvTool.getClassDataLoader().getInstance(RoleMapper.class, processUUID, rolemapperDef); try { return ConnectorExecutor.executeRoleMapper(roleMapper, task, performer.getName(), rolemapperDef.getParameters()); } catch (final Exception e) { throw new BonitaWrapperException(new RoleMapperInvocationException("be_TRT_2", rolemapperDef.toString(), e)); } } return null; } finally { Thread.currentThread().setContextClassLoader(baseClassLoader); } }
private List<Map<String, Object>> getContextsFromMultiInstantiator(final Execution execution, final ActivityDefinition activity, final MultiInstantiationDefinition instantiator) { List<Map<String, Object>> contexts; try { contexts = ConnectorExecutor.executeMultipleInstancesInstantiatior(instantiator, execution.getInstance() .getUUID(), activityName, execution.getIterationId()); if (contexts == null) { final String message = ExceptionManager.getInstance().getFullMessage("be_AA_8", activity.getName()); throw new BonitaRuntimeException(message); } else if (contexts.isEmpty()) { final String message = ExceptionManager.getInstance().getFullMessage("be_AA_9", activity.getName()); throw new BonitaRuntimeException(message); } } catch (final Exception e) { throw new BonitaRuntimeException(e.getMessage(), e); } return contexts; }
execution.getInstance().getProcessDefinitionUUID(), multiDef); try { actInstDescr = ConnectorExecutor.executeMultiInstantiator(execution, activity.getName(), actInstantiator, multiDef.getParameters()); if (actInstDescr == null) {
boolean join = false; try { join = ConnectorExecutor.executeMultipleInstancesJoinChecker(joinChecker, internalExecution .getActivityInstance().getUUID()); } catch (final Exception e) {
@Override public void signal(final Execution execution, final String signal, final Map<String, Object> signalParameters) { if (EventConstants.TIMER.equals(signal)) { Authentication.setUserId(BonitaConstants.SYSTEM_USER); ConnectorExecutor.executeConnectors(execution.getNode(), execution, Event.onTimer); super.signal(execution, BODY_FINISHED, null); } else { super.signal(execution, signal, signalParameters); } }
private static Set<String> executeFilter(final TaskInstance task, final Set<String> candidates, final Performer performer) { final ProcessDefinitionUUID processUUID = task.getProcessDefinitionUUID(); final ClassLoader baseClassLoader = Thread.currentThread().getContextClassLoader(); try { final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader(processUUID); Thread.currentThread().setContextClassLoader(processClassLoader); final FilterDefinition filterDefinition = performer.getFilterDefinition(); if (filterDefinition != null) { final PerformerAssign performerAssign = getPerformerAssign(processUUID, filterDefinition); Filter filter = null; if (performerAssign == null) { filter = EnvTool.getClassDataLoader().getInstance(Filter.class, processUUID, filterDefinition); } else { filter = new PerformerAssignFilter(); } try { return ConnectorExecutor.executeFilter(filter, performerAssign, task, candidates, filterDefinition.getParameters()); } catch (final Exception e) { throw new BonitaWrapperException(e); } } return candidates; } finally { Thread.currentThread().setContextClassLoader(baseClassLoader); } }
throws BonitaException { if (connector instanceof Connector) { final Map<String, Object> values = getGetterValues((Connector) connector); dataTypeClassName = getDataTypeClassName(variableName, instanceUUID, activityInstanceUUID); } catch (final BonitaRuntimeException e) { final ProcessDefinition process = accessor.getQueryDefinitionAPI().getProcess( final QueryRuntimeAPI queryRuntimeAPI = accessor.getQueryRuntimeAPI(); final LightProcessInstance processInstance = queryRuntimeAPI.getLightProcessInstance(instanceUUID); dataTypeClassName = getDataTypeClassName(variableName, processInstance.getParentInstanceUUID(), null); final Object newValue = convertIfPossible(variableValue, dataTypeClassName); if (activityInstanceUUID != null) { runtime.setVariable(activityInstanceUUID, variableName, newValue);
@Override public void signal(final Execution execution, final String signal, final Map<String, Object> signalParameters) { if (EventConstants.MESSAGE.equals(signal)) { Authentication.setUserId(BonitaConstants.SYSTEM_USER); ConnectorExecutor.executeConnectors(execution.getNode(), execution, Event.onEvent, signalParameters); super.signal(execution, BODY_FINISHED, null); } else { super.signal(execution, signal, signalParameters); } }
private Map<String, Object> executeConnectorWithClassLoaderSet(final String connectorClassName, final Map<String, Object[]> parameters, final ProcessDefinitionUUID definitionUUID, final ProcessInstanceUUID instanceUUID, final ActivityInstanceUUID activityInstanceUUID, final ClassLoader classLoader, final Map<String, Object> context, final boolean useCurrentVariableValues, final ClassDataLoader classDataLoader) throws ClassNotFoundException, InstantiationException, IllegalAccessException, Exception { Connector connector = null; if (classDataLoader != null) { connector = (Connector) classDataLoader.getInstance(null, connectorClassName); } else { final Class<?> objectClass = Class.forName(connectorClassName, true, classLoader); connector = (Connector) objectClass.newInstance(); } if (connector instanceof Mapper) { throw new IllegalAccessException(connectorClassName + " is a instance of RoleResolver or Filter"); } return ConnectorExecutor.executeConnector(connector, definitionUUID, instanceUUID, activityInstanceUUID, parameters, context, useCurrentVariableValues); }
ConnectorExecutor.executeConnectors(activityDef, internalExecution, HookDefinition.Event.taskOnResume);
@Override public Map<String, Object> executeConnectorAndGetVariablesToSet(final String connectorClassName, final Map<String, Object[]> parameters, final ProcessDefinitionUUID processDefinitionUUID, final Map<String, Object> context) throws Exception { final Connector connector = (Connector) EnvTool.getClassDataLoader().getInstance(processDefinitionUUID, connectorClassName); if (connector instanceof Mapper) { throw new IllegalAccessException(connectorClassName + " is a instance of RoleResolver or Filter"); } return ConnectorExecutor.executeConnector(connector, parameters, processDefinitionUUID, context); }
public static void ready(final Execution internalExecution) throws TaskNotFoundException { final ActivityInstanceUUID taskUUID = new ActivityInstanceUUID(internalExecution.getActivityInstanceUUID() .toString()); final InternalActivityDefinition activityDef = internalExecution.getNode(); final TaskInstance task = getTask(taskUUID); final String activityName = task.getActivityName(); if (LOG.isLoggable(Level.FINE)) { LOG.fine("Ready task : " + taskUUID + " on activity " + activityName); } // get performer (aka participant/swimlane) final Set<Performer> performers = getPerformers(activityDef); String userId = null; Set<String> candidates = null; if (performers != null) { candidates = getCandidates(performers, task); final Performer performer = performers.iterator().next(); if (performer.getFilterDefinition() != null) { candidates = executeFilter(task, candidates, performer); if (candidates.size() == 1) { userId = candidates.iterator().next(); } } } if (userId != null) { EnvTool.getRecorder().recordTaskReady(taskUUID, null, userId); } else { EnvTool.getRecorder().recordTaskReady(taskUUID, candidates, null); } ConnectorExecutor.executeConnectors(activityDef, internalExecution, HookDefinition.Event.taskOnReady); }
@Override public void executeConnectorAndSetVariables(final String connectorClassName, final Map<String, Object[]> parameters, final ActivityInstance activityInstance, final Map<String, Object> context) throws Exception { final ProcessDefinitionUUID processDefinitionUUID = activityInstance.getProcessDefinitionUUID(); final Connector connector = (Connector) EnvTool.getClassDataLoader().getInstance(processDefinitionUUID, connectorClassName); if (connector instanceof Mapper) { throw new IllegalAccessException(connectorClassName + " is a instance of RoleResolver or Filter"); } ConnectorExecutor.executeConnector(connector, parameters, activityInstance.getProcessInstanceUUID(), activityInstance, context); }