private bool OnAucFill(Order order)
 {
     if (order.Type == OrderType.Limit)
     {
         int instrumentId = order.Instrument.Id;
         if (FillOnQuote)
         {
             Ask ask = framework.DataManager.GetAsk(instrumentId);
             if (ask != null && OnAsk(order, ask))
             {
                 return(true);
             }
             Bid bid = framework.DataManager.GetBid(instrumentId);
             if (bid != null && OnBid(order, bid))
             {
                 return(true);
             }
         }
         if (FillOnTrade)
         {
             Trade trade = framework.DataManager.GetTrade(instrumentId);
             if (trade != null && OnTrade(order, trade))
             {
                 return(true);
             }
         }
         if (FillOnBar)
         {
             Bar bar = framework.DataManager.GetBar(instrumentId);
             if (BarFilter.Count != 0 && !BarFilter.Contains(bar.Type, bar.Size))
             {
                 return(false);
             }
             if (bar != null && OnBar(order, bar))
             {
                 return(true);
             }
         }
         if (FillOnLevel2)
         {
             Level2Snapshot snapshot = framework.DataManager.GetAggregatedSnapshot(instrumentId);
             if (snapshot != null)
             {
                 return(OnLevel2(order, snapshot));
             }
         }
     }
     return(false);
 }
        public void OnBarOpen(Bar bar)
        {
            if (_orders[bar.InstrumentId] == null || !FillOnBarOpen || (BarFilter.Count != 0 && !BarFilter.Contains(bar.Type, bar.Size)))
            {
                return;
            }
            for (int i = 0; i < _orders[bar.InstrumentId].Count; i++)
            {
                Order order = _orders[bar.InstrumentId][i];
                if (CheckDataProvider && !IsProviderPassed(order, bar.ProviderId))
                {
                    continue;
                }
                while (true)
                {
                    switch (order.Type)
                    {
                    case OrderType.Market:
                    case OrderType.Pegged:
                        Fill(order, bar.Open, (int)bar.Volume);
                        break;

                    case OrderType.Limit:
                        switch (order.Side)
                        {
                        case OrderSide.Buy:
                            if (bar.Open <= order.Price)
                            {
                                if (UseProbability && bar.Open == order.Price && _random.NextDouble() < Probability)
                                {
                                    return;
                                }
                                if (FillAtLimitPrice)
                                {
                                    Fill(order, order.Price, (int)bar.Volume);
                                }
                                else
                                {
                                    Fill(order, bar.Open, (int)bar.Volume);
                                }
                            }
                            break;

                        case OrderSide.Sell:
                            if (bar.Open >= order.Price)
                            {
                                if (UseProbability && bar.Open == order.Price && _random.NextDouble() < Probability)
                                {
                                    return;
                                }
                                if (FillAtLimitPrice)
                                {
                                    Fill(order, order.Price, (int)bar.Volume);
                                }
                                else
                                {
                                    Fill(order, bar.Open, (int)bar.Volume);
                                }
                            }
                            break;
                        }
                        break;

                    case OrderType.Stop:
                        switch (order.Side)
                        {
                        case OrderSide.Buy:
                            if (bar.Open >= order.StopPx)
                            {
                                if (!FillAtStopPrice)
                                {
                                    order.SetOrderType(OrderType.Market);
                                    continue;
                                }
                                Fill(order, order.StopPx, (int)bar.Volume);
                            }
                            break;

                        case OrderSide.Sell:
                            if (bar.Open <= order.StopPx)
                            {
                                if (!FillAtStopPrice)
                                {
                                    order.SetOrderType(OrderType.Market);
                                    continue;
                                }
                                Fill(order, order.StopPx, (int)bar.Volume);
                            }
                            break;
                        }
                        break;

                    case OrderType.StopLimit:
                        switch (order.Side)
                        {
                        case OrderSide.Buy:
                            if (bar.Open >= order.StopPx)
                            {
                                order.SetOrderType(OrderType.Limit);
                                continue;
                            }
                            break;

                        case OrderSide.Sell:
                            if (bar.Open <= order.StopPx)
                            {
                                order.SetOrderType(OrderType.Limit);
                                continue;
                            }
                            break;
                        }
                        break;
                    }
                    break;
                }
            }
            RemoveDoneOrders();
        }
 public void OnBar(Bar bar)
 {
     if (_orders[bar.InstrumentId] != null && FillOnBar && (BarFilter.Count == 0 || BarFilter.Contains(bar.Type, bar.Size)))
     {
         for (int i = 0; i < _orders[bar.InstrumentId].Count; i++)
         {
             Order order = _orders[bar.InstrumentId][i];
             OnBar(order, bar);
         }
         RemoveDoneOrders();
     }
 }