public async Task SanitiseMailAsync(GenericActionMessage receivedMessage)
{
_coreDependencies.DiagnosticLogging.Verbose("SanitiseMail: Sanitise All Mail");
try
{
var mail = await _repository.GetCollectedMailAsync();
if (mail.Count == 0)
{
_coreDependencies.DiagnosticLogging.Verbose("SanitiseMail: Nothing to sanitise");
await _repository.LodgeMailSanitisedAcknowledgementAsync(receivedMessage);
return;
}
mail.ForEach(m =>
{
m.SanitisedBody = SanitiseForAllContentTypes(m.Body);
});
await _repository.StoreSanitisedMailAsync(mail);
await _repository.ClearCollectedMailAsync();
await _repository.LodgeMailSanitisedAcknowledgementAsync(receivedMessage);
} catch (Exception ex)
{
_coreDependencies.DiagnosticLogging.Fatal(ex, "Error attempting to Sanitise Mail");
}
}
public async Task AnalyseAllMailAsync(GenericActionMessage receivedMessage)
{
_coreDependencies.DiagnosticLogging.Verbose("ProcessMail: Process All Mail");
try
{
var mail = await _repository.GetSanitisedMailAsync();
if (mail.Count == 0)
{
_coreDependencies.DiagnosticLogging.Verbose("ProcessMail: Nothing to process");
await _repository.LodgeMailProcessorAcknowledgementAsync(receivedMessage);
return;
}
await AnalyseAllMail(mail);
var success = await _repository.StoreAllAnalysedMailAsync(mail);
if (success)
{
await _repository.ClearSanitisedMailAsync();
}
await _repository.LodgeMailProcessorAcknowledgementAsync(receivedMessage);
}
catch (Exception ex)
{
_coreDependencies.DiagnosticLogging.Fatal(ex, "ProcessMail: Error attempting to Analyse Mail");
}
}
public async Task PerformMailCollectionAsync(GenericActionMessage receivedMessage)
{
_coreDependencies.DiagnosticLogging.Verbose("MailCollection: Performing Mail Collection:{0}", receivedMessage);
try
{
var emails = await _repository.CollectMailAsync(_mailConfig);
TrimMailDataIfRequired(emails);
await _repository.StoreMailAsync(emails);
} catch (Exception ex)
{
_coreDependencies.DiagnosticLogging.Fatal(ex, "MailCollection: Error performing mail collection");
}
try
{
await _repository.LodgeMailCollectedAcknowledgementAsync(receivedMessage);
_coreDependencies.DiagnosticLogging.Debug("Completed performing mail collection");
} catch (Exception ex)
{
_coreDependencies.DiagnosticLogging.Fatal(ex, "MailCollection: Could not Lodge mail collection acknowledgement. Manual intervention required");
}
return;
}
public void ShouldReadEnvironmentVariable()
{
var originalMsg = new GenericActionMessage();
var serialisedData = originalMsg.ToString();
var deserialisedMsg = GenericActionMessage.FromString(serialisedData);
Assert.NotNull(deserialisedMsg);
Assert.Equal(originalMsg.ActionDateTimeUtc, deserialisedMsg.ActionDateTimeUtc);
Assert.Equal(originalMsg.CorrelationId, deserialisedMsg.CorrelationId);
}
public async Task MailSanitisationShouldOnlyProceedThroughFirstStepOfWorkflowWhenNoMailCollected()
{
var repo = new DummySanitiserRepo(0);
var engine = new MailSanitiserEngine(_coreDependencies, repo);
var msg = new GenericActionMessage();
await engine.SanitiseMailAsync(msg);
Assert.Equal(1, repo.MailCollectionCount);
Assert.Equal(0, repo.StoreSanitisedMaiLCount);
Assert.Equal(0, repo.ClearedMailCount);
Assert.Equal(1, repo.LodgeMailAcknowledgementCount); // need to ensure the ack is still sent
}
public async static Task Run([QueueTrigger(DataStores.Queues.QueueNameCleanEmail)] string myQueueItem, ILogger log)
{
var dependencies = CoreDependencies.Setup(log);
var receivedMessage = GenericActionMessage.FromString(myQueueItem);
var now = DateTime.UtcNow;
dependencies.DiagnosticLogging.Verbose("Sanitisation: MailSanitiser Timer trigger function executed at: {now} UTC", now);
var repo = new MailSanitiserRepository(dependencies);
var engine = new MailSanitiserEngine(dependencies, repo);
await engine.SanitiseMailAsync(receivedMessage);
}
public async Task MailSanitisationShouldProceedThroughEntireWorkflowWhenMessagesAreCollected()
{
var repo = new DummySanitiserRepo(2);
var engine = new MailSanitiserEngine(_coreDependencies, repo);
var msg = new GenericActionMessage();
await engine.SanitiseMailAsync(msg);
Assert.Equal(1, repo.MailCollectionCount);
Assert.Equal(1, repo.StoreSanitisedMaiLCount);
Assert.Equal(1, repo.ClearedMailCount);
Assert.Equal(1, repo.LodgeMailAcknowledgementCount);
Assert.Equal(msg, repo.ActionMessageRecentlyLodged);
}
public static async Task Run([QueueTrigger(DataStores.Queues.QueueNameCollectEmail)] string myQueueItem, ILogger log)
{
var dependencies = CoreDependencies.Setup(log);
var now = DateTime.UtcNow;
dependencies.DiagnosticLogging.Verbose("MailCollection: MailCollector Queue trigger function executed at: {now} UTC", now);
var mailConfig = EmailConfiguration.PopulateConfigFromEnviromentVariables(dependencies);
var engine = new CollectionEngine(dependencies, new MailCollectionRepository(dependencies), mailConfig);
var queueMsg = GenericActionMessage.FromString(myQueueItem);
await engine.PerformMailCollectionAsync(queueMsg);
}
public async static Task Run([QueueTrigger(DataStores.Queues.QueueNameProcessEmail)] string myQueueItem, ILogger log)
//public async static Task Run([HttpTrigger("GET")]string myQueueItem, ILogger log)
{
var dependencies = CoreDependencies.Setup(log);
var receivedMessage = GenericActionMessage.FromString(myQueueItem);
var analysisConfig = AnalysisConfiguration.PopulateConfigFromEnviromentVariables(dependencies);
var now = DateTime.UtcNow;
dependencies.DiagnosticLogging.Verbose("MailProcessor: Timer trigger function executed at: {now} UTC", now);
var repo = new MailProcessorRepository(dependencies);
var engine = new MailProcessingEngine(dependencies, repo, analysisConfig);
await engine.AnalyseAllMailAsync(receivedMessage);
}
public async Task SetMailOperationToInProgressAsync()
{
var acct = CreateStorageAccountReference();
var queueClient = acct.CreateCloudQueueClient();
var queueRef = queueClient.GetQueueReference(DataStores.Queues.QueueNameCollectEmail);
try
{
await queueRef.AddMessageAsync(GenericActionMessage.CreateNewQueueMessage());
Dependencies.DiagnosticLogging.Verbose("MailScheduler: Email collection trigger message sent");
var tblRef = CreateClientTableReference(DataStores.Tables.TableNameMailSchedulerStatus);
var op = TableOperation.Insert(new MailSchedulerEntity());
var result = await tblRef.ExecuteAsync(op);
}
catch (Exception ex)
{
Dependencies.DiagnosticLogging.Error(ex, "MailScheduler: Error setting mail operation progress");
}
}
public Task LodgeMailSanitisedAcknowledgementAsync(GenericActionMessage receivedMessage)
{
_actionMessageToLodge = receivedMessage;
_lodgeMailAckCount++;
return(Task.FromResult(0));
}
public async Task LodgeMailSanitisedAcknowledgementAsync(GenericActionMessage receivedMessage)
{
await LodgeAcknowledgementMessageAsync(receivedMessage, "Sanitisation", DataStores.Queues.QueueNameProcessEmail);
}
public Task LodgeMailCollectedAcknowledgementAsync(GenericActionMessage receivedMessage)
{
LodgeAcknowledgementCount++;
return(Task.FromResult(0));
}
public async Task LodgeMailCollectedAcknowledgementAsync(GenericActionMessage receivedMessage)
{
await LodgeAcknowledgementMessageAsync(receivedMessage, "MailCollection", DataStores.Queues.QueueNameCleanEmail);
}
public async Task LodgeMailProcessorAcknowledgementAsync(GenericActionMessage receivedMessage)
{
await LodgeAcknowledgementMessageAsync(receivedMessage, "MailProcessor", DataStores.Queues.QueueNameTriggerEmail);
}
