Esempio n. 1
0
        /// <summary>
        /// Propagate transition to children.
        /// </summary>
        /// <param name="elementId"></param>
        /// <param name="transition"></param>
        private void PropagateTransition(BaseCaseEltInstance elt, CMMNTransitions transition)
        {
            CMMNTransitions?newTransition = null;

            if (transition == CMMNTransitions.Terminate || transition == CMMNTransitions.ParentTerminate)
            {
                newTransition = CMMNTransitions.ParentTerminate;
            }

            if (newTransition == null)
            {
                return;
            }

            var stage = elt as StageElementInstance;

            if (stage == null)
            {
                return;
            }

            foreach (var child in stage.Children)
            {
                MakeTransition(child, newTransition.Value);
            }
        }
 public void MakeTransition(CMMNTransitions transition, DateTime executionDateTime)
 {
     UpdateTransition(transition, executionDateTime);
     TransitionHistories.Add(new CasePlanElementInstanceTransitionHistory {
         ExecutionDateTime = executionDateTime, Transition = transition
     });
 }
Esempio n. 3
0
 public CaseElementTransitionRaisedEvent(string id, string aggregateId, int version, string elementId, CMMNTransitions transition, string message, Dictionary <string, string> incomingTokens, DateTime updateDateTime) : base(id, aggregateId, version)
 {
     ElementId      = elementId;
     Transition     = transition;
     Message        = message;
     IncomingTokens = incomingTokens;
     UpdateDateTime = updateDateTime;
 }
 public CriteriaBuilder AddFileItemOnPart(string sourceRef, CMMNTransitions transition)
 {
     _fileItems.Add(new CaseFileItemOnPart
     {
         SourceRef     = sourceRef,
         StandardEvent = transition
     });
     return(this);
 }
Esempio n. 5
0
        protected override void UpdateTransition(CMMNTransitions transition, DateTime executionDateTime)
        {
            var newState = GetMilestoneOrEventListenerState(State, transition);

            if (newState != null)
            {
                State = newState;
            }
        }
Esempio n. 6
0
        public void MakeTransition(CMMNTransitions transition, bool isEvtPropagate = true)
        {
            var evt = new CaseTransitionRaisedEvent(Guid.NewGuid().ToString(), AggregateId, Version + 1, transition, DateTime.UtcNow);

            Handle(evt);
            DomainEvents.Add(evt);
            if (isEvtPropagate)
            {
                PropagateTransition(StageContent, transition);
            }
        }
 protected override void UpdateTransition(CMMNTransitions transition, DateTime executionDateTime)
 {
     if (transition == CMMNTransitions.ParentTerminate)
     {
         if (State != TaskStageStates.Completed && State != TaskStageStates.Terminated)
         {
             State = TaskStageStates.Terminated;
         }
     }
     else
     {
         State = GetTaskStageState(State, transition);
     }
 }
        protected CaseFileItemStates?GetCaseFileItemState(CaseFileItemStates?state, CMMNTransitions transition)
        {
            CaseFileItemStates?result = null;

            switch (transition)
            {
            case CMMNTransitions.Create:
                if (state != null)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "already initialized")
                    });
                }

                result = CaseFileItemStates.Available;
                break;

            case CMMNTransitions.Update:
            case CMMNTransitions.Replace:
            case CMMNTransitions.RemoveChild:
            case CMMNTransitions.AddChild:
            case CMMNTransitions.AddReference:
            case CMMNTransitions.RemoveReference:
                if (state != CaseFileItemStates.Available)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "case file item is not available")
                    });
                }

                result = CaseFileItemStates.Available;
                break;

            case CMMNTransitions.Delete:
                if (state != CaseFileItemStates.Available)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "case file item is not available")
                    });
                }

                result = CaseFileItemStates.Discarded;
                break;
            }

            return(result);
        }
        public void MakeTransition(CMMNTransitions transition, string message, DateTime executionDateTime)
        {
            switch (Type)
            {
            case CasePlanElementInstanceTypes.MILESTONE:
            case CasePlanElementInstanceTypes.TIMER:
            {
                var newState = GetMilestoneOrEventListenerState(MilestoneState, transition);
                if (newState != null)
                {
                    MilestoneState = newState;
                }
            }
            break;

            case CasePlanElementInstanceTypes.EMPTYTASK:
            case CasePlanElementInstanceTypes.HUMANTASK:
            case CasePlanElementInstanceTypes.PROCESSTASK:
            case CasePlanElementInstanceTypes.STAGE:
            {
                if (transition == CMMNTransitions.ParentTerminate)
                {
                    if (TakeStageState != TaskStageStates.Completed && TakeStageState != TaskStageStates.Terminated)
                    {
                        TakeStageState = TaskStageStates.Terminated;
                    }
                }
                else
                {
                    TakeStageState = GetTaskStageState(TakeStageState, transition);
                }
            }
            break;

            case CasePlanElementInstanceTypes.FILEITEM:
            {
                var newState = GetCaseFileItemState(FileState, transition);
                if (newState != null)
                {
                    FileState = newState;
                }
            }
            break;
            }
            TransitionHistories.Add(new CaseEltInstanceTransitionHistory {
                Message = message, ExecutionDateTime = executionDateTime, Transition = transition
            });
        }
Esempio n. 10
0
        public void MakeTransition(BaseCaseEltInstance element, CMMNTransitions transition, bool isEvtPropagate = true)
        {
            var evt = new CaseElementTransitionRaisedEvent(Guid.NewGuid().ToString(), AggregateId, Version + 1, element.Id, transition, DateTime.UtcNow);

            Handle(evt);
            DomainEvents.Add(evt);
            var caseWorkerTask = WorkerTasks.FirstOrDefault(_ => _.CasePlanElementInstanceId == element.Id);

            if (caseWorkerTask != null && (transition == CMMNTransitions.Complete ||
                                           transition == CMMNTransitions.Terminate ||
                                           transition == CMMNTransitions.ParentTerminate))
            {
                var removeCWT = new CaseInstanceWorkerTaskRemovedEvent(Guid.NewGuid().ToString(), AggregateId, Version + 1, element.Id, DateTime.UtcNow);
                Handle(removeCWT);
                DomainEvents.Add(removeCWT);
            }

            if (isEvtPropagate)
            {
                PropagateTransition(element, transition);
            }
        }
Esempio n. 11
0
        /// <summary>
        /// Propagate transition to children.
        /// </summary>
        /// <param name="elementId"></param>
        /// <param name="transition"></param>
        private void PropagateTransition(CaseEltInstance elt, CMMNTransitions transition)
        {
            CMMNTransitions?newTransition = null;

            if (transition == CMMNTransitions.Terminate || transition == CMMNTransitions.ParentTerminate)
            {
                newTransition = CMMNTransitions.ParentTerminate;
            }

            if (newTransition == null)
            {
                return;
            }

            if (elt.Type != CasePlanElementInstanceTypes.STAGE)
            {
                return;
            }

            foreach (var child in elt.Children)
            {
                MakeTransition(child, newTransition.Value);
            }
        }
        protected TaskStageStates?GetTaskStageState(TaskStageStates?state, CMMNTransitions transition)
        {
            TaskStageStates?result = null;

            switch (transition)
            {
            case CMMNTransitions.Create:
                if (state != null)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "already initialized")
                    });
                }

                result = TaskStageStates.Available;
                break;

            case CMMNTransitions.Enable:
                if (state != TaskStageStates.Available)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not available")
                    });
                }

                result = TaskStageStates.Enabled;
                break;

            case CMMNTransitions.Disable:
                if (state != TaskStageStates.Enabled)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not enabled")
                    });
                }

                result = TaskStageStates.Disabled;
                break;

            case CMMNTransitions.Reenable:
                if (state != TaskStageStates.Enabled)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not disabled")
                    });
                }

                result = TaskStageStates.Disabled;
                break;

            case CMMNTransitions.Fault:
                if (state != TaskStageStates.Active)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not active")
                    });
                }

                result = TaskStageStates.Failed;
                break;

            case CMMNTransitions.Reactivate:
                if (state != TaskStageStates.Failed)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not failed")
                    });
                }

                result = TaskStageStates.Active;
                break;

            case CMMNTransitions.ManualStart:
                if (state != TaskStageStates.Enabled)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not enabled")
                    });
                }

                result = TaskStageStates.Active;
                break;

            case CMMNTransitions.Start:
                if (state != TaskStageStates.Available)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not available")
                    });
                }

                result = TaskStageStates.Active;
                break;

            case CMMNTransitions.Terminate:
                if (state != TaskStageStates.Active)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not active")
                    });
                }

                result = TaskStageStates.Terminated;
                break;

            case CMMNTransitions.Suspend:
                if (state != TaskStageStates.Active)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not active")
                    });
                }

                result = TaskStageStates.Suspended;
                break;

            case CMMNTransitions.Resume:
                if (state != TaskStageStates.Suspended)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not suspended")
                    });
                }

                result = TaskStageStates.Active;
                break;

            case CMMNTransitions.Complete:
                if (state != TaskStageStates.Active)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "planitem instance is not active")
                    });
                }

                result = TaskStageStates.Completed;
                break;
            }

            return(result);
        }
 protected abstract void UpdateTransition(CMMNTransitions transition, DateTime executionDateTime);
Esempio n. 14
0
 public CaseElementTransitionRaisedEvent(string id, string aggregateId, int version, string elementId, CMMNTransitions transition, DateTime updateDateTime) : base(id, aggregateId, version)
 {
     ElementId      = elementId;
     Transition     = transition;
     UpdateDateTime = updateDateTime;
 }
        protected MilestoneEventStates?GetMilestoneOrEventListenerState(MilestoneEventStates?state, CMMNTransitions transition)
        {
            MilestoneEventStates?result = null;

            switch (transition)
            {
            case CMMNTransitions.Create:
                if (state != null)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "already initialized")
                    });
                }

                result = MilestoneEventStates.Available;
                break;

            case CMMNTransitions.Occur:
                if (state != MilestoneEventStates.Available)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "milestone instance is not available")
                    });
                }

                result = MilestoneEventStates.Completed;
                break;

            case CMMNTransitions.Suspend:
                if (state != MilestoneEventStates.Available)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "milestone instance is not available")
                    });
                }

                result = MilestoneEventStates.Suspended;
                break;

            case CMMNTransitions.Terminate:
                if (state != MilestoneEventStates.Available)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "milestone instance is not available")
                    });
                }

                result = MilestoneEventStates.Terminated;
                break;

            case CMMNTransitions.Resume:
                if (state != MilestoneEventStates.Suspended)
                {
                    throw new AggregateValidationException(new List <KeyValuePair <string, string> >
                    {
                        new KeyValuePair <string, string>("transition", "milestone instance is not suspended")
                    });
                }

                result = MilestoneEventStates.Available;
                break;
            }

            return(result);
        }
Esempio n. 16
0
 public IncomingTransition(CMMNTransitions transition, Dictionary <string, string> incomingTokens)
 {
     Transition     = transition;
     IncomingTokens = incomingTokens;
 }
Esempio n. 17
0
 public CaseTransitionRaisedEvent(string id, string aggregateId, int version, CMMNTransitions transition, DateTime updateDateTime) : base(id, aggregateId, version)
 {
     Transition     = transition;
     UpdateDateTime = updateDateTime;
 }