Apr 1152 store not required rules

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

@@ -1,3 +1,4 @@
+using SFA.DAS.ApplyService.Application.Apply.Roatp;
 using SFA.DAS.ApplyService.Application.Apply.Submit;
 using SFA.DAS.ApplyService.Domain.Apply;
 using SFA.DAS.ApplyService.Domain.Entities;
@@ -93,6 +94,10 @@ public interface IApplyRepository
         Task<bool> IsSectionCompleted(Guid applicationId, Guid applicationSectionId);
 
         Task RemoveSectionCompleted(Guid applicationId, Guid applicationSectionId);
+
+        Task<NotRequiredOverrideConfiguration> GetNotRequiredOverrides(Guid applicationId);
+
+        Task<bool> SaveNotRequiredOverrides(Guid applicationId, NotRequiredOverrideConfiguration notRequiredOverrides);
 
     }
 }

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

@@ -0,0 +1,27 @@
+
+using MediatR;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SFA.DAS.ApplyService.Application.Apply.Roatp
+{
+    public class GetNotRequiredOverridesHandler : IRequestHandler<GetNotRequiredOverridesRequest, NotRequiredOverrideConfiguration>
+    {
+        private readonly IApplyRepository _applyRepository;
+        private readonly ILogger<GetNotRequiredOverridesHandler> _logger;
+
+        public GetNotRequiredOverridesHandler(IApplyRepository applyRepository, ILogger<GetNotRequiredOverridesHandler> logger)
+        {
+            _applyRepository = applyRepository;
+            _logger = logger;
+        }
+
+        public async Task<NotRequiredOverrideConfiguration> Handle(GetNotRequiredOverridesRequest request, CancellationToken cancellationToken)
+        {
+            var configuration = await _applyRepository.GetNotRequiredOverrides(request.ApplicationId);
+            return await Task.FromResult(configuration);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+
+namespace SFA.DAS.ApplyService.Application.Apply.Roatp
+{
+    public class NotRequiredOverride
+    {
+        public int SequenceId { get; set; }
+        public int SectionId { get; set; }
+        public List<NotRequiredCondition> Conditions { get; set; }        
+    }
+
+    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.Application/Apply/Roatp/UpdateNotRequiredOverridesHandler.cs

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

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

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

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

@@ -1,6 +1,8 @@
 using Dapper;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
 using SFA.DAS.ApplyService.Application.Apply;
+using SFA.DAS.ApplyService.Application.Apply.Roatp;
 using SFA.DAS.ApplyService.Configuration;
 using SFA.DAS.ApplyService.Data.DapperTypeHandlers;
 using SFA.DAS.ApplyService.Domain.Apply;
@@ -29,6 +31,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)
@@ -1208,5 +1211,32 @@ await connection.ExecuteAsync(@"UPDATE Apply SET ApplyData = @applyData,
             return await Task.FromResult(true);
         }
 
+        public async Task<NotRequiredOverrideConfiguration> GetNotRequiredOverrides(Guid applicationId)
+        {
+            using (var connection = new SqlConnection(_config.SqlConnectionString))
+            {
+                var applyDataResults = await connection.QueryAsync<NotRequiredOverrideConfiguration>(@"SELECT NotRequiredOverrides FROM Apply WHERE ApplicationId = @applicationId",
+                    new { applicationId });
+
+                return applyDataResults.FirstOrDefault();
+            }
+        }
+
+        public async Task<bool> SaveNotRequiredOverrides(Guid applicationId, NotRequiredOverrideConfiguration notRequiredOverrides)
+        {
+            using (var connection = new SqlConnection(_config.SqlConnectionString))
+            {
+                await connection.ExecuteAsync(@"UPDATE Apply SET NotRequiredOverrides = @notRequiredOverrides
+                                                WHERE ApplicationId = @applicationId",
+                new
+                {
+                    applicationId,
+                    notRequiredOverrides
+                });
+            }
+
+            return await Task.FromResult(true);
+        }
+
     }
 }

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

@@ -0,0 +1,20 @@
+using Dapper;
+using Newtonsoft.Json;
+using SFA.DAS.ApplyService.Application.Apply.Roatp;
+using System.Data;
+
+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.Database/Tables/Apply.sql

@@ -15,7 +15,8 @@
     [UpdatedBy] NVARCHAR(256) NULL, 
     [DeletedAt] DATETIME2 NULL, 
     [DeletedBy] NVARCHAR(256) NULL,
-    [UKPRN] AS JSON_VALUE(ApplyData, '$.ApplyDetails.UKPRN') PERSISTED
+    [UKPRN] AS JSON_VALUE(ApplyData, '$.ApplyDetails.UKPRN') PERSISTED,
+    [NotRequiredOverrides] NVARCHAR(MAX) NULL
 )
 GO
 CREATE INDEX [IX_Apply_ApplicationId] ON [Apply] ([ApplicationId])

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

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

src/SFA.DAS.ApplyService.Web.UnitTests/Controllers/RoatpApplicationControllerTests.cs

@@ -27,6 +27,7 @@
 using System.Linq;
 using System.Security.Claims;
 using System.Threading.Tasks;
+using NotRequiredOverrideConfiguration = SFA.DAS.ApplyService.Web.Configuration.NotRequiredOverrideConfiguration;
 
 namespace SFA.DAS.ApplyService.Web.UnitTests.Controllers
 {