public async Task ShouldProcessDiscountOrder()
{
// arrange
var saga = new DiscountPolicy
{
Data = new DiscountPolicyData()
};
var context = new TestableMessageHandlerContext();
var discountOrder = new SubmitOrder
{
CustomerId = Guid.NewGuid(),
OrderId = Guid.NewGuid(),
TotalAmount = 1000
};
// act
await saga.Handle(discountOrder, context)
.ConfigureAwait(false);
// assert
var processMessage = (ProcessOrder)context.SentMessages[0].Message;
Assert.That(processMessage.TotalAmount, Is.EqualTo(900));
Assert.That(saga.Completed, Is.False);
}
internal void OnSubmitOrderCommand_WhenCommandValid_OperatesDatabaseAndSendsToGateway()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
var command = new SubmitOrder(
traderId,
accountId,
strategyId,
positionId,
order,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
this.engine.Endpoint.SendAsync(command).Wait();
Task.Delay(100).Wait(); // Buffer to avoid intermittent tests
// Assert
Assert.Null(this.engine.UnhandledMessages.FirstOrDefault());
Assert.Equal(2, this.engine.ProcessedCount);
Assert.Equal(1, this.engine.CommandCount);
Assert.Single(this.tradingGateway.CalledMethods);
Assert.Single(this.tradingGateway.ReceivedObjects);
Assert.Equal("SubmitOrder", this.tradingGateway.CalledMethods[0]);
Assert.Equal(order, this.tradingGateway.ReceivedObjects[0]);
}
internal void OnOrderPartiallyFilledEvent_UpdatesOrderSendsToPublisher()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
var submitOrder = new SubmitOrder(
traderId,
accountId,
strategyId,
positionId,
order,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
this.engine.Endpoint.SendAsync(submitOrder).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderAcceptedEvent(order)).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderPartiallyFilledEvent(
order,
Quantity.Create(50000),
Quantity.Create(50000))).Wait();
Task.Delay(100).Wait(); // Buffer to avoid intermittent tests
// Assert
Assert.Null(this.engine.UnhandledMessages.FirstOrDefault());
Assert.Equal(4, this.engine.ProcessedCount);
Assert.Equal(1, this.engine.CommandCount);
Assert.Equal(2, this.engine.EventCount);
Assert.Equal(3, this.receiver.Messages.Count);
Assert.Equal(OrderState.PartiallyFilled, order.State);
}
public void PlaceOrder(string[] productIds)
{
bool isDebug = (bool)Clients.Caller.debug;
if (isDebug)
{
Debugger.Break();
}
var command = new SubmitOrder
{
ClientId = Context.ConnectionId,
OrderNumber = Interlocked.Increment(ref orderNumber),
ProductIds = productIds,
// This property will be encrypted. Therefore when viewing the message in the queue, the actual values will not be shown.
EncryptedCreditCardNumber = "4000 0000 0000 0008",
// This property will be encrypted.
EncryptedExpirationDate = "10/13"
};
SendOptions sendOptions = new SendOptions();
sendOptions.SetHeader("Debug", isDebug.ToString());
MvcApplication.BusContext.Send(command, sendOptions);
}
static void Main()
{
var serviceProvider = new ServiceCollection()
.AddRawRabbit(new RawRabbitOptions
{
ClientConfiguration = new RawRabbitConfiguration
{
Username = "******",
Password = "******",
Port = 5672,
VirtualHost = "/",
Hostnames = { "localhost" }
}
})
.BuildServiceProvider();
var client = serviceProvider.GetService <IBusClient>();
Console.WriteLine("Publishing order command...");
var submitOrder = new SubmitOrder(Guid.NewGuid(), $"Order - {DateTime.Now}", 1230);
client.PublishAsync(submitOrder).Wait();
Console.WriteLine($"Command {submitOrder.Id} published.");
}
public async Task ChangeStatus()
{
var cartId = Guid.NewGuid().ToString();
var customerId = Guid.NewGuid().ToString();
var submitOrder = new SubmitOrder {
CartId = cartId, Customer = customerId, Items = new List <Filling>()
};
var bookPayment = new BookPayment {
Id = Guid.NewGuid(), CartId = cartId, Customer = customerId
};
var cancelPayment = new CancelPayment {
Id = Guid.NewGuid(), CartId = cartId, Customer = customerId
};
await SendInOrder(new IMessage[]
{
submitOrder,
bookPayment,
cancelPayment,
bookPayment
}
);
var(order, _) = await ordersRepository.Get <Order>(customerId, cartId);
Assert.AreEqual(order.PaymentBooked, false);
}
/// <summary>
/// This is just a sample of usage
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button1_Click(object sender, EventArgs e)
{
// SOME DATA FROM UI
var userId = 1;
var orderItems = new List <OrderItemDTO>();
orderItems.Add(new OrderItemDTO
{
Name = "SomeBook",
Amount = 2,
Price = 1750
});
// DomainModel
var order = new Order(userId, orderItems);
order.SubmitOrder();
// TableModule
var tableModule = new OrderModule();
tableModule.SubmitOrder(userId, orderItems);
// TransactionScript
var transactionScript = new SubmitOrder();
transactionScript.Execute(userId, orderItems);
}
public Order SetOrder(SubmitOrder model)
{
var total = model.CartDetails.Select(n => n.Price).Sum();
var orderDetails = model.CartDetails.Select(n => new OrderDetail
{
AlbumId = n.AlbumId,
Quantity = 1,
UnitPrice = n.Price
}).ToList();
return(new Order
{
OrderDate = System.DateTime.Now,
Username = LoginUserInfo.Name,
FirstName = model.FirstName,
LastName = model.LastName,
Address = model.Address,
City = model.City,
State = model.State,
PostalCode = model.PostalCode,
Country = model.Country,
Phone = model.Phone,
Email = model.Email,
UserId = LoginUserInfo.UserId,
Total = total,
OrderDetails = orderDetails
});
}
partial void HandleImplementation(SubmitOrder message)
{
// Implement your handler logic here.
Console.WriteLine("Sales received " + message.GetType().Name);
Bus.Publish<OrderAccepted>();
}
static async Task Main(string[] args)
{
var endpointConfiguration = new EndpointConfiguration("Sender");
endpointConfiguration.HostName = "192.168.1.25";
var routing = endpointConfiguration.Routing();
routing.RouteToEndpoint(typeof(SubmitOrder), "Sales");
var endpointInstance = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false);
Console.WriteLine("Press [s] to send a message");
Console.WriteLine("Press any other key to exit");
while (Console.ReadKey(true).Key == ConsoleKey.S)
{
var order = new SubmitOrder
{
CustomerId = Guid.NewGuid(),
Id = Guid.NewGuid()
};
await endpointInstance.Send(order).ConfigureAwait(false);
Console.WriteLine($"Send message with OrderId {order.Id}");
}
await endpointInstance.Shutdown().ConfigureAwait(false);
}
//-- COMMANDS ------------------------------------------------------------------------------------------------//
private void OnMessage(SubmitOrder command)
{
this.CommandCount++;
this.Logger.LogInformation(LogId.Trading, $"{Received}{Command} {command}.");
var result = this.database.AddOrder(
command.Order,
command.TraderId,
command.AccountId,
command.StrategyId,
command.PositionId);
if (result.IsSuccess)
{
var positionIdBroker = this.database.GetPositionIdBroker(command.PositionId);
this.gateway.SubmitOrder(command.Order, positionIdBroker);
var submitted = new OrderSubmitted(
command.AccountId,
command.Order.Id,
this.TimeNow(),
this.NewGuid(),
this.TimeNow());
command.Order.Apply(submitted);
this.database.UpdateOrder(command.Order);
this.SendToEventPublisher(submitted);
}
else
{
this.Logger.LogError(LogId.Database, $"Cannot execute command {command} ({result.Message}).");
}
}
public async Task Submit(SubmitOrder order)
{
//_publishEndpoint.Publish<ISubmitOrder>(order);
var sendEndpoint = await _sendEndpointProvider.GetSendEndpoint(new Uri("queue:order-saga"));
await sendEndpoint.Send <ISubmitOrder>(order);
}
internal void OnOrderFilledEvent_WithNoPosition_OpensPosition()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
var submitOrder = new SubmitOrder(
traderId,
accountId,
strategyId,
positionId,
order,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
this.engine.Endpoint.SendAsync(submitOrder).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderSubmittedEvent(order)).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderAcceptedEvent(order)).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderFilledEvent(order)).Wait();
Task.Delay(100).Wait(); // Buffer to avoid intermittent tests
// Assert
Assert.Single(this.database.GetPositions());
}
public async Task OrderBasketAsync()
{
var products = _basketService.GetProducts().ToList();
if (products.Count > 0)
{
var productItems = new List <ProductItem>();
var orderedProducts = from p in products
group p by p.ProductId;
foreach (var item in orderedProducts)
{
productItems.Add(new ProductItem {
ProductId = item.Key, Quantity = item.Count()
});
}
var order = new SubmitOrder {
CustomerId = 1, // Lets assume guest
Items = productItems.ToArray()
};
var client = _httpClientFactory.CreateClient();
var stringContent = new StringContent(JsonConvert.SerializeObject(order), Encoding.UTF8, "application/json");
var salesServiceHost = _configuration["SalesServiceHost"];
var response = await client.PostAsync($"http://{salesServiceHost}/api/orders", stringContent);
_basketService.Clear();
}
}
Task ProcessWithDiscount(SubmitOrder message, IMessageHandlerContext context)
{
return(context.Send(new ProcessOrder
{
CustomerId = Data.CustomerId,
OrderId = message.OrderId,
TotalAmount = message.TotalAmount * (decimal)0.9
}));
}
Task ProcessExternalOrder(SubmitOrder message, IMessageHandlerContext context)
{
return(context.Send <ProcessOrder>("remote.orderQueue", m =>
{
m.CustomerId = Data.CustomerId;
m.OrderId = message.OrderId;
m.Total = message.Total;
}));
}
Task ProcessOrderWithDiscount(SubmitOrder message, IMessageHandlerContext context)
{
return(context.Send <ProcessOrder>(m =>
{
m.CustomerId = Data.CustomerId;
m.OrderId = message.OrderId;
m.Total = message.Total * (decimal)0.9;
}));
}
Task ProcessOrder(SubmitOrder message, IMessageHandlerContext context)
{
return(context.Send <ProcessOrder>(m =>
{
m.CustomerId = Data.CustomerId;
m.OrderId = message.OrderId;
m.TotalAmount = message.TotalAmount;
}));
}
public Task Handle(SubmitOrder message, IMessageHandlerContext context)
{
Data.OrderNumber = message.OrderNumber;
Data.ProductIds = message.ProductIds;
Data.ClientId = message.ClientId;
log.Info($"Starting cool down period for order #{Data.OrderNumber}.");
return(RequestTimeout(context, TimeSpan.FromSeconds(20), new BuyersRemorseIsOver()));
}
public void Handle(SubmitOrder message)
{
//var rand = new Random();
//if (rand.Next(0, 2) == 0)
//{
// throw new Exception("Problem with message");
//}
Console.WriteLine("Order {0} submitted with {1} item(s)", message.OrderId, Data.Items.Count);
MarkAsComplete();
}
internal void OnModifyOrderCommand_WhenOrderAlreadyBeingModified_DoesNotSendToGateway()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildStopMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
var submit = new SubmitOrder(
traderId,
accountId,
strategyId,
positionId,
order,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var modify1 = new ModifyOrder(
traderId,
accountId,
order.Id,
order.Quantity,
Price.Create(1.00010m, 5),
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var modify2 = new ModifyOrder(
traderId,
accountId,
order.Id,
order.Quantity,
Price.Create(1.00010m, 5),
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
this.engine.Endpoint.SendAsync(submit).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderAcceptedEvent(order)).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderWorkingEvent(order)).Wait();
this.engine.Endpoint.SendAsync(modify1).Wait();
this.engine.Endpoint.SendAsync(modify2).Wait();
Task.Delay(100).Wait(); // Buffer to avoid intermittent tests
// Assert
Assert.Null(this.engine.UnhandledMessages.FirstOrDefault());
Assert.Equal(6, this.engine.ProcessedCount);
Assert.Equal(3, this.engine.CommandCount);
Assert.Equal(2, this.engine.EventCount);
Assert.Equal(2, this.tradingGateway.CalledMethods.Count);
Assert.Equal(2, this.tradingGateway.ReceivedObjects.Count);
Assert.Equal("SubmitOrder", this.tradingGateway.CalledMethods[0]);
Assert.Equal("ModifyOrder", this.tradingGateway.CalledMethods[1]);
Assert.Equal(3, this.receiver.Messages.Count);
}
Task ProcessOrder(SubmitOrder message, IMessageHandlerContext context)
{
var processOrder = new ProcessOrder
{
CustomerId = Data.CustomerId,
OrderId = message.OrderId,
TotalAmount = message.TotalAmount
};
return(context.Send(processOrder));
}
public Task Handle(SubmitOrder message, IMessageHandlerContext context)
{
Data.CustomerId = message.CustomerId;
Data.TotalAmount += message.TotalAmount;
if (Data.TotalAmount >= 1000)
{
return(ProcessWithDiscount(message, context));
}
return(ProcessOrder(message, context));
}
public IActionResult PayCallBack([FromBody] SubmitOrder model)
{
//if (dBPeriods.OverplusNum == 0)
//{
// dBPeriods.WaitOpenTime = DateTime.Now.AddMinutes(10);
// dBPeriods.Status = 1;//0 进行中 1正在开奖中2开奖成功3开奖失败
// OpenPeriods waitopen = new OpenPeriods();
// waitopen.WaitOpen(dBPeriods.ID);
//}
return(new ObjectResult(FormatResult.Failure("no imp...")));
}
public static Order ToOrder(this SubmitOrder message)
{
var order = new Order
{
OrderId = message.OrderId,
SubmittedOn = message.SubmittedOn,
ProcessedOn = DateTime.UtcNow
};
return(order);
}
public ActionResult About()
{
var submitOrderMessage = new SubmitOrder {
OrderId = Guid.NewGuid()
};
MvcApplication.Bus.Send(submitOrderMessage);
ViewBag.Message = "Your app description page. order id: " + submitOrderMessage.OrderId.ToString();
return(View());
}
public ActionResult CheckOut()
{
var nameDetails = LoginUserInfo.Name.Split(' ');
SubmitOrder order = new SubmitOrder
{
CartDetails = _cartService.ViewCart(LoginUserInfo.UserId, LoginUserInfo.CartId),
FirstName = nameDetails[0].ToString(),
LastName = nameDetails[1].ToString()
};
return(View(order));
}
public ActionResult CheckOut(SubmitOrder order)
{
order.CartDetails = _cartService.ViewCart(LoginUserInfo.UserId, LoginUserInfo.CartId);
if (ModelState.IsValid)
{
_orderService.Save(order);
return(RedirectToAction("Order/" + order.OrderId, "AddToCart"));
}
return(View(order));
}
public async void Post([FromBody] SubmitOrder submittedOrder)
{
var command = new SubmitOrderCommand()
{
CustomerId = submittedOrder.CustomerId,
Items = submittedOrder.Items.Select(t => new Item()
{
ProductId = t.ProductId, Quantity = t.Quantity
}).ToArray()
};
await _bus.Send(command);
}
public void Handle(SubmitOrder message)
{
if (DebugFlagMutator.Debug)
{
Debugger.Break();
}
Data.OrderNumber = message.OrderNumber;
Data.VideoIds = message.VideoIds;
Data.ClientId = message.ClientId;
RequestTimeout(TimeSpan.FromSeconds(20), new BuyersRemorseIsOver());
Console.WriteLine("Starting cool down period for order #{0}.", Data.OrderNumber);
}
public void Handle(SubmitOrder message)
{
if (DebugFlagMutator.Debug)
{
Debugger.Break();
}
Data.OrderNumber = message.OrderNumber;
Data.ProductIds = message.ProductIds;
Data.ClientId = message.ClientId;
RequestTimeout(TimeSpan.FromSeconds(20), new BuyersRemorseIsOver());
log.Info($"Starting cool down period for order #{Data.OrderNumber}.");
}
public async Task ShouldProcessRegularOrder()
{
var saga = new DiscountPolicy
{
Data = new DiscountPolicyData()
};
var context = new TestableMessageHandlerContext();
var regularOrder = new SubmitOrder
{
CustomerId = Guid.NewGuid(),
OrderId = Guid.NewGuid(),
TotalAmount = 50
};
await saga.Handle(regularOrder, context);
var processMessage = (ProcessOrder)context.SentMessages[0].Message;
Assert.AreEqual(50, processMessage.TotalAmount);
}
public void PlaceOrder(string[] productIds)
{
bool isDebug = (bool)Clients.Caller.debug;
if (isDebug)
{
Debugger.Break();
}
SubmitOrder command = new SubmitOrder
{
ClientId = Context.ConnectionId,
OrderNumber = Interlocked.Increment(ref orderNumber),
ProductIds = productIds,
// This property will be encrypted. Therefore when viewing the message in the queue, the actual values will not be shown.
EncryptedCreditCardNumber = "4000 0000 0000 0008",
// This property will be encrypted.
EncryptedExpirationDate = "10/13"
};
MvcApplication.Bus.SetMessageHeader(command, "Debug", isDebug.ToString());
MvcApplication.Bus.Send(command);
}
public void Send(SubmitOrder message)
{
Bus.Send(message);
}
