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(); } } }