private static async Task <MessageJournalReadResult> ParseResponseContent(HttpResponseMessage responseMessage)
{
var content = await responseMessage.Content.ReadAsStringAsync();
var model = JsonConvert.DeserializeObject <JournalGetResponseModel>(content);
var start = new VerbatimMessageJournalPosition(model.Start);
var next = new VerbatimMessageJournalPosition(model.Next);
var endOfJournal = model.EndOfJournal;
var entries = new List <MessageJournalEntry>();
foreach (var entryModel in model.Entries)
{
var category = entryModel.Category;
var position = new VerbatimMessageJournalPosition(entryModel.Position);
var timestamp = entryModel.Timestamp;
var headers = new MessageHeaders(entryModel.Data.Headers);
var messageContent = entryModel.Data.Content;
var message = new Message(headers, messageContent);
var entry = new MessageJournalEntry(category, position, timestamp, message);
entries.Add(entry);
}
return(new MessageJournalReadResult(start, next, endOfJournal, entries));
}
/// <inheritdoc />
public virtual async Task <MessageJournalReadResult> Read(MessageJournalPosition start, int count, MessageJournalFilter filter = null, CancellationToken cancellationToken = default(CancellationToken))
{
var myFilter = filter ?? new MessageJournalFilter();
var next = start;
var journaledMessages = new List <MessageJournalEntry>();
var endOfJournal = true;
var connection = ConnectionProvider.GetConnection();
try
{
var commandBuilder = CommandBuilders.NewSelectJournaledMessagesCommandBuilder();
commandBuilder.Categories = myFilter.Categories.Select(c => (string)c).ToList();
commandBuilder.Topics = myFilter.Topics.Select(t => (string)t).ToList();
commandBuilder.From = myFilter.From;
commandBuilder.To = myFilter.To;
commandBuilder.Origination = myFilter.Origination;
commandBuilder.Destination = myFilter.Destination;
commandBuilder.RelatedTo = myFilter.RelatedTo;
commandBuilder.MessageName = myFilter.MessageName;
commandBuilder.Start = ((SQLMessageJournalPosition)start).Id;
commandBuilder.Count = count + 1;
using (var scope = new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
{
using (var command = commandBuilder.BuildDbCommand(connection))
{
using (var reader = await command.ExecuteReaderAsync(cancellationToken))
{
while (await reader.ReadAsync(cancellationToken))
{
var record = commandBuilder.BuildJournaledMessageRecord(reader);
next = new SQLMessageJournalPosition(record.Id);
if (journaledMessages.Count < count)
{
var category = record.Category;
var timestamp = record.Timestamp;
var headers = DeserializeHeaders(record.Headers);
var messageContent = record.Content;
var offset = new SQLMessageJournalPosition(record.Id);
var message = new Message(headers, messageContent);
var journaledMessage = new MessageJournalEntry(category, offset, timestamp, message);
journaledMessages.Add(journaledMessage);
next = new SQLMessageJournalPosition(record.Id + 1);
}
else
{
endOfJournal = false;
}
}
}
}
scope.Complete();
}
}
finally
{
ConnectionProvider.ReleaseConnection(connection);
}
return(new MessageJournalReadResult(start, next, endOfJournal, journaledMessages));
}
private static bool MatchesFilter(MessageJournalFilter filter, MessageJournalEntry entry)
{
if (filter == null)
{
return(true);
}
var headers = entry.Data.Headers;
if (!string.IsNullOrWhiteSpace(filter.MessageName))
{
var messageName = (string)headers.MessageName;
if (!messageName.Contains(filter.MessageName))
{
return(false);
}
}
if (filter.Topics.Any())
{
var topic = headers.Topic;
if (!filter.Topics.Contains(topic))
{
return(false);
}
}
if (filter.Categories.Any())
{
var category = entry.Category;
if (!filter.Categories.Contains(category))
{
return(false);
}
}
var timestamp = entry.Timestamp;
if (filter.From > timestamp)
{
return(false);
}
if (filter.To <= timestamp)
{
return(false);
}
if (filter.Origination != null)
{
var origination = headers.Origination;
if (!origination.Equals(filter.Origination))
{
return(false);
}
}
if (filter.Destination != null)
{
var destination = headers.Destination;
if (!destination.Equals(filter.Destination))
{
return(false);
}
}
if (filter.RelatedTo != null)
{
var relatedTo = headers.RelatedTo;
if (!relatedTo.Equals(filter.RelatedTo))
{
return(false);
}
}
return(true);
}
// This is a hacky way to avoid creating a nuget package for the
// integration events in the Customer API
private string GetEventName(MessageJournalEntry messageName)
{
return(typeof(CustomerNameChangedEvent).Namespace + '.' +
messageName.Data.Headers.MessageName.ToString().Split('.').LastOrDefault());
}
