public async Task <IActionResult> PutOrder(Guid id, Order order)
{
if (id != order.Id)
{
return(BadRequest());
}
_context.Entry(order).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public override async Task Invoke(IIncomingLogicalMessageContext context, Func <Task> next)
{
var dbContext = new OrdersDataContext();
using (var dbContextTransaction = dbContext
.Database.BeginTransaction())
{
var processedMessage = await dbContext
.ProcessedMessages
.FirstOrDefaultAsync(m => m.MessageId == context.MessageId);
if (processedMessage != null)
{
dbContext.Processed = true;
}
else
{
dbContext.ProcessedMessages.Add(new ProcessedMessage {
MessageId = context.MessageId
});
}
await dbContext.SaveChangesAsync()
.ConfigureAwait(false);
context.Extensions.Set(dbContext);
await next().ConfigureAwait(false); //Process
await dbContext.SaveChangesAsync()
.ConfigureAwait(false);
dbContextTransaction.Commit();
}
}
public async Task Handle(AddItem message,
IMessageHandlerContext context)
{
var dbContext = new OrdersDataContext();
var order = await dbContext.Orders
.FirstAsync(o => o.OrderId == message.OrderId);
if (order.Lines.Any(x => x.Filling == message.Filling))
{
log.Info("Duplicate AddItem message detected. Ignoring.");
return;
}
var line = new OrderLine(message.Filling);
order.Lines.Add(line);
await dbContext.SaveChangesAsync();
await context.PublishImmediately(
new ItemAdded(message.OrderId, message.Filling));
log.Info($"Item {message.Filling} added.");
}
public async Task Handle(RemoveItem message,
IMessageHandlerContext context)
{
var dbContext = new OrdersDataContext();
var order = await dbContext.Orders
.FirstAsync(o => o.OrderId == message.OrderId);
var lineToRemove = order.Lines.FirstOrDefault(x => x.Filling == message.Filling);
if (lineToRemove == null)
{
log.Info("Potential duplicate RemoveItem message detected.");
}
else
{
order.Lines.Remove(lineToRemove);
dbContext.OrderLines.Remove(lineToRemove);
await dbContext.SaveChangesAsync();
log.Info($"Item {message.Filling} removed.");
}
await context.PublishImmediately(
new ItemRemoved(message.OrderId, message.Filling));
}
public override async Task Invoke(IIncomingLogicalMessageContext context, Func <Task> next)
{
var dbContext = new OrdersDataContext();
ProcessedMessage processedMessage;
using (var dbContextTransaction = dbContext
.Database.BeginTransaction())
{
processedMessage = await dbContext
.ProcessedMessages
.FirstOrDefaultAsync(m => m.MessageId == context.MessageId);
if (processedMessage == null)
{
processedMessage = new ProcessedMessage {
MessageId = context.MessageId
};
dbContext.ProcessedMessages.Add(processedMessage);
await dbContext.SaveChangesAsync()
.ConfigureAwait(false);
context.Extensions.Set(dbContext);
await next().ConfigureAwait(false); //Process
var serializedMessages = JsonConvert.SerializeObject(dbContext.OutgoingMessages, serializerSettings);
processedMessage.OutgoingMessages = serializedMessages;
await dbContext.SaveChangesAsync()
.ConfigureAwait(false);
}
dbContextTransaction.Commit();
}
var outgoingMessages =
JsonConvert.DeserializeObject <List <OutgoingMessage> >(processedMessage.OutgoingMessages, serializerSettings);
foreach (var outgoingMessage in outgoingMessages)
{
var publishOptions = new PublishOptions();
publishOptions.SetMessageId(outgoingMessage.MessageId);
await context.Publish(outgoingMessage.Payload, publishOptions);
}
}
public async Task Handle(SubmitOrder message, IMessageHandlerContext context)
{
var dbContext = new OrdersDataContext(new SqlConnection(Program.ConnectionString));
if (await dbContext.Orders.AnyAsync(o => o.OrderId == message.OrderId).ConfigureAwait(false))
{
log.Info("Duplicate SubmitOrder message detected. Ignoring");
return;
}
var order = new Order
{
OrderId = message.OrderId
};
dbContext.Orders.Add(order);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
log.Info($"Order {message.OrderId} created.");
}
