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();
log.Info($"Item {message.Filling} added.");
await context.PublishImmediately(
new ItemAdded(message.OrderId, message.Filling));
}
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();
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 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 bool UpdateTransactionCode(int OrderCode, int UserTransactionCode)
{
try
{
OrdersDataContext dc = new OrdersDataContext();
Orders CurOrder = dc.Orders.SingleOrDefault(p => p.Code.Equals(OrderCode));
CurOrder.UserTransactionCode = UserTransactionCode;
dc.SubmitChanges();
return(true);
}
catch (Exception err)
{
HttpContext.Current.Response.Write(err.Message);
return(false);
}
}
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.");
}
static async Task Start()
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Information()
.Enrich.With(new ExceptionMessageEnricher())
.WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{ExceptionMessage}{NewLine}")
.CreateLogger();
LogManager.Use <SerilogFactory>();
Console.Title = "Orders";
var config = new EndpointConfiguration("ExactlyOnce.Orders");
config.UseTransport <LearningTransport>();
config.Recoverability().Immediate(x => x.NumberOfRetries(5));
config.Recoverability().Delayed(x => x.NumberOfRetries(0));
config.Recoverability().AddUnrecoverableException(typeof(DbEntityValidationException));
config.Pipeline.Register(new BrokerFailureBehavior(), "Simulates broker failures");
config.Pipeline.Register(new DeduplicatingBehavior(), "Deduplicates incoming messages");
config.SendFailedMessagesTo("error");
config.EnableInstallers();
config.LimitMessageProcessingConcurrencyTo(10);
SqlHelper.EnsureDatabaseExists(ConnectionString);
using (var receiverDataContext = new OrdersDataContext(new SqlConnection(ConnectionString)))
{
receiverDataContext.Database.Initialize(true);
}
var endpoint = await Endpoint.Start(config).ConfigureAwait(false);
Console.WriteLine("Press <enter> to exit.");
Console.ReadLine();
await endpoint.Stop().ConfigureAwait(false);
}
static async Task Start()
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Information()
.Enrich.With(new ExceptionMessageEnricher())
.Filter.ByExcluding(Matching.FromSource("NServiceBus.Transport.Msmq.QueuePermissions"))
.Filter.ByExcluding(Matching.FromSource("NServiceBus.SubscriptionReceiverBehavior"))
.WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{ExceptionMessage}{NewLine}")
.CreateLogger();
LogManager.Use <SerilogFactory>();
Console.Title = "Orders";
var config = new EndpointConfiguration("OnlyOnce.Demo0.Orders");
config.UsePersistence <InMemoryPersistence>();
config.UseTransport <MsmqTransport>().Transactions(TransportTransactionMode.ReceiveOnly);
config.Recoverability().Immediate(x => x.NumberOfRetries(5));
config.Recoverability().Delayed(x => x.NumberOfRetries(0));
config.Recoverability().AddUnrecoverableException(typeof(DbEntityValidationException));
config.SendFailedMessagesTo("error");
config.EnableInstallers();
SqlHelper.EnsureDatabaseExists(ConnectionString);
using (var receiverDataContext = new OrdersDataContext(new SqlConnection(ConnectionString)))
{
receiverDataContext.Database.Initialize(true);
}
var endpoint = await Endpoint.Start(config).ConfigureAwait(false);
Console.WriteLine("Press <enter> to exit.");
Console.ReadLine();
await endpoint.Stop().ConfigureAwait(false);
}
public OrdersRepository(OrdersDataContext context)
{
_context = context;
}
private static Coupon GetCoupon(OrdersDataContext dc, Guid id)
{
dc.LoadOptions = CouponLoadOptions;
return(GetCouponQuery(dc, id));
}
public OrderContext(bool isTransactional)
{
_db = new OrdersDataContext();
if (isTransactional)
_ts = new TransactionScope();
}
public OrdersController(OrdersDataContext context)
{
_context = context;
}
private Order GetOrder(OrdersDataContext dc, string confirmationCode)
{
dc.LoadOptions = OrderLoadOptions;
return(GetOrderByConfirmationCodeQuery(dc, confirmationCode, _adjustmentPersister));
}
public BaseBOLOrderProducts(params int[] MCodes)
{
MasterCode = Convert.ToInt32(MCodes[0]);
dataContext = new OrdersDataContext();
}
private Order GetPurchasedOrder(OrdersDataContext dc, Guid id)
{
dc.LoadOptions = OrderLoadOptions;
return(GetPurchasedOrderQuery(dc, id, _adjustmentPersister));
}
private IEnumerable <Order> GetOrders(OrdersDataContext dc, IEnumerable <Guid> orderIds)
{
dc.LoadOptions = OrderLoadOptions;
return(GetOrdersByIdsQuery(dc, new SplitList <Guid>(orderIds.Distinct()).ToString(), _adjustmentPersister));
}
private IEnumerable <Order> GetPurchasedOrders(OrdersDataContext dc, Guid ownerId)
{
dc.LoadOptions = OrderLoadOptions;
return(GetPurchasedOrdersQuery(dc, ownerId, _adjustmentPersister));
}
private static Coupon GetCoupon(OrdersDataContext dc, string code)
{
dc.LoadOptions = CouponLoadOptions;
return(GetCouponByCodeQuery(dc, code));
}
public BaseBOLOrders()
{
dataContext = new OrdersDataContext();
}
