More changes for logging and error handling

TransactionProcessing.SchedulerService/TransactionProcessing.SchedulerService.Jobs/BaseJob.cs

@@ -0,0 +1,54 @@
+namespace TransactionProcessing.SchedulerService.Jobs;
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using DataGeneration;
+using EstateManagement.Client;
+using SecurityService.Client;
+using SecurityService.DataTransferObjects.Responses;
+using Shared.Logger;
+using TransactionProcessor.Client;
+
+public abstract class BaseJob{
+    public String JobName { get; set; }
+
+    protected ITransactionDataGenerator CreateTransactionDataGenerator(String clientId, String clientSecret, RunningMode runningMode){
+        ISecurityServiceClient securityServiceClient = Bootstrapper.GetService<ISecurityServiceClient>();
+        IEstateClient estateClient = Bootstrapper.GetService<IEstateClient>();
+        ITransactionProcessorClient transactionProcessorClient = Bootstrapper.GetService<ITransactionProcessorClient>();
+        Func<String, String> baseAddressFunc = Bootstrapper.GetService<Func<String, String>>();
+
+        ITransactionDataGenerator g = new TransactionDataGenerator(securityServiceClient,
+                                                                   estateClient,
+                                                                   transactionProcessorClient,
+                                                                   baseAddressFunc("EstateManagementApi"),
+                                                                   baseAddressFunc("FileProcessorApi"),
+                                                                   baseAddressFunc("TestHostApi"),
+                                                                   clientId,
+                                                                   clientSecret,
+                                                                   runningMode);
+        return g;
+    }
+
+    protected async Task<String> GetToken(String clientId, String clientSecret, CancellationToken cancellationToken)
+    {
+        ISecurityServiceClient securityServiceClient = Bootstrapper.GetService<ISecurityServiceClient>();
+        TokenResponse token = await securityServiceClient.GetToken(clientId, clientSecret, cancellationToken);
+
+        return token.AccessToken;
+    }
+
+    protected void TraceGenerated(TraceEventArgs traceArguments)
+    {
+        if (traceArguments.TraceLevel == TraceEventArgs.Level.Error){
+            Logger.LogError(new Exception(traceArguments.Message));
+        }
+        else if (traceArguments.TraceLevel == TraceEventArgs.Level.Warning){
+            Logger.LogWarning(traceArguments.Message);
+        }
+        else{
+            Logger.LogInformation(traceArguments.Message);
+        }
+    }
+}

TransactionProcessing.SchedulerService/TransactionProcessing.SchedulerService.Jobs/Bootstrapper.cs

@@ -1,17 +1,14 @@
 namespace TransactionProcessing.SchedulerService.Jobs;
 
 using System;
+using System.Diagnostics.Eventing.Reader;
 using System.Net.Http;
-using System.Threading.Tasks;
-using System.Threading;
-using DataGeneration;
 using EstateManagement.Client;
 using EstateManagement.DataTransferObjects.Responses;
 using MessagingService.Client;
 using Microsoft.Extensions.DependencyInjection;
 using Quartz;
 using SecurityService.Client;
-using SecurityService.DataTransferObjects.Responses;
 using TransactionProcessor.Client;
 
 public static class Bootstrapper{
@@ -50,32 +47,4 @@ public static T GetService<T>()
     {
         return Bootstrapper.ServiceProvider.GetService<T>();
     }
-}
-
-public class BaseJob{
-    protected ITransactionDataGenerator CreateTransactionDataGenerator(String clientId, String clientSecret, RunningMode runningMode){
-        ISecurityServiceClient securityServiceClient = Bootstrapper.GetService<ISecurityServiceClient>();
-        IEstateClient estateClient = Bootstrapper.GetService<IEstateClient>();
-        TransactionProcessorClient transactionProcessorClient = Bootstrapper.GetService<TransactionProcessorClient>();
-        Func<String, String> baseAddressFunc = Bootstrapper.GetService<Func<String, String>>();
-
-        ITransactionDataGenerator g = new TransactionDataGenerator(securityServiceClient,
-                                                                   estateClient,
-                                                                   transactionProcessorClient,
-                                                                   baseAddressFunc("EstateManagementApi"),
-                                                                   baseAddressFunc("FileProcessorApi"),
-                                                                   baseAddressFunc("TestHostApi"),
-                                                                   clientId,
-                                                                   clientSecret,
-                                                                   runningMode);
-        return g;
-    }
-
-    protected async Task<String> GetToken(String clientId, String clientSecret, CancellationToken cancellationToken)
-    {
-        ISecurityServiceClient securityServiceClient = Bootstrapper.GetService<ISecurityServiceClient>();
-        TokenResponse token = await securityServiceClient.GetToken(clientId, clientSecret, cancellationToken);
-
-        return token.AccessToken;
-    }
 }

TransactionProcessing.SchedulerService/TransactionProcessing.SchedulerService.Jobs/GenerateFileUploadsJob.cs

@@ -6,7 +6,7 @@
     using DataGeneration;
     using EstateManagement.DataTransferObjects.Responses;
     using Quartz;
-    using Quartz.Logging;
+    using Shared.Logger;
 
     [DisallowConcurrentExecution]
     public class GenerateFileUploadsJob : BaseJob, IJob
@@ -21,13 +21,15 @@ public async Task Execute(IJobExecutionContext context)
             Guid estateId = context.MergedJobDataMap.GetGuidValueFromString("EstateId");
             Guid merchantId = context.MergedJobDataMap.GetGuidValueFromString("MerchantId");
 
-            ITransactionDataGenerator t = CreateTransactionDataGenerator(clientId, clientSecret, RunningMode.Live);
+            Logger.LogInformation($"Running Job {context.JobDetail.Description}");
+            Logger.LogInformation($"Client Id: [{clientId}]");
+            Logger.LogInformation($"Estate Id: [{estateId}]");
+            Logger.LogInformation($"Merchant Id: [{merchantId}]");
 
+            ITransactionDataGenerator t = CreateTransactionDataGenerator(clientId, clientSecret, RunningMode.Live);
+            t.TraceGenerated += TraceGenerated; 
             await Jobs.GenerateFileUploads(t, estateId, merchantId, context.CancellationToken);
         }
-
-
-
         #endregion
     }
 }

TransactionProcessing.SchedulerService/TransactionProcessing.SchedulerService.Jobs/GenerateMerchantStatementJob.cs

@@ -4,6 +4,7 @@
 using System.Threading.Tasks;
 using DataGeneration;
 using Quartz;
+using Shared.Logger;
 
 public class GenerateMerchantStatementJob : BaseJob, IJob
 {
@@ -14,23 +15,12 @@ public async Task Execute(IJobExecutionContext context)
         String clientSecret = context.MergedJobDataMap.GetString("ClientSecret");
         Guid estateId = context.MergedJobDataMap.GetGuidValueFromString("EstateId");
 
+        Logger.LogInformation($"Running Job {context.JobDetail.Description}");
+        Logger.LogInformation($"Client Id: [{clientId}]");
+        Logger.LogInformation($"Estate Id: [{estateId}]");
+
         ITransactionDataGenerator t = this.CreateTransactionDataGenerator(clientId, clientSecret, RunningMode.Live);
-
+        t.TraceGenerated += TraceGenerated;
         await Jobs.GenerateMerchantStatements(t, estateId, context.CancellationToken);
     }
-}
-
-public class SupportReportJob : BaseJob, IJob
-{
-    public async Task Execute(IJobExecutionContext context)
-    {
-        Bootstrapper.ConfigureServices(context);
-
-        String eventStoreAddress = context.MergedJobDataMap.GetString("EventStoreAddress");
-        String databaseConnectionString = context.MergedJobDataMap.GetString("DatabaseConnectionString");
-
-        // Events in Parked Queues
-        // Incomplete Files
-    }
-
 }

TransactionProcessing.SchedulerService/TransactionProcessing.SchedulerService.Jobs/GenerateTransactionsJob.cs

@@ -28,25 +28,25 @@ public class GenerateTransactionsJob : BaseJob, IJob{
         #region Methods
 
         public async Task Execute(IJobExecutionContext context){
-                Bootstrapper.ConfigureServices(context);
+            this.JobName = context.JobDetail.Description;
+            Bootstrapper.ConfigureServices(context);
 
-                String clientId = context.MergedJobDataMap.GetString("ClientId");
-                String clientSecret = context.MergedJobDataMap.GetString("ClientSecret");
-                Guid estateId = context.MergedJobDataMap.GetGuidValueFromString("EstateId");
-                Guid merchantId = context.MergedJobDataMap.GetGuidValueFromString("MerchantId");
-                Boolean requireLogon = context.MergedJobDataMap.GetBooleanValueFromString("requireLogon");
+            String clientId = context.MergedJobDataMap.GetString("ClientId");
+            String clientSecret = context.MergedJobDataMap.GetString("ClientSecret");
+            Guid estateId = context.MergedJobDataMap.GetGuidValueFromString("EstateId");
+            Guid merchantId = context.MergedJobDataMap.GetGuidValueFromString("MerchantId");
+            Boolean requireLogon = context.MergedJobDataMap.GetBooleanValueFromString("requireLogon");
+
+            Logger.LogInformation($"Running Job {context.JobDetail.Description}");
+            Logger.LogInformation($"Client Id: [{clientId}]");
+            Logger.LogInformation($"Estate Id: [{estateId}]");
+            Logger.LogInformation($"Merchant Id: [{merchantId}]");
+            Logger.LogInformation($"Require Logon: [{requireLogon}]");
 
-                Logger.LogInformation($"Running Job {context.JobDetail.Description}");
-                Logger.LogInformation($"Client Id: [{clientId}]");
-                Logger.LogInformation($"Client Secret: [{clientSecret}]");
-                Logger.LogInformation($"Estate Id: [{estateId}]");
-                Logger.LogInformation($"Merchant Id: [{merchantId}]");
-                Logger.LogInformation($"Require Logon: [{requireLogon}]");
-
-                ITransactionDataGenerator t = CreateTransactionDataGenerator(clientId, clientSecret, RunningMode.Live);
-
-                await Jobs.GenerateTransactions(t, estateId, merchantId, requireLogon, context.CancellationToken);
-            }
+            ITransactionDataGenerator t = CreateTransactionDataGenerator(clientId, clientSecret, RunningMode.Live);
+            t.TraceGenerated += TraceGenerated;
+            await Jobs.GenerateTransactions(t, estateId, merchantId, requireLogon, context.CancellationToken);
+        }
         #endregion
     }
 }

TransactionProcessing.SchedulerService/TransactionProcessing.SchedulerService.Jobs/Jobs.cs

@@ -14,68 +14,116 @@
 using MessagingService.Client;
 using MessagingService.DataTransferObjects;
 using Microsoft.Data.SqlClient;
+using Microsoft.VisualBasic;
 using Newtonsoft.Json;
 using Quartz;
 using Shared.Logger;
 
 public static class Jobs{
     public static async Task GenerateMerchantStatements(ITransactionDataGenerator t, Guid estateId, CancellationToken cancellationToken){
         List<MerchantResponse> merchants = await t.GetMerchants(estateId, cancellationToken);
+
+        if (merchants.Any() == false){
+            throw new JobExecutionException($"No merchants returned for Estate [{estateId}]");
+        }
+
+        List<String> results = new List<String>();
         foreach (MerchantResponse merchantResponse in merchants)
         {
-            await t.GenerateMerchantStatement(merchantResponse.EstateId, merchantResponse.MerchantId, DateTime.Now, cancellationToken);
+            Boolean success = await t.GenerateMerchantStatement(merchantResponse.EstateId, merchantResponse.MerchantId, DateTime.Now, cancellationToken);
+            if (success == false){
+                results.Add(merchantResponse.MerchantName);
+            }
+        }
+
+        if (results.Any()){
+            throw new JobExecutionException($"Error generating statements for merchants [{String.Join(",", results)}]");
         }
     }
 
     public static async Task GenerateFileUploads(ITransactionDataGenerator t, Guid estateId, Guid merchantId, CancellationToken cancellationToken)
     {
         MerchantResponse merchant = await t.GetMerchant(estateId, merchantId, cancellationToken);
 
+        if (merchant == default)
+        {
+            throw new JobExecutionException($"No merchant returned for Estate Id [{estateId}] Merchant Id [{merchantId}]");
+        }
+
         List<ContractResponse> contracts = await t.GetMerchantContracts(merchant, cancellationToken);
         DateTime fileDate = DateTime.Now;
+        List<String> results = new List<String>();
         foreach (ContractResponse contract in contracts)
         {
             // Generate a file and upload
-            await t.SendUploadFile(fileDate, contract, merchant, cancellationToken);
+            Boolean success = await t.SendUploadFile(fileDate, contract, merchant, cancellationToken);
+
+            if (success == false)
+            {
+                results.Add(contract.OperatorName);
+            }
+        }
+
+        if (results.Any())
+        {
+            throw new JobExecutionException($"Error uploading files for merchant [{merchant.MerchantName}] [{String.Join(",", results)}]");
         }
     }
 
     public static async Task GenerateTransactions(ITransactionDataGenerator t, Guid estateId, Guid merchantId, Boolean requireLogon, CancellationToken cancellationToken){
-        MerchantResponse merchant = null;
         // get the merchant
-        try
-        {
-            merchant = await t.GetMerchant(estateId, merchantId, cancellationToken);
-        }
-        catch(Exception e){
-            Logger.LogWarning($"Error getting merchant record [{merchantId}]");
-            throw new JobExecutionException(new Exception($"Error getting merchant record [{merchantId}]"), false);
+        MerchantResponse merchant = await t.GetMerchant(estateId, merchantId, cancellationToken);
+
+        if (merchant == default){
+            throw new JobExecutionException($"Error getting Merchant Id [{merchantId}] for Estate Id [{estateId}]");
         }
 
         DateTime transactionDate = DateTime.Now;
 
+        // Get the merchants contracts
+        List<ContractResponse> contracts = await t.GetMerchantContracts(merchant, cancellationToken);
+
+        if (contracts.Any() == false)
+        {
+            throw new JobExecutionException($"No contracts returned for Merchant [{merchant.MerchantName}]");
+        }
+
         if (requireLogon)
         {
             // Do a logon transaction for the merchant
-            await t.PerformMerchantLogon(transactionDate, merchant, cancellationToken);
-        }
+            Boolean logonSuccess = await t.PerformMerchantLogon(transactionDate, merchant, cancellationToken);
 
-        // Get the merchants contracts
-        List<ContractResponse> contracts = await t.GetMerchantContracts(merchant, cancellationToken);
+            if (logonSuccess == false)
+            {
+                throw new JobExecutionException($"Error performing logon for Merchant [{merchant.MerchantName}]");
+            }
+        }
 
+        List<String> results = new List<String>();
         foreach (ContractResponse contract in contracts)
         {
             // Generate and send some sales
-            await t.SendSales(transactionDate, merchant, contract, cancellationToken);
+            Boolean success = await t.SendSales(transactionDate, merchant, contract, cancellationToken);
 
-            // Generate a file and upload
-            await t.SendUploadFile(transactionDate, contract, merchant, cancellationToken);
+            if (success == false)
+            {
+                results.Add(contract.OperatorName);
+            }
+        }
+
+        if (results.Any())
+        {
+            throw new JobExecutionException($"Error sending sales files for merchant [{merchant.MerchantName}] [{String.Join(",", results)}]");
         }
     }
 
     public static async Task PerformSettlement(ITransactionDataGenerator t, DateTime dateTime, Guid estateId, CancellationToken cancellationToken)
     {
-        await t.PerformSettlement(dateTime, estateId, cancellationToken);
+        Boolean success = await t.PerformSettlement(dateTime, estateId, cancellationToken);
+
+        if (success == false){
+            throw new JobExecutionException($"Error performing settlement for Estate Id [{estateId}] and date [{dateTime:dd-MM-yyyy}]");
+        }
     }
 
     public static async Task<List<(String groupName, String streamName, Int64 parkedMessageCount)>> GetParkedQueueInformation(String eventStoreConnectionString, CancellationToken cancellationToken){

TransactionProcessing.SchedulerService/TransactionProcessing.SchedulerService.Jobs/ProcessSettlementJob.cs

@@ -10,6 +10,7 @@ namespace TransactionProcessing.SchedulerService.Jobs
     using Quartz;
     using SecurityService.Client;
     using SecurityService.DataTransferObjects.Responses;
+    using Shared.Logger;
     using TransactionProcessing.DataGeneration;
     using TransactionProcessor.Client;
 
@@ -22,8 +23,12 @@ public async Task Execute(IJobExecutionContext context)
             String clientSecret = context.MergedJobDataMap.GetString("ClientSecret");
             Guid estateId = context.MergedJobDataMap.GetGuidValueFromString("EstateId");
 
-            ITransactionDataGenerator t = CreateTransactionDataGenerator(clientId, clientSecret, RunningMode.Live);
+            Logger.LogInformation($"Running Job {context.JobDetail.Description}");
+            Logger.LogInformation($"Client Id: [{clientId}]");
+            Logger.LogInformation($"Estate Id: [{estateId}]");
 
+            ITransactionDataGenerator t = CreateTransactionDataGenerator(clientId, clientSecret, RunningMode.Live);
+            t.TraceGenerated += TraceGenerated;
             await Jobs.PerformSettlement(t, DateTime.Now, estateId, context.CancellationToken);
         }
     }

TransactionProcessing.SchedulerService/TransactionProcessing.SchedulerService.Jobs/SupportReportEmailJob.cs

@@ -5,6 +5,7 @@
 using System.Threading.Tasks;
 using MessagingService.Client;
 using Quartz;
+using Shared.Logger;
 
 public class SupportReportEmailJob : BaseJob, IJob
 {
@@ -19,6 +20,10 @@ public async Task Execute(IJobExecutionContext context)
         String databaseConnectionString = context.MergedJobDataMap.GetString("DatabaseConnectionString");
         String estateIds = context.MergedJobDataMap.GetString("EstateIds");
 
+        Logger.LogInformation($"Running Job {context.JobDetail.Description}");
+        Logger.LogInformation($"Client Id: [{clientId}]");
+        Logger.LogInformation($"Estate Id: [{estateIds}]");
+
         String token = await this.GetToken(clientId, clientSecret, context.CancellationToken);
 
         IMessagingServiceClient messagingServiceClient =  Bootstrapper.GetService<IMessagingServiceClient>();