Ticket ## : Add milestone + support exit criteria + timereventlistener + casefileitem

Author: Thierry Habart

src/CaseManagement.CMMN/Apis/CaseDefinitionsController.cs

@@ -1,5 +1,5 @@
-using CaseManagement.CMMN.Extensions;
-using CaseManagement.CMMN.Parser;
+using CaseManagement.CMMN.Domains;
+using CaseManagement.CMMN.Extensions;
 using CaseManagement.CMMN.Persistence;
 using CaseManagement.CMMN.Persistence.Parameters;
 using CaseManagement.CMMN.Persistence.Responses;
@@ -14,26 +14,24 @@ namespace CaseManagement.CMMN.Apis
     [Route(CMMNConstants.RouteNames.CaseDefinitions)]
     public class CaseDefinitionsController : Controller
     {
-        private readonly ICMMNDefinitionsQueryRepository _queryRepository;
+        private readonly ICMMNWorkflowDefinitionQueryRepository _queryRepository;
 
-        public CaseDefinitionsController(ICMMNDefinitionsQueryRepository queryRepository)
+        public CaseDefinitionsController(ICMMNWorkflowDefinitionQueryRepository queryRepository)
         {
             _queryRepository = queryRepository;
         }
 
-        [HttpGet(".search")]
-        public async Task<IActionResult> Get()
+        [HttpGet("cmmndefinitions")]
+        public async Task<IActionResult> GetCMMNDefinitions()
         {
-            var query = HttpContext.Request.Query;
-            // var result = await _queryRepository.Find(ExtractFindParameter(query));
-            // return new OkObjectResult(ToDto(result));
-            return null;
+            var result = await _queryRepository.GetCMMDefinitions();
+            return new OkObjectResult(result);
         }
-
+                
         [HttpGet("{id}")]
         public async Task<IActionResult> Get(string id)
         {
-            var result = await _queryRepository.FindDefinitionById(id);
+            var result = await _queryRepository.FindById(id);
             if (result == null)
             {
                 return new NotFoundResult();
@@ -42,25 +40,48 @@ public async Task<IActionResult> Get(string id)
             return new OkObjectResult(ToDto(result));
         }
 
-        [HttpGet("{id}/cases")]
-        public async Task<IActionResult> GetCases(string id)
+        [HttpGet(".search")]
+        public async Task<IActionResult> Search()
         {
-            var result = await _queryRepository.FindDefinitionById(id);
-            if (result == null)
+            var query = HttpContext.Request.Query;
+            var result = await _queryRepository.Find(ExtractFindParameter(query));
+            return new OkObjectResult(ToDto(result));
+        }
+
+        private static JObject ToDto(FindResponse<CMMNWorkflowDefinition> resp)
+        {
+            return new JObject
             {
-                return new NotFoundResult();
-            }
+                { "start_index", resp.StartIndex },
+                { "total_length", resp.TotalLength },
+                { "count", resp.Count },
+                { "content", new JArray(resp.Content.Select(r => new JObject
+                {
+                    { "id", r.Id },
+                    { "name", r.Name },
+                    { "create_datetime", r.CreateDateTime }
+                })) }
+            };
+        }
 
-            return new OkObjectResult(result.@case);
+        private static JObject ToDto(CMMNWorkflowDefinition def)
+        {
+            return new JObject
+            {
+                { "id", def.Id },
+                { "name", def.Name },
+                { "create_datetime", def.CreateDateTime }
+            };
         }
 
-        private static BaseFindParameter ExtractFindParameter(IQueryCollection query)
+        private static FindWorkflowDefinitionsParameter ExtractFindParameter(IQueryCollection query)
         {
             int startIndex;
             int count;
             string orderBy;
+            string cmmnDefinition;
             FindOrders findOrder;
-            var parameter = new BaseFindParameter();
+            var parameter = new FindWorkflowDefinitionsParameter();
             if (query.TryGet("start_index", out startIndex))
             {
                 parameter.StartIndex = startIndex;
@@ -81,50 +102,12 @@ private static BaseFindParameter ExtractFindParameter(IQueryCollection query)
                 parameter.Order = findOrder;
             }
 
-            return parameter;
-        }
-
-        private static JObject ToDto(FindResponse<tDefinitions> resp)
-        {
-            return new JObject
-            {
-                { "start_index", resp.StartIndex },
-                { "total_length", resp.TotalLength },
-                { "count", resp.Count },
-                { "content", new JArray(resp.Content.Select(r => new JObject
-                {
-                    { "id", r.id },
-                    { "name", r.name },
-                    { "create_datetime", r.creationDate }
-                })) }
-            };
-        }
-
-        private static JObject ToDto(tDefinitions def)
-        {
-            return new JObject
-            {
-                { "id", def.id },
-                { "name", def.name },
-                { "create_datetime", def.creationDate },
-                { "cases", ToDto(def.@case) },
-                { "xml",  new CMMNParser().Serialize(def) }
-            };
-        }
-
-        private static JArray ToDto(tCase[] tCases)
-        {
-            var result = new JArray();
-            foreach(var tCase in tCases)
+            if (query.TryGet("cmmn_definition", out cmmnDefinition))
             {
-                result.Add(new JObject
-                {
-                    { "id", tCase.id },
-                    { "name", tCase.casePlanModel.name }
-                });
+                parameter.CMMNDefinition = cmmnDefinition;
             }
 
-            return result;
+            return parameter;
         }
     }
 }

src/CaseManagement.CMMN/Apis/CaseInstancesController.cs

@@ -1,15 +1,9 @@
 using CaseManagement.CMMN.CaseInstance.CommandHandlers;
 using CaseManagement.CMMN.CaseInstance.Commands;
-using CaseManagement.CMMN.CaseInstance.Exceptions;
 using CaseManagement.CMMN.Domains;
-using CaseManagement.CMMN.Extensions;
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Newtonsoft.Json.Linq;
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Net;
 using System.Threading.Tasks;
 
@@ -18,21 +12,13 @@ namespace CaseManagement.CMMN.Apis
     [Route(CMMNConstants.RouteNames.CaseInstances)]
     public class CaseInstancesController : Controller
     {
+        private readonly ICreateCaseInstanceCommandHandler _createCaseInstanceCommandHandler;
         private readonly ILaunchCaseInstanceCommandHandler _launchCaseInstanceCommandHandler;
-        private readonly IConfirmFormCommandHandler _confirmFormCommandHandler;
-        private readonly IStopCaseInstanceCommandHandler _stopCaseInstanceCommandHandler;
-        // private readonly IProcessFlowInstanceQueryRepository _processFlowInstanceQueryRepository;
-        private readonly IActivateCommandHandler _activateCommandHandler;
-        private readonly ITerminateCommandHandler _terminateCommandHandler;
 
-        public CaseInstancesController(ILaunchCaseInstanceCommandHandler launchCaseInstanceCommandHandler, IConfirmFormCommandHandler confirmFormCommandHandler, IStopCaseInstanceCommandHandler stopCaseInstanceCommandHandler, /* IProcessFlowInstanceQueryRepository processFlowInstanceQueryRepository, */IActivateCommandHandler activateCommandHandler, ITerminateCommandHandler terminateCommandHandler)
+        public CaseInstancesController(ICreateCaseInstanceCommandHandler createCaseInstanceCommandHandler, ILaunchCaseInstanceCommandHandler launchCaseInstanceCommandHandler)
         {
+            _createCaseInstanceCommandHandler = createCaseInstanceCommandHandler;
             _launchCaseInstanceCommandHandler = launchCaseInstanceCommandHandler;
-            _confirmFormCommandHandler = confirmFormCommandHandler;
-            _stopCaseInstanceCommandHandler = stopCaseInstanceCommandHandler;
-            // _processFlowInstanceQueryRepository = processFlowInstanceQueryRepository;
-            _activateCommandHandler = activateCommandHandler;
-            _terminateCommandHandler = terminateCommandHandler;
         }
 
         /*
@@ -43,6 +29,7 @@ public async Task<IActionResult> Search()
             var result = await _processFlowInstanceQueryRepository.Find(ExtractFindWorkflowInstanceParameter(query));
             return new OkObjectResult(ToDto(result));
         }
+        */
 
         [HttpPost]
         public async Task<IActionResult> Create([FromBody] CreateCaseInstanceCommand createCaseInstance)
@@ -62,6 +49,7 @@ public async Task<IActionResult> Launch(string id)
             return new OkResult();
         }
 
+        /*
         [HttpGet("{id}/stop")]
         public async Task<IActionResult> Stop(string id)
         {
@@ -256,81 +244,111 @@ private static JObject ToDto(FindResponse<ProcessFlowInstance> resp)
                 })) }
             };
         }
+        */
 
-        private static JObject ToDto(ProcessFlowInstance flowInstance)
+        private static JObject ToDto(CMMNWorkflowInstance workflowInstance)
         {
             var result = new JObject
             {
-                { "id", flowInstance.Id },
-                { "create_datetime", flowInstance.CreateDateTime },
-                { "template_id", flowInstance.ProcessFlowTemplateId },
-                { "name", flowInstance.ProcessFlowName },
-                { "context", ToDto(flowInstance.ExecutionContext) }
+                { "id", workflowInstance.Id },
+                { "create_datetime", workflowInstance.CreateDateTime},
+                { "definition_id", workflowInstance.WorkflowDefinitionId },
+                { "context", ToDto(workflowInstance.ExecutionContext) },
+                { "state", workflowInstance.State }
             };
-            if (flowInstance.Status != null)
+            var stateHistories = new JArray();
+            var transitionHistories = new JArray();
+            var executionHistories = new JArray();
+            var elts = new JArray();
+            foreach(var stateHistory in workflowInstance.StateHistories)
             {
-                result.Add("status", Enum.GetName(typeof(ProcessFlowInstanceStatus), flowInstance.Status).ToLowerInvariant());
+                stateHistories.Add(new JObject
+                {
+                    { "state", stateHistory.State },
+                    { "datetime", stateHistory.UpdateDateTime }
+                });
             }
 
-            var planItems = new JArray();
-            foreach(var planItem in flowInstance.Elements.Where(e => e is CMMNPlanItemDefinition).Cast<CMMNPlanItemDefinition>())
+            foreach(var transitionHistory in workflowInstance.TransitionHistories)
             {
-                planItems.Add(ToDto(planItem));
+                transitionHistories.Add(new JObject
+                {
+                    { "transition", Enum.GetName(typeof(CMMNTransitions), transitionHistory.Transition) },
+                    { "datetime", transitionHistory.CreateDateTime }
+                });
             }
 
-            var fileItems = new JArray();
-            foreach(var caseFileItem in flowInstance.Elements.Where(e => e is CMMNCaseFileItem).Cast<CMMNCaseFileItem>())
+            foreach (var executionHistory in workflowInstance.ExecutionHistories)
             {
-                fileItems.Add(ToDto(caseFileItem));
+                executionHistories.Add(new JObject
+                {
+                    { "start_datetime", executionHistory.StartDateTime },
+                    { "end_datetime", executionHistory.EndDateTime },
+                    { "id", executionHistory.WorkflowElementDefinitionId }
+                });
             }
 
-            result.Add("items", planItems);
-            result.Add("fileitems", fileItems);
-            return result;
-        }
-
-        private static JObject ToDto(CMMNWorkflowInstanceExecutionContext context)
-        {
-            var jObj = new JObject();
-            foreach (var kvp in context.Variables)
+            foreach(var elt in workflowInstance.WorkflowElementInstances)
             {
-                jObj.Add(kvp.Key, kvp.Value);
+                elts.Add(ToDto(elt));
             }
 
-            return jObj;
+            result.Add("state_histories", stateHistories);
+            result.Add("transition_histories", transitionHistories);
+            result.Add("execution_histories", executionHistories);
+            result.Add("elements", elts);
+            return result;
         }
 
-        private static JObject ToDto(CMMNPlanItemDefinition planItem)
+        private static JObject ToDto(CMMNWorkflowElementInstance elt)
         {
             var result = new JObject
             {
-                { "id", planItem.Id },
-                { "name", planItem.Name },
-                { "version", planItem.Version }
+                { "id", elt.Id },
+                { "version", elt.Version },
+                { "create_datetime", elt.CreateDateTime},
+                { "definition_id", elt.WorkflowElementDefinitionId },
+                { "form_instanceid", elt.FormInstanceId },
+                { "state", elt.State }
             };
+            var stateHistories = new JArray();
             var transitionHistories = new JArray();
-            if (planItem.TransitionHistories != null)
+            foreach (var stateHistory in elt.StateHistories)
             {
-                foreach(var transitionHistory in planItem.TransitionHistories)
+                stateHistories.Add(new JObject
                 {
-                    transitionHistories.Add(new JObject
-                    {
-                        { "create_datetime", transitionHistory.CreateDateTime },
-                        { "transition", Enum.GetName(typeof(CMMNPlanItemTransitions), transitionHistory.Transition).ToLowerInvariant() },
-                        { "version", transitionHistory.Version }
-                    });
-                }
+                    { "state", stateHistory.State },
+                    { "datetime", stateHistory.UpdateDateTime }
+                });
             }
 
-            if (planItem.Status != null)
+            foreach (var transitionHistory in elt.TransitionHistories)
             {
-                result.Add("status", Enum.GetName(typeof(ProcessFlowInstanceElementStatus), planItem.Status).ToLowerInvariant());
+                transitionHistories.Add(new JObject
+                {
+                    { "transition", Enum.GetName(typeof(CMMNTransitions), transitionHistory.Transition) },
+                    { "datetime", transitionHistory.CreateDateTime }
+                });
             }
 
-            result.Add("histories", transitionHistories);
+            result.Add("state_histories", stateHistories);
+            result.Add("transition_histories", transitionHistories);
             return result;
         }
 
+        private static JObject ToDto(CMMNWorkflowInstanceExecutionContext context)
+        {
+            var jObj = new JObject();
+            foreach (var kvp in context.Variables)
+            {
+                jObj.Add(kvp.Key, kvp.Value);
+            }
+
+            return jObj;
+        }
+
+        /*
+
         private static JObject ToDto(CMMNCaseFileItem fileItem)
         {
             var result = new JObject();

src/CaseManagement.CMMN/ApplicationBuilderExtensions.cs

@@ -1,12 +1,9 @@
-using Hangfire;
-
-namespace Microsoft.AspNetCore.Builder
+namespace Microsoft.AspNetCore.Builder
 {
     public static class ApplicationBuilderExtensions
     {
         public static IApplicationBuilder UseCMMN(this IApplicationBuilder appBuilder)
         {
-            appBuilder.UseHangfireServer();
             appBuilder.UseMvc();
             return appBuilder;
         }