public ClientOrderStatisticalDTO GetClientOrdersStatistics(OrderCommand cmd, int userId, ref int pagesCount)
{
var user = new UserDalFacade().GetAccountUser(userId);
var isAdmin = user.isSunnat || user.PositionRole == 1;
return(new OrderDalFacade().GetClientOrdersStats(cmd, user.WorkPlace.Id.Value, isAdmin, ref pagesCount));
}
private void btn_Click(object sender, EventArgs e)
{
Button btn = sender as Button;
OrderCommand command = (OrderCommand)Enum.Parse(typeof(OrderCommand), btn.ID, true);
ProcOrder(command);
}
private Order BindItem(OrderCommand order)
{
return(new Order
{
Customer = new Customer
{
CustomerId = order.CustomerId
},
Restaurant = new Restaurant
{
RestaurantId = order.RestaurantId
},
Amount = order.Amount,
Quantity = order.Quantity,
Status = 0,
TransactionId = order.TransactionId,
Items = order.Items.Select(x => new OrderItems
{
Amount = x.Amount,
Quantity = x.Quantity,
Meal = new Meal
{
MealId = x.MealId
}
})
});
}
/// <summary>
/// Invokes a commands on the <c>Machine</c> instance
/// </summary>
/// <param name="commandType">One of the <c>Command</c> enum</param>
/// <param name="commandInput">Dynamic Input recieved from MachineClient.
/// Manager must cast it to the type the command requires, trusting the validations in client to filter out incorrect command parameters entered by user</param>
public void ExecuteCommand(Command commandType, object commandInput)
{
IMachineCommand machineCommand;
switch (commandType)
{
case Command.InsertMoney:
machineCommand = new InsertMoneyCommand((int)commandInput);
break;
case Command.Order:
machineCommand = new OrderCommand((string)commandInput);
break;
case Command.SmsOrder:
machineCommand = new SmsOrderCommand((string)commandInput);
break;
case Command.Recall:
machineCommand = new RecallCommand();
break;
default: return; //No command will be executed
}
_machine = machineCommand.Execute(_machine);
}
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("Creating topics and subscriptions ... ");
//create predefined topics for the sample application
InfrastructureManagement.CreateTopics();
Console.WriteLine("Done!");
Console.ResetColor();
WaitForEnter("Press enter to send the messages");
//place orders
var command = new OrderCommand();
command.PlaceOrders();
WaitForEnter("Press enter to receive messages");
var orderSubscriptionQuery = new OrderSubscriptionQuery();
orderSubscriptionQuery.ReceiveOrder();
WaitForEnter("Press any key to continue");
}
public void CanOrderOrderedDocuments()
{
var path = Path.GetFullPath(@"data\ordered-documents\");
var command = new LoadDocumentsCommand();
command.Author = new Author();
command.DocumentsPath = path;
command.OutputRootPath = Path.GetFullPath("output");
command.RenderedExtensions = new[] { "md" };
command.RootUrl = "http://www.example.com/";
command.ApplicationUrl = "/foo";
command.ExecuteAsync().Wait();
var order = new OrderCommand();
order.Documents = command.Documents;
order.Execute();
Assert.Equal(1, order.Books.Count());
var doc = command.Documents.Skip(3).Take(1).Single();
var data = order.Books.First().GetAsDynamic(doc);
}
//[Fact]
public async Task Send()
{
var command = new OrderCommand();
var order = await this._mediator.SendAsync <Order>(command);
this.WriteLine(order);
}
public IActionResult Post([FromBody] OrderCommand order)
{
try
{
return(Ok(orderService.Insert(order)));
} catch (System.Exception ex) { System.Console.WriteLine(ex.Message); }
return(BadRequest("Order was not registered"));
}
static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.AddEnvironmentVariables();
Configuration = builder.Build();
var loggerFactory = new LoggerFactory()
.AddConsole()
.AddDebug();
ILogger logger = loggerFactory.CreateLogger <Program>();
var port = int.Parse(Configuration["service:port"]);
var brokerList = Configuration["kafkaclient:brokerlist"];
var config = new Dictionary <string, object>
{
{ "group.id", "order-command" },
{ "enable.auto.commit", "false" },
{ "bootstrap.servers", brokerList }
};
IEventEmitter kafkaEmitter = new KafkaEventEmitter(config, loggerFactory.CreateLogger <KafkaEventEmitter>());
// TODO: this channel needs to use a service-discovery hostname
var orderChannel = new Channel($"{Configuration["orderclient:hostname"]}:{Configuration["orderclient:port"]}",
ChannelCredentials.Insecure);
var inventoryChannel = new Channel($"{Configuration["inventoryclient:hostname"]}:{Configuration["inventoryclient:port"]}",
ChannelCredentials.Insecure);
logger.LogInformation($"Configured gRPC channel for Order Management client: {orderChannel.ResolvedTarget}");
logger.LogInformation($"Configured gRPC channel for Inventory Management client: {inventoryChannel.ResolvedTarget}");
var orderClient = new OrderManagement.OrderManagementClient(orderChannel);
var inventoryClient = new InventoryManagement.InventoryManagementClient(inventoryChannel);
var refImpl = new ReflectionServiceImpl(
ServerReflection.Descriptor, OrderCommand.Descriptor);
var rpcLogger = loggerFactory.CreateLogger <OrderCommandImpl>();
var server = new Server
{
Services = { OrderCommand.BindService(new OrderCommandImpl(rpcLogger, kafkaEmitter, orderClient, inventoryClient)),
ServerReflection.BindService(refImpl) },
Ports = { new ServerPort("localhost", port, ServerCredentials.Insecure) }
};
server.Start();
logger.LogInformation("Orders Command gRPC Service Listening on Port " + port);
// Keep the process alive without consuming CPU cycles
mre.WaitOne();
}
private void Order(Site site)
{
using (var capture = Statistics.Current.Start(StatisticTiming.Ordering))
{
var order = new OrderCommand();
order.Documents = site.Documents;
order.Execute();
site.Books = order.Books;
}
}
public Order Map(OrderCommand order)
{
return(new Order()
{
Id = order.Id,
OrderDate = order.OrderDate,
Price = order.Price,
Quantity = order.Quantity,
CustomerId = order.CustomerId
});
}
public void SetOrder(OrderCommand order)
{
if (order.ToString() == "BakeChickenWingCommand")
{
Console.WriteLine("鸡翅没有了，换点别的吧");
}
else
{
Console.WriteLine($"{order} 下单成功");
_orders.Add(order);
}
}
public IActionResult Post([FromBody] OrderCommand command)
{
try
{
_orderAppService.Add_a_new_Order_and_Order_Item_for_an_existing_Customer(command);
return(Ok("Customer added with success."));
}
catch (System.Exception ex)
{
return(Problem(ex.Message));
}
}
public async Task <ActionResult <RegBookResponseObj> > CheckInBook([FromBody] OrderObj requestObj)
{
OrderCommand command = _mapper.Map <OrderCommand>(requestObj);
var response = await _mediator.Send(command);
if (response.OrderId < 1 || !response.Status.IsSuccessful)
{
return(BadRequest(response));
}
var locatioUri = _uriService.GetBookUri(response.OrderId.ToString());
return(Created(locatioUri, response));
}
public Order Insert(OrderCommand order)
{
var _order = BindItem(order);
_order = repository.Insert(_order);
foreach (var item in order.Items)
{
item.OrderId = _order.OrderId;
repository.InsertItem(BindOrderItem(item));
}
return(GetById(_order.OrderId));
}
public ActionResult Order(OrderCommand order, [FromServices] OrderCommandHandler handler)
{
var result = handler.Handle(order);
if (result.PaymentOk)
{
ViewData["Message"] = "Thank you. Your order has been placed.";
return(View(result));
}
else
{
return(RedirectToAction("PaymentFailed"));
}
}
public void Checkout(CheckoutParameter checkoutParameter)
{
foreach (var product in checkoutParameter.CartParameter.Products)
{
var orderCommand = new OrderCommand
{
CustomerId = checkoutParameter.CustomerId,
CartId = checkoutParameter.CartParameter.CartId,
ProductId = product.ProductId,
ItemCount = product.ItemCount
};
_orderCommandHandler.Handle(orderCommand);
}
}
public static Command Build(string[] data)
{
Command command;
if (int.TryParse(data[0], out _))
{
command = new OrderCommand(data);
}
else
{
command = new RegisterProductCommand(data);
}
return(command);
}
private void ProcOrder(OrderCommand command)
{
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CRMDataStoreKey))
{
OrderFacade facade = new OrderFacade(uow);
IFacadeUpdateResult <OrderData> result = null;
switch (command)
{
case OrderCommand.Accept:
result = facade.OrderAccept(Order.OrderId);
break;
case OrderCommand.Reject:
result = facade.OrderReject(Order.OrderId);
break;
case OrderCommand.Delivering:
result = facade.OrderDelivering(Order.OrderId);
break;
case OrderCommand.Complete:
result = facade.OrderComplete(Order.OrderId);
break;
case OrderCommand.Incomplete:
result = facade.OrderIncomplete(Order.OrderId);
break;
}
if (result.IsSuccessful)
{
// retrieve saved order info
// remove this line on May.23, move retrieve action to caller page
//Order = facade.RetrieveOrderInfo(Order.OrderId, new OrderInfoConverter());
if (OrderChanged != null)
{
InstanceChangedEventArgs arg = new InstanceChangedEventArgs(Order);
OrderChanged(this, arg);
}
}
else
{
// Deal with Update result
//ProcUpdateResult(result.ValidationResult, result.Exception);
}
}
}
public async Task <IActionResult> Order(OrderCommand orderCommand)
{
return(await
// Try to generate an order
from maybeOrder in
from product in _repository.FindByIdAsync(orderCommand.ProductId)
select OrderBehavior.TryOrder(product, orderCommand.Quantity)
// Update the DB
from result in maybeOrder.AwaitSideEffect(_repository.UpdateAsync)
// Return results
select result.Match <IActionResult>(
Ok,
StatusCode(500, new { Error = "No available units." })));
}
public TradingSignal(
Instrument instrument,
string orderId, OrderCommand command, TradeType tradeType, decimal?price, decimal volume, bool isMarginOrder, DateTime time, OrderType orderType = OrderType.Market)
{
Instrument = instrument;
OrderId = orderId;
Command = command;
TradeType = tradeType;
Price = price;
Volume = volume;
Time = time;
OrderType = orderType;
IsMarginOrder = isMarginOrder;
}
public TradingSignal(
Instrument instrument,
string orderId, OrderCommand command, TradeType tradeType, decimal?price, decimal volume, DateTime time, OrderType orderType = OrderType.Market,
TimeInForce timeInForce = TimeInForce.FillOrKill)
{
Instrument = instrument;
OrderId = orderId;
Command = command;
TradeType = tradeType;
Price = price;
Volume = volume;
Time = time;
OrderType = orderType;
TimeInForce = timeInForce;
}
public void ExecuteOrder(OrderCommand orderCommand)
{
var productAggregate = _productRepository.Get(orderCommand.ProductId);
var totalAvailable = productAggregate.GetTotalAvailable();
if (totalAvailable < orderCommand.ItemCount)
{
PublishOrderFailedEvent(orderCommand);
return;
}
var orderResult = CreateOrders(productAggregate, orderCommand);
PersistOrderResult(orderResult);
PublishOrderSucceededEvent(orderCommand);
UpdateProductAvailability(orderCommand.ProductId, totalAvailable - orderCommand.ItemCount);
}
/// <summary>
/// 根据下单指令下单。
/// </summary>
/// <param name="command">下单指令。</param>
private bool PlaceOrderForOrderCommand(OrderCommand command)
{
string errorMessage = string.Empty;
USeOrderNum orderNum = m_orderDriver.PlaceOrder(command.Instrument, command.OrderQty, command.OrderPrice, command.OffsetType, command.OrderSide, out errorMessage);
command.OrderNum = orderNum;
if (orderNum == null)
{
Debug.Assert(string.IsNullOrEmpty(errorMessage) == false);
command.OrderErrorMessage = errorMessage;
return(false); // 下单失败
}
else
{
return(true);
}
}
public void TestShoes()
{
// Given
IProduct shoes = new Shoes();
PurchaseController controller = new PurchaseController();
ICommand order = new OrderCommand(shoes);
controller.InsertCommand(order);
ICommand buy = new BuyCommand(shoes);
controller.InsertCommand(buy);
// When
var order_t = order.Execute();
var buy_t = buy.Execute();
// Then
Assert.AreEqual("Shoes", order_t);
Assert.AreEqual("39.99", buy_t);
}
public void TestTshirt()
{
// Given
IProduct tshirt = new Tshirt();
PurchaseController controller = new PurchaseController();
ICommand order = new OrderCommand(tshirt);
controller.InsertCommand(order);
ICommand buy = new BuyCommand(tshirt);
controller.InsertCommand(buy);
// When
var order_t = order.Execute();
var buy_t = buy.Execute();
// Then
Assert.AreEqual("T-shirt", order_t);
Assert.AreEqual("19.99", buy_t);
}
public void CanOrderUnorderedDocuments()
{
var path = Path.GetFullPath(@"data\dated-documents\");
var command = new LoadDocumentsCommand();
command.Author = new Author();
command.DocumentsPath = path;
command.OutputRootPath = Path.GetFullPath("output");
command.RenderedExtensions = new[] { "md" };
command.RootUrl = "http://www.example.com/";
command.ApplicationUrl = "/foo";
command.ExecuteAsync().Wait();
var order = new OrderCommand();
order.Documents = command.Documents;
order.Execute();
Assert.Equal(0, order.Books.Count());
}
static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.AddEnvironmentVariables();
Configuration = builder.Build();
ILoggerFactory loggerFactory = new LoggerFactory()
.AddConsole()
.AddDebug();
ILogger logger = loggerFactory.CreateLogger <Program>();
var port = int.Parse(Configuration["service:port"]);
IEventEmitter kafkaEmitter = new KafkaEventEmitter();
// TODO: this channel needs to use a service-discovery hostname
Channel orderChannel = new Channel($"{Configuration["orderclient:hostname"]}:{Configuration["orderclient:port"]}",
ChannelCredentials.Insecure);
logger.LogInformation($"Configured gRPC channel for Order Management client: {orderChannel.ResolvedTarget}");
var orderClient = new OrderManagement.OrderManagementClient(orderChannel);
Server server = new Server
{
Services = { OrderCommand.BindService(new OrderCommandImpl(kafkaEmitter, orderClient)) },
Ports = { new ServerPort("localhost", port, ServerCredentials.Insecure) }
};
server.Start();
logger.LogInformation("Orders Command RPC Service Listening on Port " + port);
// Keep the process alive without consuming CPU cycles
mre.WaitOne();
}
static void Main(string[] args)
{
const int Port = 3000;
IEventEmitter kafkaEmitter = new KafkaEventEmitter();
Channel orderChannel = new Channel("127.0.0.1:3001", ChannelCredentials.Insecure);
var orderClient = new OrderManagement.OrderManagementClient(orderChannel);
Server server = new Server
{
Services = { OrderCommand.BindService(new OrderCommandImpl(kafkaEmitter, orderClient)) },
Ports = { new ServerPort("localhost", Port, ServerCredentials.Insecure) }
};
server.Start();
Console.WriteLine("Orders Command RPC Service Listening on Port " + Port);
Console.WriteLine("Press any key to stop");
Console.ReadKey();
server.ShutdownAsync().Wait();
}
internal IFacadeUpdateResult <OrderData> PerformOrderCommand(object orderId, OrderCommand command)
{
ArgumentValidator.IsNotNull("orderId", orderId);
FacadeUpdateResult <OrderData> result = new FacadeUpdateResult <OrderData>();
IOrderService service = UnitOfWork.GetService <IOrderService>();
Order instance = RetrieveOrNew <OrderData, Order, IOrderService>(result.ValidationResult, orderId);
if (result.IsSuccessful)
{
ValidateOrderCommand(instance, command, result.ValidationResult);
if (result.IsSuccessful)
{
instance.StatusId = (int)command;
var saveQuery = service.Save(instance);
result.AttachResult(instance.RetrieveData <OrderData>());
result.Merge(saveQuery);
}
}
return(result);
}
