コード例 #1
0
        public virtual ProcessDefinitionBuilder AttachedTo(string id, bool isInterrupting)
        {
            var activity = Activity;

            activity.EventScope = (IPvmScope)ProcessDefinition.FindActivity(id);

            if (isInterrupting)
            {
                activity.ActivityStartBehavior = ActivityStartBehavior.InterruptEventScope;
            }
            else
            {
                activity.ActivityStartBehavior = ActivityStartBehavior.ConcurrentInFlowScope;
            }

            return(this);
        }
コード例 #2
0
        protected internal virtual ScopeImpl GetScopeForActivityInstance(ProcessDefinitionImpl processDefinition,
                                                                         IActivityInstance activityInstance)
        {
            var scopeId = activityInstance.ActivityId;

            if (processDefinition.Id.Equals(scopeId))
            {
                return(processDefinition);
            }
            return((ScopeImpl)processDefinition.FindActivity(scopeId));
        }
コード例 #3
0
        protected internal virtual ValidatingMigrationInstructions WrapMigrationInstructions(
            IMigrationPlan migrationPlan, ProcessDefinitionImpl sourceProcessDefinition,
            ProcessDefinitionImpl targetProcessDefinition, MigrationPlanValidationReportImpl planReport)
        {
            var validatingMigrationInstructions = new ValidatingMigrationInstructions();

            foreach (var migrationInstruction in migrationPlan.Instructions)
            {
                var instructionReport = new MigrationInstructionValidationReportImpl(migrationInstruction);

                var sourceActivityId = migrationInstruction.SourceActivityId;
                var targetActivityId = migrationInstruction.TargetActivityId;
                if (!ReferenceEquals(sourceActivityId, null) && !ReferenceEquals(targetActivityId, null))
                {
                    IPvmActivity sourceActivity = sourceProcessDefinition.FindActivity(sourceActivityId);
                    IPvmActivity targetActivity = targetProcessDefinition.FindActivity(migrationInstruction.TargetActivityId);

                    if (sourceActivity != null && targetActivity != null)
                    {
                        validatingMigrationInstructions.AddInstruction(new ValidatingMigrationInstructionImpl(sourceActivity, targetActivity, migrationInstruction.UpdateEventTrigger));
                    }
                    else
                    {
                        if (sourceActivity == null)
                        {
                            instructionReport.AddFailure("Source activity '" + sourceActivityId + "' does not exist");
                        }
                        if (targetActivity == null)
                        {
                            instructionReport.AddFailure("Target activity '" + targetActivityId + "' does not exist");
                        }
                    }
                }
                else
                {
                    if (ReferenceEquals(sourceActivityId, null))
                    {
                        instructionReport.AddFailure("Source activity id is null");
                    }
                    if (ReferenceEquals(targetActivityId, null))
                    {
                        instructionReport.AddFailure("Target activity id is null");
                    }
                }

                if (instructionReport.HasFailures())
                {
                    planReport.AddInstructionReport(instructionReport);
                }
            }
            return(validatingMigrationInstructions);
        }
コード例 #4
0
        protected internal virtual ISet <string> CollectParentScopeIdsForActivity(
            ProcessDefinitionImpl processDefinition, string activityId)
        {
            ISet <string> parentScopeIds = new HashSet <string>();
            var           scope          = (ScopeImpl)processDefinition.FindActivity(activityId);

            while (scope != null)
            {
                parentScopeIds.Add(scope.Id);
                scope = scope.FlowScope;
            }

            return(parentScopeIds);
        }
コード例 #5
0
        public virtual ExecutionEntity GetExecution(IActivityInstance activityInstance)
        {
            ScopeImpl scope = null;

            if (activityInstance.Id.Equals(activityInstance.ProcessInstanceId))
            {
                scope = ProcessDefinition;
            }
            else
            {
                scope = (ScopeImpl)ProcessDefinition.FindActivity(activityInstance.ActivityId);
            }

            return(Intersect(GetExecutions(scope), activityInstance.ExecutionIds));
        }
コード例 #6
0
        public override object Execute(CommandContext commandContext)
        {
            var processInstance = commandContext.ExecutionManager.FindExecutionById(processInstanceId);
            ProcessDefinitionImpl processDefinition = processInstance.GetProcessDefinition();

            var activity = processDefinition.FindActivity(ActivityId);

            //forbid instantiation of compensation boundary events
            if (activity != null && "compensationBoundaryCatch".Equals(activity.GetProperty("type")))
            {
                throw new ProcessEngineException("Cannot start before activity " + ActivityId + "; activity " +
                                                 "is a compensation boundary event.");
            }

            return(base.Execute(commandContext));
        }
コード例 #7
0
        protected internal virtual TransitionImpl FindTransition(ProcessDefinitionImpl processDefinition)
        {
            var activity = (IPvmActivity)processDefinition.FindActivity(ActivityId);

            EnsureUtil.EnsureNotNull(typeof(NotValidException),
                                     DescribeFailure("Activity '" + ActivityId + "' does not exist"), "activity", activity);

            if (activity.OutgoingTransitions.Count == 0)
            {
                throw new ProcessEngineException("Cannot start after activity " + ActivityId + "; activity " +
                                                 "has no outgoing sequence flow to take");
            }
            if (activity.OutgoingTransitions.Count > 1)
            {
                throw new ProcessEngineException("Cannot start after activity " + ActivityId + "; " +
                                                 "activity has more than one outgoing sequence flow");
            }

            return((TransitionImpl)activity.OutgoingTransitions[0]);
        }
コード例 #8
0
        protected internal override CoreModelElement GetTargetElement(ProcessDefinitionImpl processDefinition)
        {
            var activity = (ActivityImpl)processDefinition.FindActivity(ActivityId);

            return(activity);
        }
コード例 #9
0
        protected internal override ScopeImpl GetTargetFlowScope(ProcessDefinitionImpl processDefinition)
        {
            var activity = processDefinition.FindActivity(ActivityId);

            return(activity.FlowScope);
        }