private void TradingRobotMain()
{
if (!m_oImperaturData.IsAutomaticMaintained || ImperaturGlobal.ExchangeStatus != ExchangeStatus.Open)
{
return;
}
CreateSystemNotification("Trading automation process running - processing order queue first");
//start with an evaluation of the orders
OrderQueue.EvaluateOrdersInQueue();
CreateSystemNotification("Trading automation process running - retrieving info to calculate trading recommendations");
List <IOrder> NewOrders = m_oTradeAutomation.RunTradeAutomation();
CreateSystemNotification("Adding orders to queue");
OrderQueue.AddOrders(NewOrders.Where(x => x != null).ToList());
//do all the others that might have ended up in the list.
CreateSystemNotification("processing order queue after recommendations");
OrderQueue.EvaluateOrdersInQueue();
CreateSystemNotification("processing order queue maintence");
OrderQueue.QueueMaintence(m_oAccountHandler);
CreateSystemNotification("Trading automation process finished");
}
/// <summary>
/// Remove this order from outstanding queue: its been filled or cancelled.
/// </summary>
/// <param name="orderId">Specific order id to remove</param>
public virtual void RemoveOrder(int orderId)
{
try
{
//Error check
if (!Orders.ContainsKey(orderId))
{
Log.Error("Security.Holdings.RemoveOutstandingOrder(): Cannot find this id.");
return;
}
if (Orders[orderId].Status != OrderStatus.Submitted)
{
Log.Error("Security.Holdings.RemoveOutstandingOrder(): Order already filled");
return;
}
Order orderToRemove = new Order("", 0, OrderType.Market, new DateTime());
orderToRemove.Id = orderId;
orderToRemove.Status = OrderStatus.Canceled;
OrderQueue.Enqueue(orderToRemove);
}
catch (Exception err)
{
Log.Error("TransactionManager.RemoveOrder(): " + err.Message);
}
}
public void Collections_OrderQueue_Is_Singleton()
{
OrderQueue q = OrderQueue.Instance;
OrderQueue q2 = OrderQueue.Instance;
Assert.AreSame(q, q2);
}
/// <summary>
/// Remove this order from outstanding queue: user is requesting a cancel.
/// </summary>
/// <param name="orderId">Specific order id to remove</param>
public virtual void RemoveOrder(int orderId)
{
try
{
//Error check
if (!Orders.ContainsKey(orderId))
{
Log.Error("Security.TransactionManager.RemoveOutstandingOrder(): Cannot find this id.");
return;
}
var order = Orders[orderId];
if (order.Status != OrderStatus.Submitted && order.Type != OrderType.Market)
{
Log.Error("Security.TransactionManager.RemoveOutstandingOrder(): Order already filled");
return;
}
//Update the status of the order
order.Status = OrderStatus.Canceled;
//Send back to queue to be reprocessed with new status
OrderQueue.Enqueue(order);
}
catch (Exception err)
{
Log.Error("TransactionManager.RemoveOrder(): " + err.Message);
}
}
private void SaveOrder(Order order)
{
var orderInDb = _context.OrderQueues
.Include(o => o.Queue)
.FirstOrDefault(o => o.Price == order.Price && o.Type == order.Type);
if (orderInDb == null)
{
var orderQueue = new OrderQueue
{
Price = order.Price,
Type = order.Type,
TotalCount = order.Quantity,
Queue = new List <Order>()
};
orderQueue.Queue.Add(order);
_context.OrderQueues.Add(orderQueue);
_context.Orders.Add(order);
}
else
{
orderInDb.Queue.Add(order);
orderInDb.TotalCount += order.Quantity;
}
_context.SaveChanges();
}
public void Given_InvalidStringParameter_When_CallingPlaceOrder_Then_ThrowsException(string dish)
{
var waiter = new Waiter("Jan", "Kowalski");
var orderQueue = new OrderQueue();
Assert.Throws <Exception>(() => waiter.PlaceOrder(dish, orderQueue));
}
public ActionResult DeleteConfirmed(int id)
{
OrderQueue orderQueue = db.Orders.Find(id);
db.Orders.Remove(orderQueue);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void InitClasses()
{
_bottleshelf = new List <Bottle>(); //TODO: replace with actual bottleshelf
_drinkdb = new List <Drink>();
_bs = new Bottleshelf(shelfsize, 10);
_queue = new OrderQueue();
_activity = new ActivityQueue(new Activity(ActivityType.Idle));
}
public void When_CallingPeek_Then_ReturnsNull()
{
var orderQueue = new OrderQueue();
Order expected = null;
var result = orderQueue.Peek();
Assert.Equal(expected, result);
}
public Stack <StackNode> Merge(string identName)
{
Stack <StackNode> MergeOrder = new Stack <StackNode>();
List <DictionaryNode> list = ResultTableRelations.dict[identName];
int dictionaryNodeReference = list[0].Value;
MergeOrder.Push(new StackNode(dictionaryNodeReference, -1));
VisitedNode.Add(dictionaryNodeReference);
VisitedName.Add(identName);
if (list[0].KeyInRelatedNode != "$")
{
OrderQueue.Enqueue(list[0]);
VisitedName.Add(list[0].KeyInRelatedNode);
}
for (int i = 1; i < list.Count; i++)
{
MergeOrder.Push(new StackNode(list[i].Value, dictionaryNodeReference));
VisitedNode.Add(list[i].Value);
VisitedName.Add(list[i].KeyInRelatedNode);
if (list[i].KeyInRelatedNode != "$")
{
OrderQueue.Enqueue(list[i]);
VisitedName.Add(list[i].KeyInRelatedNode);
}
}
while (OrderQueue.Count > 0)
{
DictionaryNode top = OrderQueue.Dequeue();
VisitedNode.Add(top.Value);
list = ResultTableRelations.dict[top.KeyInRelatedNode];
for (int i = 0; i < list.Count; i++)
{
if (!VisitedNode.Contains(list[i].Value))
{
MergeOrder.Push(new StackNode(list[i].Value, top.Value));
VisitedNode.Add(list[i].Value);
VisitedName.Add(list[i].KeyInRelatedNode);
if (list[i].KeyInRelatedNode != "$")
{
OrderQueue.Enqueue(list[i]);
}
}
}
}
return(MergeOrder);
}
public ActionResult Edit([Bind(Include = "OrderId,DrinkId,DrinkName")] OrderQueue orderQueue)
{
if (ModelState.IsValid)
{
db.Entry(orderQueue).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(orderQueue));
}
public void When_CallingPeek_Then_ReturnsOrder()
{
var orderQueue = new OrderQueue();
orderQueue.AddOrder(new Order("Pizza"));
var result = orderQueue.Peek();
Assert.IsType <Order>(result);
}
private static IEnumerable<DeliveryPerson> CreateDeliveryPeople(int numberOfDeliveryPeople, OrderQueue queue)
{
var deliveryPeople = new List<DeliveryPerson>();
for(int i = 0; i < numberOfDeliveryPeople; i++){
deliveryPeople.Add(new DeliveryPerson(queue));
}
return deliveryPeople;
}
public void Given_EmptyOrderQueue_When_CallingReadFromOrderQueue_CurrentOrderEqualsNull()
{
var orderQueue = new OrderQueue();
var chef = new Chef("Jan", "Kowalski");
Order expected = null;
chef.ReadFromOrderQueue(orderQueue);
Assert.Equal(expected, chef.GetCurrentOrder());
}
public ActionResult Create([Bind(Include = "OrderId,DrinkId,DrinkName")] OrderQueue orderQueue)
{
if (ModelState.IsValid)
{
db.Orders.Add(orderQueue);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(orderQueue));
}
public void QueueNewOrder(Order order, bool isHigh)
{
if (isHigh)
{
OrderQueue.EnqueueHighpriority(order.Id);
}
else
{
OrderQueue.Enque(order.Id);
}
}
public void When_CallingPeek_Then_RemovesOrderFromQueue()
{
var orderQueue = new OrderQueue();
var order = new Order("Pizza");
orderQueue.AddOrder(order);
orderQueue.Peek();
Assert.DoesNotContain(order, orderQueue.GetOrders());
}
public void Given_ValidOrderQueue_When_CallingReadFromOrderQueue_CurrentOrderEqualsExpected()
{
var orderQueue = new OrderQueue();
var expected = new Order("Pizza");
var chef = new Chef("Jan", "Kowalski");
orderQueue.AddOrder(expected);
chef.ReadFromOrderQueue(orderQueue);
Assert.Equal(expected, chef.GetCurrentOrder());
}
static void Main(string[] args)
{
try
{
// Wire up the payment queue to use mainContainer
var paymentQueue = new PaymentQueue(
Configure
.With(new CastleWindsorContainerAdapter(CreateContainer()))
.Transport(t => t.UseSqlServerAsOneWayClient("server=.;database=Scratch;trusted_connection=true"))
.Routing(r => r.TypeBased().Map <Payment>("PaymentQueue"))
.Start()
);
// Need another container for the orders queue
var orderQueue = new OrderQueue(
Configure
.With(new CastleWindsorContainerAdapter(CreateContainer()))
.Transport(t => t.UseRabbitMqAsOneWayClient("amqp://localhost"))
.Routing(r => r.TypeBased().Map <Order>("OrderQueue"))
.Start()
);
var mainContainer = CreateContainer();
mainContainer.Register(Component.For <PaymentQueue>().Instance(paymentQueue), Component.For <OrderQueue>().Instance(orderQueue));
var bus = Configure
.With(new CastleWindsorContainerAdapter(mainContainer))
.Logging(l => l.ColoredConsole())
.Transport(t => t.UseSqlServer("server=.;database=Scratch;trusted_connection=true", "PaymentQueue"))
.Options(o =>
{
o.SimpleRetryStrategy(errorQueueAddress: "PaymentQueue-error");
o.SetMaxParallelism(1);
o.SetNumberOfWorkers(1);
})
.Start();
while (true)
{
var input = Console.ReadLine();
if (input == "q")
{
bus.Dispose();
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
/// <summary>
/// Cancel the order specified
/// </summary>
/// <param name="order">Order we'd like to cancel.</param>
/// <returns>True if successful, false if its already been cancelled or filled.</returns>
public bool CancelOrder(Order order)
{
//Filled or already cancelled, can't recancel.
if (Orders[order.Id].Status == OrderStatus.Filled || Orders[order.Id].Status == OrderStatus.Canceled)
{
return(false);
}
//Flag the order as new, send it to the queue:
order.Status = OrderStatus.Canceled;
OrderQueue.Enqueue(order);
_ready = false;
return(true);
}
// GET: OrderQueues/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
OrderQueue orderQueue = db.Orders.Find(id);
if (orderQueue == null)
{
return(HttpNotFound());
}
return(View(orderQueue));
}
/// <summary>
/// Submit a new order to be processed.
/// </summary>
/// <param name="order">New order object</param>
/// <returns>New unique quantconnect order id</returns>
public int NewOrder(Order order)
{
//If this is a new order (with no id) set it:
if (order.Id == 0)
{
order.Id = _orderId++;
}
//Submit to queue
order.Status = OrderStatus.New;
OrderQueue.Enqueue(order);
_ready = false;
return(order.Id);
}
/********************************************************
* CLASS METHODS
*********************************************************/
/// <summary>
/// Add an Order and return the Order ID or negative if an error.
/// </summary>
public virtual int AddOrder(Order order)
{
try {
//Ensure its flagged as a new order for the transaction handler.
order.Id = _orderId++;
order.Status = OrderStatus.New;
//Add the order to the cache to monitor
OrderQueue.Enqueue(order);
} catch (Exception err) {
Log.Error("Algorithm.Transaction.AddOrder(): " + err.Message);
}
return(order.Id);
}
/// <summary>
/// Update and resubmit the order to the OrderQueue for processing.
/// </summary>
/// <param name="order">Order we'd like updated</param>
/// <returns>True if successful, false if already cancelled or filled.</returns>
public bool UpdateOrder(Order order)
{
//Failed.
if (Orders[order.Id].Status == OrderStatus.Filled || Orders[order.Id].Status == OrderStatus.Canceled)
{
return(false);
}
//Flag the order as new, send it to the queue:
order.Status = OrderStatus.Update;
OrderQueue.Enqueue(order);
_ready = false;
return(true);
}
private OrderQueue QueueFromID(long queueID)
{
OrderQueue foundQueue = null;
foreach (OrderQueue queue in _app.CurrentCampaign.OrderQueues)
{
if (queue.OrderQueueID == queueID)
{
foundQueue = queue;
break;
}
}
return(foundQueue);
}
public List <Order> ProcessOrders()
{
Console.WriteLine($"{Chef.Name} is processing the orders");
List <Order> completedOrders = new List <Order>();
while (OrderQueue.Any())
{
Order currentOrder = OrderQueue.Dequeue();
Chef.Cook(currentOrder);
completedOrders.Add(currentOrder);
}
return(completedOrders);
}
/// <summary>
/// 要求显示
/// </summary>
/// <param name="queueInfo"></param>
public void Show(OrderCacheItem queueInfo)
{
lock (_lockObject)
{
if (_queueDlg == null)
{
_queueDlg = new OrderQueue(Session, queueInfo);
_queueDlg.Closed += (s, e) =>
{
_queueDlg = null;
};
UiUtility.PlaceFormAtCenter(_queueDlg, AppContext.HostForm);
}
}
}
protected void Application_Start()
{
// Main container first
var mainContainer = CreateContainer();
// Hook the main container into the web api dependency resolver
var dependencyResolver = new WindsorDependencyResolver(mainContainer);
var configuration = GlobalConfiguration.Configuration;
configuration.DependencyResolver = dependencyResolver;
ControllerBuilder.Current.SetControllerFactory(new WindsorControllerFactory(mainContainer.Kernel));
// Wire up the payment queue to use mainContainer
var paymentQueue = new PaymentQueue(
Configure
.With(new CastleWindsorContainerAdapter(CreateContainer()))
.Transport(t => t.UseSqlServerAsOneWayClient("server=.;database=Scratch;trusted_connection=true"))
.Routing(r => r.TypeBased().Map <Payment>("PaymentQueue"))
.Start()
);
// Need another container for the orders queue
var orderQueue = new OrderQueue(
Configure
.With(new CastleWindsorContainerAdapter(CreateContainer()))
.Transport(t => t.UseRabbitMqAsOneWayClient("amqp://localhost"))
.Routing(r => r.TypeBased().Map <Order>("OrderQueue"))
.Start()
);
// Register our custom queues in every container... not sure this is going to work, should
foreach (var container in _containers)
{
container.Register(
Component.For <PaymentQueue>().Instance(paymentQueue),
Component.For <OrderQueue>().Instance(orderQueue)
);
}
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
}
public Order TakeNewOrder()
{
int id = OrderQueue.Dequeue();
if (id == -1)
{
return(null);
}
else
{
Order pick = new Order(new List <Item>(), new List <int>());
SocketServiceImpl socket = new SocketServiceImpl();
pick = socket.GetOrder(id);
pick.ChangeOrderState();
return(pick);
}
}
private static OrderQueue GenerateOrders(int numberOfOrders, IEnumerable<Product> products)
{
var rand = new Random();
int productCount = products.Count();
OrderQueue queue = new OrderQueue();
for (int i=0;i<numberOfOrders;i++){
var product = products.ElementAt(rand.Next(productCount));
queue.Enqueue(new Order(){
Product = product,
Quantity = rand.Next(10),
DeliveryAddress = new Address()
});
}
return queue;
}
public void InitClasses()
{
ser = new ServiceLayer.ServiceLayer();
rob = new RobotCellLayer.RobotCellLayer();
da = new DataAccess.DataAccess();
rob.AddRobot("SIM", "SIM");
logic = new LogicLayer.LogicLayer(ser, rob, da);
var shelf = new Bottleshelf(10, 0);
shelf.AddBottle(new Bottle("Vodka"));
shelf.AddBottle(new Bottle("Vesi"));
shelf.AddBottle(new Bottle("Mehu"));
var queue = new OrderQueue();
var kv = new Drink("Kossuvissy");
Assert.IsTrue(kv.AddPortion("Vodka", 4));
Assert.IsTrue(kv.AddPortion("Vesi", 10));
var mehu = new Drink("Mehu");
Assert.IsTrue(mehu.AddPortion("Mehu", 10));
queue.Add(new Tuple <Order, int>(new Order(OrderType.Drink, 1, 1, kv), 10));
queue.Add(new Tuple <Order, int>(new Order(OrderType.Drink, 2, 4, mehu), 10));
queue.Add(new Tuple <Order, int>(new Order(OrderType.Drink, 3, 3, kv), 10));
queue.Add(new Tuple <Order, int>(new Order(OrderType.Drink, 4, 1, kv), 10));
var startarg = new StartArguments();
startarg.BackupShelf = shelf;
startarg.Mode = RunMode.Simulation;
startarg.Beer = false;
startarg.Drinks = true;
startarg.Sparkling = false;
startarg.IdleActivity = new Activity(ActivityType.ProcessOrders);
startarg.BacckupQueue = queue;
var init = Task.Run(() => logic.Initialize(startarg, new CancellationToken()));
init.Wait();
Assert.IsTrue(init.Result);
}
/// <summary>
/// Update an order yet to be filled / stop / limit.
/// </summary>
/// <param name="order">Order to Update</param>
/// <param name="portfolio"></param>
/// <returns>id if the order we modified.</returns>
public int UpdateOrder(Order order, SecurityPortfolioManager portfolio)
{
try
{
//Update the order from the behaviour
int id = order.Id;
order.Time = Securities[order.Symbol].Time;
//Validate order:
if (order.Price == 0 || order.Quantity == 0)
{
return(-1);
}
if (_orders.ContainsKey(id))
{
//-> If its already filled return false; can't be updated
if (_orders[id].Status == OrderStatus.Filled || _orders[id].Status == OrderStatus.Canceled)
{
return(-5);
}
else
{
//Flag the order to be resubmitted.
order.Status = OrderStatus.Update;
_orders[id] = order;
//Send the order to transaction handler to be processed.
OrderQueue.Enqueue(order);
}
}
else
{
//-> Its not in the orders cache, shouldn't get here
return(-6);
}
}
catch (Exception err)
{
Log.Error("Algorithm.Transactions.UpdateOrder(): " + err.Message);
return(-7);
}
return(0);
}
/// <summary>
/// Initializes a new instance of the <see cref="NSimulate.Example3.DeliveryPerson"/> class.
/// </summary>
/// <param name='orderQueue'>
/// Order queue.
/// </param>
public DeliveryPerson(OrderQueue orderQueue)
{
_orderQueue = orderQueue;
}
