public LightActivityInstanceImpl(final ActivityInstance src) { super(src); uuid = new ActivityInstanceUUID(src.getUUID()); iterationId = src.getIterationId(); activityInstanceId = src.getActivityInstanceId(); loopId = src.getLoopId(); lastUpdate = Misc.getTime(src.getLastUpdateDate()); startedDate = Misc.getTime(src.getStartedDate()); endedDate = Misc.getTime(src.getEndedDate()); expectedEndDate = Misc.getTime(src.getExpectedEndDate()); readyDate = Misc.getTime(src.getReadyDate()); activityDefinitionUUID = new ActivityDefinitionUUID(src.getActivityDefinitionUUID()); if (src.getSubflowProcessInstanceUUID() != null) { subflowProcessInstanceUUID = new ProcessInstanceUUID(src.getSubflowProcessInstanceUUID()); priority = src.getPriority(); type = src.getType(); name = src.getActivityName(); description = src.getActivityDescription(); label = src.getActivityLabel(); dynamicDescription = src.getDynamicDescription(); dynamicLabel = src.getDynamicLabel(); executionSummary = src.getDynamicExecutionSummary(); if (src.isTask()) { final TaskInstance task = src.getTask(); human = true; startedBy = task.getStartedBy(); state = src.getState();
@SuppressWarnings("unchecked") public ActivityInstanceImpl(final ActivityInstance< ? extends ActivityBody > record) { super(record); this.uuid = new ActivityInstanceUUID(record.getUUID()); this.activityId = record.getActivityId(); this.body = (T) record.getBody().copy(); this.iterationId = record.getIterationId(); this.activityInstanceId = record.getActivityInstanceId(); this.variablesBeforeStarted = record.getVariablesBeforeStarted(); List<VariableUpdate> list = record.getVariableUpdates(); if (list != null && !list.isEmpty()) { this.variableUpdates = new ArrayList<VariableUpdate>(); for (VariableUpdate varUpdate : list) { this.variableUpdates.add(new VariableUpdateImpl(varUpdate)); } } }
public void recordBodyCancelled(final ActivityInstance activityInstance) { if (LOG.isLoggable(this.level)) { LOG.log(this.level, "Activity body cancelled: " + activityInstance.getActivityName() + " (" + activityInstance.getProcessInstanceUUID() + ")"); } }
@Override public ActivityInstance getActivity(final String activityId, final String iterationId, final String activityInstanceId) { if (getActivities() != null) { for (final ActivityInstance activity : getActivities()) { if (activity.getActivityName().equals(activityId) && (activity.getIterationId() == null && iterationId == null || activity.getIterationId().equals( iterationId)) && (activity.getActivityInstanceId() == null && activityInstanceId == null || activity .getActivityInstanceId().equals(activityInstanceId))) { return activity; } } } return null; }
public ActivityInstanceImpl(final ActivityInstance src) { super(src); clientVariables = src.getVariablesBeforeStarted(); final List<VariableUpdate> list = src.getVariableUpdates(); if (list != null && !list.isEmpty()) { variableUpdates = new ArrayList<VariableUpdate>(); for (final VariableUpdate varUpdate : list) { variableUpdates.add(new VariableUpdateImpl(varUpdate)); } } final List<StateUpdate> stateList = src.getStateUpdates(); if (stateList != null && !stateList.isEmpty()) { stateUpdates = new ArrayList<StateUpdate>(); for (final StateUpdate update : stateList) { stateUpdates.add(new StateUpdateImpl(update)); } } if (src.isTask()) { final TaskInstance task = src.getTask(); final List<AssignUpdate> assignList = task.getAssignUpdates(); if (assignList != null && !assignList.isEmpty()) { assignUpdates = new ArrayList<AssignUpdate>(); for (final AssignUpdate update : assignList) { assignUpdates.add(new AssignUpdateImpl(update)); } } candidates = CopyTool.copy(task.getTaskCandidates()); } }
public void recordActivitySkipped(ActivityInstance activityInstance, String loggedInUserId) { if (LOG.isLoggable(this.level)) { LOG.log(this.level, "Activity " + activityInstance.getUUID() + " skipped by " + loggedInUserId + "."); } }
private static void assign(final ActivityInstance task, final java.util.Set<java.lang.String> candidates, final String userId) { final ActivityInstanceUUID taskUUID = task.getUUID(); if (LOG.isLoggable(Level.FINE)) { LOG.fine("assigning task : " + taskUUID + " on activity " + task.getActivityName()); } final Recorder recorder = EnvTool.getRecorder(); recorder.recordTaskAssigned(taskUUID, task.getState(), EnvTool.getUserId(), candidates, userId); }
LOG.fine("Checking compatible state of " + activityInstance); final ActivityInstanceUUID activityInstanceUUID = activityInstance.getUUID(); final ActivityState state = activityInstance.getState(); if (!state.equals(ActivityState.READY) && !state.equals(ActivityState.FAILED)) { final Set<ActivityState> expectedStates = new HashSet<ActivityState>(); if (LOG.isLoggable(Level.SEVERE)) { LOG.severe("Error while setting the variable on skip task : " + activityInstance.getActivityName() + ". Exception: " + Misc.getStackTraceFrom(e)); String activityName = activityInstance.getActivityName(); if (LOG.isLoggable(Level.FINE)) { LOG.fine("Skiping activity : " + activityInstanceUUID + " on activity " + activityName); TransientData.removeTransientData(activityInstanceUUID); Set<InternalActivityInstance> activities = EnvTool.getJournalQueriers().getActivityInstances(activityInstance.getProcessInstanceUUID(), activityName);
public InternalActivityInstance(final ActivityInstance src) { super(src); setVariables(VariableUtil.createVariableMap(src.getProcessDefinitionUUID(), src.getVariablesBeforeStarted())); variableUpdates = null; for (final VariableUpdate varUpdate : src.getVariableUpdates()) { final Serializable value = varUpdate.getValue(); addVariableUpdate(new InternalVariableUpdate(varUpdate.getDate(), varUpdate.getUserId(), varUpdate.getName(), VariableUtil.createVariable(src.getProcessDefinitionUUID(), varUpdate.getName(), value))); } }
protected static Execution getExecution(final ActivityInstance activityInstance) throws ActivityNotFoundException { return EnvTool.getJournalQueriers().getExecutionOnActivity(activityInstance.getProcessInstanceUUID(), activityInstance.getUUID()); }
try { final ClassLoader processClassLoader = EnvTool.getClassDataLoader().getProcessClassLoader( activityInstance.getProcessDefinitionUUID()); Thread.currentThread().setContextClassLoader(processClassLoader); Map<String, Object[]> inputs = new HashMap<String, Object[]>(); ((PerformerAssignFilter) filter).setPerformerAssign(performerAssign); if (parameters != null) { final Binding binding = getBinding(null, null, activityInstance.getUUID(), null, true); setParameters(binding, parameters, performerAssign); inputs = getInputs(parameters); filter.setActivityInstanceUUID(activityInstance.getUUID()); filter.setApiAccessor(new StandardAPIAccessorImpl()); filter.setMembers(candidates); filter.setProcessDefinitionUUID(activityInstance.getProcessDefinitionUUID()); filter.setProcessInstanceUUID(activityInstance.getProcessInstanceUUID()); if (!inputs.isEmpty()) { final Binding binding = getBinding(null, null, activityInstance.getUUID(), null, true); setParameters(binding, inputs, filter);
public static boolean executeMultipleInstancesJoinChecker(final MultiInstantiationDefinition joinChecker, final ActivityInstanceUUID activityUUID) throws Exception { final ActivityInstance activity = EnvTool.getJournalQueriers().getActivityInstance(activityUUID); final ProcessInstanceUUID instanceUUID = activity.getProcessInstanceUUID(); final ProcessDefinitionUUID definitionUUID = activity.getProcessDefinitionUUID(); checker.setActivityName(activity.getActivityName()); checker.setApiAccessor(new StandardAPIAccessorImpl()); checker.setIterationId(activity.getIterationId()); checker.setProcessDefinitionUUID(definitionUUID); checker.setProcessInstanceUUID(instanceUUID); final Map<String, Object[]> temp = ((MultiInstantiatorJoinChecker) checker).getInstantiatorParameters(); if (temp != null) { multiInstantiator.setActivityId(activity.getActivityName()); multiInstantiator.setIterationId(activity.getIterationId()); multiInstantiator.setProcessInstanceUUID(instanceUUID); setParameters(binding, temp, multiInstantiator); final StringBuilder builder = new StringBuilder( "An Exception occurs during join checking of mutliple instances activity: '"); builder.append(activity.getActivityName()).append("' of instance: ").append(instanceUUID).append(" of process: ") .append(definitionUUID).append(".\r\n Exception : ").append(e.getMessage()); throw new BonitaRuntimeException(builder.toString());
parentActivityUUID); final ActivityDefinition parentActivityDefinition = EnvTool.getJournalQueriers().getActivity( parentActivity.getActivityDefinitionUUID()); final String parentEventName = ActivityUtil.getErrorEventName(parentActivityDefinition, errorCode); final Execution parentExecution = EnvTool.getJournal().getExecutionOnActivity( parentActivity.getProcessInstanceUUID(), parentActivity.getUUID()); final int indexOf = parentEventName.indexOf(EventConstants.SEPARATOR); final Job boundaryError = JobBuilder.boundaryErrorJob(parentEventName.substring(0, indexOf),
public void setInstanceState(final InstanceState newState, final String userId) { updateLastUpdateDate(); final InstanceState oldState = getInstanceState(); state = newState; if (getInstanceStateUpdates() == null) { instanceStateUpdates = new ArrayList<InstanceStateUpdate>(); } // add a state update final Date newDate = new Date(); getInstanceStateUpdates().add(new InstanceStateUpdateImpl(newDate, userId, oldState, newState)); if (newState.equals(InstanceState.STARTED)) { startedDate = newDate.getTime(); startedBy = userId; } else { endedDate = newDate.getTime(); endedBy = userId; if (activities != null) { for (final ActivityInstance activity : activities) { if (activity.getEndedDate() == null) { EnvTool.getRecorder().recordBodyAborted(activity); TransientData.removeTransientData(activity.getUUID()); } } } } }
private static boolean evaluateGroovy(final String value, final Execution execution) throws GroovyException { final String groovyExpression = GroovyExpression.START_DELIMITER + value + GroovyExpression.END_DELIMITER; final ProcessInstanceUUID instanceUUID = execution.getInstance().getUUID(); final Querier journal = EnvTool.getJournalQueriers(); final ActivityInstance instance = execution.getActivityInstance(); String loopId = "noLoop"; if (instance != null) { loopId = instance.getLoopId(); } final ActivityInstance activityInstance = journal.getActivityInstance(instanceUUID, execution.getNodeName(), execution.getIterationId(), execution.getActivityInstanceId(), loopId); Object result = null; if (activityInstance != null) { result = GroovyUtil.evaluate(groovyExpression, null, activityInstance.getUUID(), false, false); } else { result = GroovyUtil.evaluate(groovyExpression, null, instanceUUID, false, false); } return ((Boolean) result).booleanValue(); }
throw new ActivityNotFoundException("bai_RAPII_22", activityUUID); final ProcessInstanceUUID instanceUUID = activity.getProcessInstanceUUID(); final String activityId = activity.getActivityName(); activity.getActivityDefinitionUUID()); if (variableId.contains(BonitaConstants.XPATH_VAR_SEPARATOR)) { try { } else { if (!activity.getLastKnownVariableValues().containsKey(targetVariable)) { throw new VariableNotFoundException("bai_RAPII_24", instanceUUID, activityId, targetVariable);
@Override protected boolean executeBusinessLogic(final Execution execution) { final InternalActivityDefinition activityDefinition = execution.getNode(); final ActivityInstance activity = execution.getActivityInstance(); if (activityDefinition.isAsynchronous()) { if (hasConnectorsAutomaticOnEnter(activityDefinition)) { if (!ActivityState.ABORTED.equals(activity.getState())) { final EventService eventService = EnvTool.getEventService(); final String eventName = BonitaConstants.CONNECTOR_AUTOMATIC_ON_ENTER_PREFIX + activity.getUUID(); final Job job = JobBuilder.connectorsAutomaticOnEnterJob(eventName, execution.getInstance() .getRootInstanceUUID(), execution.getEventUUID(), execution.getInstance().getProcessInstanceUUID()); eventService.storeJob(job); } // if it has connector OnEnter the execution must stop return false; } } else { ConnectorExecutor.executeConnectors(activityDefinition, execution, Event.automaticOnEnter); } ConnectorExecutor.executeConnectors(activityDefinition, execution, Event.automaticOnExit); return !ActivityState.ABORTED.equals(activity.getState()); }
public static Binding getPropagateBinding(final Map<String, Object> allVariables, final ProcessDefinitionUUID processUUID, final ProcessInstanceUUID instanceUUID, final ActivityInstanceUUID activityInstanceUUID, final Map<String, Object> context) throws IOException, ClassNotFoundException, GroovyException, InstanceNotFoundException, ActivityNotFoundException { ActivityDefinitionUUID activityUUID = null; if (activityInstanceUUID != null) { final ActivityInstance activityInstance = EnvTool.getAllQueriers().getActivityInstance(activityInstanceUUID); activityUUID = activityInstance.getActivityDefinitionUUID(); } final Set<String> initialVariables = new HashSet<String>(); initialVariables.addAll(allVariables.keySet()); if (context != null) { initialVariables.removeAll(context.keySet()); } return new PropagateBinding(processUUID, activityUUID, instanceUUID, activityInstanceUUID, allVariables, initialVariables); }
@Override public Set<ActivityInstance> getActivities(final String activityId) { final Set<ActivityInstance> matchingActivities = new HashSet<ActivityInstance>(); if (getActivities() != null) { for (final ActivityInstance activity : getActivities()) { if (activity.getActivityName().equals(activityId)) { matchingActivities.add(activity); } } } return matchingActivities; }
public Set<ActivityInstance<ActivityBody>> getActivityInstances(ProcessInstanceUUID instanceUUID, String activityId) throws ActivityNotFoundException { final Set<ActivityInstance<ActivityBody>> result = new HashSet<ActivityInstance<ActivityBody>>(); for (ActivityInstance<ActivityBody> record : EnvTool.getAllQueriers().getActivityInstances(instanceUUID)) { if (record.getActivityId().equals(activityId)) { result.add(new ActivityInstanceImpl<ActivityBody>(record)); } } if (result.isEmpty()) { throw new ActivityNotFoundException(instanceUUID, activityId); } return result; }