Ticket #105 : Can update notification + escalation + fix integration tests

Author: habarthierry-hue

src/CaseManagement.BPMN/Infrastructure/Jobs/Notifications/StateTransitionNotification.cs

@@ -19,6 +19,11 @@ public JObject JObjContent
         {
             get
             {
+                if (Content == null)
+                {
+                    return null;
+                }
+
                 return JObject.Parse(Content);
             }
         }

src/CaseManagement.BPMN/ProcessInstance/Processors/Activities/Handlers/WsHumanTaskHandler.cs

@@ -8,6 +8,7 @@
 using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Net.Http;
 using System.Text;
@@ -113,6 +114,7 @@ public async Task<ICollection<MessageToken>> Execute(BPMNExecutionContext execut
                 result.Add(MessageToken.NewMessage(userTask.Id, stateTransition.Content));
             }
 
+            Debug.WriteLine("COUCOU");
             return result;
         }
     }

src/CaseManagement.HumanTask.AspNetCore/Apis/HumanTaskDefsController.cs

@@ -420,6 +420,37 @@ public async Task<IActionResult> AddDeadlineEscalation(string id, string deadLin
             }
         }
 
+        [HttpPut("{id}/deadlines/{deadLineId}/escalations/{escalationId}")]
+        public async Task<IActionResult> UpdateDeadlineEscalation(string id, string deadLineId, string escalationId, [FromBody] UpdateHumanTaskDefEscalationDeadlineCommand updateHumanTaskDefEscalationStartDeadlineCommand, CancellationToken token)
+        {
+            try
+            {
+                updateHumanTaskDefEscalationStartDeadlineCommand.Id = id;
+                updateHumanTaskDefEscalationStartDeadlineCommand.DeadlineId = deadLineId;
+                updateHumanTaskDefEscalationStartDeadlineCommand.EscalationId = escalationId;
+                var newId = await _mediator.Send(updateHumanTaskDefEscalationStartDeadlineCommand, token);
+                return new NoContentResult();
+            }
+            catch (BadRequestException ex)
+            {
+                return this.ToError(new List<KeyValuePair<string, string>>
+                {
+                    new KeyValuePair<string, string>("bad_request", ex.Message)
+                }, HttpStatusCode.BadRequest, Request);
+            }
+            catch (UnknownHumanTaskDefException ex)
+            {
+                return this.ToError(new List<KeyValuePair<string, string>>
+                {
+                    new KeyValuePair<string, string>("bad_request", ex.Message)
+                }, HttpStatusCode.NotFound, Request);
+            }
+            catch (AggregateValidationException ex)
+            {
+                return this.ToError(ex.Errors, HttpStatusCode.BadRequest, Request);
+            }
+        }
+
         [HttpDelete("{id}/deadlines/{deadLineId}/escalations/{escalationId}")]
         public async Task<IActionResult> DeleteStartDeadlineEscalation(string id, string deadLineId, string escalationId, CancellationToken token)
         {

src/CaseManagement.HumanTask.AspNetCore/Apis/NotificationDefsController.cs

@@ -39,6 +39,13 @@ public async Task<IActionResult> Add([FromBody] AddNotificationDefCommand parame
             }
         }
 
+        [HttpGet]
+        public async Task<IActionResult> GetAll(CancellationToken token)
+        {
+            var result = await _mediator.Send(new GetAllNotificationDefQuery(), token);
+            return new OkObjectResult(result);
+        }
+
         [HttpPost(".search")]
         public async Task<IActionResult> Search([FromBody] SearchNotificationDefQuery parameter, CancellationToken token)
         {

src/CaseManagement.HumanTask/Domains/HumanTaskDef/Events/HumanTaskDefEscalationDeadlineAddedEvent.cs

@@ -13,17 +13,20 @@ public HumanTaskDefEscalationDeadlineAddedEvent(string id,
             string deadlineId,
             string escalationId,
             string condition,
+            string notificationId,
             DateTime updateDateTime) : base(id, aggregateId, version)
         {
             DeadLineId = deadlineId;
             EscalationId = escalationId;
             Condition = condition;
+            NotificationId = notificationId;
             UpdateDateTime = updateDateTime;
         }
 
         public string DeadLineId { get; set; }
         public string EscalationId { get; set; }
         public string Condition { get; set; }
+        public string NotificationId { get; set; }
         public DateTime UpdateDateTime { get; set; }
     }
 }

src/CaseManagement.HumanTask/Domains/HumanTaskDef/Events/HumanTaskDefEscalationDeadlineUpdatedEvent.cs

@@ -0,0 +1,25 @@
+using CaseManagement.Common.Domains;
+using System;
+using System.Diagnostics;
+
+namespace CaseManagement.HumanTask.Domains
+{
+    [DebuggerDisplay("Escalation is updated")]
+    public class HumanTaskDefEscalationDeadlineUpdatedEvent : DomainEvent
+    {
+        public HumanTaskDefEscalationDeadlineUpdatedEvent(string id, string aggregateId, int version, string deadlineId, string escalationId, string condition, string notificationId, DateTime updateDateTime) : base(id, aggregateId, version)
+        {
+            DeadLineId = deadlineId;
+            EscalationId = escalationId;
+            Condition = condition;
+            NotificationId = notificationId;
+            UpdateDateTime = updateDateTime;
+        }
+
+        public string DeadLineId { get; set; }
+        public string EscalationId { get; set; }
+        public string Condition { get; set; }
+        public string NotificationId { get; set; }
+        public DateTime UpdateDateTime { get; set; }
+    }
+}

src/CaseManagement.HumanTask/Domains/HumanTaskDef/HumanTaskDefinitionAggregate.cs

@@ -210,14 +210,20 @@ public void UpdateDeadline(string id, string name, string forExpr, string untilE
             Handle(evt);
         }
 
-        public string AddEscalationDeadline(string startDeadlineId, string condition)
+        public string AddEscalationDeadline(string startDeadlineId, string condition, string notificationId)
         {
             var result = Guid.NewGuid().ToString();
-            var evt = new HumanTaskDefEscalationDeadlineAddedEvent(Guid.NewGuid().ToString(), AggregateId, Version + 1, startDeadlineId, result, condition, DateTime.UtcNow);
+            var evt = new HumanTaskDefEscalationDeadlineAddedEvent(Guid.NewGuid().ToString(), AggregateId, Version + 1, startDeadlineId, result, condition, notificationId, DateTime.UtcNow);
             Handle(evt);
             return result;
         }
 
+        public void UpdateEscalationDeadline(string deadlineId, string escalationId, string condition, string notificationId)
+        {
+            var evt = new HumanTaskDefEscalationDeadlineUpdatedEvent(Guid.NewGuid().ToString(), AggregateId, Version + 1, deadlineId, escalationId, condition, notificationId, DateTime.UtcNow);
+            Handle(evt);
+        }
+
         public void DeleteEscalationDeadline(string completionDeadLineId, string escalationId)
         {
             var evt = new HumanTaskDefEscalationDeadlineRemovedEvent(Guid.NewGuid().ToString(), AggregateId, Version + 1, completionDeadLineId, escalationId, DateTime.UtcNow);
@@ -390,34 +396,64 @@ private void Handle(HumanTaskDefDeadLineRemovedEvent evt)
         private void Handle(HumanTaskDefEscalationDeadlineAddedEvent evt)
         {
             var errors = new List<KeyValuePair<string, string>>();
-            var completionDeadLine = DeadLines.FirstOrDefault(_ => _.Id == evt.DeadLineId);
-            if (completionDeadLine == null)
+            var deadline = DeadLines.FirstOrDefault(_ => _.Id == evt.DeadLineId);
+            if (deadline == null)
             {
-                errors.Add(new KeyValuePair<string, string>("validation", Global.UnknownStartDeadline));
+                errors.Add(new KeyValuePair<string, string>("validation", Global.UnknownDeadline));
             }
 
             if (errors.Any())
             {
                 throw new AggregateValidationException(errors);
             }
 
-            completionDeadLine.Escalations.Add(new Escalation
+            deadline.Escalations.Add(new Escalation
             {
+                NotificationId = evt.NotificationId,
                 Condition = evt.Condition,
                 Id = evt.EscalationId
             });
             UpdateDateTime = evt.UpdateDateTime;
             Version = evt.Version;
         }
 
+        private void Handle(HumanTaskDefEscalationDeadlineUpdatedEvent evt)
+        {
+            Escalation escalation = null;
+            var errors = new List<KeyValuePair<string, string>>();
+            var deadline = DeadLines.FirstOrDefault(_ => _.Id == evt.DeadLineId);
+            if (deadline == null)
+            {
+                errors.Add(new KeyValuePair<string, string>("validation", Global.UnknownDeadline));
+            }
+            else
+            {
+                escalation = deadline.Escalations.FirstOrDefault(_ => _.Id == evt.EscalationId);
+                if (escalation == null)
+                {
+                    errors.Add(new KeyValuePair<string, string>("validation", Global.UnknownEscalation));
+                }
+            }
+
+            if (errors.Any())
+            {
+                throw new AggregateValidationException(errors);
+            }
+
+            escalation.NotificationId = evt.NotificationId;
+            escalation.Condition = evt.Condition;
+            UpdateDateTime = evt.UpdateDateTime;
+            Version = evt.Version;
+        }
+
         private void Handle(HumanTaskDefDeadlineUpdatedEvent evt)
         {
             var d = DeadLines.FirstOrDefault(_ => _.Id == evt.DeadLineId);
             if (d == null)
             {
                 throw new AggregateValidationException(new List<KeyValuePair<string, string>>
                 {
-                    new KeyValuePair<string, string>("validation", Global.UnknownStartDeadline)
+                    new KeyValuePair<string, string>("validation", Global.UnknownDeadline)
                 });
             }
 

src/CaseManagement.HumanTask/HumanTaskDef/Commands/AddHumanTaskDefEscalationDeadlineCommand.cs

@@ -7,5 +7,6 @@ public class AddHumanTaskDefEscalationDeadlineCommand : IRequest<string>
         public string Id { get; set; }
         public string DeadlineId { get; set; }
         public string Condition { get; set; }
+        public string NotificationId { get; set; }
     }
 }

src/CaseManagement.HumanTask/HumanTaskDef/Commands/Handlers/AddHumanTaskDefEscalationDeadlineCommandHandler.cs

@@ -40,7 +40,7 @@ public async Task<string> Handle(AddHumanTaskDefEscalationDeadlineCommand reques
                 throw new UnknownHumanTaskDefException(string.Format(Global.UnknownHumanTaskDef, request.Id));
             }
 
-            var id = result.AddEscalationDeadline(request.DeadlineId, request.Condition);
+            var id = result.AddEscalationDeadline(request.DeadlineId, request.Condition, request.NotificationId);
             await _humanTaskDefCommandRepository.Update(result, cancellationToken);
             await _humanTaskDefCommandRepository.SaveChanges(cancellationToken);
             _logger.LogInformation("Escalation has been added to deadline");

src/CaseManagement.HumanTask/HumanTaskDef/Commands/Handlers/UpdateHumanTaskDefEscalationDeadlineCommandHandler.cs

@@ -0,0 +1,50 @@
+using CaseManagement.Common.Exceptions;
+using CaseManagement.HumanTask.Exceptions;
+using CaseManagement.HumanTask.Persistence;
+using CaseManagement.HumanTask.Resources;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CaseManagement.HumanTask.HumanTaskDef.Commands.Handlers
+{
+    public class UpdateHumanTaskDefEscalationDeadlineCommandHandler : IRequestHandler<UpdateHumanTaskDefEscalationDeadlineCommand, bool>
+    {
+        private readonly IHumanTaskDefCommandRepository _humanTaskDefCommandRepository;
+        private readonly IHumanTaskDefQueryRepository _humanTaskDefQueryRepository;
+        private readonly ILogger<UpdateHumanTaskDefEscalationDeadlineCommandHandler> _logger;
+
+        public UpdateHumanTaskDefEscalationDeadlineCommandHandler(
+            IHumanTaskDefCommandRepository humanTaskDefCommandRepository,
+            IHumanTaskDefQueryRepository humanTaskDefQueryRepository,
+            ILogger<UpdateHumanTaskDefEscalationDeadlineCommandHandler> logger)
+        {
+            _humanTaskDefCommandRepository = humanTaskDefCommandRepository;
+            _humanTaskDefQueryRepository = humanTaskDefQueryRepository;
+            _logger = logger;
+        }
+
+        public async Task<bool> Handle(UpdateHumanTaskDefEscalationDeadlineCommand request, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrWhiteSpace(request.Condition))
+            {
+                _logger.LogError("the parameter 'condition' is missing");
+                throw new BadRequestException(string.Format(Global.MissingParameter, "condition"));
+            }
+
+            var result = await _humanTaskDefQueryRepository.Get(request.Id, cancellationToken);
+            if (result == null)
+            {
+                _logger.LogError($"The human task definition '{request.Id}' doesn't exist");
+                throw new UnknownHumanTaskDefException(string.Format(Global.UnknownHumanTaskDef, request.Id));
+            }
+
+            result.UpdateEscalationDeadline(request.DeadlineId, request.EscalationId, request.Condition, request.NotificationId);
+            await _humanTaskDefCommandRepository.Update(result, cancellationToken);
+            await _humanTaskDefCommandRepository.SaveChanges(cancellationToken);
+            _logger.LogInformation("Escalation has been updated");
+            return true;
+        }
+    }
+}