public IHttpActionResult CompleteOrder(OrderReadModel OrderItem) //give it a read model
{
IHttpActionResult newOrder;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var listOfOrderItemIDs = this.addOrderItems(OrderItem);
using (OrderSystemEntitiesCtx entities = new OrderSystemEntitiesCtx())
{
Order currentOrder = new Order()
{
CustomerID = OrderItem.CustomerID,
Completed = true,
Cancelled = false,
TotalPrice = OrderItem.TotalPrice,
Tax = OrderItem.TotalPrice - OrderItem.Price,
Date = DateTime.Now,
MonthYear = string.Format("{0:MMMM yyyy}", DateTime.Now)
};
entities.Orders.Add(currentOrder);
entities.SaveChanges();
newOrder = CreatedAtRoute("GetOrder", new
{
OrderID = currentOrder.OrderID
}, currentOrder);
this.addOrderDetails(listOfOrderItemIDs, currentOrder.OrderID);
}
return(newOrder);
}
private void Handle(OrderCompleted @event)
{
var oldOrder = _state.Orders.Single(x => x.Id == @event.OrderId);
var order = new OrderReadModel(@event.OrderId, OrderStateReadModel.Finalized);
_state.Orders.Replace(oldOrder, order);
}
private Guid InnerCreateOrder(Guid customerId, OrderCreateModel order)
{
var rnd = new Random(10000);
var model = new OrderReadModel()
{
Goods = order.Goods,
ArriveAt = DateTime.UtcNow.AddDays(2),
OrderId = Guid.NewGuid(),
Cost = (decimal)rnd.NextDouble(),
Currency = order.Currency
};
if (!Orders.ContainsKey(customerId))
{
Orders.Add(customerId, new List <OrderReadModel>()
{
model
});
}
else
{
Orders[customerId].Add(model);
}
return(model.OrderId);
}
private void Handle(OrderDiscarded @event)
{
var oldOrder = _state.Orders.Single(x => x.Id == @event.OrderId);
var order = new OrderReadModel(@event.OrderId, OrderStateReadModel.Canceled);
_state.Orders.Replace(oldOrder, order);
}
public void GetOpenOrders_IfTraderIdIsProvided_RetrievedOrdersShouldBeDateTimeSortedAsDescending()
{
ManualResetEvent resetEvent = new ManualResetEvent(false);
Order order = OrderFactory.CreateOrder("100", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
resetEvent.WaitOne(2000);
resetEvent.Reset();
Order order1 = OrderFactory.CreateOrder("100", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
resetEvent.WaitOne(2000);
resetEvent.Reset();
Order order2 = OrderFactory.CreateOrder("100", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
resetEvent.WaitOne(2000);
resetEvent.Reset();
OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order);
_persistanceRepository.SaveOrUpdate(model);
OrderReadModel model1 = ReadModelAdapter.GetOrderReadModel(order1);
_persistanceRepository.SaveOrUpdate(model1);
OrderReadModel model2 = ReadModelAdapter.GetOrderReadModel(order2);
_persistanceRepository.SaveOrUpdate(model2);
IList <OrderReadModel> getReadModel = _orderRepository.GetOpenOrders("100");
Assert.NotNull(getReadModel);
Assert.AreEqual(getReadModel.Count, 3);
Assert.True(getReadModel[0].DateTime > getReadModel[1].DateTime);
Assert.True(getReadModel[1].DateTime > getReadModel[2].DateTime);
}
public List <int> addOrderItems(OrderReadModel OrderItem)
{
IHttpActionResult newOrderItem;
List <int> listOfOrderItemIDs = new List <int>();
using (OrderSystemEntitiesCtx entities = new OrderSystemEntitiesCtx())
{
//for each item
foreach (var item in OrderItem.Items)
{
foreach (var extra in item.ExtraItems)
{
OrderItem currentOrderItem = new OrderItem()
{
ItemID = item.ItemID,
ExtraID = extra.ExtraID
};
OrderItem createdOrderItem = entities.OrderItems.Add(currentOrderItem);
entities.SaveChanges();
newOrderItem = CreatedAtRoute("GetOrderItem", new
{
OrderItemID = currentOrderItem.OrderItemID
}, currentOrderItem);
listOfOrderItemIDs.Add(createdOrderItem.OrderItemID);
}
}
}
return(listOfOrderItemIDs);
}
/// <summary>
/// paramterized constructor
/// </summary>
/// <param name="order"></param>
/// <param name="executionDateTime"></param>
/// <param name="executionPrice"></param>
public TradeDetailsRepresentation(OrderReadModel order, DateTime executionDateTime, decimal executionPrice, decimal volume, string tradeId)
{
Order = order;
ExecutionDateTime = executionDateTime;
ExecutionPrice = executionPrice;
Volume = volume;
TradeId = tradeId;
}
public OrderReadModel GetOrderById(TraderId traderId, OrderId orderId)
{
OrderReadModel model = CurrentSession.Get <OrderReadModel>(orderId.Id);
if (model.TraderId.Equals(traderId.Id, StringComparison.InvariantCultureIgnoreCase))
{
return(model);
}
return(null);
}
private void AssertAreEqual(OrderReadModel expected, OrderReadModel actual)
{
Assert.AreEqual(expected.OrderId, actual.OrderId);
Assert.AreEqual(expected.Side, actual.Side);
Assert.AreEqual(expected.Type, actual.Type);
Assert.AreEqual(expected.Price, actual.Price);
Assert.AreEqual(expected.Status, actual.Status);
Assert.AreEqual(expected.TraderId, actual.TraderId);
Assert.AreEqual(expected.VolumeExecuted, actual.VolumeExecuted);
Assert.AreEqual(expected.CurrencyPair, actual.CurrencyPair);
}
public void Handle(OrderPlaced @event, TicketManagementDbContext db)
{
var orderReadModel = new OrderReadModel()
{
EventName = @event.Order.Event.Name,
OrderId = @event.Order.Id,
TicketCount = @event.Order.TicketCount
};
db.Set <OrderReadModel>().Add(orderReadModel);
}
public object GetOrderById(TraderId traderId, OrderId orderId)
{
OrderReadModel order = _orderRepository.GetOrderById(traderId, orderId);
Tuple <decimal, DateTime?> data = CalculateAveragePrice(_tradeRepository.GetTradesByorderId(orderId.Id));
order.AveragePrice = data.Item1;
if (order.Status == OrderState.Complete.ToString())
{
order.ClosingDateTime = data.Item2;
}
return(order);
}
public void ValidateCancelOrderCommand_IfOrderIdAndTraderIdIsValidAndOrderStatusIsNotCompleteOrCancelled_CommandWillBeValidated()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order);
_persistanceRepository.SaveOrUpdate(model);
CancelOrderCommand command = new CancelOrderCommand(order.OrderId, order.TraderId);
ICancelOrderCommandValidation validation = new CancelOrderCommandValidation(_orderRepository);
Assert.True(validation.ValidateCancelOrderCommand(command));
}
public void ValidateCancelOrderCommand_IfOrderIdAndTraderIdIsValidAndOrderStatusIsCancelled_InvalidOperationException()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
order.OrderState = OrderState.Cancelled;
OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order);
_persistanceRepository.SaveOrUpdate(model);
CancelOrderCommand command = new CancelOrderCommand(order.OrderId, order.TraderId);
ICancelOrderCommandValidation validation = new CancelOrderCommandValidation(_orderRepository);
validation.ValidateCancelOrderCommand(command);
}
public void PublishOrderToOutputDisruptor_IfOrderListenerIsInitiated_ItShouldSaveInDatabase()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
OutputDisruptor.Publish(order);
_manualResetEvent.WaitOne(5000);
OrderReadModel receivedOrder = _orderRepository.GetOrderById(order.OrderId.Id.ToString());
Assert.NotNull(receivedOrder);
Assert.AreEqual(receivedOrder.OrderId, order.OrderId.Id.ToString());
Assert.AreEqual(receivedOrder.Side, order.OrderSide.ToString());
Assert.AreEqual(receivedOrder.Type, order.OrderType.ToString());
Assert.AreEqual(receivedOrder.Price, order.Price.Value);
Assert.AreEqual(receivedOrder.CurrencyPair, order.CurrencyPair);
}
public void SaveOrderReadModel_IfStateIsAccepted_ClosingTimeShouldBeNull()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
string id = DateTime.Now.ToString();
order.OrderState = OrderState.Accepted;
OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order);
_persistanceRepository.SaveOrUpdate(model);
OrderReadModel getReadModel = _orderRepository.GetOrderById(order.OrderId.Id.ToString());
Assert.NotNull(getReadModel);
AssertAreEqual(getReadModel, model);
Assert.Null(getReadModel.ClosingDateTime);
}
public void SaveOrderReadModel_IfSaveOrUpdateMethodIsCalled_ItShouldGetSavedInTheDatabase()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
string id = DateTime.Now.ToString();
order.OrderState = OrderState.Complete;
OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order);
_persistanceRepository.SaveOrUpdate(model);
OrderReadModel getReadModel = _orderRepository.GetOrderById(order.OrderId.Id.ToString());
Assert.NotNull(getReadModel);
AssertAreEqual(getReadModel, model);
Assert.NotNull(getReadModel.ClosingDateTime);
}
public void GetClosedOrders_IfTraderIdIsProvided_ItShouldRetireveAllClosedOrdersOfTrader()
{
Order order = OrderFactory.CreateOrder("999", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
order.OrderState = OrderState.Complete;
string id = DateTime.Now.ToString();
OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order);
_persistanceRepository.SaveOrUpdate(model);
IList <OrderReadModel> getReadModel = _orderRepository.GetClosedOrders("999");
Assert.NotNull(getReadModel);
Assert.AreEqual(getReadModel.Count, 1);
AssertAreEqual(getReadModel[0], model);
}
/// <summary>
/// Trade Details
/// </summary>
/// <param name="traderId"></param>
/// <param name="tradeId"></param>
/// <returns></returns>
public TradeDetailsRepresentation GetTradeDetails(string traderId, string tradeId)
{
TradeReadModel model = _tradeRepository.GetByIdAndTraderId(traderId, tradeId);
OrderReadModel buyOrder = _orderRepository.GetOrderById(model.BuyOrderId);
OrderReadModel sellOrder = _orderRepository.GetOrderById(model.SellOrderId);
if (buyOrder.TraderId == traderId && sellOrder.TraderId == traderId)
{
OrderReadModel fillingOrder = buyOrder.DateTime > sellOrder.DateTime ? buyOrder : sellOrder;
return(new TradeDetailsRepresentation(fillingOrder, model.ExecutionDateTime, model.Price, model.Volume, model.TradeId));
}
if (buyOrder.TraderId == traderId)
{
return(new TradeDetailsRepresentation(buyOrder, model.ExecutionDateTime, model.Price, model.Volume, model.TradeId));
}
return(new TradeDetailsRepresentation(sellOrder, model.ExecutionDateTime, model.Price, model.Volume, model.TradeId));
}
public void Handle(OrderPlacedEvent @event, DatabaseContext db)
{
var order = @event.Order;
var orderItemJson = order.OrderItems?.Any() ?? true?JsonConvert.SerializeObject(order.OrderItems) :
string.Empty;
var orderStatus = (int)order.OrderStatus;
var orderReadModel = new OrderReadModel(order.Id,
orderStatus,
order.TotalAmount,
order.BoothId,
orderItemJson);
db.Set <OrderReadModel>()
.Add(orderReadModel);
}
static void Main(string[] args)
{
Menu menu = new Menu();
Bus bus = new Bus();
Manager manager = new Manager();
var managerQueue = new QueuedHandler <OrderCompleted>(manager, "Manager Queue");
cashier = new Cashier(bus);
var cashierQueue = new QueuedHandler <PayForOrder>(cashier, "Cashier Queue");
AssistantManager assistantManager = new AssistantManager(bus);
var assistantManagerQueue = new QueuedHandler <PriceOrder>(assistantManager, "Assistant Manager Queue");
Cook cook1 = new Cook(bus, 200);
var cook1Queue = new QueuedHandler <CookOrder>(cook1, "Cook Queue1");
Cook cook2 = new Cook(bus, 400);
var cook2Queue = new QueuedHandler <CookOrder>(cook2, "Cook Queue2");
Cook cook3 = new Cook(bus, 600);
var cook3Queue = new QueuedHandler <CookOrder>(cook3, "Cook Queue3");
EvilActor evilActor = new EvilActor(bus);
var cookdispatcher = new QueueDispatcher <CookOrder>(new List <QueuedHandler <CookOrder> > {
cook1Queue, cook2Queue, cook3Queue
});
//var dropper = new MessageDropper<CookOrder>(cookdispatcher);
//var ttlh = new TimeToLiveHandler<CookOrder>(dropper);
var cookDispatcherQueue = new QueuedHandler <CookOrder>(cookdispatcher, "Cook Dispatcher");
UkRestaurantProcessManagerPool processManagerPool = new UkRestaurantProcessManagerPool(bus);
bus.Subscribe(processManagerPool);
AlarmClock <OrderPlaced> orderPlacedReminder = new AlarmClock <OrderPlaced>(bus);
AlarmClock <CookOrder> cookReminder = new AlarmClock <CookOrder>(bus);
Waiter waiter = new Waiter(bus, menu);
var orderReadModel = new OrderReadModel();
bus.Subscribe(orderPlacedReminder);
bus.Subscribe(cookReminder);
bus.Subscribe(cookDispatcherQueue);
bus.Subscribe(assistantManagerQueue);
bus.Subscribe(cashierQueue);
bus.Subscribe(managerQueue);
//bus.Subscribe(evilActor);
bus.Subscribe <HumanInterventionRequired>(manager);
List <IStartable> startable = new List <IStartable> {
managerQueue, cashierQueue, assistantManagerQueue, cook1Queue, cook2Queue, cook3Queue, cookDispatcherQueue, orderReadModel
};
queues = new List <IMonitorableQueue>()
{
managerQueue, cashierQueue, assistantManagerQueue, cook1Queue, cook2Queue, cook3Queue, cookDispatcherQueue
};
startable.ForEach(s => s.Start());
//Thread monitor = new Thread(Printout) { IsBackground = true };
KeepOnMonitoring = true;
//monitor.Start();
Stopwatch sw = new Stopwatch();
sw.Start();
bus.SubscribeToAll <OrderPlaced>(orderReadModel);
bus.SubscribeToAll <OrderCooked>(orderReadModel);
bus.SubscribeToAll <OrderPriced>(orderReadModel);
bus.SubscribeToAll <OrderPaid>(orderReadModel);
bus.SubscribeToAll <OrderCompleted>(orderReadModel);
for (int i = 0; i <= 20; i++)
{
Customer cust = new Customer(bus, waiter, cashier);
cust.PlaceOrder();
}
Console.ReadLine();
KeepOnMonitoring = false;
sw.Stop();
Console.WriteLine("Completed in {0} milliseconds", sw.ElapsedMilliseconds);
Console.WriteLine("Paid Orders: {0}, Completed Orders: {1}, Total: {2}", paidOrders, manager.Count, manager.Total);
Console.ReadLine();
}
