Apr 1152 store not required rules

src/SFA.DAS.ApplyService.Application.UnitTests/Handlers/NotRequiredOverrideHandlerTests/GetNotRequiredOverridesHandlerTests.cs

@@ -0,0 +1,74 @@
+using FluentAssertions;
+using Moq;
+using NUnit.Framework;
+using SFA.DAS.ApplyService.Application.Apply;
+using SFA.DAS.ApplyService.Application.Apply.Roatp;
+using SFA.DAS.ApplyService.Domain.Entities;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SFA.DAS.ApplyService.Application.UnitTests.Handlers.NotRequiredOverrideHandlerTests
+{
+    [TestFixture]
+    public class GetNotRequiredOverridesHandlerTests
+    {
+        private readonly Guid _applicationId = Guid.NewGuid();
+
+        private Mock<IApplyRepository> _repository;
+
+        private GetNotRequiredOverridesHandler _handler;
+
+        [SetUp]
+        public void Before_each_test()
+        {
+            _repository = new Mock<IApplyRepository>();
+
+            _handler = new GetNotRequiredOverridesHandler(_repository.Object);
+        }
+
+        [Test]
+        public async Task Handler_returns_null_if_NotRequiredOverrides_not_persisted()
+        {
+            List<NotRequiredOverride> notRequiredOverrides = null;
+
+            _repository.Setup(x => x.GetNotRequiredOverrides(_applicationId)).ReturnsAsync(notRequiredOverrides);
+
+            var result = await _handler.Handle(new GetNotRequiredOverridesRequest(_applicationId), new CancellationToken());
+
+            _repository.Verify(x => x.GetNotRequiredOverrides(_applicationId), Times.Once);
+            result.Should().BeNull();
+        }
+
+        [Test]
+        public async Task Handler_returns_NotRequiredOverrides_if_persisted()
+        {
+            var notRequiredOverrides = new List<NotRequiredOverride>
+                {
+                    new NotRequiredOverride
+                    {
+                        Conditions = new List<NotRequiredCondition>
+                        {
+                            new NotRequiredCondition
+                            {
+                                ConditionalCheckField = "FIELD1",
+                                MustEqual = "Y",
+                                Value = ""
+                            }
+                        },
+                        SectionId = 1,
+                        SequenceId = 4
+                    }
+                };
+
+            _repository.Setup(x => x.GetNotRequiredOverrides(_applicationId)).ReturnsAsync(notRequiredOverrides);
+
+            var result = await _handler.Handle(new GetNotRequiredOverridesRequest(_applicationId), new CancellationToken());
+
+            _repository.Verify(x => x.GetNotRequiredOverrides(_applicationId), Times.Once);
+            result.Should().NotBeNull();
+            result.Count.Should().Be(1);
+        }
+    }
+}

src/SFA.DAS.ApplyService.Application.UnitTests/Handlers/NotRequiredOverrideHandlerTests/UpdateNotRequiredOverridesHandlerTests.cs

@@ -0,0 +1,60 @@
+using FluentAssertions;
+using Moq;
+using NUnit.Framework;
+using SFA.DAS.ApplyService.Application.Apply;
+using SFA.DAS.ApplyService.Application.Apply.Roatp;
+using SFA.DAS.ApplyService.Domain.Entities;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SFA.DAS.ApplyService.Application.UnitTests.Handlers.NotRequiredOverrideHandlerTests
+{
+    [TestFixture]
+    public class UpdateNotRequiredOverridesHandlerTests
+    {
+        private readonly Guid _applicationId = Guid.NewGuid();
+
+        private Mock<IApplyRepository> _repository;
+
+        private UpdateNotRequiredOverridesHandler _handler;
+
+        [SetUp]
+        public void Before_each_test()
+        {
+            _repository = new Mock<IApplyRepository>();
+
+            _handler = new UpdateNotRequiredOverridesHandler(_repository.Object);
+        }
+
+        [Test]
+        public async Task Handler_returns_true_when_NotRequiredOverrides_are_persisted()
+        {
+            var notRequiredOverrides = new List<NotRequiredOverride>
+                {
+                    new NotRequiredOverride
+                    {
+                        Conditions = new List<NotRequiredCondition>
+                        {
+                            new NotRequiredCondition
+                            {
+                                ConditionalCheckField = "FIELD1",
+                                MustEqual = "Y",
+                                Value = ""
+                            }
+                        },
+                        SectionId = 1,
+                        SequenceId = 4
+                    }
+                };
+
+            _repository.Setup(x => x.UpdateNotRequiredOverrides(_applicationId, notRequiredOverrides)).ReturnsAsync(true);
+
+            var result = await _handler.Handle(new UpdateNotRequiredOverridesRequest(_applicationId, notRequiredOverrides), new CancellationToken());
+
+            _repository.Verify(x => x.UpdateNotRequiredOverrides(_applicationId, notRequiredOverrides), Times.Once);
+            result.Should().BeTrue();
+        }
+    }
+}

src/SFA.DAS.ApplyService.Application/Apply/IApplyRepository.cs

@@ -1,3 +1,4 @@
+using SFA.DAS.ApplyService.Application.Apply.Roatp;
 using SFA.DAS.ApplyService.Domain.Apply;
 using SFA.DAS.ApplyService.Domain.Entities;
 using SFA.DAS.ApplyService.Domain.Roatp;
@@ -67,6 +68,9 @@ public interface IApplyRepository
         Task<Contact> GetContactForApplication(Guid applicationId);
         Task<Organisation> GetOrganisationForApplication(Guid applicationId);
 
+        Task<List<NotRequiredOverride>> GetNotRequiredOverrides(Guid applicationId);
+        Task<bool> UpdateNotRequiredOverrides(Guid applicationId, IEnumerable<NotRequiredOverride> notRequiredOverrides);
+
         Task<List<ApplicationOversightDetails>> GetOversightsPending();
         Task<List<ApplicationOversightDetails>> GetOversightsCompleted();
 

src/SFA.DAS.ApplyService.Application/Apply/Roatp/GetNotRequiredOverridesHandler.cs

@@ -0,0 +1,23 @@
+using MediatR;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using SFA.DAS.ApplyService.Domain.Entities;
+
+namespace SFA.DAS.ApplyService.Application.Apply.Roatp
+{
+    public class GetNotRequiredOverridesHandler : IRequestHandler<GetNotRequiredOverridesRequest, List<NotRequiredOverride>>
+    {
+        private readonly IApplyRepository _applyRepository;
+
+        public GetNotRequiredOverridesHandler(IApplyRepository applyRepository)
+        {
+            _applyRepository = applyRepository;
+        }
+
+        public async Task<List<NotRequiredOverride>> Handle(GetNotRequiredOverridesRequest request, CancellationToken cancellationToken)
+        {
+            return await _applyRepository.GetNotRequiredOverrides(request.ApplicationId);
+        }
+    }
+}

src/SFA.DAS.ApplyService.Application/Apply/Roatp/GetNotRequiredOverridesRequest.cs

@@ -0,0 +1,17 @@
+using MediatR;
+using System;
+using System.Collections.Generic;
+using SFA.DAS.ApplyService.Domain.Entities;
+
+namespace SFA.DAS.ApplyService.Application.Apply.Roatp
+{
+    public class GetNotRequiredOverridesRequest : IRequest<List<NotRequiredOverride>>
+    {
+        public Guid ApplicationId { get; }
+
+        public GetNotRequiredOverridesRequest(Guid applicationId)
+        {
+            ApplicationId = applicationId;
+        }
+    }
+}

src/SFA.DAS.ApplyService.Application/Apply/Roatp/UpdateNotRequiredOverridesHandler.cs

@@ -0,0 +1,21 @@
+using MediatR;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SFA.DAS.ApplyService.Application.Apply.Roatp
+{
+    public class UpdateNotRequiredOverridesHandler : IRequestHandler<UpdateNotRequiredOverridesRequest, bool>
+    {
+        private readonly IApplyRepository _applyRepository;
+
+        public UpdateNotRequiredOverridesHandler(IApplyRepository applyRepository)
+        {
+            _applyRepository = applyRepository;
+        }
+
+        public async Task<bool> Handle(UpdateNotRequiredOverridesRequest request, CancellationToken cancellationToken)
+        {
+            return await _applyRepository.UpdateNotRequiredOverrides(request.ApplicationId, request.NotRequiredOverrides);
+        }
+    }
+}

src/SFA.DAS.ApplyService.Application/Apply/Roatp/UpdateNotRequiredOverridesRequest.cs

@@ -0,0 +1,19 @@
+using MediatR;
+using System;
+using System.Collections.Generic;
+using SFA.DAS.ApplyService.Domain.Entities;
+
+namespace SFA.DAS.ApplyService.Application.Apply.Roatp
+{
+    public class UpdateNotRequiredOverridesRequest : IRequest<bool>
+    {
+        public Guid ApplicationId { get; }
+        public IEnumerable<NotRequiredOverride> NotRequiredOverrides { get; }
+
+        public UpdateNotRequiredOverridesRequest(Guid applicationId, IEnumerable<NotRequiredOverride> notRequiredOverrides)
+        {
+            ApplicationId = applicationId;
+            NotRequiredOverrides = notRequiredOverrides;
+        }
+    }
+}

src/SFA.DAS.ApplyService.Data/ApplyRepository.cs

@@ -29,6 +29,7 @@ public ApplyRepository(IConfigurationService configurationService, ILogger<Apply
             SqlMapper.AddTypeHandler(typeof(QnAData), new QnADataHandler());
             SqlMapper.AddTypeHandler(typeof(ApplicationData), new ApplicationDataHandler());
             SqlMapper.AddTypeHandler(typeof(FinancialReviewDetails), new FinancialReviewDetailsDataHandler());
+            SqlMapper.AddTypeHandler(typeof(NotRequiredOverrideConfiguration), new NotRequiredOverrideDataHandler());
         }
 
         public async Task<Guid> StartApplication(Guid applicationId, ApplyData applyData, Guid organisationId, Guid createdBy)
@@ -935,6 +936,38 @@ await connection.ExecuteAsync(@"UPDATE Apply SET ApplyData = @applyData,
             return await Task.FromResult(true);
         }
 
+        public async Task<List<NotRequiredOverride>> GetNotRequiredOverrides(Guid applicationId)
+        {
+            using (var connection = new SqlConnection(_config.SqlConnectionString))
+            {
+                var notRequiredOverrideConfiguration = await connection.QuerySingleAsync<NotRequiredOverrideConfiguration>(@"SELECT NotRequiredOverrides FROM Apply WHERE ApplicationId = @applicationId",
+                     new { applicationId });
+
+                return notRequiredOverrideConfiguration?.NotRequiredOverrides.ToList();
+            }
+        }
+
+        public async Task<bool> UpdateNotRequiredOverrides(Guid applicationId, IEnumerable<NotRequiredOverride> notRequiredOverrides)
+        {
+            var notRequiredOverrideConfiguration = new NotRequiredOverrideConfiguration
+            {
+                NotRequiredOverrides = notRequiredOverrides
+            };
+
+            using (var connection = new SqlConnection(_config.SqlConnectionString))
+            {
+                await connection.ExecuteAsync(@"UPDATE Apply SET NotRequiredOverrides = @notRequiredOverrideConfiguration
+                                                WHERE ApplicationId = @applicationId",
+                new
+                {
+                    applicationId,
+                    notRequiredOverrideConfiguration
+                });
+            }
+
+            return true;
+        }
+
         public async Task<bool> UpdateOversightReviewStatus(Guid applicationId, string oversightStatus, DateTime applicationDeterminedDate, string updatedBy)
         {
             using (var connection = new SqlConnection(_config.SqlConnectionString))

src/SFA.DAS.ApplyService.Data/DapperTypeHandlers/NotRequiredOverrideDataHandler.cs

@@ -0,0 +1,20 @@
+using Dapper;
+using Newtonsoft.Json;
+using System.Data;
+using SFA.DAS.ApplyService.Domain.Entities;
+
+namespace SFA.DAS.ApplyService.Data.DapperTypeHandlers
+{
+    public class NotRequiredOverrideDataHandler : SqlMapper.TypeHandler<NotRequiredOverrideConfiguration>
+    {
+        public override NotRequiredOverrideConfiguration Parse(object value)
+        {
+            return JsonConvert.DeserializeObject<NotRequiredOverrideConfiguration>(value.ToString());
+        }
+
+        public override void SetValue(IDbDataParameter parameter, NotRequiredOverrideConfiguration value)
+        {
+            parameter.Value = JsonConvert.SerializeObject(value);
+        }
+    }
+}

src/SFA.DAS.ApplyService.Domain/Entities/NotRequiredOverride.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+
+namespace SFA.DAS.ApplyService.Domain.Entities
+{
+    public class NotRequiredOverride
+    {
+        public int SequenceId { get; set; }
+        public int SectionId { get; set; }
+        public List<NotRequiredCondition> Conditions { get; set; }
+
+        public bool AllConditionsMet
+        {
+            get
+            {
+                var allConditionsMet = true;
+
+                if (Conditions != null)
+                {
+                    foreach (var condition in Conditions)
+                    {
+                        if (condition.Value != condition.MustEqual)
+                        {
+                            allConditionsMet = false;
+                            break;
+                        }
+                    }
+                }
+
+                return allConditionsMet;
+            }
+        }
+    }
+
+    public class NotRequiredCondition
+    {
+        public string ConditionalCheckField { get; set; }
+        public string MustEqual { get; set; }
+        public string Value { get; set; }
+    }
+
+    public class NotRequiredOverrideConfiguration
+    {
+        public IEnumerable<NotRequiredOverride> NotRequiredOverrides { get; set; }
+    }
+}

src/SFA.DAS.ApplyService.InternalApi/Controllers/NotRequiredOverridesController.cs

@@ -0,0 +1,36 @@
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using SFA.DAS.ApplyService.Application.Apply.Roatp;
+using SFA.DAS.ApplyService.Domain.Entities;
+
+namespace SFA.DAS.ApplyService.InternalApi.Controllers
+{
+    [Authorize]
+    public class NotRequiredOverridesController : Controller
+    {
+        private readonly IMediator _mediator;
+
+        public NotRequiredOverridesController(IMediator mediator)
+        {
+            _mediator = mediator;
+        }
+
+        [HttpGet("NotRequiredOverrides/{applicationId}")]
+        public async Task<IActionResult> GetNotRequiredOverrides(Guid applicationId)
+        {
+            var notRequiredOverrides = await _mediator.Send(new GetNotRequiredOverridesRequest(applicationId));
+            return Ok(notRequiredOverrides);
+        }
+
+        [HttpPost("NotRequiredOverrides/{applicationId}")]
+        public async Task<IActionResult> SaveNotRequiredOverrides(Guid applicationId, [FromBody] IEnumerable<NotRequiredOverride> notRequiredOverrides)
+        {
+            var updateResult = await _mediator.Send(new UpdateNotRequiredOverridesRequest(applicationId, notRequiredOverrides));
+            return Ok(updateResult);
+        }
+    }
+}