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