public void Handle(OrderSubmitted message)
{
log.Info($"Order {message.OrderId} worth {message.Value} submitted");
#region StoreUserData
var dbConnection = (SqlConnection)storageContext.Connection;
using (var receiverDataContext = new ReceiverDataContext(dbConnection))
{
var dbTransaction = (DbTransaction)storageContext.DatabaseTransaction;
receiverDataContext.Database.UseTransaction(dbTransaction);
var order = new Order
{
OrderId = message.OrderId,
Value = message.Value
};
receiverDataContext.Orders.Add(order);
receiverDataContext.SaveChanges();
}
#endregion
#region Reply
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
bus.Reply(orderAccepted);
#endregion
}
public async Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
log.Info($"Order {message.OrderId} worth {message.Value} submitted");
#region StoreUserData
var storageContext = context.SynchronizedStorageSession.SqlPersistenceSession();
var dbConnection = storageContext.Connection;
using (var receiverDataContext = new ReceiverDataContext(dbConnection))
{
receiverDataContext.Database.UseTransaction(storageContext.Transaction);
var order = new Order
{
OrderId = message.OrderId,
Value = message.Value
};
receiverDataContext.Orders.Add(order);
await receiverDataContext.SaveChangesAsync()
.ConfigureAwait(false);
}
#endregion
#region Reply
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
await context.Reply(orderAccepted)
.ConfigureAwait(false);
#endregion
}
public void Handle(OrderSubmitted message)
{
log.Info($"Order {message.OrderId} worth {message.Value} submitted");
#region StoreUserData
var order = new Order
{
OrderId = message.OrderId,
Value = message.Value
};
session.Save(order);
#endregion
#region Reply
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
bus.Reply(orderAccepted);
#endregion
}
public void Handle(OrderSubmitted message)
{
log.InfoFormat("Order {0} worth {1} submitted", message.OrderId, message.Value);
#region StoreUserData
using (var receiverDataContext = new ReceiverDataContext(storageContext.Connection))
{
receiverDataContext.Database.UseTransaction((DbTransaction)storageContext.DatabaseTransaction);
var order = new Order
{
OrderId = message.OrderId,
Value = message.Value
};
receiverDataContext.Orders.Add(order);
receiverDataContext.SaveChanges();
}
#endregion
#region Reply
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
bus.Reply(orderAccepted);
#endregion
}
public void Handle(OrderSubmitted message)
{
log.Info($"Order {message.OrderId} worth {message.Value} submitted");
#region StoreUserData
var order = new Order
{
OrderId = message.OrderId,
Value = message.Value
};
session.Save(order);
#endregion
#region Reply
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
bus.Reply(orderAccepted);
#endregion
if (ChaosGenerator.Next(4) == 0)
{
throw new Exception("Boom!");
}
}
public async Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
log.Info($"Order {message.OrderId} worth {message.Value} submitted");
#region StoreUserData
var nhibernateSession = context.SynchronizedStorageSession.Session();
var order = new Order
{
OrderId = message.OrderId,
Value = message.Value
};
nhibernateSession.Save(order);
#endregion
#region Reply
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
await context.Reply(orderAccepted)
.ConfigureAwait(false);
#endregion
if (ChaosGenerator.Next(2) == 0)
{
throw new Exception("Boom!");
}
}
public Task Handle(OrderAccepted message, IMessageHandlerContext context)
{
log.Info($"Order '{message.OrderId}' has been accepted. Prepare inventory ready for shipping");
Data.IsOrderAccepted = true;
CompleteSagaIfBothEventsReceived();
return(Task.CompletedTask);
}
public Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
log.Info($"Order {message.OrderId} worth {message.Value} submitted");
#region StoreUserData
var session = context.SynchronizedStorageSession.SqlPersistenceSession();
var connection = session.Connection as SqlConnection;
const string sqlCommand = "INSERT INTO [receiver].[Orders] (OrderId, Value) VALUES (@OrderId, @Value)";
using (var dbCommand = new SqlCommand(sqlCommand, connection))
{
dbCommand.Parameters.AddWithValue("OrderId", message.OrderId);
dbCommand.Parameters.AddWithValue("Value", message.Value);
dbCommand.ExecuteNonQuery();
}
#endregion
#region Reply
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
return(context.Reply(orderAccepted));
#endregion
}
public async Task Consume(ConsumeContext <OrderRegistered> context)
{
System.Threading.Thread.Sleep(10);
if (context.Message.OrderId == 2)
{
var orderRejectedMessage = new OrderRejected
{
RejectBy = "Alireza Oroumand rejector",
Reason = "nothing else matter",
RejectDate = DateTime.Now,
OrderId = context.Message.OrderId
};
await context.RespondAsync(orderRejectedMessage);
}
else
{
var orderAcceptedMessage = new OrderAccepted
{
AcceptBy = "Alireza Oroumand",
AcceptDate = DateTime.Now,
OrderId = context.Message.OrderId
};
await context.RespondAsync(orderAcceptedMessage);
}
}
public async Task Consume(ConsumeContext <OrderRegistered> context)
{
System.Threading.Thread.Sleep(10);
if (context.Message.OrderId % 2 == 0)
{
var orderRejectedMessage = new OrderRejected
{
RejectBy = "OddConsumer",
Reason = "i don't like even request",
RejectDate = DateTime.Now,
OrderId = context.Message.OrderId
};
await context.RespondAsync(orderRejectedMessage);
}
else
{
var orderAcceptedMessage = new OrderAccepted
{
AcceptBy = "OddConsumer",
AcceptDate = DateTime.Now,
OrderId = context.Message.OrderId
};
await context.RespondAsync(orderAcceptedMessage);
}
}
public Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
log.Info($"Order {message.OrderId} worth {message.Value} submitted");
#region StoreUserData
var nhibernateSession = context.SynchronizedStorageSession.Session();
nhibernateSession.Save(new Order
{
OrderId = message.OrderId,
Value = message.Value
});
#endregion
#region Reply
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
return(context.Reply(orderAccepted));
#endregion
}
public void ParentMessageIdIsRecorded()
{
var message = new OrderAccepted();
var downStreamMessage = new DownStreamMessage(message);
Assert.That(downStreamMessage.CorrelationId, Is.EqualTo(message.Id));
}
private void OnMessage(OrderAccepted @event)
{
this.EventCount++;
this.Logger.LogInformation(LogId.Trading, $"{Received}{Event} {@event}.");
this.ProcessOrderEvent(@event);
this.SendToEventPublisher(@event);
}
public void Handle(OrderAccepted message)
{
Data.CustomerId = message.CustomerId;
AdjustRunningTotal(message.OrderValue);
RequestTimeout(message.OrderDate.AddSeconds(20), message);
}
public Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId
};
return(context.Reply(orderAccepted));
}
public void Handle(OrderAccepted message)
{
LogManager.GetLogger(typeof(ShippingSaga))
.Info("Received Order Accepted: " + message.OrderId);
Data.OrderId = message.OrderId;
Data.OrderAccepted = true;
CheckIfComplete();
}
public Task Handle(PlaceOrder message, IMessageHandlerContext context)
{
log.Info($"Order {message.OrderId} accepted.");
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
return(context.Publish(orderAccepted));
}
public async Task Handle(OrderAccepted domainEvent)
{
var orderDate = DateTime.Now.ToString("yy-MM-dd");
await StoreCustomerOrder(orderDate, domainEvent);
await StoreAcceptedOrder(orderDate, domainEvent);
await StoreOrderItem(orderDate, domainEvent);
}
public void Handle_OrderAccepted_TimeoutFor10Seconds()
{
Test.Initialize();
var orderAccepted = new OrderAccepted();
Test.Saga <OrderPolicy>()
.When(saga => saga.Handle(orderAccepted))
.ExpectTimeoutToBeSetIn <OrderAccepted>((state, span) => span == TimeSpan.FromSeconds(10));
}
public void Setup()
{
neverMatches = new object();
orderAccepted = new OrderAccepted();
orderDeclined = new OrderDeclined();
orderApproved = new OrderApproved();
extractorBase = new ExtractorUsingPatternMatching();
extractorForeach = new ExtractorUsingForEach();
}
public Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
log.Info($"Order {message.OrderId} worth {message.Value} submitted");
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
return(context.Reply(orderAccepted));
}
public void Handle(OrderSubmitted message)
{
log.Info($"Order {message.OrderId} worth {message.Value} submitted");
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
bus.Reply(orderAccepted);
}
public Task Handle(PlaceOrder message, IMessageHandlerContext context)
{
log.Info($"Received order {message.OrderId} for ${message.Value}.");
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId
};
return(context.Publish(orderAccepted));
}
public Task Timeout(BuyersRemorseIsOver state, IMessageHandlerContext context)
{
MarkAsComplete();
var orderAccepted = new OrderAccepted
{
OrderId = Data.OrderId,
};
return(context.Publish(orderAccepted));
}
public async Task <string> AddToServiceBus(CancellationToken cancellationToken)
{
//1
await _busRepository.Publish <IPubSub>(new PubSub { Message = "send message" });
//2
await _busRepository.SendToEndpoint <IDataAdded>(nameof(DataAddedConsumer), new DataAdded { Message = "data passed" });
//3
OrderAccepted result = await _requestClient.Request(new { OrderId = 123 }, cancellationToken);
return(result.OrderId);
}
private async Task StoreAcceptedOrder(string orderDate, OrderAccepted domainEvent)
{
await _projectionsStore.Add(new AcceptedOrder(domainEvent.OrderId)
{
OrderDate = orderDate,
OrderNumber = domainEvent.OrderNumber,
Paste = domainEvent.Paste,
Tomatoes = domainEvent.Tomatoes,
Cheese = domainEvent.Cheese,
Amount = domainEvent.Amount,
CustomerId = domainEvent.CustomerId
});
}
public async Task WhenAMessageIsHandled_TheInnerResultTrueIsReturned()
{
var inner = Substitute.For<IHandler<OrderAccepted>>();
inner.Handle(Arg.Any<OrderAccepted>())
.Returns(true);
var handler = new BlockingHandler<OrderAccepted>(inner);
var message = new OrderAccepted();
var result = await handler.Handle(message);
Assert.That(result, Is.True);
}
public async Task WhenAMessageIsHandled_TheInnerIsCalled()
{
var inner = Substitute.For<IHandler<OrderAccepted>>();
inner.Handle(Arg.Any<OrderAccepted>())
.Returns(false);
var handler = new BlockingHandler<OrderAccepted>(inner);
var message = new OrderAccepted();
await handler.Handle(message);
inner.Received().Handle(message);
}
public async Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
var orderTimeout = new OrderTimeout();
await RequestTimeout(context, TimeSpan.FromSeconds(5), orderTimeout)
.ConfigureAwait(false);
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
await context.Reply(orderAccepted)
.ConfigureAwait(false);
}
public Task Timeout(BuyersRemorseIsOver state, IMessageHandlerContext context)
{
log.Info($"Cooling down period for order #{Data.OrderNumber} has elapsed.");
var orderAccepted = new OrderAccepted
{
OrderNumber = Data.OrderNumber,
ProductIds = Data.ProductIds,
ClientId = Data.ClientId
};
MarkAsComplete();
return(context.Publish(orderAccepted));
}
public async Task WhenAMessageIsHandled_TheInnerResultTrueIsReturned()
{
var inner = Substitute.For <IHandler <OrderAccepted> >();
inner.Handle(Arg.Any <OrderAccepted>())
.Returns(true);
var handler = new BlockingHandler <OrderAccepted>(inner);
var message = new OrderAccepted();
var result = await handler.Handle(message);
Assert.That(result, Is.True);
}
private async Task StoreOrderItem(string orderDate, OrderAccepted domainEvent)
{
var customer = await _projectionsStore.Get <Customer>(domainEvent.CustomerId);
await _projectionsStore.Add(new OrderItem
{
OrderId = domainEvent.OrderId,
OrderNumber = domainEvent.OrderNumber,
OrderDate = orderDate,
Amount = domainEvent.Amount,
Toppings = $"Paste: {domainEvent.Paste}, Tomatoes: {domainEvent.Tomatoes}, Cheese: {domainEvent.Cheese}",
CustomerName = $"{customer.LastName} {customer.FirstName}",
CustomerAddress = $"{customer.Address}, {customer.ZipCode} {customer.City}"
});
}
partial void HandleImplementation(OrderAccepted message)
{
// Implement your handler logic here.
Console.WriteLine("Billing received " + message.GetType().Name);
}
