monorepo/LCU.API.Operations.IncentiveAPI/LCU.API.Internal.Operations.IncentiveApi/Services/DnaActivityServices/ReferralActivityService.cs

using LCU.API.Internal.Operations.IncentiveApi.Exceptions;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.API.Internal.Operations.IncentiveApi.Models.ExternalActivities;
using LCU.API.Internal.Operations.IncentiveApi.Services.MicroApiServices;
using LCU.Library.Internal.IncentiveApiModels.Requests;
using LCU.Api.Internal.MaidBotLib.Models;
using LCU.Library.Internal.Exceptions;
using LCU.Library.Internal.IncentiveApiModels.Results;
using LCU.API.Internal.Operations.IncentiveApi.Services.IncentiveProcesses;
using LCU.Library.Internal.LCUServiceFactory.Configurations;
using Microsoft.Extensions.DependencyInjection;

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

public class ReferralActivityService : IncentiveProcessesService, IIncentiveProcessesService
{
    private readonly ICoreApiWrapperService _coreApiWrapperService;
    private readonly IServiceScopeFactory _serviceScopeFactory;
    private readonly ProcessResult _incentiveProcessResult;

    public ReferralActivityService(ServicesFactoryConfiguration servicesFactoryConfiguration, 
        ICoreApiWrapperService coreApiWrapperService, IServiceScopeFactory serviceScopeFactory)
        : base(servicesFactoryConfiguration)
    {
        _coreApiWrapperService = coreApiWrapperService;
        _serviceScopeFactory = serviceScopeFactory;
        _incentiveProcessResult = new ProcessResult();
    }

    public async Task<ProcessResult> SyncLatestActivitiesFromDna(IncentiveProcessRequest request)
    {
        try
        {
            var externalActivities = await ProcessLatestActivity();
            var message = $"Added {externalActivities.Count()} Referrals from DNA";
            Log.Information(message);
            _incentiveProcessResult.MessageStack.Add(message);
        }
        catch (Exception exception)
        {
            var message = $"There was an issue with Referrals from DNA process. Exception Message: {exception.Message}.";
            _incentiveProcessResult.MessageStack.Add(message);
            _incentiveProcessResult.Success = false;
        }

        return _incentiveProcessResult;
    }

    public async Task<List<IExternalActivity>> ProcessLatestActivity()
    {
        try
        {
            using var scope = _serviceScopeFactory.CreateScope();
            var lastUpdate = await Task.Run(async () => await scope.ServiceProvider.GetRequiredService<IDnaActivityProcessingService>().GetLastActivityProcessedData(Process.ImportActivityManagerReferralsFromDna) ?? throw new MissingProcessorRunHistoryException(Process.ImportActivityManagerReferralsFromDna));
            var allActivities = (await _coreApiWrapperService.GetNewActivityManagerReferralsActivity(lastUpdate.LastProcessedRecordTimestamp)).ToList();
            var filteredActivities = await Task.Run(async () => await scope.ServiceProvider.GetRequiredService<IDnaActivityProcessingService>().GetFilteredExternalActivities(allActivities.Cast<IExternalActivity>().ToList()));
            var mappedActivities = await Task.Run(async () => await scope.ServiceProvider.GetRequiredService<IDnaActivityProcessingService>().HandleMapExternalActivities(filteredActivities.ToList(), Product.Unknown, ActivityType.Referral));

            if (mappedActivities.Count > 0)
            {
                foreach (var activity in mappedActivities)
                {
                    await Task.Run(async () => await scope.ServiceProvider.GetRequiredService<IDnaActivityProcessingService>().HandleIncomingActivityDecision(activity, Product.Unknown, ActivityType.Referral));
                }
            }

            if (allActivities.Count < 1)
            {
                await Task.Run(async () => await scope.ServiceProvider.GetRequiredService<IDnaActivityProcessingService>().UpdateProcessorHistory(Process.ImportActivityManagerReferralsFromDna, lastUpdate.LastProcessedRecordId, lastUpdate.LastProcessedRecordTimestamp));
                return filteredActivities;
            }

            var latestActivity = allActivities.Where(activity => activity.OriginationDateTime == allActivities.Select(ca => ca.OriginationDateTime).Max()).OrderByDescending(x => x.ActivityId).First();
            await Task.Run(async () => await scope.ServiceProvider.GetRequiredService<IDnaActivityProcessingService>().UpdateProcessorHistory(Process.ImportActivityManagerReferralsFromDna, latestActivity.ActivityId, latestActivity.OriginationDateTime));

            return filteredActivities;
        }
        catch (ServiceException serviceException) 
        {
            Log.ForContext(Enum.GetName(typeof(PropertyEnum), PropertyEnum.Group), Enum.GetName(typeof(GroupEnum), GroupEnum.ITDevelopment))
               .Error(serviceException, $"Import Referrals Failure. " +
                                        $"Failed to Process Referrals. Will try again from same starting position on next run.");
            throw;
        }
        catch (Exception exception)
        {
            Log.ForContext(Enum.GetName(typeof(PropertyEnum), PropertyEnum.Group), Enum.GetName(typeof(GroupEnum), GroupEnum.ITDevelopment))
               .Fatal(exception, $"Import Referrals Failure. " +
                                 $"Failed to Process Referrals. Will try again from same starting position on next run.");
            throw;
        }
    }
}