UpdateBlockedFlag.cs

namespace NHS.CohortManager.ParticipantManagementService;

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using Common;
using System.Net;
using System.Text.Json;
using Azure.Messaging.EventGrid.SystemEvents;

public class UpdateBlockedFlag
{
    private readonly ILogger<UpdateBlockedFlag> _logger;
    private readonly ICreateResponse _createResponse;
    private readonly IBlockParticipantHandler _blockParticipantHandler;

    private const string cannotBeDeserializedMessage = "Participant Block Dto couldn't be deserialized";


    public UpdateBlockedFlag(ILogger<UpdateBlockedFlag> logger, ICreateResponse createResponse, IBlockParticipantHandler blockParticipantHandler)
    {
        _logger = logger;
        _createResponse = createResponse;
        _blockParticipantHandler = blockParticipantHandler;
    }

    /// <summary>
    /// Takes in a http request that if the input is valid then it updates the blocked flag within participant management table to 1.
    /// Otherwise, adds an exception to the exception table.
    /// </summary>
    /// <param name="req">
    /// A Http request that should contain an NHS number, family name, date of birth and a screening ID.
    /// </param>
    /// <returns>
    /// A http status code. (200 - Ok / 404 - Not Found / 500 - Internal server error)
    /// </returns>
    [Function("BlockParticipant")]
    public async Task<HttpResponseData> BlockParticipant([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req)
    {


        _logger.LogInformation("Block Participant Called");
        try
        {
            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 blockParticipantResult = await _blockParticipantHandler.BlockParticipant(blockParticipantDTO);

            if (blockParticipantResult.Success)
            {
                return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.OK, req, blockParticipantResult.ResponseMessage!);
            }
            return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.BadRequest, req, blockParticipantResult.ResponseMessage!);
        }
        catch (JsonException jex)
        {
            _logger.LogError(jex, cannotBeDeserializedMessage);
            return _createResponse.CreateHttpResponse(HttpStatusCode.BadRequest, req);
        }
        catch (FormatException fex)
        {
            _logger.LogError(fex, cannotBeDeserializedMessage);
            return _createResponse.CreateHttpResponse(HttpStatusCode.BadRequest, req);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An error occurred while blocking a participant");
            return _createResponse.CreateHttpResponse(HttpStatusCode.InternalServerError, req);
        }

    }
    /// <summary>
    /// Get Participant details will look up a participant in cohort manager if they do not exist in cohort manager then they
    /// will be looked up in PDS. Once they are found a three point check will be carried out to ensure thier details matched, the found
    /// details will be returned for manual assurance that the correct individual has been found
    /// </summary>
    /// <param name="req"></param>
    /// <returns>BlockParticipantDto or Error message</returns>
    [Function("GetParticipant")]
    public async Task<HttpResponseData> GetParticipantDetails([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req)
    {
        _logger.LogInformation("Get Participant Details Called");
        try
        {
            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);

            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)
        {
            _logger.LogError(jex, cannotBeDeserializedMessage);
            return _createResponse.CreateHttpResponse(HttpStatusCode.BadRequest, req);
        }
        catch (FormatException fex)
        {
            _logger.LogError(fex, cannotBeDeserializedMessage);
            return _createResponse.CreateHttpResponse(HttpStatusCode.BadRequest, req);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An error occurred while blocking a participant");
            return _createResponse.CreateHttpResponse(HttpStatusCode.InternalServerError, req);
        }
    }

    /// <summary>
    /// Takes in a http request that if the input is valid then it updates the blocked flag within participant management table to 0.
    /// Otherwise, adds an exception to the exception table.
    /// </summary>
    /// <param name="req">
    /// A Http request that should contain an NHS number, family name, date of birth and a screening ID.
    /// </param>
    /// <returns>
    /// A http status code. (200 - Ok / 404 - Not Found / 500 - Internal server error)
    /// </returns>
    [Function("UnblockParticipant")]
    public async Task<HttpResponseData> UnblockParticipant([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req)
    {
        _logger.LogInformation("Unblock Participant Called");
        var nhsNumber = req.Query["nhsNumber"];
        if (string.IsNullOrWhiteSpace(nhsNumber))
        {
            return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.BadRequest, req, "No NHS Number provided");
        }

        if (!ValidationHelper.ValidateNHSNumber(nhsNumber))
        {
            return await _createResponse.CreateHttpResponseWithBodyAsync(HttpStatusCode.BadRequest, req, "Invalid NHS Number provided");
        }

        var nhsNumberParsed = long.Parse(nhsNumber);

        var unBlockParticipantResult = await _blockParticipantHandler.UnblockParticipant(nhsNumberParsed);

        if (unBlockParticipantResult.Success)
        {
            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!);



    }


}