monorepo/LCU.Api.Internal.DataCleanUp/LCU.Api.Internal.DataCleanUp/Services/DeactivateCustodialEAgreementsService.cs

using Serilog;
using LCU.Library.Internal.DataCleanUpModel.Models;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
using LCU.Library.Internal.CoreApiWrapperModel.Constants;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.AccessChannelPersons;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.AccessTypes;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;

namespace LCU.Api.Internal.DataCleanUp.Services;

public class DeactivateCustodialEAgreementsService : IDeactivateCustodialEAgreementsService
{
    private readonly ICoreApiWrapperService _coreApiWrapperService;
    private const string AccessTypeEAgreeementId = "WWW";

    public DeactivateCustodialEAgreementsService(ICoreApiWrapperService coreApiWrapperService)
    {
        _coreApiWrapperService = coreApiWrapperService;
    }

    public async Task<DataCleanUpResult> CleanUp(DataCleanUpRequest dataCleanUpRequest)
    {
        Log.Information($"Starting Data CleanUp {dataCleanUpRequest.CleanUpType} at {DateTime.Now}");
        var cleanUpResult = new DataCleanUpResult(dataCleanUpRequest, true, new List<string>());

        try
        {
            var activeCustodialAgreePersonNumbers = await _coreApiWrapperService.GetActiveCustodialAgreePersonNumbers();
            foreach (var personNumber in activeCustodialAgreePersonNumbers)
            {
                cleanUpResult = await HandleUpdateDeactivateCustodialEAgreement(cleanUpResult, personNumber);
            }
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Error while Deactivate Custodial Agreement CleanUp.");
            cleanUpResult.Successful = false;
            cleanUpResult.ResponseStack.Add($"Error while Deactivate Custodial EAgreement CleanUp. " +
                                            $"Exception:{exception}");
        }

        Log.Information($"Ending Data CleanUp {dataCleanUpRequest.CleanUpType} at {DateTime.Now}");
        return cleanUpResult;
    }

    public async Task<DataCleanUpResult> HandleUpdateDeactivateCustodialEAgreement(DataCleanUpResult cleanUpResult, string personNumber)
    {
        try
        {
            var accessTypeUpdateRequest = await SetUpAccessTypeUpdateRequest(personNumber);
            if (accessTypeUpdateRequest != null)
            {

                var updatedAccessType = await _coreApiWrapperService.UpdateAccessType(accessTypeUpdateRequest);
                ArgumentNullException.ThrowIfNull(updatedAccessType);

                if (updatedAccessType.IsActive)
                {
                    throw new Exception($"AccessType has not been updated. Expected False but IsActive was true. " +
                                        $"PersonNumber: {personNumber}");
                }
            }
        }
        catch (Exception exception)
        {
            cleanUpResult.Successful = false;
            cleanUpResult.ResponseStack.Add($"Failure to Deactivate Custodial EAgreement. " +
                                            $"PersonNumber:{personNumber} " +
                                            $"Exception Message:{exception.Message}");
        }

        return cleanUpResult;
    }

    public async Task<AccessTypeUpdateRequest?> SetUpAccessTypeUpdateRequest(string personNumber)
    {
        var coreApiMessage = await GetAccessChannelPersons(personNumber);
        ArgumentNullException.ThrowIfNull(coreApiMessage.MessageBody);

        var accessChannelPersons = coreApiMessage.MessageBody.ToList();
        ArgumentNullException.ThrowIfNull(coreApiMessage?.MessageHeader?.UpdateKey);

        AccessChannelPerson? accessChannelPerson = null;
        AccessType? accessType = null;
        foreach (var channelPerson in accessChannelPersons.ToList())
        {
            if (channelPerson.AccessTypes != null && channelPerson.AccessTypes.Any(accessType => accessType.Id == AccessTypeEAgreeementId && accessType.IsActive == true))
            {
                accessChannelPerson = channelPerson;
                accessType = channelPerson.AccessTypes.FirstOrDefault(accessType => accessType.Id == AccessTypeEAgreeementId && accessType.IsActive == true);
            }
        }

        if (accessType == null || accessChannelPerson == null)
        {
            return null;
        }

        accessType.IsActive = false;
        accessType.UserId = null;
        var accessTypeUpdateRequest = new AccessTypeUpdateRequest()
        {
            AccessType = accessType,
            AccessChannelPersonId = accessChannelPerson.Id,
            UpdateKey = (long)coreApiMessage.MessageHeader.UpdateKey
        };

        return accessTypeUpdateRequest;
}

public async Task<CoreApiMessage<IEnumerable<AccessChannelPerson>>> GetAccessChannelPersons(string personNumber)
    {
        long parsedPersonNumber;
        if (!long.TryParse(personNumber, out parsedPersonNumber))
        {
            throw new Exception($"Person number was not able to be parsed to long. " +
                                $"PersonNumber:{personNumber}");
        }

        var request = new AccessChannelPersonsByPersonRequest()
        {
            PersonNumber = parsedPersonNumber,
            ActiveOnly = true,
            IncludeCards = false
        };
        var includes = new List<string>()
        {
            RequestIncludeConstants.AccessTypes
        };
        var coreApiMessage = await _coreApiWrapperService.GetCoreApiMessageAccessChannelPersons(request, includes);
        
        return coreApiMessage;
    }
}