Ticket #116 : Check Input & Output tokens

habarthierry-hue · habarthierry-hue · commit ae7b98bf6e97 · 2021-07-05T16:24:46.000+02:00
diff --git a/src/CaseManagement.BPMN.Host/Delegates/GetWeatherInformationDelegate.cs b/src/CaseManagement.BPMN.Host/Delegates/GetWeatherInformationDelegate.cs
@@ -1,4 +1,5 @@
 ﻿using CaseManagement.BPMN.Domains;
+using CaseManagement.BPMN.ProcessInstance.Processors;
 using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
@@ -9,13 +10,13 @@ namespace CaseManagement.BPMN.Host.Delegates
 {
     public class GetWeatherInformationDelegate : IDelegateHandler
     {
-        public Task<ICollection<MessageToken>> Execute(ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)
+        public Task<ICollection<MessageToken>> Execute(BPMNExecutionContext context, ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)
         {
             ICollection<MessageToken> result = new List<MessageToken>();
             var rnd = new Random();
             var degree = rnd.Next(0, 40);
 
-            result.Add(MessageToken.NewMessage("weatherInformation", new JObject
+            result.Add(MessageToken.NewMessage(context.Pointer.InstanceFlowNodeId, "weatherInformation", new JObject
             {
                 { "city", "Bruxelles" },
                 { "degree", degree }
diff --git a/src/CaseManagement.BPMN.Host/Delegates/SendEmailDelegate.cs b/src/CaseManagement.BPMN.Host/Delegates/SendEmailDelegate.cs
@@ -1,6 +1,6 @@
 ﻿using CaseManagement.BPMN.Domains;
 using CaseManagement.BPMN.Exceptions;
-using Newtonsoft.Json.Linq;
+using CaseManagement.BPMN.ProcessInstance.Processors;
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
@@ -12,17 +12,20 @@ namespace CaseManagement.BPMN.Host.Delegates
 {
     public class SendEmailDelegate : IDelegateHandler
     {
-        public Task<ICollection<MessageToken>> Execute(ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)
+        public Task<ICollection<MessageToken>> Execute(BPMNExecutionContext context, ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)
         {
-            var humanTaskInstanceCreated = incoming.FirstOrDefault(i => i.Name == "humanTaskCreated");
-            if (humanTaskInstanceCreated == null)
+            var user = incoming.FirstOrDefault(i => i.Name == "user");
+            if (user == null)
             {
-                throw new BPMNProcessorException("humanTaskCreated must be passed in the request");
+                throw new BPMNProcessorException("user must be passed in the request");
+            }
+
+            var email = user.GetProperty("email");
+            if (string.IsNullOrWhiteSpace(email))
+            {
+                throw new BPMNProcessorException("email is not passed in the request");
             }
 
-            var inc = humanTaskInstanceCreated.JObjMessageContent.SelectToken("$.incoming[?(@.Name == 'user')].MessageContent");
-            var messageContent = JObject.Parse(inc.ToString());
-            var email = messageContent["email"].ToString();
             var parameter = SendDelegateParameter.Build(delegateConfiguration);
             using (var smtpClient = new SmtpClient())
             {
@@ -40,11 +43,15 @@ public Task<ICollection<MessageToken>> Execute(ICollection<MessageToken> incomin
                     IsBodyHtml = true
                 };
 
-                mailMessage.To.Add(email);
+                mailMessage.To.Add(email.ToString());
                 smtpClient.Send(mailMessage);
             }
 
-            return Task.FromResult(incoming);
+            ICollection<MessageToken> result = new List<MessageToken>
+            {
+                MessageToken.EmptyMessage(context.Pointer.InstanceFlowNodeId, "sendEmail")
+            };
+            return Task.FromResult(result);
         }
 
         private class SendDelegateParameter
diff --git a/src/CaseManagement.BPMN.Host/Delegates/UpdateUserPasswordDelegate.cs b/src/CaseManagement.BPMN.Host/Delegates/UpdateUserPasswordDelegate.cs
@@ -1,5 +1,6 @@
 ﻿using CaseManagement.BPMN.Domains;
 using CaseManagement.BPMN.Exceptions;
+using CaseManagement.BPMN.ProcessInstance.Processors;
 using IdentityModel.Client;
 using Newtonsoft.Json.Linq;
 using System;
@@ -16,7 +17,7 @@ public class UpdateUserPasswordDelegate : IDelegateHandler
     {
         private const string ActivityName = "Activity_0fhwdxz";
 
-        public async Task<ICollection<MessageToken>> Execute(ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)
+        public async Task<ICollection<MessageToken>> Execute(BPMNExecutionContext context, ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)
         {
             var user = incoming.FirstOrDefault(i => i.Name == "user");
             if (user == null)
@@ -69,7 +70,11 @@ public async Task<ICollection<MessageToken>> Execute(ICollection<MessageToken> i
                 httpResponse.EnsureSuccessStatusCode();
             }
 
-            return incoming;
+            ICollection<MessageToken> result = new List<MessageToken>
+            {
+                MessageToken.EmptyMessage(context.Pointer.InstanceFlowNodeId, "updatePassword")
+            };
+            return result;
         }
 
         private class UpdateUserPasswordParameter
diff --git a/src/CaseManagement.BPMN.SqlServer.Host/Delegates/GetWeatherInformationDelegate.cs b/src/CaseManagement.BPMN.SqlServer.Host/Delegates/GetWeatherInformationDelegate.cs
@@ -1,4 +1,5 @@
 ﻿using CaseManagement.BPMN.Domains;
+using CaseManagement.BPMN.ProcessInstance.Processors;
 using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
@@ -9,13 +10,13 @@ namespace CaseManagement.BPMN.SqlServer.Host.Delegates
 {
     public class GetWeatherInformationDelegate : IDelegateHandler
     {
-        public Task<ICollection<MessageToken>> Execute(ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)
+        public Task<ICollection<MessageToken>> Execute(BPMNExecutionContext context, ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)
         {
             ICollection<MessageToken> result = new List<MessageToken>();
             var rnd = new Random();
             var degree = rnd.Next(0, 40);
 
-            result.Add(MessageToken.NewMessage("weatherInformation", new JObject
+            result.Add(MessageToken.NewMessage(context.Pointer.InstanceFlowNodeId, "weatherInformation", new JObject
             {
                 { "city", "Bruxelles" },
                 { "degree", degree }
diff --git a/src/CaseManagement.BPMN/Domains/ProcessInstance/Defs/Events/EventDefs/MessageEventDefinition.cs b/src/CaseManagement.BPMN/Domains/ProcessInstance/Defs/Events/EventDefs/MessageEventDefinition.cs
@@ -16,7 +16,7 @@ public class MessageEventDefinition : BaseEventDefinition
 
         public override bool IsSatisfied(ProcessInstanceAggregate processInstance, MessageToken token)
         {
-            return processInstance.IsMessageCorrect(token);
+            return processInstance.IsMessageCorrect(MessageRef, token);
         }
 
         public override object Clone()
diff --git a/src/CaseManagement.BPMN/Domains/ProcessInstance/Executions/ExecutionPointer.cs b/src/CaseManagement.BPMN/Domains/ProcessInstance/Executions/ExecutionPointer.cs
@@ -42,8 +42,14 @@ public void AddIncoming(IEnumerable<MessageToken> tokens)
 
             foreach(var token in tokens)
             {
+                if (Tokens.Any(t => t.Id == token.Id))
+                {
+                    continue;
+                }
+
                 Tokens.Add(new MessageToken
                 {
+                    Id = token.Id,
                     MessageContent = token.MessageContent,
                     Name = token.Name,
                     Type = MessageTokenTypes.INCOMING
@@ -60,8 +66,14 @@ public void AddOutgoing(IEnumerable<MessageToken> tokens)
 
             foreach(var token in tokens)
             {
+                if (Tokens.Any(t => t.Id == token.Id))
+                {
+                    continue;
+                }
+
                 Tokens.Add(new MessageToken
                 {
+                    Id = token.Id,
                     MessageContent = token.MessageContent,
                     Name = token.Name,
                     Type = MessageTokenTypes.OUTGOING
diff --git a/src/CaseManagement.BPMN/Domains/ProcessInstance/MessageToken.cs b/src/CaseManagement.BPMN/Domains/ProcessInstance/MessageToken.cs
@@ -8,6 +8,7 @@ namespace CaseManagement.BPMN.Domains
     [Serializable]
     public class MessageToken : ICloneable
     {
+        public string Id { get; set; }
         public string Name { get; set; }
         public string MessageContent { get; set; }
         public MessageTokenTypes Type { get; set; }
@@ -52,22 +53,28 @@ public object Clone()
         {
             var result = new MessageToken
             {
+                Id = Id,
                 Name = Name,
                 MessageContent = MessageContent,
                 Type = Type
             };
             return result;
         }
 
-        public static MessageToken EmptyMessage()
+        public static MessageToken EmptyMessage(string id, string name)
         {
-            return new MessageToken();
+            return new MessageToken
+            {
+                Id = id,
+                Name = name
+            };
         }
 
-        public static MessageToken NewMessage(string name, string content)
+        public static MessageToken NewMessage(string id, string name, string content)
         {
             return new MessageToken
             {
+                Id = id,
                 MessageContent = content,
                 Name = name
             };
diff --git a/src/CaseManagement.BPMN/Domains/ProcessInstance/ProcessInstanceAggregate.cs b/src/CaseManagement.BPMN/Domains/ProcessInstance/ProcessInstanceAggregate.cs
@@ -48,6 +48,11 @@ public ICollection<BaseFlowNode> ElementDefs
 
         #region Getters
 
+        public bool IsEvent(string elementId)
+        {
+            return GetDefinition(elementId) as BaseEvent != null;
+        }
+
         public bool IsIncomingSatisfied(SequenceFlow incomingSequence, IEnumerable<MessageToken> incomingTokens)
         {
             if (!string.IsNullOrWhiteSpace(incomingSequence.ConditionExpression))
@@ -115,10 +120,10 @@ public ItemDefinition GetItem(string itemRef)
             return ItemDefs.FirstOrDefault(_ => _.EltId == itemRef);
         }
 
-        public bool IsMessageCorrect(MessageToken messageToken)
+        public bool IsMessageCorrect(string messageRef, MessageToken messageToken)
         {
             var message = GetMessageByName(messageToken.Name);
-            if (message == null || messageToken.Name != messageToken.Name)
+            if (message == null || messageToken.Name != message.Name || message.EltId != messageRef)
             {
                 return false;
             }
@@ -195,12 +200,12 @@ public ICollection<string> CompleteExecutionPointer(ExecutionPointer pointer, IC
             return result;
         }
 
-        public void LaunchBoundaryEvts(string pathId, List<string> evts)
+        public void LaunchBoundaryEvts(string pathId, List<string> evts, List<MessageToken> incomingTokens)
         {
             var items = evts.Select(e => GetDefinition(e));
             foreach(var item in items)
             {
-                TryAddExecutionPointer(pathId, item);
+                TryAddExecutionPointer(pathId, item, incomingTokens);
             }
         }
 
diff --git a/src/CaseManagement.BPMN/IDelegateHandler.cs b/src/CaseManagement.BPMN/IDelegateHandler.cs
@@ -1,4 +1,5 @@
 ﻿using CaseManagement.BPMN.Domains;
+using CaseManagement.BPMN.ProcessInstance.Processors;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -7,6 +8,6 @@ namespace CaseManagement.BPMN
 {
     public interface IDelegateHandler
     {
-        Task<ICollection<MessageToken>> Execute(ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken);
+        Task<ICollection<MessageToken>> Execute(BPMNExecutionContext context, ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken);
     }
 }
diff --git a/src/CaseManagement.BPMN/ProcessInstance/Commands/Handlers/ConsumeMessageProcessInstanceCommandHandler.cs b/src/CaseManagement.BPMN/ProcessInstance/Commands/Handlers/ConsumeMessageProcessInstanceCommandHandler.cs
@@ -5,6 +5,7 @@
 using MassTransit;
 using MediatR;
 using Microsoft.Extensions.Logging;
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -40,13 +41,16 @@ public async Task<bool> Handle(ConsumeMessageInstanceCommand request, Cancellati
 
             processInstance.ConsumeMessage(new Domains.MessageToken
             {
+                Id = Guid.NewGuid().ToString(),
                 Name = request.Name,
                 MessageContent = request.MessageContent == null ? string.Empty : request.MessageContent.ToString()
             });
             var isRestarted = await _processInstanceProcessor.Execute(processInstance, cancellationToken);
             if (isRestarted)
             {
                 var evt = processInstance.Restart();
+                await _processInstanceCommandRepository.Update(processInstance, cancellationToken);
+                await _processInstanceCommandRepository.SaveChanges(cancellationToken);
                 await _busControl.Publish(evt, cancellationToken);
             }
 
diff --git a/src/CaseManagement.BPMN/ProcessInstance/Commands/Handlers/MakeStateTransitionCommandHandler.cs b/src/CaseManagement.BPMN/ProcessInstance/Commands/Handlers/MakeStateTransitionCommandHandler.cs
@@ -5,6 +5,7 @@
 using MassTransit;
 using MediatR;
 using Microsoft.Extensions.Logging;
+using System;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
diff --git a/src/CaseManagement.BPMN/ProcessInstance/Commands/Handlers/StartProcessInstanceCommandHandler.cs b/src/CaseManagement.BPMN/ProcessInstance/Commands/Handlers/StartProcessInstanceCommandHandler.cs
@@ -48,6 +48,8 @@ public async Task<bool> Handle(StartProcessInstanceCommand request, Cancellation
             if (isRestarted)
             {
                 var evt = processInstance.Restart();
+                await _processInstanceCommandRepository.Update(processInstance, cancellationToken);
+                await _processInstanceCommandRepository.SaveChanges(cancellationToken);
                 await _busControl.Publish(evt, cancellationToken);
             }
 
diff --git a/src/CaseManagement.BPMN/ProcessInstance/Processors/Activities/BaseActivityProcessor.cs b/src/CaseManagement.BPMN/ProcessInstance/Processors/Activities/BaseActivityProcessor.cs
@@ -42,7 +42,7 @@ protected override async Task<BPMNExecutionResult> Handle(BPMNExecutionContext e
             {
                 try
                 {
-                    executionContext.Instance.LaunchBoundaryEvts(executionContext.Pointer.ExecutionPathId, elt.BoundaryEvtRefs);
+                    executionContext.Instance.LaunchBoundaryEvts(executionContext.Pointer.ExecutionPathId, elt.BoundaryEvtRefs, executionContext.Pointer.Incoming.ToList());
                     var addOutcome = await Process(executionContext, elt, cancellationToken);
                     outcome.AddRange(addOutcome);
                     executionContext.Instance.UpdateState(instance, ActivityStates.COMPLETED);
diff --git a/src/CaseManagement.BPMN/ProcessInstance/Processors/Activities/EmptyTaskProcessor.cs b/src/CaseManagement.BPMN/ProcessInstance/Processors/Activities/EmptyTaskProcessor.cs
@@ -9,8 +9,8 @@ public class EmptyTaskProcessor : BaseActivityProcessor<EmptyTask>
     {
         protected override Task<ICollection<MessageToken>> Process(BPMNExecutionContext context, EmptyTask elt, CancellationToken cancellationToken)
         {
-            ICollection<MessageToken> emptyTokens = new List<MessageToken>();
-            return Task.FromResult(emptyTokens);
+            ICollection<MessageToken> result = new List<MessageToken> { MessageToken.EmptyMessage(context.Pointer.InstanceFlowNodeId, elt.EltId) };
+            return Task.FromResult(result);
         }
     }
 }
diff --git a/src/CaseManagement.BPMN/ProcessInstance/Processors/Activities/Handlers/CallbackServiceTaskHandler.cs b/src/CaseManagement.BPMN/ProcessInstance/Processors/Activities/Handlers/CallbackServiceTaskHandler.cs
@@ -36,7 +36,7 @@ public async Task<ICollection<MessageToken>> Execute(BPMNExecutionContext contex
 
             var type = TypeResolver.ResolveType(configuration.FullQualifiedName);
             var handler = (IDelegateHandler)_serviceProvider.GetService(type);
-            return await handler.Execute(context.Pointer.Incoming.ToList(), configuration, cancellationToken);
+            return await handler.Execute(context, context.Pointer.Incoming.ToList(), configuration, cancellationToken);
         }
     }
 }
diff --git a/src/CaseManagement.BPMN/ProcessInstance/Processors/Activities/Handlers/WsHumanTaskHandler.cs b/src/CaseManagement.BPMN/ProcessInstance/Processors/Activities/Handlers/WsHumanTaskHandler.cs
@@ -4,7 +4,6 @@
 using CaseManagement.Common.Factories;
 using IdentityModel.Client;
 using Microsoft.Extensions.Options;
-using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
@@ -91,20 +90,15 @@ public async Task<ICollection<MessageToken>> Execute(BPMNExecutionContext execut
                     var httpResult = await httpClient.SendAsync(request, token);
                     var str = await httpResult.Content.ReadAsStringAsync();
                     var o = JObject.Parse(str);
-                    var humanTaskInstancId = o["id"].ToString();
-                    executionContext.Instance.UpdateMetadata(pointer.InstanceFlowNodeId, HUMANTASK_INSTANCE_ID_NAME, humanTaskInstancId);
-                    var jObj = new JObject();
-                    jObj.Add("id", humanTaskInstancId);
-                    var incoming = executionContext.Pointer.Incoming.ToList();
-                    incoming.Add(new MessageToken
-                    {
-                        Name = "humanTaskInstance",
-                        MessageContent = jObj.ToString()
-                    });
+                    var humanTaskInstanceId = o["id"].ToString();
+                    executionContext.Instance.UpdateMetadata(pointer.InstanceFlowNodeId, HUMANTASK_INSTANCE_ID_NAME, humanTaskInstanceId);
+                    var humanTaskInstance = new JObject();
+                    humanTaskInstance.Add("id", humanTaskInstanceId);
                     var messageContent = new JObject();
-                    messageContent.Add("incoming", JArray.FromObject(incoming));
+                    messageContent.Add("humanTaskInstance", humanTaskInstance);
                     executionContext.Instance.ConsumeMessage(new MessageToken
                     {
+                        Id = Guid.NewGuid().ToString(),
                         Name = "humanTaskCreated",
                         MessageContent = messageContent.ToString()
                     });
@@ -119,13 +113,13 @@ public async Task<ICollection<MessageToken>> Execute(BPMNExecutionContext execut
             }
 
             var result = new List<MessageToken>();
-            if (stateTransition.Content == null)
+            if (string.IsNullOrWhiteSpace(stateTransition.Content))
             {
-                result.Add(MessageToken.EmptyMessage());
+                result.Add(MessageToken.EmptyMessage(pointer.InstanceFlowNodeId, userTask.EltId));
             }
             else
             {
-                result.Add(MessageToken.NewMessage(userTask.EltId, stateTransition.Content));
+                result.Add(MessageToken.NewMessage(pointer.InstanceFlowNodeId, userTask.EltId, stateTransition.Content));
             }
 
             return result;
diff --git a/src/CaseManagement.BPMN/ProcessInstance/Processors/BaseFlowNodeProcessor.cs b/src/CaseManagement.BPMN/ProcessInstance/Processors/BaseFlowNodeProcessor.cs
@@ -19,7 +19,8 @@ public async Task<ExecutionResult> Execute(BPMNExecutionContext executionContext
         protected virtual ICollection<string> GetNextFlowNodeIds(BPMNExecutionContext executionContext, BaseFlowNode flowNode)
         {
             var outgoing = executionContext.Instance.GetOutgoingSequenceFlows(flowNode.EltId);
-            var filteredOutgoing = outgoing.Where(_ => executionContext.Instance.IsIncomingSatisfied(_, executionContext.Pointer.Incoming));
+            var filteredOutgoing = outgoing.Where(_ => executionContext.Instance.IsIncomingSatisfied(_, executionContext.Pointer.Incoming) 
+                && !executionContext.Instance.IsEvent(_.TargetRef));
             return filteredOutgoing.Select(_ => _.TargetRef).ToList();
         }
 
diff --git a/src/CaseManagement.BPMN/ProcessInstance/Processors/Evts/BaseCatchEventProcessor.cs b/src/CaseManagement.BPMN/ProcessInstance/Processors/Evts/BaseCatchEventProcessor.cs
diff --git a/src/CaseManagement.BPMN/ProcessInstance/Processors/ProcessInstanceProcessor.cs b/src/CaseManagement.BPMN/ProcessInstance/Processors/ProcessInstanceProcessor.cs
diff --git a/tests/CaseManagement.BPMN.Acceptance.Tests/Delegates/GetWeatherInformationDelegate.cs b/tests/CaseManagement.BPMN.Acceptance.Tests/Delegates/GetWeatherInformationDelegate.cs
diff --git a/tests/CaseManagement.BPMN.Acceptance.Tests/Features/ProcessInstances.feature b/tests/CaseManagement.BPMN.Acceptance.Tests/Features/ProcessInstances.feature
diff --git a/tests/CaseManagement.BPMN.Acceptance.Tests/Features/ProcessInstances.feature.cs b/tests/CaseManagement.BPMN.Acceptance.Tests/Features/ProcessInstances.feature.cs
diff --git a/tests/CaseManagement.BPMN.Tests/Delegates/GetWeatherInformationDelegate.cs b/tests/CaseManagement.BPMN.Tests/Delegates/GetWeatherInformationDelegate.cs
diff --git a/tests/CaseManagement.BPMN.Tests/ProcessJobServerBuilderFixture.cs b/tests/CaseManagement.BPMN.Tests/ProcessJobServerBuilderFixture.cs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using CaseManagement.BPMN.Domains;`
	`2`	`+using CaseManagement.BPMN.ProcessInstance.Processors;`
`2`	`3`	`using Newtonsoft.Json.Linq;`
`3`	`4`	`using System;`
`4`	`5`	`using System.Collections.Generic;`
`@@ -9,13 +10,13 @@ namespace CaseManagement.BPMN.Host.Delegates`
`9`	`10`	`{`
`10`	`11`	`public class GetWeatherInformationDelegate : IDelegateHandler`
`11`	`12`	`{`
`12`		`- public Task<ICollection<MessageToken>> Execute(ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)`
	`13`	`+ public Task<ICollection<MessageToken>> Execute(BPMNExecutionContext context, ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)`
`13`	`14`	`{`
`14`	`15`	`ICollection<MessageToken> result = new List<MessageToken>();`
`15`	`16`	`var rnd = new Random();`
`16`	`17`	`var degree = rnd.Next(0, 40);`
`17`	`18`
`18`		`- result.Add(MessageToken.NewMessage("weatherInformation", new JObject`
	`19`	`+ result.Add(MessageToken.NewMessage(context.Pointer.InstanceFlowNodeId, "weatherInformation", new JObject`
`19`	`20`	`{`
`20`	`21`	`{ "city", "Bruxelles" },`
`21`	`22`	`{ "degree", degree }`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using CaseManagement.BPMN.Domains;`
`2`	`2`	`using CaseManagement.BPMN.Exceptions;`
	`3`	`+using CaseManagement.BPMN.ProcessInstance.Processors;`
`3`	`4`	`using IdentityModel.Client;`
`4`	`5`	`using Newtonsoft.Json.Linq;`
`5`	`6`	`using System;`
`@@ -16,7 +17,7 @@ public class UpdateUserPasswordDelegate : IDelegateHandler`
`16`	`17`	`{`
`17`	`18`	`private const string ActivityName = "Activity_0fhwdxz";`
`18`	`19`
`19`		`- public async Task<ICollection<MessageToken>> Execute(ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)`
	`20`	`+ public async Task<ICollection<MessageToken>> Execute(BPMNExecutionContext context, ICollection<MessageToken> incoming, DelegateConfigurationAggregate delegateConfiguration, CancellationToken cancellationToken)`
`20`	`21`	`{`
`21`	`22`	`var user = incoming.FirstOrDefault(i => i.Name == "user");`
`22`	`23`	`if (user == null)`
`@@ -69,7 +70,11 @@ public async Task<ICollection<MessageToken>> Execute(ICollection<MessageToken> i`
`69`	`70`	`httpResponse.EnsureSuccessStatusCode();`
`70`	`71`	`}`
`71`	`72`
`72`		`- return incoming;`
	`73`	`+ ICollection<MessageToken> result = new List<MessageToken>`
	`74`	`+ {`
	`75`	`+ MessageToken.EmptyMessage(context.Pointer.InstanceFlowNodeId, "updatePassword")`
	`76`	`+ };`
	`77`	`+ return result;`
`73`	`78`	`}`
`74`	`79`
`75`	`80`	`private class UpdateUserPasswordParameter`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class MessageEventDefinition : BaseEventDefinition`
`16`	`16`
`17`	`17`	`public override bool IsSatisfied(ProcessInstanceAggregate processInstance, MessageToken token)`
`18`	`18`	`{`
`19`		`- return processInstance.IsMessageCorrect(token);`
	`19`	`+ return processInstance.IsMessageCorrect(MessageRef, token);`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`public override object Clone()`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@ namespace CaseManagement.BPMN.Domains`
`8`	`8`	`[Serializable]`
`9`	`9`	`public class MessageToken : ICloneable`
`10`	`10`	`{`
	`11`	`+ public string Id { get; set; }`
`11`	`12`	`public string Name { get; set; }`
`12`	`13`	`public string MessageContent { get; set; }`
`13`	`14`	`public MessageTokenTypes Type { get; set; }`
`@@ -52,22 +53,28 @@ public object Clone()`
`52`	`53`	`{`
`53`	`54`	`var result = new MessageToken`
`54`	`55`	`{`
	`56`	`+ Id = Id,`
`55`	`57`	`Name = Name,`
`56`	`58`	`MessageContent = MessageContent,`
`57`	`59`	`Type = Type`
`58`	`60`	`};`
`59`	`61`	`return result;`
`60`	`62`	`}`
`61`	`63`
`62`		`- public static MessageToken EmptyMessage()`
	`64`	`+ public static MessageToken EmptyMessage(string id, string name)`
`63`	`65`	`{`
`64`		`- return new MessageToken();`
	`66`	`+ return new MessageToken`
	`67`	`+ {`
	`68`	`+ Id = id,`
	`69`	`+ Name = name`
	`70`	`+ };`
`65`	`71`	`}`
`66`	`72`
`67`		`- public static MessageToken NewMessage(string name, string content)`
	`73`	`+ public static MessageToken NewMessage(string id, string name, string content)`
`68`	`74`	`{`
`69`	`75`	`return new MessageToken`
`70`	`76`	`{`
	`77`	`+ Id = id,`
`71`	`78`	`MessageContent = content,`
`72`	`79`	`Name = name`
`73`	`80`	`};`
Original file line number	Diff line number	Diff line change
`@@ -48,6 +48,11 @@ public ICollection<BaseFlowNode> ElementDefs`
`48`	`48`
`49`	`49`	`#region Getters`
`50`	`50`
	`51`	`+ public bool IsEvent(string elementId)`
	`52`	`+ {`
	`53`	`+ return GetDefinition(elementId) as BaseEvent != null;`
	`54`	`+ }`
	`55`	`+`
`51`	`56`	`public bool IsIncomingSatisfied(SequenceFlow incomingSequence, IEnumerable<MessageToken> incomingTokens)`
`52`	`57`	`{`
`53`	`58`	`if (!string.IsNullOrWhiteSpace(incomingSequence.ConditionExpression))`
`@@ -115,10 +120,10 @@ public ItemDefinition GetItem(string itemRef)`
`115`	`120`	`return ItemDefs.FirstOrDefault(_ => _.EltId == itemRef);`
`116`	`121`	`}`
`117`	`122`
`118`		`- public bool IsMessageCorrect(MessageToken messageToken)`
	`123`	`+ public bool IsMessageCorrect(string messageRef, MessageToken messageToken)`
`119`	`124`	`{`
`120`	`125`	`var message = GetMessageByName(messageToken.Name);`
`121`		`- if (message == null \|\| messageToken.Name != messageToken.Name)`
	`126`	`+ if (message == null \|\| messageToken.Name != message.Name \|\| message.EltId != messageRef)`
`122`	`127`	`{`
`123`	`128`	`return false;`
`124`	`129`	`}`
`@@ -195,12 +200,12 @@ public ICollection<string> CompleteExecutionPointer(ExecutionPointer pointer, IC`
`195`	`200`	`return result;`
`196`	`201`	`}`
`197`	`202`
`198`		`- public void LaunchBoundaryEvts(string pathId, List<string> evts)`
	`203`	`+ public void LaunchBoundaryEvts(string pathId, List<string> evts, List<MessageToken> incomingTokens)`
`199`	`204`	`{`
`200`	`205`	`var items = evts.Select(e => GetDefinition(e));`
`201`	`206`	`foreach(var item in items)`
`202`	`207`	`{`
`203`		`- TryAddExecutionPointer(pathId, item);`
	`208`	`+ TryAddExecutionPointer(pathId, item, incomingTokens);`
`204`	`209`	`}`
`205`	`210`	`}`
`206`	`211`