/// <summary>
/// Adds an activity to the routing slip specifying activity arguments a dictionary
/// </summary>
/// <param name="name">The activity name</param>
/// <param name="executeAddress">The execution address of the activity</param>
/// <param name="arguments">A dictionary of name/values matching the activity argument properties</param>
public void AddActivity(string name, Uri executeAddress, IDictionary <string, object> arguments)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (executeAddress == null)
{
throw new ArgumentNullException(nameof(executeAddress));
}
if (arguments == null)
{
throw new ArgumentNullException(nameof(arguments));
}
Activity activity = new ActivityImpl(name, executeAddress, arguments);
_itinerary.Add(activity);
}
public virtual void TestExecutionEntitySerialization()
{
var execution = new ExecutionEntity();
var activityImpl = new ActivityImpl("test", null);
activityImpl.ExecutionListeners.Add("start", new List <IDelegateListener <IBaseDelegateExecution> > {
new TestExecutionListener()
});
execution.Activity = activityImpl;
var processDefinitionImpl = new ProcessDefinitionImpl("test");
processDefinitionImpl.ExecutionListeners.Add("start",
new List <IDelegateListener <IBaseDelegateExecution> > {
new TestExecutionListener()
});
execution.ProcessDefinition = processDefinitionImpl;
var transitionImpl = new TransitionImpl("test", new ProcessDefinitionImpl("test"));
transitionImpl.AddExecutionListener(new TestExecutionListener());
execution.Transition = (transitionImpl);
execution.ProcessInstanceStartContext.Initial = activityImpl;
execution.SuperExecution = (new ExecutionEntity());
execution.IsActive = true;
execution.Canceled = false;
execution.BusinessKey = "myBusinessKey";
execution.DeleteReason = "no reason";
execution.ActivityInstanceId = "123";
execution.IsScope = false;
var data = WriteObject(execution);
execution = (ExecutionEntity)ReadObject(data);
Assert.AreEqual("myBusinessKey", execution.BusinessKey);
Assert.AreEqual("no reason", execution.DeleteReason);
Assert.AreEqual("123", execution.ActivityInstanceId);
}
protected internal virtual void updateAsyncAfterTargetConfiguration(AsyncContinuationConfiguration currentConfiguration)
{
ActivityImpl targetActivity = (ActivityImpl)targetScope;
IList <PvmTransition> outgoingTransitions = targetActivity.OutgoingTransitions;
AsyncContinuationConfiguration targetConfiguration = new AsyncContinuationConfiguration();
if (outgoingTransitions.Count == 0)
{
targetConfiguration.AtomicOperation = org.camunda.bpm.engine.impl.pvm.runtime.operation.PvmAtomicOperation_Fields.ACTIVITY_END.CanonicalName;
}
else
{
targetConfiguration.AtomicOperation = org.camunda.bpm.engine.impl.pvm.runtime.operation.PvmAtomicOperation_Fields.TRANSITION_NOTIFY_LISTENER_TAKE.CanonicalName;
if (outgoingTransitions.Count == 1)
{
targetConfiguration.TransitionId = outgoingTransitions[0].Id;
}
else
{
TransitionImpl matchingTargetTransition = null;
string currentTransitionId = currentConfiguration.TransitionId;
if (!string.ReferenceEquals(currentTransitionId, null))
{
matchingTargetTransition = targetActivity.findOutgoingTransition(currentTransitionId);
}
if (matchingTargetTransition != null)
{
targetConfiguration.TransitionId = matchingTargetTransition.Id;
}
else
{
// should not happen since it is avoided by validation
throw new ProcessEngineException("Cannot determine matching outgoing sequence flow");
}
}
}
jobEntity.JobHandlerConfiguration = targetConfiguration;
}
protected internal virtual MigratingProcessElementInstance createMigratingEventSubscriptionInstance(MigratingInstanceParseContext parseContext, EventSubscriptionEntity element)
{
ActivityImpl compensationHandler = parseContext.SourceProcessDefinition.findActivity(element.ActivityId);
MigrationInstruction migrationInstruction = getMigrationInstruction(parseContext, compensationHandler);
ActivityImpl targetScope = null;
if (migrationInstruction != null)
{
ActivityImpl targetEventScope = (ActivityImpl)parseContext.getTargetActivity(migrationInstruction).EventScope;
targetScope = targetEventScope.findCompensationHandler();
}
MigratingCompensationEventSubscriptionInstance migratingCompensationInstance = parseContext.MigratingProcessInstance.addCompensationSubscriptionInstance(migrationInstruction, element, compensationHandler, targetScope);
parseContext.consume(element);
return(migratingCompensationInstance);
}
public virtual void execute(TimerJobConfiguration configuration, ExecutionEntity execution, CommandContext commandContext, string tenantId)
{
string activityId = configuration.TimerElementKey;
ActivityImpl activity = execution.getProcessDefinition().findActivity(activityId);
ensureNotNull("Error while firing timer: boundary event activity " + configuration + " not found", "boundary event activity", activity);
try
{
execution.executeEventHandlerActivity(activity);
}
catch (Exception e)
{
throw e;
}
catch (Exception e)
{
throw new ProcessEngineException("exception during timer execution: " + e.Message, e);
}
}
protected internal virtual MigratingProcessElementInstance CreateMigratingEventScopeInstance(
MigratingInstanceParseContext parseContext, EventSubscriptionEntity element)
{
var compensatingActivity =
(ActivityImpl)parseContext.SourceProcessDefinition.FindActivity(element.ActivityId);
var migrationInstruction = GetMigrationInstruction(parseContext, compensatingActivity);
ActivityImpl eventSubscriptionTargetScope = null;
if (migrationInstruction != null)
{
if (compensatingActivity.CompensationHandler)
{
var targetEventScope =
(ActivityImpl)parseContext.GetTargetActivity(migrationInstruction).EventScope;
eventSubscriptionTargetScope = targetEventScope.findCompensationHandler();
}
else
{
eventSubscriptionTargetScope = parseContext.GetTargetActivity(migrationInstruction);
}
}
var eventScopeExecution = CompensationUtil.GetCompensatingExecution(element);
var eventScopeInstruction = parseContext.FindSingleMigrationInstruction(eventScopeExecution.ActivityId);
var targetScope = parseContext.GetTargetActivity(eventScopeInstruction);
//var migratingCompensationInstance =
// parseContext.MigratingProcessInstance.addEventScopeInstance(eventScopeInstruction, eventScopeExecution,
// eventScopeExecution.getActivity(), targetScope, migrationInstruction, element, compensatingActivity,
// eventSubscriptionTargetScope);
//parseContext.consume(element);
//parseContext.submit(migratingCompensationInstance);
//parseDependentEntities(parseContext, migratingCompensationInstance);
//return migratingCompensationInstance;
return(null);
}
protected internal virtual void handleStartEvent(EventSubscriptionEntity eventSubscription,IDictionary <string,object> payload,string businessKey,CommandContext commandContext)
{
string processDefinitionId = eventSubscription.Configuration;
ensureNotNull("Configuration of signal start event subscription '" + eventSubscription.Id + "' contains no process definition id.",processDefinitionId);
DeploymentCache deploymentCache = Context.ProcessEngineConfiguration.DeploymentCache;
ProcessDefinitionEntity processDefinition = deploymentCache.findDeployedProcessDefinitionById(processDefinitionId);
if (processDefinition == null || processDefinition.Suspended)
{
// ignore event subscription
LOG.debugIgnoringEventSubscription(eventSubscription,processDefinitionId);
}
else
{
ActivityImpl signalStartEvent = processDefinition.findActivity(eventSubscription.ActivityId);
PvmProcessInstance processInstance = processDefinition.createProcessInstance(businessKey,signalStartEvent);
processInstance.start(payload);
}
}
protected internal virtual bool evaluateCondition(ConditionSet conditionSet, ActivityImpl activity)
{
ExecutionEntity temporaryExecution = new ExecutionEntity();
if (conditionSet.Variables != null)
{
temporaryExecution.initializeVariableStore(conditionSet.Variables);
}
temporaryExecution.setProcessDefinition(activity.ProcessDefinition);
ConditionalEventDefinition conditionalEventDefinition = activity.Properties.get(BpmnProperties.CONDITIONAL_EVENT_DEFINITION);
if (string.ReferenceEquals(conditionalEventDefinition.VariableName, null) || conditionSet.Variables.containsKey(conditionalEventDefinition.VariableName))
{
return(conditionalEventDefinition.tryEvaluate(temporaryExecution));
}
else
{
return(false);
}
}
private static string GetSubscriptionActivityId(IActivityExecution execution, string activityRef)
{
ActivityImpl activityToCompensate = (ActivityImpl)((ExecutionEntity)execution).GetProcessDefinition().FindActivity(activityRef);
if (activityToCompensate.MultiInstance)
{
ActivityImpl flowScope = (ActivityImpl)activityToCompensate.FlowScope;
return(flowScope.ActivityId);
}
else
{
ActivityImpl compensationHandler = activityToCompensate.findCompensationHandler();
if (compensationHandler != null)
{
return(compensationHandler.ActivityId);
}
else
{
// if activityRef = subprocess and subprocess has no compensation handler
return(activityRef);
}
}
}
public Void callback(PvmExecutionImpl execution)
{
ActivityBehavior activityBehavior = getActivityBehavior(execution);
ActivityImpl activity = execution.getActivity();
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
LOG.debugExecutesActivity(execution, activity, activityBehavior.GetType().FullName);
try
{
activityBehavior.execute(execution);
}
catch (Exception e)
{
throw e;
}
catch (Exception e)
{
throw new PvmException("couldn't execute activity <" + activity.getProperty("type") + " id=\"" + activity.Id + "\" ...>: " + e.Message, e);
}
return(null);
}
protected internal virtual void parseActivity(Element element, ActivityImpl activity)
{
if (isMultiInstance(activity))
{
// in case of multi-instance, the extension elements is set according to the async attributes
// the extension for multi-instance body is set on the element of the activity
ActivityImpl miBody = activity.ParentFlowScopeActivity;
if (isAsync(miBody))
{
setFailedJobRetryTimeCycleValue(element, miBody);
}
// the extension for inner activity is set on the multiInstanceLoopCharacteristics element
if (isAsync(activity))
{
Element multiInstanceLoopCharacteristics = element.element(MULTI_INSTANCE_LOOP_CHARACTERISTICS);
setFailedJobRetryTimeCycleValue(multiInstanceLoopCharacteristics, activity);
}
}
else if (isAsync(activity))
{
setFailedJobRetryTimeCycleValue(element, activity);
}
}
protected internal virtual void ParseActivity(Element element, ActivityImpl activity)
{
if (IsMultiInstance(activity))
{
// in case of multi-instance, the extension elements is set according to the async attributes
// the extension for multi-instance body is set on the element of the activity
var miBody = activity.ParentFlowScopeActivity;
if (IsAsync(miBody))
{
SetFailedJobRetryTimeCycleValue(element, miBody);
}
// the extension for inner activity is set on the multiInstanceLoopCharacteristics element
if (IsAsync(activity))
{
var multiInstanceLoopCharacteristics = element.element(MultiInstanceLoopCharacteristics);
SetFailedJobRetryTimeCycleValue(multiInstanceLoopCharacteristics, activity);
}
}
else if (IsAsync(activity))
{
SetFailedJobRetryTimeCycleValue(element, activity);
}
}
public void StopSessionActivity(int id)
{
WsUserModel usu = GetCurUser();
if (usu != null)
{
IActivityDAL dalAct = new ActivityImpl();
bool res = dalAct.StopTime(id, usu.user.idUser);
if (res)
{
if (usu.thread != null)
{
try {
usu.thread.Abort();
usu.thread = null;
Clients.AllExcept(GetExcepts(usu)).UpdateTime(new { stop = true });
} catch (Exception e) {
}
}
usu.idActivityAssistance = -5;
Clients.AllExcept(GetExcepts(usu)).StopCurActivitie(res);
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testExecutionEntitySerialization() throws Exception
public virtual void testExecutionEntitySerialization()
{
ExecutionEntity execution = new ExecutionEntity();
ActivityImpl activityImpl = new ActivityImpl("test", null);
activityImpl.ExecutionListeners["start"] = Collections.singletonList <ExecutionListener>(new TestExecutionListener());
execution.setActivity(activityImpl);
ProcessDefinitionImpl processDefinitionImpl = new ProcessDefinitionImpl("test");
processDefinitionImpl.ExecutionListeners["start"] = Collections.singletonList <ExecutionListener>(new TestExecutionListener());
execution.setProcessDefinition(processDefinitionImpl);
TransitionImpl transitionImpl = new TransitionImpl("test", new ProcessDefinitionImpl("test"));
transitionImpl.addExecutionListener(new TestExecutionListener());
execution.Transition = transitionImpl;
execution.ProcessInstanceStartContext.Initial = activityImpl;
execution.setSuperExecution(new ExecutionEntity());
execution.Active = true;
execution.Canceled = false;
execution.BusinessKey = "myBusinessKey";
execution.DeleteReason = "no reason";
execution.ActivityInstanceId = "123";
execution.Scope = false;
sbyte[] data = writeObject(execution);
execution = (ExecutionEntity)readObject(data);
assertEquals("myBusinessKey", execution.BusinessKey);
assertEquals("no reason", execution.DeleteReason);
assertEquals("123", execution.ActivityInstanceId);
}
public override void Execute(IJobHandlerConfiguration _configuration, ExecutionEntity execution,
CommandContext commandContext, string tenantId)
{
TimerJobConfiguration configuration = _configuration as TimerJobConfiguration;
var activityId = configuration.TimerElementKey;
ActivityImpl intermediateEventActivity = execution.GetProcessDefinition().FindActivity(activityId) as ActivityImpl;
EnsureUtil.EnsureNotNull(
"Error while firing timer: intermediate event activity " + configuration + " not found",
"intermediateEventActivity", intermediateEventActivity);
try
{
if (activityId.Equals(execution.ActivityId))
{
// Regular Intermediate timer catch
execution.Signal("signal", null);
}
}
catch (System.Exception e)
{
throw new ProcessEngineException("exception during timer execution: " + e.Message, e);
}
}
public virtual void handle(MigratingInstanceParseContext parseContext, MigratingActivityInstance owningInstance, IList <EventSubscriptionEntity> elements)
{
IDictionary <string, EventSubscriptionDeclaration> targetDeclarations = getDeclarationsByTriggeringActivity(owningInstance.TargetScope);
foreach (EventSubscriptionEntity eventSubscription in elements)
{
if (!SupportedEventTypes.Contains(eventSubscription.EventType))
{
// ignore unsupported event subscriptions
continue;
}
MigrationInstruction migrationInstruction = parseContext.findSingleMigrationInstruction(eventSubscription.ActivityId);
ActivityImpl targetActivity = parseContext.getTargetActivity(migrationInstruction);
if (targetActivity != null && owningInstance.migratesTo(targetActivity.EventScope))
{
// the event subscription is migrated
EventSubscriptionDeclaration targetDeclaration = targetDeclarations.Remove(targetActivity.Id);
owningInstance.addMigratingDependentInstance(new MigratingEventSubscriptionInstance(eventSubscription, targetActivity, migrationInstruction.UpdateEventTrigger, targetDeclaration));
}
else
{
// the event subscription will be removed
owningInstance.addRemovingDependentInstance(new MigratingEventSubscriptionInstance(eventSubscription));
}
parseContext.consume(eventSubscription);
}
if (owningInstance.migrates())
{
addEmergingEventSubscriptions(owningInstance, targetDeclarations);
}
}
public override void Execute(IJobHandlerConfiguration _configuration, ExecutionEntity execution,
CommandContext commandContext, string tenantId)
{
TimerJobConfiguration configuration = _configuration as TimerJobConfiguration;
var activityId = configuration.TimerElementKey;
ActivityImpl activity = execution.GetProcessDefinition().FindActivity(activityId) as ActivityImpl;
EnsureUtil.EnsureNotNull(
"Error while firing timer: boundary event activity " + configuration + " not found",
"boundary event activity", activity);
try
{
execution.ExecuteEventHandlerActivity(activity);
}
//catch (Exception e)
//{
// throw e;
//}
catch (System.Exception e)
{
throw new ProcessEngineException("exception during timer execution: " + e.Message, e);
}
}
public virtual bool isSupportedEventType(ActivityImpl activity)
{
return(supportedTypes.Contains(activity.Properties.get(BpmnProperties.TYPE)));
}
protected internal static bool isMultiInstanceInCompensation(ActivityImpl activity, PvmExecutionImpl scopeExecutionCandidate)
{
return(activity.ActivityBehavior is MultiInstanceActivityBehavior && ((scopeExecutionCandidate != null && findCompensationThrowingAncestorExecution(scopeExecutionCandidate) != null) || scopeExecutionCandidate == null));
}
public virtual bool valid(ActivityImpl activity)
{
return(activity != null && (!isPassivelyWaitingEvent(activity) || isSupportedEventType(activity)));
}
public virtual bool isPassivelyWaitingEvent(ActivityImpl activity)
{
return(activity.ActivityBehavior is BoundaryEventActivityBehavior || activity.ActivityBehavior is EventSubProcessStartEventActivityBehavior);
}
public void AddActivity(string name, Uri executeAddress, IDictionary<string, string> arguments)
{
Activity activity = new ActivityImpl(name, executeAddress, arguments);
_itinerary.Add(activity);
}
public ConditionalEventDefinition(Condition condition, ActivityImpl conditionalActivity) : base(null, EventType.CONDITONAL)
{
this.activityId = conditionalActivity.ActivityId;
this.conditionalActivity = conditionalActivity;
this.condition = condition;
}
public void AddActivity(string name, Uri executeAddress)
{
Activity activity = new ActivityImpl(name, executeAddress, _noArguments);
_itinerary.Add(activity);
}
public virtual bool isSupportedActivity(ActivityImpl activity)
{
return(SUPPORTED_ACTIVITY_BEHAVIORS.Contains(activity.ActivityBehavior.GetType()));
}
protected internal virtual bool IsTopLevelActivity(ActivityImpl activity)
{
return(activity.FlowScope == activity.ProcessDefinition);
}
public override void ParseServiceTask(Element serviceTaskElement, ScopeImpl scope, ActivityImpl activity)
{
activity.AsyncBefore = false;
}
protected internal virtual bool isReachable(PvmActivity srcActivity, PvmActivity targetActivity, ISet <PvmActivity> visitedActivities)
{
if (srcActivity.Equals(targetActivity))
{
return(true);
}
if (visitedActivities.Contains(srcActivity))
{
return(false);
}
// To avoid infinite looping, we must capture every node we visit and
// check before going further in the graph if we have already visited the node.
visitedActivities.Add(srcActivity);
IList <PvmTransition> outgoingTransitions = srcActivity.OutgoingTransitions;
if (outgoingTransitions.Count == 0)
{
if (srcActivity.ActivityBehavior is EventBasedGatewayActivityBehavior)
{
ActivityImpl eventBasedGateway = (ActivityImpl)srcActivity;
ISet <ActivityImpl> eventActivities = eventBasedGateway.EventActivities;
foreach (ActivityImpl eventActivity in eventActivities)
{
bool isReachable = isReachable(eventActivity, targetActivity, visitedActivities);
if (isReachable)
{
return(true);
}
}
}
else
{
ScopeImpl flowScope = srcActivity.FlowScope;
if (flowScope != null && flowScope is PvmActivity)
{
return(isReachable((PvmActivity)flowScope, targetActivity, visitedActivities));
}
}
return(false);
}
else
{
foreach (PvmTransition pvmTransition in outgoingTransitions)
{
PvmActivity destinationActivity = pvmTransition.Destination;
if (destinationActivity != null && !visitedActivities.Contains(destinationActivity))
{
bool reachable = isReachable(destinationActivity, targetActivity, visitedActivities);
// If false, we should investigate other paths, and not yet return the result
if (reachable)
{
return(true);
}
}
}
}
return(false);
}
protected internal virtual ActivityImpl GetInnerActivity(ActivityImpl multiInstanceBody)
{
var activityBehavior = (MultiInstanceActivityBehavior)multiInstanceBody.ActivityBehavior;
return(activityBehavior.GetInnerActivity(multiInstanceBody));
}
protected internal virtual bool isAsync(ActivityImpl activity)
{
return(activity.AsyncBefore || activity.AsyncAfter);
}
/// <summary>
/// Adds an activity to the routing slip specifying activity arguments a dictionary
/// </summary>
/// <param name="name">The activity name</param>
/// <param name="executeAddress">The execution address of the activity</param>
/// <param name="arguments">A dictionary of name/values matching the activity argument properties</param>
public void AddActivity(string name, Uri executeAddress, IDictionary<string, object> arguments)
{
if (name == null)
throw new ArgumentNullException(nameof(name));
if (executeAddress == null)
throw new ArgumentNullException(nameof(executeAddress));
if (arguments == null)
throw new ArgumentNullException(nameof(arguments));
Activity activity = new ActivityImpl(name, executeAddress, arguments);
_itinerary.Add(activity);
}
public void AddActivity(string name, Uri executeAddress, object arguments)
{
Activity activity = new ActivityImpl(name, executeAddress, GetObjectAsDictionary(arguments));
_itinerary.Add(activity);
}
public virtual bool valid(ActivityImpl activity)
{
return(activity != null && (isSupportedActivity(activity) || isAsync(activity)));
}
/// <seealso cref= #signalCancelBoundaryEvent(String) </seealso>
public static void parseCancelBoundaryEvent(ActivityImpl activity)
{
activity.setProperty(BpmnParse.PROPERTYNAME_THROWS_COMPENSATION, true);
}
