protected void becomeNonScope() { for (MigratingInstance dependentInstance : migratingDependentInstances) { dependentInstance.detachState(); } ExecutionEntity parentExecution = representativeExecution.getParent(); parentExecution.setActivity(representativeExecution.getActivity()); parentExecution.setActivityInstanceId(representativeExecution.getActivityInstanceId()); representativeExecution.remove(); representativeExecution = parentExecution; for (MigratingInstance dependentInstance : migratingDependentInstances) { dependentInstance.attachState(MigratingActivityInstance.this); } instanceBehavior = new MigratingNonScopeActivityInstanceBehavior(); }
@Override public void setVariable(String variableName, Object value) { ExecutionEntity execution = getExecutionFromContext(); if(execution != null) { execution.setVariable(variableName, value); execution.getVariable(variableName); } else { getScopedAssociation().setVariable(variableName, value); } }
protected static ExecutionEntity createNewExecution() { ExecutionEntity newExecution = new ExecutionEntity(); initializeAssociations(newExecution); newExecution.insert(); return newExecution; }
@Override public String getProcessBusinessKey() { return getProcessInstance().getBusinessKey(); }
public void setExecution(PvmExecutionImpl execution) { if (execution!=null) { this.execution = (ExecutionEntity) execution; this.executionId = this.execution.getId(); this.processInstanceId = this.execution.getProcessInstanceId(); this.processDefinitionId = this.execution.getProcessDefinitionId(); // get the process instance ExecutionEntity instance = this.execution.getProcessInstance(); if (instance != null) { // set case instance id on this task this.caseInstanceId = instance.getCaseInstanceId(); } } else { this.execution = null; this.executionId = null; this.processInstanceId = null; this.processDefinitionId = null; this.caseInstanceId = null; } }
ActivityImpl activity = execution.getActivity(); ExecutionEntity scopeExecution = (ExecutionEntity) execution.findExecutionForFlowScope(activity.getFlowScope()); List<EventSubscriptionEntity> eventSubscriptions = execution.getCompensateEventSubscriptions(); ExecutionEntity eventScopeExecution = scopeExecution.createExecution(); eventScopeExecution.setActivity(execution.getActivity()); eventScopeExecution.activityInstanceStarting(); eventScopeExecution.enterActivityInstance(); eventScopeExecution.setActive(false); eventScopeExecution.setConcurrent(false); eventScopeExecution.setEventScope(true); Map<String, Object> variables = execution.getVariablesLocal(); for (Entry<String, Object> variable : variables.entrySet()) { eventScopeExecution.setVariableLocal(variable.getKey(), variable.getValue()); for (PvmExecutionImpl childEventScopeExecution : execution.getEventScopeExecutions()) { childEventScopeExecution.setParent(eventScopeExecution); compensationHandler ); eventSubscription.setConfiguration(eventScopeExecution.getId());
public void testExecutionEntitySerialization() throws Exception { ExecutionEntity execution = new ExecutionEntity(); ActivityImpl activityImpl = new ActivityImpl("test", null); activityImpl.getExecutionListeners().put("start", Collections.<ExecutionListener>singletonList(new TestExecutionListener())); execution.setActivity(activityImpl); ProcessDefinitionImpl processDefinitionImpl = new ProcessDefinitionImpl("test"); processDefinitionImpl.getExecutionListeners().put("start", Collections.<ExecutionListener>singletonList(new TestExecutionListener())); execution.setProcessDefinition(processDefinitionImpl); TransitionImpl transitionImpl = new TransitionImpl("test", new ProcessDefinitionImpl("test")); transitionImpl.addExecutionListener(new TestExecutionListener()); execution.setTransition(transitionImpl); execution.getProcessInstanceStartContext().setInitial(activityImpl); execution.setSuperExecution(new ExecutionEntity()); execution.setActive(true); execution.setCanceled(false); execution.setBusinessKey("myBusinessKey"); execution.setDeleteReason("no reason"); execution.setActivityInstanceId("123"); execution.setScope(false); byte[] data = writeObject(execution); execution = (ExecutionEntity) readObject(data); assertEquals("myBusinessKey", execution.getBusinessKey()); assertEquals("no reason", execution.getDeleteReason()); assertEquals("123", execution.getActivityInstanceId()); }
protected void initProcessInstanceEvent(HistoricProcessInstanceEventEntity evt, ExecutionEntity execution, HistoryEventType eventType) { String processDefinitionId = execution.getProcessDefinitionId(); String processInstanceId = execution.getProcessInstanceId(); String executionId = execution.getId(); // the given execution is the process instance! String caseInstanceId = execution.getCaseInstanceId(); String tenantId = execution.getTenantId(); ProcessDefinitionEntity definition = execution.getProcessDefinition(); String processDefinitionKey = null; if (definition != null) { processDefinitionKey = definition.getKey(); } evt.setId(processInstanceId); evt.setEventType(eventType.getEventName()); evt.setProcessDefinitionKey(processDefinitionKey); evt.setProcessDefinitionId(processDefinitionId); evt.setProcessInstanceId(processInstanceId); evt.setExecutionId(executionId); evt.setBusinessKey(execution.getProcessBusinessKey()); evt.setCaseInstanceId(caseInstanceId); evt.setTenantId(tenantId); evt.setRootProcessInstanceId(execution.getRootProcessInstanceId()); if (execution.getSuperCaseExecution() != null) { evt.setSuperCaseInstanceId(execution.getSuperCaseExecution().getCaseInstanceId()); } if (execution.getSuperExecution() != null) { evt.setSuperProcessInstanceId(execution.getSuperExecution().getProcessInstanceId()); } }
public static ExternalTaskEntity createAndInsert(ExecutionEntity execution, String topic, long priority) { ExternalTaskEntity externalTask = new ExternalTaskEntity(); externalTask.setTopicName(topic); externalTask.setExecutionId(execution.getId()); externalTask.setProcessInstanceId(execution.getProcessInstanceId()); externalTask.setProcessDefinitionId(execution.getProcessDefinitionId()); externalTask.setActivityId(execution.getActivityId()); externalTask.setActivityInstanceId(execution.getActivityInstanceId()); externalTask.setTenantId(execution.getTenantId()); externalTask.setPriority(priority); ProcessDefinitionEntity processDefinition = execution.getProcessDefinition(); externalTask.setProcessDefinitionKey(processDefinition.getKey()); externalTask.insert(); externalTask.produceHistoricExternalTaskCreatedEvent(); return externalTask; }
protected void setReferenceToProcessInstance(HistoricDecisionInstanceEntity event, ExecutionEntity execution) { event.setProcessDefinitionKey(getProcessDefinitionKey(execution)); event.setProcessDefinitionId(execution.getProcessDefinitionId()); event.setRootProcessInstanceId(execution.getRootProcessInstanceId()); event.setProcessInstanceId(execution.getProcessInstanceId()); event.setExecutionId(execution.getId()); event.setActivityId(execution.getActivityId()); event.setActivityInstanceId(execution.getActivityInstanceId()); }
public UserOperationLogContextEntryBuilder inContextOf(ExecutionEntity processInstance, List<PropertyChange> propertyChanges) { if (propertyChanges == null || propertyChanges.isEmpty()) { if (OPERATION_TYPE_CREATE.equals(entry.getOperationType())) { propertyChanges = Arrays.asList(PropertyChange.EMPTY_CHANGE); } } entry.setPropertyChanges(propertyChanges); entry.setRootProcessInstanceId(processInstance.getRootProcessInstanceId()); entry.setProcessInstanceId(processInstance.getProcessInstanceId()); entry.setProcessDefinitionId(processInstance.getProcessDefinitionId()); entry.setExecutionId(processInstance.getId()); entry.setCaseInstanceId(processInstance.getCaseInstanceId()); ResourceDefinitionEntity definition = processInstance.getProcessDefinition(); if (definition != null) { entry.setProcessDefinitionKey(definition.getKey()); entry.setDeploymentId(definition.getDeploymentId()); } return this; }
@Override @SuppressWarnings("unchecked") public void initialize() { LOG.initializeExecution(this); ScopeImpl scope = getScopeActivity(); ensureParentInitialized(); List<VariableDeclaration> variableDeclarations = (List<VariableDeclaration>) scope.getProperty(BpmnParse.PROPERTYNAME_VARIABLE_DECLARATIONS); if (variableDeclarations != null) { for (VariableDeclaration variableDeclaration : variableDeclarations) { variableDeclaration.initialize(this, parent); } } if (isProcessInstanceExecution()) { String initiatorVariableName = (String) processDefinition.getProperty(BpmnParse.PROPERTYNAME_INITIATOR_VARIABLE_NAME); if (initiatorVariableName != null) { String authenticatedUserId = Context.getCommandContext().getAuthenticatedUserId(); setVariable(initiatorVariableName, authenticatedUserId); } } // create event subscriptions for the current scope for (EventSubscriptionDeclaration declaration : EventSubscriptionDeclaration.getDeclarationsForScope(scope).values()) { if(!declaration.isStartEvent()) { declaration.createSubscriptionForExecution(this); } } }
assertEquals(caseInstanceId, processInstance.getCaseInstanceId()); assertEquals(processTaskId, processInstance.getSuperCaseExecutionId()); assertEquals("myOwnBusinessKey", processInstance.getBusinessKey()); assertFalse(businessKey.equals(processInstance.getBusinessKey())); assertProcessEnded(processInstance.getId());
@Test public void testRestoreProcessInstance() { //given parent execution List<ExecutionEntity> entities = new ArrayList<ExecutionEntity>(); ExecutionEntity parent = new ExecutionEntity(); parent.setId("parent"); entities.add(parent); //when restore process instance is called parent.restoreProcessInstance(entities, null, null, null, null, null, null); //then no problem should occure //when child is added and restore is called again ExecutionEntity entity = new ExecutionEntity(); entity.setId("child"); entity.setParentId(parent.getId()); entities.add(entity); parent.restoreProcessInstance(entities, null, null, null, null, null, null); //then again no problem should occure //when parent is deleted from the list entities.remove(parent); //then exception is thrown because child reference to parent which does not exist anymore thrown.expect(ProcessEngineException.class); thrown.expectMessage("Cannot resolve parent with id 'parent' of execution 'child', perhaps it was deleted in the meantime"); parent.restoreProcessInstance(entities, null, null, null, null, null, null); }
@Override public void visit(ExecutionEntity obj) { if (!obj.getEventSubscriptions().isEmpty() && (obj.isInState(ActivityInstanceState.DEFAULT) || (!obj.getActivity().isScope()))) { // state is default or tree is compacted execs.add(obj); } } }).walkUntil();
public Object execute(CommandContext commandContext) { ensureNotNull("executionId", executionId); ensureNotNull("variableName", variableName); ExecutionEntity execution = commandContext .getExecutionManager() .findExecutionById(executionId); ensureNotNull("execution " + executionId + " doesn't exist", "execution", execution); checkGetExecutionVariable(execution, commandContext); Object value; if (isLocal) { value = execution.getVariableLocal(variableName, true); } else { value = execution.getVariable(variableName, true); } return value; }
@Deployment(resources = { "org/camunda/bpm/engine/test/api/cmmn/oneProcessTaskCase.cmmn", "org/camunda/bpm/engine/test/api/oneTaskProcess.bpmn20.xml" }) public void testCallProcessAsConstant() { // given String caseInstanceId = createCaseInstanceByKey(ONE_PROCESS_TASK_CASE).getId(); String processTaskId = queryCaseExecutionByActivityId(PROCESS_TASK).getId(); // then // there exists a process instance ExecutionEntity processInstance = (ExecutionEntity) queryProcessInstance(); assertNotNull(processInstance); // the case instance id is set on called process instance assertEquals(caseInstanceId, processInstance.getCaseInstanceId()); // the super case execution id is equals the processTaskId assertEquals(processTaskId, processInstance.getSuperCaseExecutionId()); TaskEntity task = (TaskEntity) queryTask(); // the case instance id has been also set on the task assertEquals(caseInstanceId, task.getCaseInstanceId()); // the case execution id should be null assertNull(task.getCaseExecutionId()); // complete //////////////////////////////////////////////////////// taskService.complete(task.getId()); assertProcessEnded(processInstance.getId()); close(caseInstanceId); assertCaseEnded(caseInstanceId); }
public EventSubscriptionEntity(ExecutionEntity executionEntity, EventType eventType) { this(eventType); setExecution(executionEntity); setActivity(execution.getActivity()); this.processInstanceId = executionEntity.getProcessInstanceId(); this.tenantId = executionEntity.getTenantId(); }
protected boolean evaluateCondition(ConditionSet conditionSet, ActivityImpl activity) { ExecutionEntity temporaryExecution = new ExecutionEntity(); if (conditionSet.getVariables() != null) { temporaryExecution.initializeVariableStore(conditionSet.getVariables()); } temporaryExecution.setProcessDefinition(activity.getProcessDefinition()); ConditionalEventDefinition conditionalEventDefinition = activity.getProperties().get(BpmnProperties.CONDITIONAL_EVENT_DEFINITION); if (conditionalEventDefinition.getVariableName() == null || conditionSet.getVariables().containsKey(conditionalEventDefinition.getVariableName())) { return conditionalEventDefinition.tryEvaluate(temporaryExecution); } else { return false; } }
public ProcessEngineException processDefinitionOfInstanceDoesNotMatchMigrationPlan(ExecutionEntity processInstance, String processDefinitionId) { return new ProcessEngineException(exceptionMessage( "002", "Process instance '{}' cannot be migrated. Its process definition '{}' does not match the source process definition of the migration plan '{}'", processInstance.getId(), processInstance.getProcessDefinitionId(), processDefinitionId )); }