コード例 #1
0
        void _executor_OrderUpdatedEvent(IOrderSink providerSink, AccountInfo accountInfo, string[] previousOrdersIds,
                                         OrderInfo[] ordersInfos, Order.UpdateTypeEnum[] updatesType)
        {
            ISourceOrderExecution provider = _provider;

            if (providerSink != _provider)
            {
                SystemMonitor.Warning("Provider mismatch.");
                return;
            }

            List <Order> updatedOrders = new List <Order>();
            List <Order.UpdateTypeEnum> updatedOrdersUpdateTypes = new List <Order.UpdateTypeEnum>();

            for (int i = 0; i < ordersInfos.Length; i++)
            {
                if (string.IsNullOrEmpty(ordersInfos[i].Id))
                {
                    SystemMonitor.Warning("Order update of order with no ID.");
                    continue;
                }

                if (previousOrdersIds.Length > i && previousOrdersIds[i] != ordersInfos[i].Id &&
                    string.IsNullOrEmpty(previousOrdersIds[i]) == false)
                {// Order Id has changed, remove old order.
                    Order superceededOrder = GetOrderById(previousOrdersIds[i]);
                    RemoveOrder(superceededOrder);
                }

                Order order = GetOrderById(ordersInfos[i].Id);
                if (order == null)
                {// Create new order based on incoming information.
                    if (provider.SupportsActiveOrderManagement)
                    {
                        order = new ActiveOrder(_manager, provider, _delivery.SourceId, true);
                    }
                    else
                    {
                        order = new PassiveOrder(_manager, _delivery.SourceId, provider.SourceId);
                    }

                    order.AdoptInfo(ordersInfos[i]);

                    if (AddOrder(order) == false)
                    {
                        SystemMonitor.OperationError("Failed to add order to keeper (id [" + order.Id + "] already used for another order).", TracerItem.PriorityEnum.Medium);
                    }
                }
                else
                {// Existing order, to be updated.
                    OrderInfo info = ordersInfos[i];

                    // First, check for critical modifications (price changes).
                    if (order.Info.IsCriticalUpdate(info))
                    {
                        SystemMonitor.Report(string.Format("Order has received a critical data modication Id[{0}], Open[{1} / {2}], Close[{3} / {4}].", order.Id, order.OpenPrice.ToString(), info.OpenPrice.ToString(), order.ClosePrice.ToString(),
                                                           info.ClosePrice.ToString()), TracerItem.PriorityEnum.High);

                        if (OrdersCriticalInformationChangedEvent != null)
                        {
                            OrdersCriticalInformationChangedEvent(this, accountInfo, order, info);
                        }
                    }

                    if (order.UpdateInfo(info) == false)
                    {
                        SystemMonitor.OperationError("Failed to update order [" + order.Id + "].");
                        continue;
                    }

                    lock (this)
                    {
                        // Remove from any of the sub arrays it may be in.
                        foreach (OrderStateEnum state in Enum.GetValues(typeof(OrderStateEnum)))
                        {
                            if (_ordersByState.ContainsKey(state) && _ordersByState[state].Contains(order))
                            {
                                _ordersByState[state].Remove(order);
                            }
                        }

                        _ordersByState[info.State].Add(order);
                    }

                    updatedOrders.Add(order);
                    updatedOrdersUpdateTypes.Add(updatesType[i]);
                }
            }

            if (updatedOrders.Count > 0 && OrdersUpdatedEvent != null)
            {
                OrdersUpdatedEvent(this, accountInfo, updatedOrders.ToArray(), updatedOrdersUpdateTypes.ToArray());
            }
        }
コード例 #2
0
 void executor_OrderUpdatedEvent(IOrderSink executor, AccountInfo account, string[] previousOrdersIds, OrderInfo[] orderInfos, Order.UpdateTypeEnum[] updatesType)
 {
     //RaiseSeriesValuesUpdated(true);
 }
コード例 #3
0
 void management_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable <Order> order)
 {
     RaiseSeriesValuesUpdated(true);
 }
コード例 #4
0
 protected override void Orders_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
 {
     base.Orders_OrderUpdatedEvent(provider, account, orders, updatesType);
     DoUpdate();
 }
コード例 #5
0
 void management_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
 {
     //RaiseSeriesValuesUpdated(true);
 }
コード例 #6
0
 /// <summary>
 ///
 /// </summary>
 public new void AdoptInfo(AccountInfo info)
 {
     base.AdoptInfo(info);
 }
コード例 #7
0
 protected override void Orders_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable <Order> order)
 {
     base.Orders_OrdersRemovedEvent(provider, account, order);
     DoUpdate();
 }
コード例 #8
0
 /// <summary>
 /// Constructor.
 /// </summary>
 public Account(AccountInfo info)
 {
     _accountInfo = info;
 }
コード例 #9
0
 /// <summary>
 /// Constructor.
 /// </summary>
 public BackTestAccount(AccountInfo info)
     : base(info)
 {
 }
コード例 #10
0
 protected virtual void Orders_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
 {
 }
コード例 #11
0
 protected virtual void Orders_OrdersAddedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable <Order> order)
 {
 }
コード例 #12
0
        /// <summary>
        ///
        /// </summary>
        public bool CloseOrder(AccountInfo account, Order order, decimal?allowedSlippage,
                               decimal?desiredPrice, out decimal closingPrice, out DateTime closingTime,
                               out string modifiedId, out string operationResultMessage)
        {
            closingPrice = decimal.MinValue;
            closingTime  = DateTime.MinValue;
            modifiedId   = order.Id;

            if (_orders.ContainsValue(order) == false)
            {
                operationResultMessage = "Order [" + order.Id + "] not registered in provider.";
                SystemMonitor.OperationError(operationResultMessage);
                return(false);
            }

            if (_lastDataBar.HasValue == false || _lastDataQuote.HasValue == false)
            {
                operationResultMessage = "Data bar/quote information not available.";
                SystemMonitor.OperationError(operationResultMessage);
                return(false);
            }

            decimal?currentPrice = _lastDataQuote.Value.Bid;

            if (order.IsBuy == false)
            {// Sell order.
                currentPrice = _lastDataQuote.Value.Ask;
            }

            if (desiredPrice.HasValue == false)
            {
                desiredPrice = currentPrice;
            }

            if (UpdatePosition(order.Symbol, -order.Info.DirectionalVolume, out operationResultMessage) == false)
            {
                return(false);
            }

            //if (dataProvider.DataBars.Current.HasValue && currentPrice.HasValue)
            {//Check if we have reached the stoploss or takeprofit in last bar
                //Default case.
                closingPrice = currentPrice.Value;

                if (order.StopLoss.HasValue && CheckStopLossInsideBar(order))
                {// StopLoss has been triggered inside bar.
                    closingPrice = order.StopLoss.Value;
                }

                if (order.TakeProfit.HasValue && CheckTakeProfitInsideBar(order))
                {// TakeProfit has been triggered inside bar.
                    closingPrice = order.TakeProfit.Value;
                }

                //Check if both : StopLoss and TakeProfit has been triggered inside bar
                if (CheckForConflictsInsideBar(order))
                {//We have a collision here, If SL > lastbar.Low and TP < lastbar.High we do not know what have been triggered first : the SL or the TP
                    //To solve the situation, 4 posiblities are offered for now : best case, worst case, probabilistic case, exact case
                    switch (_resultsApproximationMode)
                    {
                    case ResultsAproximationModeEnum.PesimisticResult:
                        if (order.StopLoss.HasValue)
                        {
                            closingPrice = order.StopLoss.Value;
                        }
                        break;

                    case ResultsAproximationModeEnum.OptimisticResult:
                        if (order.TakeProfit.HasValue)
                        {
                            closingPrice = order.TakeProfit.Value;
                        }
                        break;

                    case ResultsAproximationModeEnum.MostProbableResult:
                        //Probabilistic aproximation : If open is nearest stoploss than takeprofit, stoploss win otherwise takeprofit win
                        if (order.TakeProfit.HasValue && order.StopLoss.HasValue)
                        {
                            decimal diffToStopLoss   = Math.Abs(order.StopLoss.Value - _lastDataBar.Value.Open);
                            decimal diffToTakeProfit = Math.Abs(_lastDataBar.Value.Open - order.TakeProfit.Value);
                            if (diffToStopLoss > diffToTakeProfit)
                            {    //Most probable that takeprofit was triggered
                                closingPrice = order.TakeProfit.Value;
                            }
                            else
                            {    //Most probable that stoploss was triggered
                                closingPrice = order.StopLoss.Value;
                            }
                        }
                        break;
                        //case ResultsAproximationModeEnum.ExactResult:
                        //    // Not implemented yet
                        //    // To implement this part, we need tick by tick dataDelivery to know exactly what has happened inside bar
                        //    closingPrice = currentPrice;
                        //    break;
                    }
                }
            }
            //else if (currentPrice.HasValue)
            //{
            //    closingPrice = currentPrice.Value;
            //}
            //else
            //{
            //    operationResultMessage = "Current price has no value.";
            //    return false;
            //}

            if (desiredPrice.HasValue && allowedSlippage.HasValue &&
                allowedSlippage > 0 && Math.Abs(currentPrice.Value - desiredPrice.Value) > allowedSlippage)
            {
                operationResultMessage = "Slippage criteria not met.";
                return(false);
            }

            closingTime            = _lastDataQuote.Value.Time.Value;
            operationResultMessage = string.Empty;

            RaiseOrderUpdateEvent(order.Info, Order.UpdateTypeEnum.Closed);

            return(true);
        }
コード例 #13
0
        public bool IncreaseOrderVolume(AccountInfo account, Order order, decimal volumeIncrease,
                                        decimal?allowedSlippage, decimal?desiredPrice, out decimal increasalPrice, out string modifiedId,
                                        out string operationResultMessage)
        {
            increasalPrice = 0;

            if (order.State != OrderStateEnum.Submitted)
            {
                modifiedId             = string.Empty;
                operationResultMessage = "Only submitted orders can be modified in volume.";
                return(false);
            }

            SystemMonitor.NotImplementedWarning();

            modifiedId             = order.Info.Id;
            operationResultMessage = string.Empty;
            return(true);

            #region Old Active Orders Implementation

            //            increasalPrice = 0;

            //            modifiedId = order.Id;

            //            lock (this)
            //            {
            //                if (_provider.Account.TradeEntities.GetOrderById(order.Id) == null)
            //                {
            //                    operationResultMessage = "Order [" + order.Guid + "] not registered in provider.";
            //                    SystemMonitor.OperationError(operationResultMessage);
            //                    return false;
            //                }
            //            }

            //            increasalPrice = decimal.MinValue;

            //            ISessionDataProvider dataProvider = SessionDataProvider;
            //            if (dataProvider == null || dataProvider.Quotes == null
            //                 || dataProvider.DataBars == null)
            //            {
            //                operationResultMessage = "Data provider not assigned.";
            //                SystemMonitor.OperationError(operationResultMessage);
            //                return false;
            //            }

            //            if (desiredPrice.HasValue == false)
            //            {
            //                desiredPrice = dataProvider.Quotes.Ask;
            //            }

            //            if (volumeIncrease == 0)
            //            {
            //                increasalPrice = desiredPrice.Value;
            //                operationResultMessage = "No change.";
            //                return true;
            //            }

            //            decimal? currentPrice = dataProvider.Quotes.Bid;
            //            if (order.IsBuy == false)
            //            {// Sell order.
            //                currentPrice = dataProvider.Quotes.Ask;
            //            }

            //            if (desiredPrice.HasValue && allowedSlippage.HasValue
            //                && allowedSlippage > 0 && (currentPrice.HasValue && Math.Abs(currentPrice.Value - desiredPrice.Value) > allowedSlippage))
            //            {// Fail.
            //                operationResultMessage = "Slippage criteria not met.";
            //                return false;
            //            }

            //            if (currentPrice.HasValue == false)
            //            {
            //                operationResultMessage = "Current price not assigned.";
            //                return false;
            //            }

            //            operationResultMessage = string.Empty;
            //            increasalPrice = currentPrice.Value;

            //            RaiseOrderUpdateEvent(order.Info, Order.UpdateTypeEnum.VolumeChanged);
            //            return true;

            #endregion
        }
コード例 #14
0
        public bool DecreaseOrderVolume(AccountInfo account, Order order, decimal volumeDecreasal,
                                        decimal?allowedSlippage, decimal?desiredPrice, out decimal decreasalPrice,
                                        out string modifiedId, out string operationResultMessage)
        {
            decreasalPrice = 0;

            if (order.State != OrderStateEnum.Submitted)
            {
                modifiedId             = string.Empty;
                operationResultMessage = "Only submitted orders can be modified in volume.";
                return(false);
            }

            SystemMonitor.NotImplementedWarning();

            modifiedId             = order.Info.Id;
            operationResultMessage = string.Empty;
            return(true);

            #region Old Active Orders Implementation
            //            modifiedId = order.Id;
            //            decreasalPrice = 0;
            //            if (_provider.Account.TradeEntities.ContainsOrder(order) == false)
            //            {
            //                operationResultMessage = "Order [" + order.Guid + "] not registered in provider.";
            //                SystemMonitor.OperationError(operationResultMessage);
            //                return false;
            //            }

            //            decreasalPrice = decimal.MinValue;

            //            ISessionDataProvider dataProvider = SessionDataProvider;
            //            if (dataProvider == null || dataProvider.Quotes == null)
            //            {
            //                operationResultMessage = "Data provider not assigned or initialized properly.";
            //                SystemMonitor.OperationError(operationResultMessage);
            //                return false;
            //            }

            //            decimal? currentPrice = dataProvider.Quotes.Bid;
            //            if (order.IsSell)
            //            {// Sell order.
            //                currentPrice = dataProvider.Quotes.Ask;
            //            }

            //            if (desiredPrice.HasValue && allowedSlippage.HasValue
            //                && allowedSlippage > 0 &&
            //                (currentPrice.HasValue && Math.Abs(currentPrice.Value - desiredPrice.Value) > allowedSlippage))
            //            {//
            //                operationResultMessage = "Slippage criteria not met.";
            //                return false;
            //            }

            //            if (volumeDecreasal == order.CurrentVolume)
            //            {// Closing order.
            //                DateTime closingDateTime;
            //                CloseOrder(_provider.Account.Info, order, allowedSlippage, desiredPrice, out decreasalPrice, out closingDateTime, out modifiedId, out operationResultMessage);
            //                return true;
            //            }

            //            if (currentPrice.HasValue == false)
            //            {//
            //                operationResultMessage = "Can not decrease order since dataDelivery provider has no Ask/Bid values.";
            //                return false;
            //            }

            //            operationResultMessage = string.Empty;
            //            // TODO: implement a proper decreasal model here, just like the cloing one.
            //            // This is a rough estimation.
            //            decreasalPrice = currentPrice.Value;

            //            RaiseOrderUpdateEvent(order.Info, Order.UpdateTypeEnum.VolumeChanged);

            //            return true;

            #endregion
        }
コード例 #15
0
        /// <summary>
        ///
        /// </summary>
        public bool SynchronousExecute(AccountInfo account, Order order, Symbol symbol,
                                       OrderTypeEnum orderType, int volume, decimal?allowedSlippage, decimal?desiredPrice,
                                       decimal?takeProfit, decimal?stopLoss, string comment, TimeSpan operationTimeOut, out OrderInfo?info, out string operationResultMessage)
        {
            info = null;

            OrderInfo updatedInfo = order.Info;

            updatedInfo.OpenPrice = null;
            updatedInfo.OpenTime  = null;
            updatedInfo.State     = OrderStateEnum.Unknown;

            IQuoteProvider          quotes;
            IDataBarHistoryProvider bars;

            if (GetProviders(symbol, out quotes, out bars) == false)
            {
                operationResultMessage = "Failed to establish corresponding providers.";
                return(false);
            }

            if (quotes.OperationalState != OperationalStateEnum.Operational ||
                quotes.Ask.HasValue == false || quotes.Bid.HasValue == false || quotes.Time.HasValue == false)
            {
                operationResultMessage = "Data provider not operational or not providing valid dataDelivery.";
                return(false);
            }

            decimal?currentPrice = quotes.GetOrderOpenQuote(orderType);

            if (desiredPrice.HasValue && allowedSlippage.HasValue && currentPrice.HasValue &&
                allowedSlippage > 0 && Math.Abs(currentPrice.Value - desiredPrice.Value) > allowedSlippage)
            {// Slippage requirements failed.
                operationResultMessage = "Slippage criteria not met.";
                return(false);
            }

            operationResultMessage = string.Empty;

            updatedInfo.OpenTime = quotes.Time.Value;

            if (orderType == OrderTypeEnum.BUY_MARKET ||
                orderType == OrderTypeEnum.SELL_MARKET)
            {// Immediate order.
                updatedInfo.State     = OrderStateEnum.Executed;
                updatedInfo.OpenPrice = currentPrice;
            }
            else
            {// Delayed pending order.
                //updatedInfo.State = OrderStateEnum.Submitted;
                //updatedInfo.OpenPrice = desiredPrice;
                operationResultMessage = "Order type not currently supported in back testing mode.";
                return(false);
            }

            updatedInfo.StopLoss   = stopLoss;
            updatedInfo.TakeProfit = takeProfit;
            updatedInfo.Comment    = comment;
            updatedInfo.Type       = orderType;
            updatedInfo.Symbol     = symbol;
            updatedInfo.Volume     = volume;

            updatedInfo.Id = (_pendingOrderId++).ToString();

            if (UpdatePosition(symbol, OrderInfo.TypeIsBuy(updatedInfo.Type) ? volume : -volume, out operationResultMessage) == false)
            {
                return(false);
            }

            info = updatedInfo;

            lock (this)
            {
                _orders.Add(updatedInfo.Id, order);
            }

            BeginAccountInfoUpdate(_account.Info);

            BeginManagedOrdersUpdate(_lastDataQuote);

            //RaiseOrderUpdateEvent(updatedInfo, Order.UpdateTypeEnum.Executed);

            return(true);
        }
コード例 #16
0
 public bool GetAvailableAccountInfos(out AccountInfo[] accounts)
 {
     accounts = new AccountInfo[] { _account.Info };
     return(true);
 }