feat: block phase 2 pds

application/CohortManager/src/Functions/ParticipantManagementServices/UpdateBlockedFlag/BlockParticipantHandler.cs

@@ -5,6 +5,7 @@ namespace NHS.CohortManager.ParticipantManagementService;
 using System.Text.Json;
 using Common;
 using DataServices.Client;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion.Internal;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Model;
@@ -70,17 +71,12 @@ public async Task<BlockParticipantResult> BlockParticipant(BlockParticipantDto b
 
     public async Task<BlockParticipantResult> UnblockParticipant(long nhsNumber)
     {
-        if (!ValidationHelper.ValidateNHSNumber(nhsNumber.ToString()))
-        {
-            _logger.LogWarning("Invalid NHS Number and cannot be unblocked");
-            return new BlockParticipantResult(false, "Invalid NHS Number");
-        }
 
         var participantManagementRecord = await _participantManagementDataService.GetSingleByFilter(x => x.NHSNumber == nhsNumber);
 
         if (participantManagementRecord == null)
         {
-            return new BlockParticipantResult(false, "Participant couldn't be found");
+            return new BlockParticipantResult(false, "Participant Couldn't be found");
         }
 
         if (participantManagementRecord.BlockedFlag != 1)
@@ -227,6 +223,12 @@ private async Task<bool> SetBlockedFlag(ParticipantManagement participant, bool
     private async Task<ParticipantDemographic> GetPDSParticipant(long nhsNumber)
     {
         var pdsResponse = await _httpClient.SendGet(_config.RetrievePdsDemographicURL, CreateNhsNumberQueryParams(nhsNumber));
+        if (string.IsNullOrEmpty(pdsResponse))
+        {
+            _logger.LogWarning("RetrievePDSDemographic Didn't return a valid response");
+            return null!;
+        }
+
         var pdsDemographic = JsonSerializer.Deserialize<ParticipantDemographic>(pdsResponse);
 
         return pdsDemographic!;

application/CohortManager/src/Functions/ParticipantManagementServices/UpdateBlockedFlag/UpdateBlockedFlag.cs

@@ -6,6 +6,7 @@ namespace NHS.CohortManager.ParticipantManagementService;
 using Common;
 using System.Net;
 using System.Text.Json;
+using Azure.Messaging.EventGrid.SystemEvents;
 
 public class UpdateBlockedFlag
 {
@@ -91,16 +92,35 @@ public async Task<HttpResponseData> GetParticipantDetails([HttpTrigger(Authoriza
         _logger.LogInformation("Get Participant Details Called");
         try
         {
-            var blockParticipantDTO = await req.ReadFromJsonAsync<BlockParticipantDto>();
+            var blockParticipantDTOJson = await req.ReadAsStringAsync();
+            if (string.IsNullOrWhiteSpace(blockParticipantDTOJson))
+            {
+                return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.BadRequest, req, "Unable to parse request");
+            }
 
+            var blockParticipantDTO = JsonSerializer.Deserialize<BlockParticipantDto>(blockParticipantDTOJson);
             if (blockParticipantDTO == null)
             {
                 return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.BadRequest, req, "Unable to parse request");
             }
 
             var getParticipantResult = await _blockParticipantHandler.GetParticipant(blockParticipantDTO);
 
-            return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.OK, req, getParticipantResult.ResponseMessage!);
+            if (getParticipantResult.Success)
+            {
+                return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.OK, req, getParticipantResult.ResponseMessage!);
+            }
+
+            if (getParticipantResult.ResponseMessage == "Participant Couldn't be found")
+            {
+                return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.NotFound, req, "Participant Not found");
+            }
+            if (getParticipantResult.ResponseMessage == "Invalid NHS Number")
+            {
+                return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.BadRequest, req, getParticipantResult.ResponseMessage);
+            }
+
+            return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.InternalServerError, req, getParticipantResult.ResponseMessage!);
 
         }
         catch (JsonException jex)
@@ -149,12 +169,18 @@ public async Task<HttpResponseData> UnblockParticipant([HttpTrigger(Authorizatio
 
         var unBlockParticipantResult = await _blockParticipantHandler.UnblockParticipant(nhsNumberParsed);
 
-        if (!unBlockParticipantResult.Success)
+        if (unBlockParticipantResult.Success)
         {
-            return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.BadRequest, req, unBlockParticipantResult.ResponseMessage!);
+            return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.OK, req, "Participant successfully unblocked");
         }
+        if (unBlockParticipantResult.ResponseMessage == "Participant Couldn't be found")
+        {
+            return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.NotFound, req, "Participant Not found");
+        }
+
+        return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.BadRequest, req, unBlockParticipantResult.ResponseMessage!);
+
 
-        return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.OK, req, "Participant successfully unblocked");
 
     }
 

tests/UnitTests/ParticipantManagementServicesTests/UpdateBlockedFlagTests/UpdateBlockedFlagTests.cs

@@ -238,7 +238,7 @@ public async Task BlockParticipant_ExistingParticipantFailsThreePointCheck_Retur
         _mockParticipantDemographicClient.Verify(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantDemographic, bool>>>()), Times.Once);
         _mockParticipantDemographicClient.VerifyNoOtherCalls();
     }
-      [TestMethod]
+    [TestMethod]
     public async Task BlockParticipant_NonExistentParticipantFailsThreePointCheck_ReturnsFailure()
     {
         //arrange
@@ -280,6 +280,270 @@ public async Task BlockParticipant_NonExistentParticipantFailsThreePointCheck_Re
         _mockParticipantManagementClient.VerifyNoOtherCalls();
         _mockHttpClient.VerifyNoOtherCalls();
     }
+    [TestMethod]
+    public async Task GetParticipant_ParticipantExistsInCM_ReturnsSuccess()
+    {
+        //arrange
+        var requestBody = new BlockParticipantDto
+        {
+            NhsNumber = 6427635034,
+            FamilyName = "Jones",
+            DateOfBirth = "1923-10-12"
+        };
+
+        _request = _setupRequest.Setup(JsonSerializer.Serialize(requestBody));
+
+        _mockParticipantDemographicClient.Setup(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantDemographic, bool>>>()))
+            .ReturnsAsync(new ParticipantDemographic
+            {
+                NhsNumber = 6427635034,
+                FamilyName = "Jones",
+                DateOfBirth = "19231012"
+            });
+
+
+
+        //act
+        var result = await _sut.GetParticipantDetails(_request.Object);
+
+        //asset
+        Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
+        _mockParticipantDemographicClient.Verify(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantDemographic, bool>>>()));
+        _mockParticipantManagementClient.VerifyNoOtherCalls();
+        _mockHttpClient.VerifyNoOtherCalls();
+    }
+    [TestMethod]
+    public async Task GetParticipant_ParticipantOnlyInPDS_ReturnsSuccess()
+    {
+        //arrange
+        var requestBody = new BlockParticipantDto
+        {
+            NhsNumber = 6427635034,
+            FamilyName = "Jones",
+            DateOfBirth = "1923-10-12"
+        };
+
+        _request = _setupRequest.Setup(JsonSerializer.Serialize(requestBody));
+
+        _mockParticipantDemographicClient.Setup(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantDemographic, bool>>>()))
+            .Returns(Task.FromResult<ParticipantDemographic>(null!));
+
+        var pdsDemoResponse = JsonSerializer.Serialize(
+            new ParticipantDemographic
+            {
+                NhsNumber = 6427635034,
+                FamilyName = "Jones",
+                DateOfBirth = "19231012"
+            });
+
+        _mockHttpClient.Setup(x => x.SendGet("RetrievePdsDemographicUrl", It.IsAny<Dictionary<string, string>>()))
+            .ReturnsAsync(pdsDemoResponse);
+
+
+        //act
+        var result = await _sut.GetParticipantDetails(_request.Object);
+
+        //asset
+        Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
+        _mockHttpClient.Verify(x => x.SendGet("RetrievePdsDemographicUrl", It.IsAny<Dictionary<string, string>>()), Times.Once);
+        _mockParticipantDemographicClient.Verify(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantDemographic, bool>>>()));
+        _mockParticipantManagementClient.VerifyNoOtherCalls();
+        _mockHttpClient.VerifyNoOtherCalls();
+    }
+    [TestMethod]
+    public async Task GetParticipant_ParticipantNotExists_ReturnsFailure()
+    {
+        //arrange
+        var requestBody = new BlockParticipantDto
+        {
+            NhsNumber = 6427635034,
+            FamilyName = "Jones",
+            DateOfBirth = "1923-10-12"
+        };
+
+        _request = _setupRequest.Setup(JsonSerializer.Serialize(requestBody));
+
+        _mockParticipantDemographicClient.Setup(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantDemographic, bool>>>()))
+            .Returns(Task.FromResult<ParticipantDemographic>(null!));
+
+        var pdsDemoResponse = JsonSerializer.Serialize(
+            new ParticipantDemographic
+            {
+                NhsNumber = 6427635034,
+                FamilyName = "Jones",
+                DateOfBirth = "19231012"
+            });
+
+        _mockHttpClient.Setup(x => x.SendGet("RetrievePdsDemographicUrl", It.IsAny<Dictionary<string, string>>()))
+            .Returns(Task.FromResult<string?>("")!);
+
+
+        //act
+        var result = await _sut.GetParticipantDetails(_request.Object);
+
+        //asset
+        Assert.AreEqual(HttpStatusCode.NotFound, result.StatusCode);
+        _mockHttpClient.Verify(x => x.SendGet("RetrievePdsDemographicUrl", It.IsAny<Dictionary<string, string>>()), Times.Once);
+        _mockParticipantDemographicClient.Verify(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantDemographic, bool>>>()), Times.Once);
+        _mockParticipantManagementClient.VerifyNoOtherCalls();
+        _mockHttpClient.VerifyNoOtherCalls();
+    }
+    [TestMethod]
+    public async Task GetParticipant_InvalidNhsNumber_ReturnsFailure()
+    {
+        //arrange
+        var requestBody = new BlockParticipantDto
+        {
+            NhsNumber = 6427635035,
+            FamilyName = "Jones",
+            DateOfBirth = "1923-10-12"
+        };
+
+        _request = _setupRequest.Setup(JsonSerializer.Serialize(requestBody));
+
+        //act
+        var result = await _sut.GetParticipantDetails(_request.Object);
+
+        //asset
+        Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
+    }
+    [TestMethod]
+    public async Task UnblockParticipant_ParticipantIsBlocked_ReturnsSuccess()
+    {
+        //arrange
+        var queryParams = new NameValueCollection
+        {
+            {"nhsNumber","6427635034"}
+        };
+        _request = _setupRequest.Setup("", queryParams, HttpMethod.Post);
+
+        _mockParticipantManagementClient.Setup(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantManagement, bool>>>()))
+            .ReturnsAsync(new ParticipantManagement
+            {
+                NHSNumber = 6427635034,
+                BlockedFlag = 1,
+                EligibilityFlag = 1
+            });
+
+        _mockParticipantManagementClient.Setup(x => x.Update(It.IsAny<ParticipantManagement>()))
+            .ReturnsAsync(true);
+
+        _mockHttpClient.Setup(x => x.SendPost("NemsSubscribeUrl", It.IsAny<Dictionary<string, string>>()))
+            .ReturnsAsync(new HttpResponseMessage
+            {
+                StatusCode = HttpStatusCode.OK
+            });
+
+
+        //act
+        var result = await _sut.UnblockParticipant(_request.Object);
+
+        //asset
+        Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
+        _mockHttpClient.Verify(x => x.SendPost("NemsSubscribeUrl", It.IsAny<Dictionary<string, string>>()), Times.Once);
+        _mockParticipantManagementClient.Verify(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantManagement, bool>>>()), Times.Once);
+        _mockParticipantManagementClient.Verify(x => x.Update(It.IsAny<ParticipantManagement>()), Times.Once);
+        _mockParticipantManagementClient.VerifyNoOtherCalls();
+        _mockHttpClient.VerifyNoOtherCalls();
+    }
+
+    [TestMethod]
+    [DataRow("6427635035")]
+    [DataRow("642763")]
+    [DataRow("abs7635035")]
+    public async Task UnblockParticipant_InvalidNhsNumber_ReturnsFailure(string nhsNumber)
+    {
+        //arrange
+        var queryParams = new NameValueCollection
+        {
+            {"nhsNumber",nhsNumber}
+        };
+        _request = _setupRequest.Setup("", queryParams, HttpMethod.Post);
+
+        //act
+        var result = await _sut.UnblockParticipant(_request.Object);
+
+        //asset
+        Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
+    }
+    [TestMethod]
+    public async Task UnblockParticipant_ParticipantNotFound_ReturnsFailure()
+    {
+        //arrange
+        var queryParams = new NameValueCollection
+        {
+            {"nhsNumber","6427635034"}
+        };
+        _request = _setupRequest.Setup("", queryParams, HttpMethod.Post);
+
+        _mockParticipantManagementClient.Setup(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantManagement, bool>>>()))
+            .Returns(Task.FromResult<ParticipantManagement>(null!));
+
+        //act
+        var result = await _sut.UnblockParticipant(_request.Object);
+
+        //asset
+        Assert.AreEqual(HttpStatusCode.NotFound, result.StatusCode);
+        _mockParticipantManagementClient.Verify(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantManagement, bool>>>()), Times.Once);
+        _mockHttpClient.VerifyNoOtherCalls();
+    }
+    [TestMethod]
+    public async Task UnblockParticipant_ParticipantNotBlocked_ReturnBadRequest()
+    {
+        //arrange
+        var queryParams = new NameValueCollection
+        {
+            {"nhsNumber","6427635034"}
+        };
+        _request = _setupRequest.Setup("", queryParams, HttpMethod.Post);
+
+        _mockParticipantManagementClient.Setup(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantManagement, bool>>>()))
+            .ReturnsAsync(new ParticipantManagement
+            {
+                NHSNumber = 6427635034,
+                BlockedFlag = 0,
+                EligibilityFlag = 1
+            });
+
+
+        //act
+        var result = await _sut.UnblockParticipant(_request.Object);
+
+        //asset
+        Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
+        _mockParticipantManagementClient.Verify(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantManagement, bool>>>()), Times.Once);
+        _mockParticipantManagementClient.VerifyNoOtherCalls();
+        _mockHttpClient.VerifyNoOtherCalls();
+    }
+    // [TestMethod]
+    // public async Task UnblockParticipant_ParticipantNotBlocked_ReturnBadRequest()
+    // {
+    //     //arrange
+    //     var queryParams = new NameValueCollection
+    //     {
+    //         {"nhsNumber","6427635034"}
+    //     };
+    //     _request = _setupRequest.Setup("", queryParams, HttpMethod.Post);
+
+    //     _mockParticipantManagementClient.Setup(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantManagement, bool>>>()))
+    //         .ReturnsAsync(new ParticipantManagement
+    //         {
+    //             NHSNumber = 6427635034,
+    //             BlockedFlag = 0,
+    //             EligibilityFlag = 1
+    //         });
+
+
+    //     //act
+    //     var result = await _sut.UnblockParticipant(_request.Object);
+
+    //     //asset
+    //     Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
+    //     _mockParticipantManagementClient.Verify(x => x.GetSingleByFilter(It.IsAny<Expression<Func<ParticipantManagement, bool>>>()), Times.Once);
+    //     _mockParticipantManagementClient.VerifyNoOtherCalls();
+    //     _mockHttpClient.VerifyNoOtherCalls();
+    // }
+