Ticket #3 : Support criterias (entry + exit)

Author: habarthierry-hue

Doc.docx

@@ -12,11 +12,21 @@ public CMMNPlanItemBuilder(CMMNPlanItem planItem)
             _planItem = planItem;
         }
 
-        public CMMNPlanItemBuilder AddSEntry(string name, Action<CMMNSEntryBuilder> callback)
+        public CMMNPlanItemBuilder AddEntryCriterion(string name, Action<CMMNSEntryBuilder> callback)
         {
             var sEntry = new CMMNSEntry(name);
+            var entryCriterion = new CMMNCriterion(name) { SEntry = sEntry };
             callback(new CMMNSEntryBuilder(sEntry));
-            _planItem.SEntries.Add(sEntry);
+            _planItem.EntryCriterions.Add(entryCriterion);
+            return this;
+        }
+
+        public CMMNPlanItemBuilder AddExitCriterion(string name, Action<CMMNSEntryBuilder> callback)
+        {
+            var sEntry = new CMMNSEntry(name);
+            var entryCriterion = new CMMNCriterion(name) { SEntry = sEntry };
+            callback(new CMMNSEntryBuilder(sEntry));
+            _planItem.ExitCriterions.Add(entryCriterion);
             return this;
         }
 

src/CaseManagement.CMMN/Builders/CMMNPlanItemBuilder.cs

@@ -0,0 +1,13 @@
+namespace CaseManagement.CMMN.Domains
+{
+    public class CMMNCriterion
+    {
+        public CMMNCriterion(string name)
+        {
+            Name = name;
+        }
+
+        public string Name { get; set; }
+        public CMMNSEntry SEntry { get; set; }
+    }
+}

src/CaseManagement.CMMN/Domains/CMMNCriterion.cs

@@ -12,7 +12,13 @@ public CMMNManualActivationRule(string name, CMMNExpression expression) : this(n
             Expression = expression;
         }
 
+        /// <summary>
+        /// The name of the ManualActivationRule.
+        /// </summary>
         public string Name { get; set; }
+        /// <summary>
+        /// An Expression that MUST evaluate to boolean. [1...1]
+        /// </summary>
         public CMMNExpression Expression { get; set; }
     }
 }

src/CaseManagement.CMMN/Domains/CMMNManualActivationRule.cs

@@ -8,7 +8,8 @@ public class CMMNPlanItem : ProcessFlowInstanceElement
     {
         private CMMNPlanItem(string id, string name, CMMNPlanItemDefinition planItemDefinition) : base(id, name)
         {
-            SEntries = new List<CMMNSEntry>();
+            EntryCriterions = new List<CMMNCriterion>();
+            ExitCriterions = new List<CMMNCriterion>();
             Events = new List<CMMNPlanItemTransitionEvent>();
             var evt = new CMMNPlanItemCreated();
             Events.Add(evt);
@@ -17,17 +18,22 @@ private CMMNPlanItem(string id, string name, CMMNPlanItemDefinition planItemDefi
         }
 
         /// <summary>
-        /// [0...1]
+        /// The PlanItemControl controls aspects of the behavior of instances of the PlanItem object. [0...1]
         /// </summary>
         public CMMNPlanItemControl PlanItemControl { get; set; }
         /// <summary>
-        /// [1...1]
+        /// Reference to the corresponding PlanItemDefinition object. [1...1]
         /// </summary>
         public CMMNPlanItemDefinition PlanItemDefinition { get; set; }
         /// <summary>
-        /// [0...*] // EntryCriterion TODO !!
+        /// Zero or more EntryCriterion for that PlanItem. [0...*].
+        /// An EntryCriterion represents the condition for a PlanItem to become available.
         /// </summary>
-        public ICollection<CMMNSEntry> SEntries { get; set; }
+        public ICollection<CMMNCriterion> EntryCriterions { get; set; }
+        /// <summary>
+        /// An ExitCriterion represents the condition for a PlanItem to terminate. [0...*]
+        /// </summary>
+        public ICollection<CMMNCriterion> ExitCriterions { get; set; }
         public ICollection<CMMNPlanItemTransitionEvent> Events { get; set; }
 
         public void Enable()
@@ -63,6 +69,13 @@ public void Complete()
             PlanItemDefinition.Handle(evt);
         }
 
+        public void Terminate()
+        {
+            var evt = new CMMNPlanItemTerminated();
+            Events.Add(evt);
+            PlanItemDefinition.Handle(evt);
+        }
+
         public static CMMNPlanItem New(string id, string name, CMMNPlanItemDefinition planItemDef)
         {
             var result = new CMMNPlanItem(id, name, planItemDef);

src/CaseManagement.CMMN/Domains/CMMNPlanItem.cs

@@ -31,6 +31,21 @@ public override void Handle(DomainEvent cmmnPlanItemEvent)
             {
                 Handle((CMMNPlanItemManuallyStarted)cmmnPlanItemEvent);
             }
+
+            if (cmmnPlanItemEvent is CMMNPlanItemStarted)
+            {
+                Handle((CMMNPlanItemStarted)cmmnPlanItemEvent);
+            }
+
+            if (cmmnPlanItemEvent is CMMNPlanItemTerminated)
+            {
+                Handle((CMMNPlanItemTerminated)cmmnPlanItemEvent);
+            }
+
+            if (cmmnPlanItemEvent is CMMNPlanItemCompleted)
+            {
+                Handle((CMMNPlanItemCompleted)cmmnPlanItemEvent);
+            }
         }
 
         private void Handle(CMMNPlanItemCreated evt)
@@ -47,5 +62,20 @@ private void Handle(CMMNPlanItemManuallyStarted evt)
         {
             State = CMMNTaskStates.Active;
         }
+
+        private void Handle(CMMNPlanItemStarted evt)
+        {
+            State = CMMNTaskStates.Active;
+        }
+
+        private void Handle(CMMNPlanItemTerminated evt)
+        {
+            State = CMMNTaskStates.Terminated;
+        }
+
+        private void Handle(CMMNPlanItemCompleted evt)
+        {
+            State = CMMNTaskStates.Completed;
+        }
     }
 }

src/CaseManagement.CMMN/Domains/CMMNTask.cs

@@ -0,0 +1,9 @@
+namespace CaseManagement.CMMN.Domains.Events
+{
+    public class CMMNPlanItemTerminated : CMMNPlanItemTransitionEvent
+    {
+        public CMMNPlanItemTerminated() : base(CMMNPlanItemTransitions.Terminate)
+        {
+        }
+    }
+}

src/CaseManagement.CMMN/Domains/Events/CMMNPlanItemTerminated.cs

@@ -14,48 +14,60 @@ public class CMMNPlanItemProcessor : BaseProcessFlowElementProcessor
         protected override Task<bool> HandleProcessFlowInstance(ProcessFlowInstanceElement pfe, ProcessFlowInstanceExecutionContext context)
         {
             var planItem = (CMMNPlanItem)pfe;
-            var processTask = (CMMNProcessTask)planItem.PlanItemDefinition;
-            // TODO : check the plan definition status and execute the correct logic.
-            if (processTask.State == CMMNTaskStates.Active)
+            var processTask = planItem.PlanItemDefinition as CMMNProcessTask;
+            if (processTask != null)
             {
-                planItem.Complete();
-                return Task.FromResult(true);
+                return HandleProcessTask(planItem, processTask, context);
             }
 
-            if (!HandlePlanItemControl(planItem, context))
-            {
-                return Task.FromResult(false);
-            }
-
-            // TODO : execute the plan item definition.
-            planItem.Complete();
             return Task.FromResult(true);
         }
 
-        protected bool HandlePlanItemControl(CMMNPlanItem pfe, ProcessFlowInstanceExecutionContext context)
+        protected Task<bool> HandleProcessTask(CMMNPlanItem planItem, CMMNProcessTask processTask, ProcessFlowInstanceExecutionContext context)
         {
-            var planItem = (CMMNPlanItem)pfe;
-            if (planItem.SEntries.Any() && !planItem.SEntries.Any(s => CheckSEntry(s, context)))
+            if (planItem.ExitCriterions.Any() && planItem.ExitCriterions.Any(s => CheckCriterion(s, context)))
             {
-                return false;
+                planItem.Terminate();
+                return Task.FromResult(true);
             }
-
-            if (planItem.PlanItemControl != null)
+            
+            if (processTask.State == CMMNTaskStates.Available)
             {
-                if (planItem.PlanItemControl is CMMNManualActivationRule)
+                if (planItem.EntryCriterions.Any() && !planItem.EntryCriterions.Any(s => CheckCriterion(s, context)))
                 {
-                    planItem.Enable();
-                    return false;
+                    return Task.FromResult(true);
                 }
+
+                if (planItem.PlanItemControl != null)
+                {
+                    var manualActivationRule = planItem.PlanItemControl as CMMNManualActivationRule;
+                    if (manualActivationRule != null)
+                    {
+                        // Note : at the moment the ContextRef is ignored.
+                        if (ExpressionParser.IsValid(manualActivationRule.Expression.Body, context))
+                        {
+                            planItem.Enable();
+                            return Task.FromResult(false);
+                        }
+                    }
+                }
+
+                planItem.Start();
             }
 
-            planItem.Start();
-            return true;
+            if (processTask.State == CMMNTaskStates.Active)
+            {
+                // TODO : Execute the plan item definition.
+                planItem.Complete();
+                return Task.FromResult(true);
+            }
+
+            return Task.FromResult(true);
         }
 
-        private bool CheckSEntry(CMMNSEntry sEntry, ProcessFlowInstanceExecutionContext context)
+        private bool CheckCriterion(CMMNCriterion sCriterion, ProcessFlowInstanceExecutionContext context)
         {
-            foreach (var onPart in sEntry.OnParts)
+            foreach (var onPart in sCriterion.SEntry.OnParts)
             {
                 if (onPart is CMMNPlanItemOnPart)
                 {
@@ -70,9 +82,9 @@ private bool CheckSEntry(CMMNSEntry sEntry, ProcessFlowInstanceExecutionContext
                 }
             }
 
-            if (sEntry.IfPart != null)
+            if (sCriterion.SEntry.IfPart != null)
             {
-                return ExpressionParser.IsValid(sEntry.IfPart.Condition, context);
+                return ExpressionParser.IsValid(sCriterion.SEntry.IfPart.Condition, context);
             }
 
             return true;

src/CaseManagement.CMMN/ProcessInstance/Processors/CMMNPlanItemProcessor.cs

@@ -1,42 +1,14 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using System;
-using System.IO;
-using System.Linq;
-using System.Reflection;
+using DynamicExpresso;
 
 namespace CaseManagement.Workflow.Engine
 {
     public static class ExpressionParser
     {
-        public static bool IsValid(string expression, ProcessFlowInstanceExecutionContext context)
+        public static bool IsValid(string expressionBody, ProcessFlowInstanceExecutionContext context)
         {
-            var syntaxTree = CSharpSyntaxTree.ParseText(expression);
-            var assemblyName = Path.GetRandomFileName();
-            var references = new MetadataReference[]
-            {
-                MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
-                MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
-                MetadataReference.CreateFromFile(typeof(ProcessFlowInstanceExecutionContext).Assembly.Location)
-            };
-
-            var compilation = CSharpCompilation.Create(
-                assemblyName,
-                syntaxTrees: new[] { syntaxTree },
-                references: references,
-                options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
-            using (var ms = new MemoryStream())
-            {
-                var result = compilation.Emit(ms);
-                ms.Seek(0, SeekOrigin.Begin);
-                var assembly = Assembly.Load(ms.ToArray());
-                var type = assembly.GetType("CaseManagement.Conditions");
-                var obj = Activator.CreateInstance(type);
-                return bool.Parse(type.InvokeMember("Check", BindingFlags.Default | BindingFlags.InvokeMethod, null, obj, new object[]
-                {
-                    context
-                }).ToString());
-            }
+            var interpreter = new Interpreter().SetVariable("context", context);
+            var parsedExpression = interpreter.Parse(expressionBody);
+            return (bool)parsedExpression.Invoke();
         }
     }
 }

src/CaseManagement.Workflow/Engine/ExpressionParser.cs

@@ -47,12 +47,12 @@ private async Task<bool> Start(ProcessFlowInstance processFlowInstance, ProcessF
                 return true;
             }
 
-            bool result = false;
+            bool result = true;
             foreach (var nextElt in nextElts)
             {
-                if (await Start(processFlowInstance, context, nextElt))
+                if (!await Start(processFlowInstance, context, nextElt))
                 {
-                    result = true;
+                    result = false;
                 }
             }