monorepo/LCU.API.Internal.DocumentIngestor/LCU.API.Internal.DocumentIngestor/Services/DocumentProcessorServices/FosLoanStatementProcessingService.cs

using System.Globalization;
using LCU.API.Internal.DocumentIngestor.Services.AttributeDeterminingServices;
using LCU.API.Internal.DocumentIngestor.Services.MicroApiServices;
using LCU.Library.DocumentType.Enums;
using LCU.Library.DocumentType.Extensions;
using LCU.Library.DocumentType.Models.Requests.Account;
using LCU.Library.DocumentType.Models.Requests.Attributes;
using LCU.Library.Internal.DocumentIngestorModels.Models;
using LCU.Library.Internal.DocumentIngestorModels.Models.IndexFileDocuments;
using LCU.Library.Internal.DocumentIngestorModels.Validations;
using LCU.Library.Internal.LCUServiceFactory.Configurations;
using Newtonsoft.Json;
using Serilog;

namespace LCU.API.Internal.DocumentIngestor.Services.DocumentProcessorServices
{
    public class FosLoanStatementProcessingService : DocumentProcessingService, IDocumentProcessingService
    {
        private const DataSourceTypes DataSource = DataSourceTypes.DNA;
        private const SourceTypes Source = SourceTypes.FOS;
        private const string DateFormat = "yyyyMMdd";
        private readonly IAccountOwnerDeterminingService _accountOwnerDeterminingService;
        private readonly IFileOperationsApiService _fileOperationsApiService;
        private readonly IDocumentTypeUploaderApiService _documentTypeUploaderApiService;

        public FosLoanStatementProcessingService(IAccountOwnerDeterminingService accountDeterminingService,
                                                IFileOperationsApiService fileOperationsApiService,
                                                IDocumentTypeUploaderApiService documentTypeUploaderApiService,
                                                ServicesFactoryConfiguration servicesFactoryConfiguration)
            : base(servicesFactoryConfiguration)
        {
            _documentTypeUploaderApiService = documentTypeUploaderApiService;
            _fileOperationsApiService = fileOperationsApiService;
            _accountOwnerDeterminingService = accountDeterminingService;
        }

        public async Task<ProcessResult> ProcessRequest(ProcessingRequest request)
        {
            var processResult = new ProcessResult();

            try
            {
                Log.Debug("Starting FosLoanStatement ProcessRequest.");
                ArgumentNullException.ThrowIfNull(request);
                var documentValues = JsonConvert.DeserializeObject<FosLoanStatement>(request.DocumentValuePayload);
                ArgumentNullException.ThrowIfNull(documentValues);

                processResult = ValidateRecord(processResult, documentValues);
                if (!processResult.Success)
                {
                    return processResult;
                }

                if (!DateTime.TryParseExact(documentValues.CreationDate, DateFormat, CultureInfo.InvariantCulture,
                        DateTimeStyles.AssumeLocal, out var creationDate))
                {
                    var message =
                        $"A Creation Date of {documentValues.CreationDate} could not be properly formatted from format: {DateFormat}";
                    return ProcessResult.ProcessDataMappingFailure(processResult, message);
                }

                var accountOwnerAttribute = await _accountOwnerDeterminingService.DetermineAccountOwnerAttribute(
                    documentValues.EntityName,
                    documentValues.AccountNumber,
                    creationDate,
                    request.OwnerOverrideInfo);

                if (!accountOwnerAttribute.Success)
                {
                    return ProcessResult.ProcessDataMappingFailure(processResult, 
                                                                   accountOwnerAttribute.Message);
                }

                var accountOwnerRequest = await BuildAccountUploadRequest(request, documentValues, creationDate, accountOwnerAttribute.Payload);
                await _documentTypeUploaderApiService.UploadAccountDocument(accountOwnerRequest, request, processResult);

                Log.Debug("Ending FosLoanStatement ProcessRequest.");
            }
            catch (Exception exception)
            {
                var message = $"An Exception occured while FosLoanStatement ProcessRequest. " +
                              $"Exception Message: {exception.Message} ";
                Log.Error(exception, message);
                processResult = ProcessResult.ProcessCriticalFailure(processResult, message);
            }

            return processResult;
        }

        public ProcessResult ValidateRecord(ProcessResult processResult, FosLoanStatement documentValues)
        {
            processResult = MetaDataValidation.ValidateAccountNumber(processResult, documentValues.AccountNumber);
            processResult = MetaDataValidation.ValidateFileName(processResult, documentValues.DocName);
            processResult = MetaDataValidation.ValidateFullName(processResult, documentValues.EntityName);
            processResult = MetaDataValidation.ValidateDocumentType<AccountDocumentTypes>(processResult, documentValues.DocType);

            return processResult;
        }

        public async Task<AccountDocumentRequest> BuildAccountUploadRequest(ProcessingRequest request,
                                                                            FosLoanStatement documentValues,
                                                                            DateTime creationDate,
                                                                            AccountAttribute accountAttribute)
        {
            var contentBytes = await _fileOperationsApiService.GetContentBytes(request.IngestorRequest.RootPath,
                                                                               request.DocumentFileName);

            var type = documentValues.DocType.GetValueFromName<AccountDocumentTypes>();
            ArgumentNullException.ThrowIfNull(type);

            var accountOwnerDocumentRequest = new AccountDocumentRequest
            {
                Content = contentBytes,
                AccountAttribute = accountAttribute,
                AccountDocumentMetadata = new AccountDocumentMetadata
                {
                    Source = Source,
                    DataSource = DataSource,
                    Name = request.DocumentFileName,
                    Type = type,
                    CreatedDate = creationDate,
                    TraceId = request.IngestorRunInfoId
                }
            };
            return accountOwnerDocumentRequest;
        }
    }
}