monorepo/LCU.API.Operations.IncentiveAPI/LCU.API.Internal.Operations.IncentiveApi/Services/Temenos/ImportCreditCardSalesService.cs

using CsvHelper;
using CsvHelper.Configuration;
using System.Globalization;
using System.IO;
using LCU.API.Internal.Operations.IncentiveApi.Services.MicroApiServices;
using LCU.API.Internal.Operations.IncentiveApi.Models.Temenos;
using LCU.Library.Internal.ApiResponse.Services;
using LCU.Library.Internal.Exceptions;
using LCU.Library.Internal.IncentiveApiModels.Requests;
using LCU.Library.Internal.IncentiveApiModels.Results;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.API.Internal.Operations.IncentiveApi.Services.Transformations;

namespace LCU.API.Internal.Operations.IncentiveApi.Services.Temenos;

public class ImportCreditCardSalesService : IImportCreditCardSalesService
{
    private readonly IUserRepository _userRepository;
    private readonly IActivityService _activityService;
    private readonly IFileOperationsApiService _fileOperationsApiService;
    private readonly IDeadActivityService _deadActivityService;
    private readonly ProcessResult _importCreditCardResult;

    public ImportCreditCardSalesService(IActivityService activityService, IUserRepository userRepository,
                                        IFileOperationsApiService fileOperationsService, IDeadActivityService deadActivityService)
    {
        _activityService = activityService;
        _userRepository = userRepository;
        _fileOperationsApiService = fileOperationsService;
        _deadActivityService = deadActivityService;
        _importCreditCardResult = new ProcessResult();
    }

    public async Task HandleImportCreditCardSales(ImportCreditCardSalesRequest request)
    {
        try
        {
            var records = await GetCreditCardSales(request);
            List<Activity> allActivity = await CreateActivities(records);

            var personalCardCount = 0;
            var businesCardCount = 0;

            if (allActivity.Any())
            {
                await _activityService.SaveActivityRangeAsync(allActivity);
                personalCardCount = records.Where(x => x.IsPersonal).Count();
                businesCardCount = records.Where(x => !x.IsPersonal).Count();
            }
            
            _importCreditCardResult.MessageStack.Add( $"Imported {personalCardCount} personal and {businesCardCount} business credit cards.");
            await QueueReturnResponse.QueueResponse(request, _importCreditCardResult.Success, _importCreditCardResult.MessageStack);
        }
        catch (Exception exception)
        {
            var message = $"There was an issue with handling Import Credit Card Sales Exception Message: {exception.Message}.";
            _importCreditCardResult.MessageStack.Add(message);
            _importCreditCardResult.Success = false;
            await QueueReturnResponse.QueueResponse(request, _importCreditCardResult.Success, _importCreditCardResult.MessageStack);
        }

    }

    private async Task<IEnumerable<TemenosCreditCardSale>> GetCreditCardSales(ImportCreditCardSalesRequest request)
    {
        var dynamicFileListRequest = request.ToDynamicCreditCardFileListRequest();

        var files = await _fileOperationsApiService.BuildDynamicFileList(dynamicFileListRequest);
        var records = new List<TemenosCreditCardSale>();

        foreach (var file in files) {
            var filePathAndName = request.FinalBasePath + file;
            var contents = _fileOperationsApiService.GetFileContent(filePathAndName);
            using var stringReader = new StringReader(contents.Result);
            var config = new CsvConfiguration(CultureInfo.InvariantCulture)
            {
                Delimiter = "|",
                HasHeaderRecord = false
            };

            using var csv = new CsvReader(stringReader, config);
            records.AddRange(csv.GetRecords<TemenosCreditCardSale>().ToList());
        }
        
        return records;
    }

    private async Task<List<Activity>> CreateActivities(IEnumerable<TemenosCreditCardSale> records)
    {
        var activities = new List<Activity>();
        var deadActivities = new List<DeadActivity>();

        foreach (var record in records)
        {
            string email = string.IsNullOrEmpty(record.ReferringEmployeeEmail) ? null : record.ReferringEmployeeEmail.Trim();
            var employee = string.IsNullOrEmpty(email) ? null : await FindEmployee(email);

            if (employee == null)
            {
                email = string.IsNullOrEmpty(record.LOResponsibleEmployeeEmail) ? null : record.LOResponsibleEmployeeEmail.Trim();
                employee = string.IsNullOrEmpty(email) ? null : await FindEmployee(email);
            }

            if (employee == null
                && (!string.IsNullOrWhiteSpace(record.LODirectLoanOfficer)
                && record.LODirectLoanOfficer.Contains(',')))
            {
                var lastName = record.LODirectLoanOfficer?.Split(',')[0].Trim();
                var firstName = record.LODirectLoanOfficer?.Split(',')[1].Trim();
                email = string.IsNullOrEmpty(firstName) || string.IsNullOrEmpty(lastName)
                        ? null
                        : $"{firstName}{lastName}@landmarkcu.com";
                employee = string.IsNullOrEmpty(email) ? null : await FindEmployee(email);
            }

            if (employee == null)
            {
                _importCreditCardResult.MessageStack.Add($"Action Import, No user for {email} email. Saving as Dead Activity.");
                deadActivities.Add(record.CreateDeadActivity(DeadActivityReason.MissingRequiredField, $"Action Import, No user for {email} email", email));
                continue;
            }

            var homeDept = employee.FindHomeDepartment();
            if (homeDept == null)
            {
                _importCreditCardResult.MessageStack.Add($"User has no reliably determinable home department, {employee.EmployeeId}. Saving as Dead Activity.");
                deadActivities.Add(
                    record.CreateDeadActivity(DeadActivityReason.MissingRequiredField,
                        $"User has no reliably determinable home department, {employee.EmployeeId}", email, employee.EmployeeId));
                continue;
            }

            var activity = record.CreateActivity(employee);

            if (activities.Any(x => x.SourceId == activity.SourceId))
            {
                _importCreditCardResult.MessageStack.Add($"Duplicate activity in Temenos credit card file for Incentive Manager, sourceId is {activity.SourceId}");
                continue;
            }
            activities.Add(activity);
        }

        if (deadActivities.Any())
        {
            await SaveDeadActivities(deadActivities);
        }

        return activities;
    }

    private async Task SaveDeadActivities(List<DeadActivity> deadActivities)
    {
        try
        {
            await _deadActivityService.SaveDeadActivityRange(deadActivities);
        }
        catch (Exception exception)
        {
            _importCreditCardResult.MessageStack.Add($"Failed to SaveDeadActivities in ImportCreditCardSalesService. Dead Activities will be lost. Exception message:{exception.Message}");
        }
    }

    private async Task<AppUser> FindEmployee(string employeeEmail)
    {
        try
        {
            return await _userRepository.FindUserByAdEmailAsync(employeeEmail);
        }
        catch (Exception exception)
        {
            _importCreditCardResult.MessageStack.Add($"Error to FindEmployee email in ImportCreditCardSalesService. Exception messge:{exception.Message}");
            return null;
        }
    }
}