feat: block phase 2 pds

application/CohortManager/compose.core.yaml

@@ -137,6 +137,9 @@ services:
       - ParticipantManagementUrl=http://participant-management-data-service:7994/api/ParticipantManagementDataService
       - ParticipantDemographicDataServiceURL=http://participant-demographic-data-service:7993/api/ParticipantDemographicDataService/
       - ExceptionFunctionURL=http://create-exception:7070/api/CreateException
+      - ManageNemsSubscriptionUnsubscribeURL=http://manage-nems-subscription:9081/api/Unsubscribe
+      - ManageNemsSubscriptionSubscribeURL=http://manage-nems-subscription:9081/api/ManageNemsSubscriptionSubscribeURL
+      - RetrievePdsDemographicURL=http://etrieve-pds-demographic:8082/api/RetrievePdsDemographic
 
   delete-participant:
     container_name: delete-participant

application/CohortManager/src/Functions/CaasIntegration/receiveCaasFile/receiveCaasFileConfig.cs

@@ -19,7 +19,9 @@ public class ReceiveCaasFileConfig
     public string caasfolder_STORAGE { get; set; }
     [Required]
     public string inboundBlobName { get; set; }
+    [Required]
     public string ServiceBusConnectionString_client_internal { get; set; }
     public string GetOrchestrationStatusURL { get; set; }
+    [Required]
     public string ParticipantManagementTopic { get; set; }
 }

application/CohortManager/src/Functions/DemographicServices/ManageNemsSubscription/Extensions/CertificateExtensions.cs

@@ -1,9 +1,11 @@
+namespace NHS.CohortManager.DemographicServices;
+
 using System.Security.Cryptography.X509Certificates;
 using Azure.Identity;
 using Azure.Security.KeyVault.Certificates;
 using Microsoft.Extensions.Logging;
 
-namespace NHS.CohortManager.DemographicServices;
+
 
 public static class CertificateExtensions
 {
@@ -26,15 +28,16 @@ public static async Task<X509Certificate2> LoadNemsCertificateAsync(this ManageN
             var certResult = await certClient.DownloadCertificateAsync(config.NemsKeyName);
             return certResult.Value;
         }
-        
+
         if (!string.IsNullOrEmpty(config.NemsLocalCertPath))
         {
             logger.LogInformation("Loading NEMS certificate from local file");
             return !string.IsNullOrEmpty(config.NemsLocalCertPassword)
                 ? new X509Certificate2(config.NemsLocalCertPath, config.NemsLocalCertPassword)
                 : new X509Certificate2(config.NemsLocalCertPath);
+
         }
-        
+
         throw new InvalidOperationException("No certificate configuration found. Please configure either KeyVaultConnectionString or NemsLocalCertPath.");
     }
-}
+}

application/CohortManager/src/Functions/DemographicServices/ManageNemsSubscription/ManageNemsSubscriptionConfig.cs

@@ -1,6 +1,7 @@
 namespace NHS.CohortManager.DemographicServices;
 
 using System.ComponentModel.DataAnnotations;
+using Hl7.Fhir.Specification.Navigation;
 
 /// <summary>
 /// Configuration settings for NEMS subscription management
@@ -83,14 +84,6 @@ public class ManageNemsSubscriptionConfig
     /// </summary>
     public bool NemsBypassServerCertificateValidation { get; set; } = false;
 
-    /// <summary>
-    /// Default event types to subscribe to
-    /// </summary>
-    public string[] NemsDefaultEventTypes { get; set; } = new[]
-    {
-        "pds-record-change-1"
-    };
-
     /// <summary>
     /// HTTP client timeout in seconds for NEMS API requests
     /// Default: 300 seconds (5 minutes)
@@ -101,5 +94,9 @@ public class ManageNemsSubscriptionConfig
     /// Custom validation to ensure either KeyVault or local cert is configured
     /// </summary>
     public bool IsValid => !string.IsNullOrEmpty(KeyVaultConnectionString) || !string.IsNullOrEmpty(NemsLocalCertPath);
+    /// <summary>
+    /// Bool to set the function to be in stubbed mode. Simulated responses from NEMS
+    /// </summary>
+    public bool IsStubbed { get; set; } = true;
 }
 

application/CohortManager/src/Functions/DemographicServices/ManageNemsSubscription/Program.cs

@@ -6,28 +6,37 @@
 using NHS.CohortManager.DemographicServices;
 using DataServices.Database;
 using Microsoft.Extensions.Logging;
+using System.Security.Cryptography.X509Certificates;
 
 var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
 var logger = loggerFactory.CreateLogger("Program");
 
 var host = new HostBuilder();
 
+
+logger.LogInformation("Application Has Started");
 // Load configuration
 host.AddConfiguration<ManageNemsSubscriptionConfig>(out ManageNemsSubscriptionConfig config);
 
 var nemsConfig = config;
 
+X509Certificate2 nemsCertificate;
+
+
 // Load NEMS certificate up-front and inject into DI
-var nemsCertificate = await nemsConfig.LoadNemsCertificateAsync(logger);
+
+nemsCertificate = await nemsConfig.LoadNemsCertificateAsync(logger);
+
 
 host.ConfigureFunctionsWebApplication();
 host.AddHttpClient()
-    .AddNemsHttpClient()
+    .AddNemsHttpClient(nemsConfig.IsStubbed)
     .ConfigureServices(services =>
     {
         // Register NEMS certificate
         services.AddSingleton(nemsCertificate);
 
+
         // Register NEMS subscription manager
         services.AddScoped<NemsSubscriptionManager>();
 

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

@@ -0,0 +1,8 @@
+namespace NHS.CohortManager.ParticipantManagementService;
+
+public class BlockParticipantDto
+{
+    public required long NhsNumber { get; set; }
+    public required string DateOfBirth { get; set; }
+    public required string FamilyName { get; set; }
+}

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

@@ -0,0 +1,253 @@
+namespace NHS.CohortManager.ParticipantManagementService;
+
+using System;
+using System.Globalization;
+using System.Text.Json;
+using Common;
+using DataServices.Client;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Model;
+
+public class BlockParticipantHandler : IBlockParticipantHandler
+{
+    private readonly ILogger<BlockParticipantHandler> _logger;
+    private readonly IDataServiceClient<ParticipantManagement> _participantManagementDataService;
+    private readonly IDataServiceClient<ParticipantDemographic> _participantDemographicDataService;
+    private readonly IHttpClientFunction _httpClient;
+    private readonly UpdateBlockedFlagConfig _config;
+    public BlockParticipantHandler(ILogger<BlockParticipantHandler> logger,
+        IDataServiceClient<ParticipantManagement> participantManagementDataService,
+        IDataServiceClient<ParticipantDemographic> participantDemographicDataService,
+        IHttpClientFunction httpClient,
+        IOptions<UpdateBlockedFlagConfig> config
+    )
+    {
+        _logger = logger;
+        _participantManagementDataService = participantManagementDataService;
+        _participantDemographicDataService = participantDemographicDataService;
+        _httpClient = httpClient;
+        _config = config.Value;
+    }
+
+    public async Task<BlockParticipantResult> BlockParticipant(BlockParticipantDto blockParticipantRequest)
+    {
+        if (!ValidationHelper.ValidateNHSNumber(blockParticipantRequest.NhsNumber.ToString()))
+        {
+            _logger.LogWarning("Participant had an invalid NHS Number and cannot be blocked");
+            return new BlockParticipantResult(false, "Invalid NHS Number");
+        }
+
+
+
+        var participantManagementRecord = await _participantManagementDataService.GetSingleByFilter(x => x.NHSNumber == blockParticipantRequest.NhsNumber);
+
+        if (participantManagementRecord == null)
+        {
+            return await BlockNewParticipant(blockParticipantRequest);
+        }
+
+        if (participantManagementRecord.BlockedFlag == 1)
+        {
+            _logger.LogWarning("Participant already blocked and cannot be blocked");
+            return new BlockParticipantResult(false, "Participant Already Blocked");
+        }
+
+        var participantDemographic = await _participantDemographicDataService.GetSingleByFilter(x => x.NhsNumber == blockParticipantRequest.NhsNumber);
+
+        if (!ValidateRecordsMatch(participantDemographic, blockParticipantRequest))
+        {
+            _logger.LogWarning("Participant had an didn't pass three point check and cannot be blocked");
+            return new BlockParticipantResult(false, "Participant Didn't pass three point check");
+        }
+
+        _logger.LogInformation("Participant has been blocked");
+        return await BlockExistingParticipant(participantManagementRecord);
+
+
+
+    }
+
+    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.BlockedFlag != 1)
+        {
+            _logger.LogInformation("Participant couldn't be unblocked as they are currently blocked");
+            return new BlockParticipantResult(false, "Participant is not blocked");
+        }
+
+
+        var blockedFlagSet = await SetBlockedFlag(participantManagementRecord, false);
+        if (!blockedFlagSet)
+        {
+            return new BlockParticipantResult(false, "Failed to unset blocked flag");
+        }
+
+        if (participantManagementRecord.EligibilityFlag == 1)
+        {
+            return new BlockParticipantResult(true, "Participant was unblocked but not resubscribed to Nems as they are ineligible");
+        }
+
+        var nemsSubscribed = await SubscribeParticipantToNEMS(nhsNumber);
+        if (!nemsSubscribed)
+        {
+            return new BlockParticipantResult(false, "Participant couldn't be subscribed in Nems");
+        }
+
+        _logger.LogInformation("Participant has been unblocked");
+        return new BlockParticipantResult(true, "Participant Unblocked");
+
+
+    }
+
+    public async Task<BlockParticipantResult> GetParticipant(BlockParticipantDto blockParticipantRequest)
+    {
+
+        if (!ValidationHelper.ValidateNHSNumber(blockParticipantRequest.NhsNumber.ToString()))
+        {
+            _logger.LogWarning("Participant had an invalid NHS Number and cannot be blocked");
+            return new BlockParticipantResult(false, "Invalid NHS Number");
+        }
+
+        var participantDemographic = await _participantDemographicDataService.GetSingleByFilter(x => x.NhsNumber == blockParticipantRequest.NhsNumber);
+
+        if (participantDemographic != null)
+        {
+            var recordsMatch = ValidateRecordsMatch(participantDemographic, blockParticipantRequest);
+            var responseBody = JsonSerializer.Serialize(new BlockParticipantDto
+            {
+                NhsNumber = participantDemographic.NhsNumber,
+                FamilyName = participantDemographic.FamilyName!,
+                DateOfBirth = participantDemographic.DateOfBirth!,
+            });
+            return new BlockParticipantResult(recordsMatch, responseBody);
+        }
+
+        var pdsParticipant = await GetPDSParticipant(blockParticipantRequest.NhsNumber);
+
+        if (pdsParticipant == null)
+        {
+            return new BlockParticipantResult(false, "Participant Couldn't be found");
+        }
+
+        var pdsRecordsMatch = ValidateRecordsMatch(pdsParticipant, blockParticipantRequest);
+        var pdsResponseBody = JsonSerializer.Serialize(new BlockParticipantDto
+        {
+            NhsNumber = pdsParticipant.NhsNumber,
+            FamilyName = pdsParticipant.FamilyName!,
+            DateOfBirth = pdsParticipant.DateOfBirth!
+        });
+
+        return new BlockParticipantResult(pdsRecordsMatch, pdsResponseBody);
+
+    }
+
+    private async Task<BlockParticipantResult> BlockNewParticipant(BlockParticipantDto blockParticipantRequest)
+    {
+        var pdsParticipant = await GetPDSParticipant(blockParticipantRequest.NhsNumber);
+
+        if (pdsParticipant == null || !ValidateRecordsMatch(pdsParticipant, blockParticipantRequest))
+        {
+            return new BlockParticipantResult(false, "Participant details do not match a records in Cohort Manager or PDS");
+        }
+
+        var participantManagementRecord = new ParticipantManagement
+        {
+            NHSNumber = pdsParticipant.NhsNumber,
+            BlockedFlag = 1,
+            EligibilityFlag = 0,
+        };
+
+        var participantManagementAdded = await _participantManagementDataService.Add(participantManagementRecord);
+
+        if (!participantManagementAdded)
+        {
+            return new BlockParticipantResult(false, "Unable to add participant to Cohort Manager to be blocked");
+        }
+
+        return new BlockParticipantResult(true, "Participant Has been blocked");
+
+
+    }
+
+    private async Task<BlockParticipantResult> BlockExistingParticipant(ParticipantManagement participant)
+    {
+        var blockFlagUpdated = await SetBlockedFlag(participant, true);
+
+        if (!blockFlagUpdated)
+        {
+            return new BlockParticipantResult(false, "Failed to Update participant in Cohort Manager");
+        }
+
+        var unsubscribeFromNems = await UnsubscribeParticipantFromNEMS(participant.NHSNumber);
+
+        if (!unsubscribeFromNems)
+        {
+            return new BlockParticipantResult(false, "Failed to unsubscribe Participant From NEMS");
+        }
+
+        return new BlockParticipantResult(true, "Participant Has been blocked");
+
+    }
+
+    private async Task<bool> UnsubscribeParticipantFromNEMS(long nhsNumber)
+    {
+        var nemsUnsubscribeResponse = await _httpClient.SendPost(_config.ManageNemsSubscriptionUnsubscribeURL, CreateNhsNumberQueryParams(nhsNumber));
+
+        return nemsUnsubscribeResponse.IsSuccessStatusCode;
+    }
+
+    private async Task<bool> SubscribeParticipantToNEMS(long nhsNumber)
+    {
+        var nemsSubscribeResponse = await _httpClient.SendPost(_config.ManageNemsSubscriptionSubscribeURL, CreateNhsNumberQueryParams(nhsNumber));
+
+        return nemsSubscribeResponse.IsSuccessStatusCode;
+    }
+
+
+    private async Task<bool> SetBlockedFlag(ParticipantManagement participant, bool blocked)
+    {
+        participant.BlockedFlag = blocked ? (short)1 : (short)0;
+        return await _participantManagementDataService.Update(participant);
+    }
+
+    private async Task<ParticipantDemographic> GetPDSParticipant(long nhsNumber)
+    {
+        var pdsResponse = await _httpClient.SendGet(_config.RetrievePdsDemographicURL, CreateNhsNumberQueryParams(nhsNumber));
+        var pdsDemographic = JsonSerializer.Deserialize<ParticipantDemographic>(pdsResponse);
+
+        return pdsDemographic!;
+    }
+
+    private static bool ValidateRecordsMatch(ParticipantDemographic participant, BlockParticipantDto dto)
+    {
+
+        if (!DateOnly.TryParseExact(dto.DateOfBirth, "yyyy-MM-dd",new CultureInfo("en-GB"),DateTimeStyles.None, out var dtoDateOfBirth ))
+        {
+            throw new FormatException("Date of Birth not in the correct format");
+        }
+
+        if (!DateOnly.TryParseExact(participant.DateOfBirth, "yyyyMMdd",new CultureInfo("en-GB"),DateTimeStyles.None, out var parsedDob))
+        {
+            return false;
+        }
+        return string.Equals(participant.FamilyName, dto.FamilyName, StringComparison.InvariantCultureIgnoreCase)
+            && participant.NhsNumber == dto.NhsNumber
+            && parsedDob == dtoDateOfBirth;
+    }
+
+    private static Dictionary<string, string> CreateNhsNumberQueryParams(long nhsNumber) =>
+        new Dictionary<string, string>
+        {
+            {"nhsNumber",nhsNumber.ToString()}
+        };
+
+}