public virtual void validate(MigratingTransitionInstance migratingInstance, MigratingProcessInstance migratingProcessInstance, MigratingTransitionInstanceValidationReportImpl instanceReport)
{
ActivityImpl targetActivity = (ActivityImpl)migratingInstance.TargetScope;
if (targetActivity != null && migratingInstance.AsyncAfter)
{
MigratingJobInstance jobInstance = migratingInstance.JobInstance;
AsyncContinuationConfiguration config = (AsyncContinuationConfiguration)jobInstance.JobEntity.JobHandlerConfiguration;
string sourceTransitionId = config.TransitionId;
if (targetActivity.OutgoingTransitions.Count > 1)
{
if (string.ReferenceEquals(sourceTransitionId, null))
{
instanceReport.addFailure("Transition instance is assigned to no sequence flow" + " and target activity has more than one outgoing sequence flow");
}
else
{
TransitionImpl matchingOutgoingTransition = targetActivity.findOutgoingTransition(sourceTransitionId);
if (matchingOutgoingTransition == null)
{
instanceReport.addFailure("Transition instance is assigned to a sequence flow" + " that cannot be matched in the target activity");
}
}
}
}
}
public virtual void handleEvent(EventSubscriptionEntity eventSubscription, object payload, object localPayload, string businessKey, CommandContext commandContext)
{
VariableEvent variableEvent;
if (payload == null || payload is VariableEvent)
{
variableEvent = (VariableEvent)payload;
}
else
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new ProcessEngineException("Payload have to be " + typeof(VariableEvent).FullName + ", to evaluate condition.");
}
ActivityImpl activity = eventSubscription.Activity;
ActivityBehavior activityBehavior = activity.ActivityBehavior;
if (activityBehavior is ConditionalEventBehavior)
{
ConditionalEventBehavior conditionalBehavior = (ConditionalEventBehavior)activityBehavior;
conditionalBehavior.leaveOnSatisfiedCondition(eventSubscription, variableEvent);
}
else
{
throw new ProcessEngineException("Conditional Event has not correct behavior: " + activityBehavior);
}
}
public virtual void testUserTaskParseFailedJobRetryTimeCycleInActivitiNamespace()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("asyncUserTaskFailedJobRetryTimeCycle");
ActivityImpl userTask = findActivity(pi, "task");
checkFoxFailedJobConfig(userTask);
}
public virtual void testAsyncUserTaskButWithoutParseFailedJobRetryTimeCycle()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("asyncUserTaskButWithoutFailedJobRetryTimeCycle");
ActivityImpl userTask = findActivity(pi, "asyncTaskWithoutFailedJobRetryTimeCycle");
checkNotContainingFoxFailedJobConfig(userTask);
}
public virtual void testTimerStartEventWithFailedJobRetryTimeCycle()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("startEventWithFailedJobRetryTimeCycle");
ActivityImpl startEvent = findActivity(pi, "startEventFailedJobRetryTimeCycle");
checkFoxFailedJobConfig(startEvent);
}
public virtual void testIntermediateCatchTimerEventWithFailedJobRetryTimeCycle()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("intermediateTimerEventWithFailedJobRetryTimeCycle");
ActivityImpl timer = findActivity(pi, "timerEventWithFailedJobRetryTimeCycle");
checkFoxFailedJobConfig(timer);
}
public virtual void testTimerBoundaryEventWithoutFailedJobRetryTimeCycle()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("boundaryEventWithoutFailedJobRetryTimeCycle");
ActivityImpl boundaryActivity = findActivity(pi, "boundaryTimerWithoutFailedJobRetryTimeCycle");
checkNotContainingFoxFailedJobConfig(boundaryActivity);
}
public virtual void validate(ValidatingMigrationInstruction instruction, ValidatingMigrationInstructions instructions, MigrationInstructionValidationReportImpl report)
{
ActivityImpl sourceActivity = instruction.SourceActivity;
if (sourceActivity.ActivityBehavior is ConditionalEventBehavior && !instruction.UpdateEventTrigger)
{
report.addFailure(MIGRATION_CONDITIONAL_VALIDATION_ERROR_MSG);
}
}
public virtual void validate(ValidatingMigrationInstruction instruction, ValidatingMigrationInstructions instructions, MigrationInstructionValidationReportImpl report)
{
ActivityImpl sourceActivity = instruction.SourceActivity;
if (instruction.UpdateEventTrigger && !definesPersistentEventTrigger(sourceActivity))
{
report.addFailure("Cannot update event trigger because the activity does not define a persistent event trigger");
}
}
protected internal virtual void checkFoxFailedJobConfig(ActivityImpl activity)
{
assertNotNull(activity);
assertTrue(activity.Properties.contains(FAILED_JOB_CONFIGURATION));
object value = activity.Properties.get(FAILED_JOB_CONFIGURATION).RetryIntervals.get(0);
assertEquals("R5/PT5M", value);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: @Override public void leaveOnSatisfiedCondition(final org.camunda.bpm.engine.impl.persistence.entity.EventSubscriptionEntity eventSubscription, final org.camunda.bpm.engine.impl.core.variable.event.VariableEvent variableEvent)
public virtual void leaveOnSatisfiedCondition(EventSubscriptionEntity eventSubscription, VariableEvent variableEvent)
{
PvmExecutionImpl execution = eventSubscription.Execution;
if (execution != null && !execution.Ended && execution.Scope && conditionalEvent.tryEvaluate(variableEvent, execution))
{
ActivityImpl activity = eventSubscription.Activity;
activity = (ActivityImpl)activity.FlowScope;
execution.executeEventHandlerActivity(activity);
}
}
protected internal virtual ActivityImpl findActivity(ProcessInstance pi, string activityId)
{
ProcessInstanceWithVariablesImpl entity = (ProcessInstanceWithVariablesImpl)pi;
ProcessDefinitionEntity processDefEntity = entity.ExecutionEntity.ProcessDefinition;
assertNotNull(processDefEntity);
ActivityImpl activity = processDefEntity.findActivity(activityId);
assertNotNull(activity);
return(activity);
}
public virtual void visit(ActivityExecution execution)
{
if (isProcessInstanceOfSubprocess(execution))
{
PvmExecutionImpl superExecution = (PvmExecutionImpl)execution.SuperExecution;
ActivityImpl activity = superExecution.getActivity();
SubProcessActivityBehavior subProcessActivityBehavior = (SubProcessActivityBehavior)activity.ActivityBehavior;
subProcessActivityBehavior.passOutputVariables(superExecution, execution);
}
}
protected internal virtual ActivityImpl getFlowScopeActivity(PvmActivity activity)
{
ScopeImpl flowScope = activity.FlowScope;
ActivityImpl flowScopeActivity = null;
if (flowScope.ProcessDefinition != flowScope)
{
flowScopeActivity = (ActivityImpl)flowScope;
}
return(flowScopeActivity);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testMultiInstanceBodyAndInnerActivityWithFailedJobRetryTimeCycle()
public virtual void testMultiInstanceBodyAndInnerActivityWithFailedJobRetryTimeCycle()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("process");
ActivityImpl miBody = findMultiInstanceBody(pi, "task");
checkFoxFailedJobConfig(miBody);
ActivityImpl innerActivity = findActivity(pi, "task");
checkFoxFailedJobConfig(innerActivity);
}
public virtual void validate(MigratingEventScopeInstance migratingInstance, MigratingProcessInstance migratingProcessInstance, MigratingActivityInstanceValidationReportImpl ancestorInstanceReport)
{
MigratingCompensationEventSubscriptionInstance eventSubscription = migratingInstance.EventSubscription;
ActivityImpl eventHandlerActivity = (ActivityImpl)eventSubscription.SourceScope;
// note: compensation event scopes without children are already handled by NoUnmappedLeafInstanceValidator
if (eventHandlerActivity.TriggeredByEvent && eventSubscription.TargetScope == null && migratingInstance.Children.Count > 0)
{
ancestorInstanceReport.addFailure("Cannot migrate subscription for compensation handler '" + eventSubscription.SourceScope.Id + "'. " + "There is no migration instruction for the compensation start event");
}
}
public virtual void validate(MigratingTransitionInstance migratingInstance, MigratingProcessInstance migratingProcessInstance, MigratingTransitionInstanceValidationReportImpl instanceReport)
{
ActivityImpl targetActivity = (ActivityImpl)migratingInstance.TargetScope;
if (targetActivity != null)
{
if (isProcessStartJob(migratingInstance.JobInstance.JobEntity) && !isTopLevelActivity(targetActivity))
{
instanceReport.addFailure("A transition instance that instantiates the process can only be migrated to a process-level flow node");
}
}
}
public static bool definesPersistentEventTrigger(ActivityImpl activity)
{
ScopeImpl eventScope = activity.EventScope;
if (eventScope != null)
{
return(TimerDeclarationImpl.getDeclarationsForScope(eventScope).ContainsKey(activity.Id) || EventSubscriptionDeclaration.getDeclarationsForScope(eventScope).ContainsKey(activity.Id));
}
else
{
return(false);
}
}
public virtual void validate(MigratingActivityInstance migratingInstance, MigratingProcessInstance migratingProcessInstance, MigratingActivityInstanceValidationReportImpl instanceReport)
{
ScopeImpl sourceScope = migratingInstance.SourceScope;
if (sourceScope != sourceScope.ProcessDefinition)
{
ActivityImpl sourceActivity = (ActivityImpl)migratingInstance.SourceScope;
if (!SupportedActivityValidator.INSTANCE.isSupportedActivity(sourceActivity))
{
instanceReport.addFailure("The type of the source activity is not supported for activity instance migration");
}
}
}
public virtual void execute(TimerJobConfiguration configuration, ExecutionEntity execution, CommandContext commandContext, string tenantId)
{
string activityId = configuration.TimerElementKey;
ActivityImpl eventSubprocessActivity = execution.getProcessDefinition().findActivity(activityId);
if (eventSubprocessActivity != null)
{
execution.executeEventHandlerActivity(eventSubprocessActivity);
}
else
{
throw new ProcessEngineException("Error while triggering event subprocess using timer start event: cannot find activity with id '" + configuration + "'.");
}
}
public virtual void validate(ValidatingMigrationInstruction instruction, ValidatingMigrationInstructions instructions, MigrationInstructionValidationReportImpl report)
{
ActivityImpl sourceActivity = instruction.SourceActivity;
if (isMultiInstance(sourceActivity))
{
ActivityImpl innerActivity = getInnerActivity(sourceActivity);
if (instructions.getInstructionsBySourceScope(innerActivity).Count == 0)
{
report.addFailure("Cannot remove the inner activity of a multi-instance body when the body is mapped");
}
}
}
public virtual void validate(ValidatingMigrationInstruction instruction, ValidatingMigrationInstructions instructions, MigrationInstructionValidationReportImpl report)
{
ActivityImpl targetActivity = instruction.TargetActivity;
if (isMultiInstance(targetActivity))
{
ActivityImpl innerActivity = getInnerActivity(targetActivity);
if (instructions.getInstructionsByTargetScope(innerActivity).Count == 0)
{
report.addFailure("Must map the inner activity of a multi-instance body when the body is mapped");
}
}
}
public virtual void onParseMigratingInstance(MigratingInstanceParseContext parseContext, MigratingActivityInstance migratingInstance)
{
ActivityImpl callActivity = (ActivityImpl)migratingInstance.SourceScope;
// A call activity is typically scope and since we guarantee stability of scope executions during migration,
// the superExecution link does not have to be maintained during migration.
// There are some exceptions, though: A multi-instance call activity is not scope and therefore
// does not have a dedicated scope execution. In this case, the link to the super execution
// must be maintained throughout migration
if (!callActivity.Scope)
{
ExecutionEntity callActivityExecution = migratingInstance.resolveRepresentativeExecution();
ExecutionEntity calledProcessInstance = callActivityExecution.getSubProcessInstance();
migratingInstance.addMigratingDependentInstance(new MigratingCalledProcessInstance(calledProcessInstance));
}
}
public virtual void validate(ValidatingMigrationInstruction instruction, ValidatingMigrationInstructions instructions, MigrationInstructionValidationReportImpl report)
{
ActivityImpl sourceActivity = instruction.SourceActivity;
ActivityImpl targetActivity = instruction.TargetActivity;
if (isEvent(sourceActivity) && isEvent(targetActivity))
{
string sourceType = sourceActivity.Properties.get(BpmnProperties.TYPE);
string targetType = targetActivity.Properties.get(BpmnProperties.TYPE);
if (!sourceType.Equals(targetType))
{
report.addFailure("Events are not of the same type (" + sourceType + " != " + targetType + ")");
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testAlterActivityBehaviors() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void testAlterActivityBehaviors()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskWithIntermediateThrowEvent-modified");
ProcessDefinitionImpl processDefinition = ((ProcessInstanceWithVariablesImpl)processInstance).ExecutionEntity.ProcessDefinition;
ActivityImpl cancelThrowEvent = processDefinition.findActivity("CancelthrowEvent");
assertTrue(cancelThrowEvent.ActivityBehavior is TestBPMNParseListener.TestCompensationEventActivityBehavior);
ActivityImpl startEvent = processDefinition.findActivity("theStart");
assertTrue(startEvent.ActivityBehavior is TestBPMNParseListener.TestNoneStartEventActivityBehavior);
ActivityImpl endEvent = processDefinition.findActivity("theEnd");
assertTrue(endEvent.ActivityBehavior is TestBPMNParseListener.TestNoneEndEventActivityBehavior);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: @Override public void validate(ValidatingMigrationInstruction instruction, final ValidatingMigrationInstructions instructions, MigrationInstructionValidationReportImpl report)
public virtual void validate(ValidatingMigrationInstruction instruction, ValidatingMigrationInstructions instructions, MigrationInstructionValidationReportImpl report)
{
ActivityImpl targetActivity = instruction.TargetActivity;
FlowScopeWalker flowScopeWalker = new FlowScopeWalker(targetActivity.FlowScope);
MiBodyCollector miBodyCollector = new MiBodyCollector();
flowScopeWalker.addPreVisitor(miBodyCollector);
// walk until a target scope is found that is mapped
flowScopeWalker.walkWhile(new WalkConditionAnonymousInnerClass(this, instructions));
if (miBodyCollector.firstMiBody != null)
{
report.addFailure("Target activity '" + targetActivity.Id + "' is a descendant of multi-instance body '" + miBodyCollector.firstMiBody.Id + "' that is not mapped from the source process definition.");
}
}
protected internal virtual ProcessInstance instantiateProcess(CommandContext commandContext, CorrelationHandlerResult correlationResult)
{
ProcessDefinitionEntity processDefinitionEntity = correlationResult.ProcessDefinitionEntity;
ActivityImpl messageStartEvent = processDefinitionEntity.findActivity(correlationResult.StartEventActivityId);
ExecutionEntity processInstance = processDefinitionEntity.createProcessInstance(builder.BusinessKey, messageStartEvent);
if (variablesEnabled)
{
variablesListener = new ExecutionVariableSnapshotObserver(processInstance, false, deserializeVariableValues);
}
processInstance.VariablesLocal = builder.PayloadProcessInstanceVariablesLocal;
processInstance.start(builder.PayloadProcessInstanceVariables);
return(processInstance);
}
protected internal override ScopeImpl getScope(PvmExecutionImpl execution)
{
ActivityImpl activity = execution.getActivity();
if (activity != null)
{
return(activity);
}
else
{
PvmExecutionImpl parent = execution.Parent;
if (parent != null)
{
return(getScope(execution.Parent));
}
return(execution.ProcessDefinition);
}
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: @Override public void leaveOnSatisfiedCondition(final org.camunda.bpm.engine.impl.persistence.entity.EventSubscriptionEntity eventSubscription, final org.camunda.bpm.engine.impl.core.variable.event.VariableEvent variableEvent)
public virtual void leaveOnSatisfiedCondition(EventSubscriptionEntity eventSubscription, VariableEvent variableEvent)
{
PvmExecutionImpl execution = eventSubscription.Execution;
if (execution != null && !execution.Ended && variableEvent != null && conditionalEvent.tryEvaluate(variableEvent, execution) && execution.Active && execution.Scope)
{
if (isAfterEventBasedGateway)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.pvm.process.ActivityImpl activity = eventSubscription.getActivity();
ActivityImpl activity = eventSubscription.Activity;
execution.executeEventHandlerActivity(activity);
}
else
{
leave(execution);
}
}
}
public static void handleChildRemovalInScope(ExecutionEntity removedExecution)
{
ActivityImpl activity = removedExecution.getActivity();
if (activity == null)
{
if (removedExecution.getSuperExecution() != null)
{
removedExecution = removedExecution.getSuperExecution();
activity = removedExecution.getActivity();
if (activity == null)
{
return;
}
}
else
{
return;
}
}
ScopeImpl flowScope = activity.FlowScope;
PvmExecutionImpl scopeExecution = removedExecution.getParentScopeExecution(false);
PvmExecutionImpl executionInParentScope = removedExecution.Concurrent ? removedExecution : removedExecution.Parent;
if (flowScope.ActivityBehavior != null && flowScope.ActivityBehavior is ModificationObserverBehavior)
{
// let child removal be handled by the scope itself
ModificationObserverBehavior behavior = (ModificationObserverBehavior)flowScope.ActivityBehavior;
behavior.destroyInnerInstance(executionInParentScope);
}
else
{
if (executionInParentScope.Concurrent)
{
executionInParentScope.remove();
scopeExecution.tryPruneLastConcurrentChild();
scopeExecution.forceUpdate();
}
}
}
