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

using Serilog;
using MassTransit;
using Newtonsoft.Json;
using LCU.Library.Internal.DataCleanUpModel.Models;
using LCU.Library.Internal.DataCleanUpModel.Enum;
using LCU.Library.Internal.LcuMassTransitModels;
using LCU.Library.Internal.Exceptions;
using LCU.Library.Internal.ApiResponse.Models;
using System;

namespace LCU.Api.Internal.DataCleanUp.Services;

public class QueueDataCleanUpService : IQueueDataCleanUpService
{
    private readonly ISendEndpoint _sendEndpoint;
    private readonly ReceiveEndpointConfiguration _receiveEndpointConfiguration;

    public QueueDataCleanUpService(IBusControl busControl,
                                   ReceiveEndpointConfiguration receiveEndpointConfiguration)
    {
        _receiveEndpointConfiguration = receiveEndpointConfiguration;
        _sendEndpoint = busControl.GetSendEndpoint(_receiveEndpointConfiguration.ReceiveEndpointUri).Result;
    }

    public async Task QueueDataCleanUp(DataCleanUpRequest dataCleanUpRequest)
    {
        try
        {
            var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
            await _sendEndpoint.Send(dataCleanUpRequest, cancellationTokenSource.Token);
        }
        catch (Exception exception)
        {
            var message = "Failed to Queue {dataCleanUpRequest.CleanUpType} Data Clean Up Request";
            Log.Error($"{message}, Exception Message: {exception.Message}");
            throw new ServiceException($"{message}, Exception Message: {exception.Message}");
        }
    }

    public async Task QueueHyphenatedUserIdCleanUp()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.HyphenatedUserId
            };

            var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
            await _sendEndpoint.Send(dataCleanUpRequest, cancellationTokenSource.Token);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failed to Queue Hyphenated UserId Data Clean Up Request");
            throw new ServiceException("Failed to Queue Hyphenated UserId Data Clean Up Request");
        }
    }

    public async Task QueueDeactivateCustodialEAgreements()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.DeactivateCustodialEAgreements
            };

            var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
            await _sendEndpoint.Send(dataCleanUpRequest, cancellationTokenSource.Token);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failed to Queue Deactivate Custodial EAgreements Request");
            throw new ServiceException("Failed to Queue Deactivate Custodial EAgreements Request");
        }
    }

    public async Task QueueCloseCustodialVruAgreements()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.CloseCustodialVruAgreements
            };

            var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
            await _sendEndpoint.Send(dataCleanUpRequest, cancellationTokenSource.Token);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failed to Queue Close Custodial Vru Agreements Request");
            throw new ServiceException("Failed to Queue Close Custodial Vru Agreements Request");
        }
    }

    public async Task QueueMaskTransactionExternalDescriptionWithSsn()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.MaskTransactionExternalDescriptionWithSsn
            };

            var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
            await _sendEndpoint.Send(dataCleanUpRequest, cancellationTokenSource.Token);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failed to Queue Mask Transaction External Description with SSN");
            throw new ServiceException("Failed to Queue Mask Transaction External Description with SSN");
        }
    }

    public async Task QueueAddFundsToVipSavingsAccounts()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.AddFundsToVipSavingsAccounts
            };

            var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
            await _sendEndpoint.Send(dataCleanUpRequest, cancellationTokenSource.Token);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failed to Queue Add Funds To Vip Savings");
            throw new ServiceException("Failed to Queue Add Funds To Vip Savings");
        }
    }

    public async Task QueueBatchAddFundsToVipSavingsAccounts()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.BatchAddFundsToVipSavingsAccounts
            };

            var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
            await _sendEndpoint.Send(dataCleanUpRequest, cancellationTokenSource.Token);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failed to Queue Batch Add Funds To Vip Savings");
            throw new ServiceException("Failed to Queue Batch Add Funds To Vip Savings");
        }
    }

    public async Task QueueUpdateAdminBranchCodesByAccountNumber()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.UpdateAdminBranchCodesByAccountNumber
            };

            var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
            await _sendEndpoint.Send(dataCleanUpRequest, cancellationTokenSource.Token);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failed to Queue AdminBranchCodeChanges for Account Numbers");
            throw new ServiceException("Failed to Queue AdminBranchCodeChanges for Account Numbers");
        }
    }

    public async Task QueueUpdateAccountLoanToValue()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.UpdateAccountLoanToValue
            };

            var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
            await _sendEndpoint.Send(dataCleanUpRequest, cancellationTokenSource.Token);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failed to Queue UpdateAccountLoanToValue for Account Numbers");
            throw new ServiceException("Failed to Queue UpdateAccountLoanToValue for Account Numbers");
        }
    }

    public async Task QueueUpdateAccountGroupForAnalysis()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.UpdateAccountGroupForAnalysis
            };

            var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
            await _sendEndpoint.Send(dataCleanUpRequest, cancellationTokenSource.Token);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failed to Queue UpdateAccountGroupForAnalysis for Account Numbers");
            throw new ServiceException("Failed to Queue UpdateAccountGroupForAnalysis for Account Numbers");
        }
    }

    public async Task QueueUpdateAccountNickname()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.UpdateAccountNickname
            };
            await QueueDataCleanUp(dataCleanUpRequest);
        }
        catch (Exception ex)
        {
            Log.Error(ex, "Failed to Queue UpdateAccountNickname for Account Numbers");
            throw new ServiceException("Failed to Queue UpdateAccountNickname for Account Numbers");
        }
    }

    public async Task QueuePmiCancelUpdate()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.UpdateAccountPmiCancel
            };
            await QueueDataCleanUp(dataCleanUpRequest);
        }
        catch (Exception ex)
        {
            Log.Error(ex, "Failed to Queue UpdatePmiCancel for Account Numbers");
            throw new ServiceException("Failed to Queue UpdatePmiCancel for Account Numbers");
        }
    }

    public async Task QueueDataCleanUpWithPayload<TRequest>(TRequest request, CleanUpTypes cleanUpType) where TRequest : ReturnResponse
    {
        try
        {
            ArgumentNullException.ThrowIfNull(request);
            var queueRequest = new DataCleanUpRequest
            {
                CleanUpType = cleanUpType, 
                DataCleanUpPayload = JsonConvert.SerializeObject(request),
                ResponseItems = request.ResponseItems
            };
            await QueueDataCleanUp(queueRequest);
        }
        catch (Exception ex)
        { 
            Log.Error(ex, $"Failed to Queue Data Cleanup Type: {cleanUpType}");
            throw new ServiceException($"Failed to Queue Data Cleanup Type: {cleanUpType}");
        }
    }

    public async Task QueueUpdateAccountCreditReportType()
    {
        try
        {
            var dataCleanUpRequest = new DataCleanUpRequest()
            {
                CleanUpType = CleanUpTypes.UpdateAccountCreditReportType
            };
            await QueueDataCleanUp(dataCleanUpRequest);
        }
        catch (Exception ex)
        {
            Log.Error(ex, "Failed to Queue UpdateAccountCreditReportType for Account Numbers");
            throw new ServiceException("Failed to Queue UpdateAccountCreditReportType for Account Numbers");
        }
    }
}