/// <summary> /// Open orders in position management /// </summary> public bool CancelPending(string openOrderId, out string operationResultMessage) { ISourceOrderExecution provider = _orderProvider; if (provider == null || provider.DefaultAccount == null) { operationResultMessage = "Position not initialized."; return(false); } Order order = provider.TradeEntities.GetOrderById(openOrderId); if (order.State != OrderStateEnum.Submitted) { operationResultMessage = "Order state not 'submitted', so not able to cancel as a pending order"; return(false); } ActiveOrder activeOrder = order as ActiveOrder; if (null != activeOrder) { return(activeOrder.Cancel(out operationResultMessage)); } PassiveOrder passiveOrder = order as PassiveOrder; if (null != passiveOrder) { return(passiveOrder.CloseOrCancel(null, null, out operationResultMessage)); } operationResultMessage = "Not able to cancel order"; return(false); }
/// <summary> /// Places and tries to execute a market order synchronously. Since it might be a modification of an /// existing active order, no specific order Id is returned - instead a bool indicating operation result. /// </summary> /// <param name="manipulateExistingOrders">[where applicable] Is the operation allowed to close a matching existing order, or should we always open a new one. This is suitable for Active orders brokers, that dissallow hedged orders at the same time.</param> public string ExecuteMarket(OrderTypeEnum orderType, int volume, decimal?price, decimal?slippage, decimal?takeProfit, decimal?stopLoss, TimeSpan timeOut, out PositionExecutionInfo executionInfo, out string operationResultMessage) { //TracerHelper.TraceEntry(); operationResultMessage = string.Empty; executionInfo = PositionExecutionInfo.Empty; ISourceOrderExecution provider = _provider; if (provider == null || provider.DefaultAccount == null) { operationResultMessage = "Position not properly initialized."; return(string.Empty); } _isProcessing = true; string result = OnExecuteMarket(provider, orderType, volume, price, slippage, takeProfit, stopLoss, timeOut, out executionInfo, out operationResultMessage); SystemMonitor.CheckError(result == executionInfo.ExecutionId, operationResultMessage); _isProcessing = false; return(result); }
public bool RemoveProvider(ISourceOrderExecution provider) { bool result = _providers.Remove(provider); UpdateUI(); return(result); }
/// <summary> /// This may contain a few operations on active orders, in order to match the rule "no opposing active orders" /// </summary> public virtual string ExecuteMarketBalanced(int volumeModification, decimal?desiredPrice, decimal?slippage, TimeSpan timeOut, out PositionExecutionInfo executionInfo, out string operationResultMessage) { executionInfo = PositionExecutionInfo.Empty; ISourceOrderExecution provider = _orderProvider; if (provider == null || provider.DefaultAccount == null) { operationResultMessage = "Position not properly initialized."; return(string.Empty); } // Trace pre-execution info. string traceMessage = string.Format("Submit Volume Modification [{0}] Price [{1}] Slippage [{2}] TimeOut [{3}]", volumeModification.ToString(), GeneralHelper.ToString(desiredPrice), GeneralHelper.ToString(slippage), timeOut.ToString()); traceMessage += GenerateConditionsInfo(); TracerHelper.Trace(_tracer, traceMessage, TracerItem.PriorityEnum.High); if (OnExecuteMarketBalanced(provider, volumeModification, desiredPrice, slippage, timeOut, out executionInfo, out operationResultMessage)) { return(Guid.NewGuid().ToString()); } return(string.Empty); }
/// <summary> /// /// </summary> protected override void OnRecalculateParameters(ISourceOrderExecution provider, bool fullRecalculation) { SystemMonitor.CheckError(provider.SupportsActiveOrderManagement, "Wrong position type for this provider."); Order[] orders = provider.TradeEntities.GetOrdersBySymbol(Symbol); lock (this) { _info.Volume = 0; _info.PendingBuyVolume = 0; _info.PendingSellVolume = 0; _info.Result = 0; foreach (ActiveOrder order in GeneralHelper.SafeChildTypeIteration <Order, ActiveOrder>(orders)) { if (order.State == OrderStateEnum.Executed) { _info.Volume += order.CurrentDirectionalVolume; _info.Result += order.GetResult(Order.ResultModeEnum.Currency); } else if (order.State == OrderStateEnum.Submitted) { if (order.IsBuy) { _info.PendingBuyVolume += order.CurrentVolume; } else { _info.PendingSellVolume += order.CurrentVolume; } } } } }
public virtual void Dispose() { //if (_tradeEntities != null) //{ // _tradeEntities.UnInitialize(); // _tradeEntities = null; //} if (_statistics != null) { _statistics.Dispose(); _statistics = null; } _dataDelivery = null; _manager = null; if (_provider != null) { _provider.AccountInfoUpdateEvent -= new AccountInfoUpdateDelegate(_provider_AccountInfoUpdateEvent); _provider.OperationalStateChangedEvent -= new OperationalStateChangedDelegate(_provider_OperationalStatusChangedEvent); _provider = null; } }
/// <summary> /// Will create the corresponding order, based to the passed in order information. /// Used to create corresponding orders to ones already existing in the platform. /// </summary> public override bool AdoptInfo(OrderInfo info) { base.AdoptInfo(info); ISourceOrderExecution executionProvider = _executionProvider; if (executionProvider == null || SessionInfo.HasValue == false) { return(false); } decimal lotSize = SessionInfo.Value.LotSize; lock (this) { //if (orderInfo.CurrentProfit.HasValue) //{ // _currentRawResult = orderInfo.CurrentProfit.Value / lotSize; //} //else //{ // _currentRawResult = 0; //} if (info.CurrentProfit.HasValue) { _orderMaximumResultAchieved = info.CurrentProfit.Value / lotSize; } _localOpenTime = null; } return(true); }
/// <summary> /// /// </summary> ActiveOrder ObtainManipulationOrder(ISourceOrderExecution provider, OrderTypeEnum orderType, int minVolume, out bool suitableOrdersAvailable) { suitableOrdersAvailable = false; lock (provider.TradeEntities) { foreach (ActiveOrder activeOrder in provider.TradeEntities.GetOrdersByStateUnsafe(OrderStateEnum.Executed)) { if (activeOrder.Symbol == Symbol && minVolume <= activeOrder.CurrentVolume && (activeOrder.Type == orderType)) {// Found a opposing order, close it. suitableOrdersAvailable = true; lock (_activeSelectedOrders) { if (_activeSelectedOrders.Contains(activeOrder) == false) {// Only if this order is not currently processed, take it for processing. _activeSelectedOrders.Add(activeOrder); return(activeOrder); } } } } } return(null); }
/// <summary> /// /// </summary> public virtual void Dispose() { _manager = null; _executionProvider = null; _quoteProvider = null; _dataSourceId = ComponentId.Empty; }
public void ClosePosition() { Position position = this.Position; if (position != null) { ISourceOrderExecution provider = this.Position.OrderExecutionProvider; if (provider != null) { for (int i = this.WorkingOrderIds.Count - 1; i >= 0; i--) { string orderId = this.WorkingOrderIds[i]; if (!string.IsNullOrEmpty(orderId)) { Order order = provider.TradeEntities.GetOrderById(orderId); if (order != null) { order.Close(); } } } this.WorkingOrderIds.Clear(); } } }
/// <summary> /// /// </summary> protected override string OnExecuteMarket(ISourceOrderExecution provider, OrderTypeEnum orderType, int volume, decimal? price, decimal? slippage, decimal? takeProfit, decimal? stopLoss, TimeSpan timeOut, out PositionExecutionInfo executionInfo, out string operationResultMessage) { SystemMonitor.CheckError(provider.SupportsActiveOrderManagement, "Wrong position type for this provider."); executionInfo = PositionExecutionInfo.Empty; IQuoteProvider quoteProvider = _manager.ObtainQuoteProvider(_dataDelivery.SourceId, Symbol); if (quoteProvider == null) { operationResultMessage = "Failed to establish quote provider for [" + _dataDelivery.SourceId.Name + ", " + Symbol.Name + "]."; SystemMonitor.Error(operationResultMessage); return string.Empty; } price = ProcessPrice(quoteProvider, orderType, price); // New order shall be created. ActiveOrder order = new ActiveOrder(_manager, provider, quoteProvider, _dataDelivery.SourceId, Symbol, true); OrderInfo? infoReference; // Using the extended operationTimeOut to 40 seconds. bool result = provider.SynchronousExecute(provider.DefaultAccount.Info, order, _info.Symbol, orderType, volume, slippage, price, takeProfit, stopLoss, string.Empty, TimeSpan.FromSeconds(40), out infoReference, out operationResultMessage); if (result && infoReference.HasValue) { OrderInfo infoAssign = infoReference.Value; if (infoAssign.Type == OrderTypeEnum.UNKNOWN) { infoAssign.Type = orderType; } if (infoAssign.Volume == int.MinValue || infoAssign.Volume == int.MaxValue) {// Volume was not retrieved by integration. infoAssign.Volume = volume; } if (infoAssign.OpenPrice.HasValue) { executionInfo = new PositionExecutionInfo(infoReference.Value.Id, _dataDelivery.SourceId, provider.SourceId, Symbol, infoAssign.Type, infoAssign.OpenPrice.Value, volume, volume, infoAssign.OpenTime, PositionExecutionInfo.ExecutionResultEnum.Success); } else { SystemMonitor.Error("Received execution result, but price not assigned."); } order.AdoptInfo(infoAssign); provider.TradeEntities.AddOrder(order); return infoReference.Value.Id; } return string.Empty; }
/// <summary> /// /// </summary> void RecalculateParameters(bool fullRecalculation) { if (fullRecalculation) { ISourceOrderExecution provider = _orderProvider; if (provider == null || Symbol.IsEmpty) { Symbol symbol = Symbol; _info = PositionInfo.Empty; _info.Symbol = symbol; return; } OnRecalculateParameters(provider, fullRecalculation); } lock (this) { if (_price.HasValue) { _info.MarketValue = _price * Volume; } } if (UpdateEvent != null) { UpdateEvent(this); } }
/// <summary> /// /// </summary> protected override string OnSubmit(ISourceOrderExecution provider, OrderTypeEnum orderType, int volume, decimal?price, decimal?slippage, decimal?takeProfit, decimal?stopLoss, out string operationResultMessage) { SystemMonitor.CheckError(provider.SupportsActiveOrderManagement, "Wrong position type for this provider."); IQuoteProvider quotes = _manager.ObtainQuoteProvider(_dataDelivery.SourceId, Symbol); ActiveOrder order = new ActiveOrder(_manager, provider, quotes, _dataDelivery.SourceId, Symbol, true); price = ProcessPrice(quotes, orderType, price); string id = provider.SubmitOrder(provider.DefaultAccount.Info, order, _info.Symbol, orderType, volume, slippage, price, takeProfit, stopLoss, string.Empty, out operationResultMessage); if (string.IsNullOrEmpty(id)) { return(string.Empty); } OrderInfo info = new OrderInfo(id, Symbol, orderType, OrderStateEnum.Submitted, volume, price, null, null, null, null, null, null, null, null, null, null, string.Empty, null); order.AdoptInfo(info); provider.TradeEntities.AddOrder(order); return(id); }
/// <summary> /// Places and tries to execute a market order synchronously. Since it might be a modification of an /// existing active order, no specific order Id is returned - instead a bool indicating operation result. /// </summary> /// <param name="manipulateExistingOrders">[where applicable] Is the operation allowed to close a matching existing order, or should we always open a new one. This is suitable for Active orders brokers, that dissallow hedged orders at the same time.</param> public string ExecuteMarket(OrderTypeEnum orderType, int volume, decimal?price, decimal?slippage, decimal?takeProfit, decimal?stopLoss, TimeSpan timeOut, out PositionExecutionInfo executionInfo, out string operationResultMessage) { operationResultMessage = string.Empty; executionInfo = PositionExecutionInfo.Empty; ISourceOrderExecution provider = _orderProvider; if (provider == null || provider.DefaultAccount == null) { operationResultMessage = "Position not properly initialized."; return(string.Empty); } // Trace pre-execution info. string traceMessage = string.Format("Submit Type[{0}] Volume [{1}] Price [{2}] Slippage [{3}] TP [{4}] SL [{5}] TimeOut [{6}]", orderType.ToString(), volume.ToString(), GeneralHelper.ToString(price), GeneralHelper.ToString(slippage), GeneralHelper.ToString(takeProfit), GeneralHelper.ToString(stopLoss), timeOut.ToString()); traceMessage += GenerateConditionsInfo(); TracerHelper.Trace(_tracer, traceMessage, TracerItem.PriorityEnum.High); _isProcessing = true; string result = OnExecuteMarket(provider, orderType, volume, price, slippage, takeProfit, stopLoss, timeOut, out executionInfo, out operationResultMessage); SystemMonitor.CheckError(result == executionInfo.ExecutionId, operationResultMessage); _isProcessing = false; return(result); }
/// <summary> /// Full submit of orders with a full set of parameters. /// </summary> /// <returns>The Id of the placement operation, allowing to trace its further execution or Empty if placement fails.</returns> public string Submit(OrderTypeEnum orderType, int volume, decimal?price, decimal?slippage, decimal?takeProfit, decimal?stopLoss, out string operationResultMessage) { ISourceOrderExecution provider = OrderExecutionProvider; if (provider == null || provider.DefaultAccount == null) { operationResultMessage = "Position not properly initialized."; return(string.Empty); } if (price.HasValue == false) { price = _price; } // Trace pre-execution info. string traceMessage = string.Format("Submit Type[{0}] Volume [{1}] Price [{2}] Slippage [{3}] TP [{4}] SL [{5}]", orderType.ToString(), volume.ToString(), GeneralHelper.ToString(price), GeneralHelper.ToString(slippage), GeneralHelper.ToString(takeProfit), GeneralHelper.ToString(stopLoss)); traceMessage += GenerateConditionsInfo(); TracerHelper.Trace(_tracer, traceMessage, TracerItem.PriorityEnum.High); return(OnSubmit(provider, orderType, volume, price, slippage, takeProfit, stopLoss, out operationResultMessage)); }
/// <summary> /// Change order execution related parameters. /// </summary> /// <param name="remoteStopLoss">Applicable to open or pending orders only, pass null to skip, decimal.MinValue (or zero) to signify no value.</param> /// <param name="remoteTakeProfit">Applicable to open or pending orders only, pass null to skip, decimal.MinValue (or zero) to signify no value.</param> /// <param name="operationResultMessage">Applicable ONLY to pending order. Pass null otherwise or to leave unchanged.</param> /// <returns></returns> public bool ModifyRemoteParameters(decimal?remoteStopLoss, decimal?remoteTakeProfit, decimal?remoteTargetOpenPrice, out string operationResultMessage) { if (this.IsOpenOrPending == false) { operationResultMessage = "Wrong order state."; return(false); } if (State != OrderStateEnum.Submitted && remoteTargetOpenPrice.HasValue) { operationResultMessage = "Wrong order state for this operation (operation only applicable to pending orders)."; return(false); } if (remoteStopLoss == StopLoss && TakeProfit == remoteTakeProfit) { // remoteTargetOpenPrice only counts if you do it on a pending order. if ((State == OrderStateEnum.Submitted && remoteTargetOpenPrice == OpenPrice) || (State != OrderStateEnum.Submitted)) {// No changes needed. operationResultMessage = "No changes needed."; return(true); } } operationResultMessage = "Session not assigned."; ISourceOrderExecution executionProvider = _executionProvider; string modifiedId; if (executionProvider == null || OrderExecutionProvider.ModifyOrder(Account.Info, this, remoteStopLoss, remoteTakeProfit, remoteTargetOpenPrice, out modifiedId, out operationResultMessage) == false) { return(false); } //lock (this) //{ // //_info.Id = modifiedId; // if (remoteStopLoss.HasValue) // { // _info.StopLoss = remoteStopLoss; // } // if (remoteTakeProfit.HasValue) // { // _info.TakeProfit = remoteTakeProfit; // } // if (remoteTargetOpenPrice.HasValue) // { // _info.OpenPrice = remoteTargetOpenPrice.Value; // } //} //RaiseOrderUpdatedEvent(UpdateTypeEnum.Modified); return(true); }
/// <summary> /// /// </summary> public PassiveOrder(ISourceManager manager, ComponentId dataSourceId, ComponentId orderExecutionSourceId) { SystemMonitor.CheckError(dataSourceId.IsEmpty == false && orderExecutionSourceId.IsEmpty == false, "Source Id not available to order."); _manager = manager; _dataSourceId = dataSourceId; _orderExectionSourceId = orderExecutionSourceId; _executionProvider = manager.ObtainOrderExecutionProvider(orderExecutionSourceId, dataSourceId); }
/// <summary> /// /// </summary> public PassiveOrder(ISourceManager manager, ComponentId dataSourceId, ComponentId orderExecutionSourceId) { SystemMonitor.CheckError(dataSourceId.IsEmpty == false && orderExecutionSourceId.IsEmpty == false, "Source Id not available to order."); _manager = manager; _dataSourceId = dataSourceId; _orderExectionSourceId = orderExecutionSourceId; _executionProvider = manager.ObtainOrderExecutionProvider(orderExecutionSourceId, dataSourceId); }
/// <summary> /// Startup initialization procedure, called only once in the lifecycle of an object /// (only after initial construction, not upon serialization-deserialization). /// </summary> /// <param name="dataProvider"></param> /// <param name="orderExectionProvider"></param> public bool SetInitialParameters(ISessionDataProvider dataProvider, ISourceOrderExecution orderExectionProvider) { SystemMonitor.CheckThrow(_sessionDataProvider == null && _orderExecutionProvider == null, "Session already initialized."); _sessionDataProvider = dataProvider; _orderExecutionProvider = orderExectionProvider; return(true); }
/// <summary> /// Detailed constructor. /// </summary> public ModifyOrderControl(ModeEnum mode, ActiveOrder order) { InitializeComponent(); _provider = order.OrderExecutionProvider; _mode = mode; _order = order; _dataProvider = order.QuoteProvider; _dataProvider.QuoteUpdateEvent += new QuoteProviderUpdateDelegate(_dataProvider_QuoteUpdateEvent); _session = order.SessionInfo.Value; }
/// <summary> /// Detailed constructor. /// </summary> public ModifyOrderControl(ModeEnum mode, Order order) { InitializeComponent(); _provider = order.OrderExecutionProvider; _mode = mode; _order = order; _dataProvider = order.QuoteProvider; _dataProvider.QuoteUpdateEvent += new QuoteProviderUpdateDelegate(_dataProvider_QuoteUpdateEvent); _session = order.SessionInfo.Value; }
/// <summary> /// Initialization. /// </summary> public bool Initialize() { SystemMonitor.CheckThrow(State == OrderStateEnum.UnInitialized, "Order already initialized."); ISourceOrderExecution executionProvider = _executionProvider; _quoteProvider.QuoteUpdateEvent += new QuoteProviderUpdateDelegate(Quote_QuoteUpdateEvent); State = OrderStateEnum.Initialized; return(true); }
/// <summary> /// /// </summary> public void Initialize(ISessionDataProvider dataProvider, ISourceOrderExecution orderExecutionProvider) { if (dataProvider == null) { return; } lock (this) { _dataProvider = dataProvider; if (_dataProvider != null) { _dataProvider.CurrentDataBarProviderChangedEvent += new DataProviderUpdateDelegate(_dataProvider_CurrentDataBarProviderChangedEvent); CurrentDataBarProvider = _dataProvider.DataBars; if (_dataProvider.Quotes != null) { _dataProvider.Quotes.QuoteUpdateEvent += new QuoteProviderUpdateDelegate(Quotes_QuoteUpdateEvent); } } _orderExecutionProvider = orderExecutionProvider; if (_orderExecutionProvider != null) { IOrderSink executor = _orderExecutionProvider; if (executor != null) { executor.OrdersUpdatedEvent += new OrdersUpdateDelegate(executor_OrderUpdatedEvent); } ITradeEntityManagement management = _orderExecutionProvider.TradeEntities; if (management != null) { management.OrdersAddedEvent += new OrderManagementOrdersUpdateDelegate(management_OrdersAddedEvent); management.OrdersRemovedEvent += new OrderManagementOrdersUpdateDelegate(management_OrdersRemovedEvent); management.OrdersUpdatedEvent += new OrderManagementOrdersUpdateTypeDelegate(management_OrderUpdatedEvent); } } ComponentResourceManager resources = new ComponentResourceManager(typeof(ProviderTradeChartSeries)); _imageDown = ((Image)(resources.GetObject("imageDown"))); _imageUp = ((Image)(resources.GetObject("imageUp"))); _imageCross = ((Image)(resources.GetObject("imageCross"))); _buyDashedPen.DashPattern = new float[] { 5, 5 }; _buyDashedPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom; _priceLevelPen.DashPattern = new float[] { 3, 3 }; _priceLevelPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom; _sellDashedPen.DashPattern = new float[] { 5, 5 }; _sellDashedPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom; } }
/// <summary> /// Constructor, allows direct order initialization. /// </summary> /// <param name="session"></param> /// <param name="initialize">Initialize order on construction. If init fails, exception will occur.</param> public ActiveOrder(ISourceManager manager, ISourceOrderExecution executionProvider, ComponentId dataSourceId, bool initialize) : base(manager, executionProvider, dataSourceId) { State = OrderStateEnum.UnInitialized; if (initialize) { SystemMonitor.CheckThrow(Initialize()); } }
/// <summary> /// Constructor, allows direct order initialization. /// </summary> /// <param name="session"></param> /// <param name="initialize">Initialize order on construction. If init fails, exception will occur.</param> public ActiveOrder(ISourceManager manager, ISourceOrderExecution executionProvider, ComponentId dataSourceId, bool initialize) : base(manager, executionProvider, dataSourceId) { State = OrderStateEnum.UnInitialized; if (initialize) { SystemMonitor.CheckThrow(Initialize()); } }
public bool AddProvider(ISourceOrderExecution provider) { if (_providers.Contains(provider)) { return(false); } _providers.Add(provider); UpdateUI(); return(true); }
/// <summary> /// /// </summary> public bool SetInitialParameters(ISourceManager manager, ISourceOrderExecution provider, ISourceDataDelivery dataDelivery, Symbol symbol) { _manager = manager; _orderProvider = provider; _dataDelivery = dataDelivery; _info.Symbol = symbol; return(true); }
/// <summary> /// /// </summary> protected override string OnExecuteMarket(ISourceOrderExecution provider, OrderTypeEnum orderType, int volume, decimal?price, decimal?slippage, decimal?takeProfit, decimal?stopLoss, TimeSpan timeOut, out PositionExecutionInfo executionInfo, out string operationResultMessage) { SystemMonitor.CheckError(provider.SupportsActiveOrderManagement == false, "Wrong position type for this provider."); executionInfo = PositionExecutionInfo.Empty; PassiveOrder order; lock (this) { order = new PassiveOrder(_manager, _dataDelivery.SourceId, provider.SourceId); } OrderInfo?infoReference; bool result = provider.SynchronousExecute(provider.DefaultAccount.Info, order, _info.Symbol, orderType, volume, slippage, price, takeProfit, stopLoss, string.Empty, out infoReference, out operationResultMessage); if (result && infoReference.HasValue) { OrderInfo infoAssign = infoReference.Value; if (infoAssign.Type == OrderTypeEnum.UNKNOWN) { infoAssign.Type = orderType; } if (infoAssign.Volume == int.MinValue || infoAssign.Volume == int.MaxValue) {// Volume was not retrieved by integration. infoAssign.Volume = volume; } if (infoAssign.OpenPrice.HasValue) { executionInfo = new PositionExecutionInfo(infoReference.Value.Id, _dataDelivery.SourceId, provider.SourceId, Symbol, infoAssign.Type, infoAssign.OpenPrice.Value, volume, volume, infoAssign.OpenTime, PositionExecutionInfo.ExecutionResultEnum.Success); } else { SystemMonitor.Error("Received execution result, but price not assigned."); } order.AdoptInfo(infoAssign); provider.TradeEntities.AddOrder(order); return(infoReference.Value.Id); } return(string.Empty); }
public bool AddProvider(ISourceOrderExecution provider) { if (_providers.Contains(provider)) { return false; } _providers.Add(provider); UpdateUI(); return true; }
/// <summary> /// /// </summary> protected override string OnExecuteMarket(ISourceOrderExecution provider, OrderTypeEnum orderType, int volume, decimal? price, decimal? slippage, decimal? takeProfit, decimal? stopLoss, TimeSpan timeOut, out PositionExecutionInfo executionInfo, out string operationResultMessage) { SystemMonitor.CheckError(provider.SupportsActiveOrderManagement == false, "Wrong position type for this provider."); executionInfo = PositionExecutionInfo.Empty; PassiveOrder order; lock (this) { order = new PassiveOrder(_manager, _dataDelivery.SourceId, provider.SourceId); } OrderInfo? infoReference; bool result = provider.SynchronousExecute(provider.DefaultAccount.Info, order, _info.Symbol, orderType, volume, slippage, price, takeProfit, stopLoss, string.Empty, out infoReference, out operationResultMessage); if (result && infoReference.HasValue) { OrderInfo infoAssign = infoReference.Value; if (infoAssign.Type == OrderTypeEnum.UNKNOWN) { infoAssign.Type = orderType; } if (infoAssign.Volume == int.MinValue || infoAssign.Volume == int.MaxValue) {// Volume was not retrieved by integration. infoAssign.Volume = volume; } if (infoAssign.OpenPrice.HasValue) { executionInfo = new PositionExecutionInfo(infoReference.Value.Id, _dataDelivery.SourceId, provider.SourceId, Symbol, infoAssign.Type, infoAssign.OpenPrice.Value, volume, volume, infoAssign.OpenTime, PositionExecutionInfo.ExecutionResultEnum.Success); } else { SystemMonitor.Error("Received execution result, but price not assigned."); } order.AdoptInfo(infoAssign); provider.TradeEntities.AddOrder(order); return infoReference.Value.Id; } return string.Empty; }
/// <summary> /// Initialize execution account with its owner provider. /// </summary> /// <param name="session"></param> public bool SetInitialParameters(ISourceManager manager, ISourceOrderExecution orderExecutionProvider, ISourceDataDelivery dataDelivery) { SystemMonitor.CheckError(_provider == null, "Order account already initialized."); _manager = manager; //why is the provider not ready _provider = orderExecutionProvider; _dataDelivery = dataDelivery; SystemMonitor.CheckWarning(_manager != null && _provider != null && _dataDelivery != null, "Account not properly initialized."); return(true); }
///// <summary> ///// Will try to asynchronously reverse the given execution info position part. ///// Similar to the ExecuteMarketReverse baseMethod, only this is not synchronous. ///// </summary> //public virtual string SubmitReverse(PositionExecutionInfo orderInfo, decimal? slippage, bool manipulateExistingOrders, out string operationResultMessage) //{ // if (orderInfo.IsEmpty || orderInfo.Result != PositionExecutionInfo.ExecutionResultEnum.Success) // { // operationResultMessage = "Execution info not properly assigned for reversal."; // return string.Empty; // } // OrderTypeEnum orderType = OrderTypeEnum.UNKNOWN; // if (orderInfo.OrderType == OrderTypeEnum.BUY_MARKET) // { // orderType = OrderTypeEnum.SELL_MARKET; // } // else if (orderInfo.OrderType == OrderTypeEnum.SELL_MARKET) // { // orderType = OrderTypeEnum.BUY_MARKET; // } // else // { // operationResultMessage = "Only market position can be reversed."; // SystemMonitor.OperationError(operationResultMessage); // return string.Empty; // } // return Submit(orderType, (int)orderInfo.ExecutedVolume, // null, slippage, null, null, manipulateExistingOrders, out operationResultMessage); //} ///// <summary> ///// Will try to synchronously execute a reverse of the given execution info. ///// This is a suitable replacement for a specific "order close", i.e. allowing ///// you to reverse a specific previous execution on this position. ///// </summary> ///// <param name="orderInfo"></param> ///// <param name="allowExistingActiveOrdersManipulation">Is the operation allowed to close a matching existing order, or should we always open a new one. This is suitable for Active orders brokers, that dissallow hedged orders at the same time.</param> ///// <returns></returns> //public virtual string ExecuteMarketReverse(PositionExecutionInfo orderInfo, decimal? slippage, TimeSpan timeOut, bool manipulateExistingOrders, // out PositionExecutionInfo newExecutionInfo, out string operationResultMessage) //{ // newExecutionInfo = PositionExecutionInfo.Empty; // if (orderInfo.IsEmpty == false && orderInfo.Result == PositionExecutionInfo.ExecutionResultEnum.Success) // { // OrderTypeEnum orderType = OrderTypeEnum.UNKNOWN; // if (orderInfo.OrderType == OrderTypeEnum.BUY_MARKET) // { // orderType = OrderTypeEnum.SELL_MARKET; // } // else if (orderInfo.OrderType == OrderTypeEnum.SELL_MARKET) // { // orderType = OrderTypeEnum.BUY_MARKET; // } // else // { // operationResultMessage = "Only market position can be reversed."; // SystemMonitor.OperationError(operationResultMessage); // return string.Empty; // } // return ExecuteMarket(orderType, (int)orderInfo.ExecutedVolume, null, slippage, null, null, timeOut, out newExecutionInfo, out operationResultMessage); // } // else // { // operationResultMessage = "Can not reverse execution info with result [" + orderInfo.Result.ToString() + "], no action taken."; // SystemMonitor.OperationError(operationResultMessage); // return string.Empty; // } //} /// <summary> /// /// </summary> protected virtual bool OnExecuteMarketBalanced(ISourceOrderExecution provider, int volumeModification, decimal?desiredPrice, decimal?slippage, TimeSpan timeOut, out PositionExecutionInfo executionInfo, out string operationResultMessage) { OrderTypeEnum orderType = OrderTypeEnum.BUY_MARKET; if (volumeModification < 0) { orderType = OrderTypeEnum.SELL_MARKET; } return(string.IsNullOrEmpty(ExecuteMarket(orderType, Math.Abs(volumeModification), desiredPrice, slippage, null, null, timeOut, out executionInfo, out operationResultMessage)) == false); }
public void Dispose() { if (_sessionDataProvider != null) { _sessionDataProvider.Dispose(); _sessionDataProvider = null; } if (_orderExecutionProvider != null) { _orderExecutionProvider = null; } }
/// <summary> /// Initialization. /// </summary> public bool Initialize() { SystemMonitor.CheckThrow(State == OrderStateEnum.UnInitialized, "Order already initialized."); ISourceOrderExecution executionProvider = _executionProvider; if (Symbol.IsEmpty == false && QuoteProvider != null) {// This will only work for deserialized orders, or ones that already have adopted info. QuoteProvider.QuoteUpdateEvent += new QuoteProviderUpdateDelegate(Quote_QuoteUpdateEvent); } State = OrderStateEnum.Initialized; return(true); }
public void UnInitialize() { if (_provider != null) { _provider.TradeEntities.PositionsUpdatedEvent -= new PositionsUpdateDelegate(TradeEntities_PositionsUpdatedEvent); _provider.TradeEntities.PositionsAddedEvent -= new PositionsUpdateDelegate(TradeEntities_PositionsAddedEvent); _provider.TradeEntities.PositionsRemovedEvent -= new PositionsUpdateDelegate(TradeEntities_PositionsRemovedEvent); _provider.PositionsUpdateEvent -= new PositionUpdateDelegate(_provider_PositionUpdateEvent); } _manager = null; _provider = null; _dataDelivery = null; }
/// <summary> /// /// </summary> public bool SetInitialParameters(ISourceManager manager, ISourceOrderExecution provider, ISourceDataDelivery delivery) { //SystemMonitor.CheckError(_provider == null, "OrderExecutionProvider already assigned."); _manager = manager; _provider = provider; _delivery = delivery; if (_provider == null) { SystemMonitor.Warning("Failed to properly initialize entity keeper."); } return(true); }
/// <summary> /// Constructor, allows direct order initialization. /// </summary> /// <param name="session"></param> /// <param name="initialize">Initialize order on construction. If init fails, exception will occur.</param> public ActiveOrder(ISourceManager manager, ISourceOrderExecution executionProvider, IQuoteProvider quoteProvider, ComponentId dataSourceId, Symbol symbol, bool initialize) { _manager = manager; _symbol = symbol; _dataSourceId = dataSourceId; _executionProvider = executionProvider; _quoteProvider = quoteProvider; State = OrderStateEnum.UnInitialized; if (initialize) { SystemMonitor.CheckThrow(Initialize()); } }
/// <summary> /// /// </summary> public void Initialize(ISourceAndExpertSessionManager manager, ISourceDataDelivery dataDelivery, ISourceOrderExecution provider) { _manager = manager; _provider = provider; _dataDelivery = dataDelivery; if (_provider != null) { _provider.TradeEntities.PositionsUpdatedEvent += new PositionsUpdateDelegate(TradeEntities_PositionsUpdatedEvent); _provider.TradeEntities.PositionsAddedEvent += new PositionsUpdateDelegate(TradeEntities_PositionsAddedEvent); _provider.TradeEntities.PositionsRemovedEvent += new PositionsUpdateDelegate(TradeEntities_PositionsRemovedEvent); _provider.PositionsUpdateEvent += new PositionUpdateDelegate(_provider_PositionUpdateEvent); } UpdateUI(); if (listView.Items.Count > 0 && listView.SelectedItems.Count == 0) { listView.Items[0].Selected = true; } }
/// <summary> /// /// </summary> public bool SetInitialParameters(ISourceManager manager, ISourceOrderExecution provider, ISourceDataDelivery dataDelivery, Symbol symbol) { _manager = manager; _provider = provider; _dataDelivery = dataDelivery; _info.Symbol = symbol; return true; }
/// <summary> /// Register ISourceOrderExecution. /// </summary> protected bool AddElement(ComponentId id, ISourceOrderExecution provider) { if (id.IsEmpty || provider == null) { SystemMonitor.Warning("Invalid Id or order execution provider instance."); return false; } lock (this) { if (_orderExecutionProviders.ContainsKey(id)) { SystemMonitor.Warning("Failed to add order execution provider, since already added with this Id."); return false; } _orderExecutionProviders.Add(id, provider); } return true; }
/// <summary> /// /// </summary> protected override void OnRecalculateParameters(ISourceOrderExecution provider, bool fullRecalculation) { decimal pendingVolume = 0; Order[] orders = provider.TradeEntities.GetOrdersBySymbol(Symbol); foreach (PassiveOrder order in orders) { if (order.State == OrderStateEnum.Submitted) { pendingVolume += order.CurrentVolume; } } lock (this) { _info.PendingBuyVolume = pendingVolume; } }
/// <summary> /// Constructor. /// </summary> public Order(ISourceManager manager, ISourceOrderExecution executionProvider, ComponentId dataSourceId) { _manager = manager; _executionProvider = executionProvider; _dataSourceId = dataSourceId; }
/// <summary> /// /// </summary> public virtual void Dispose() { _manager = null; _executionProvider = null; _quoteProvider = null; _dataSourceId = ComponentId.Empty; }
/// <summary> /// /// </summary> protected override void OnRecalculateParameters(ISourceOrderExecution provider, bool fullRecalculation) { SystemMonitor.CheckError(provider.SupportsActiveOrderManagement, "Wrong position type for this provider."); Order[] orders = provider.TradeEntities.GetOrdersBySymbol(Symbol); lock (this) { _info.Volume = 0; _info.PendingBuyVolume = 0; _info.PendingSellVolume = 0; _info.Result = 0; foreach (ActiveOrder order in GeneralHelper.SafeChildTypeIteration<Order, ActiveOrder>(orders)) { if (order.State == OrderStateEnum.Executed) { _info.Volume += order.CurrentDirectionalVolume; _info.Result += order.GetResult(Order.ResultModeEnum.Currency); } else if (order.State == OrderStateEnum.Submitted) { if (order.IsBuy) { _info.PendingBuyVolume += order.CurrentVolume; } else { _info.PendingSellVolume += order.CurrentVolume; } } } } }
protected abstract void OnRecalculateParameters(ISourceOrderExecution provider, bool fullRecalculation);
/// <summary> /// /// </summary> protected override string OnSubmit(ISourceOrderExecution provider, OrderTypeEnum orderType, int volume, decimal? price, decimal? slippage, decimal? takeProfit, decimal? stopLoss, out string operationResultMessage) { PassiveOrder order = new PassiveOrder(_manager, _dataDelivery.SourceId, provider.SourceId); string id = provider.SubmitOrder(provider.DefaultAccount.Info, order, _info.Symbol, orderType, volume, slippage, price, takeProfit, stopLoss, string.Empty, out operationResultMessage); if (string.IsNullOrEmpty(id)) { return string.Empty; } if (order.Info.State != OrderStateEnum.Executed) {// It is possible that the submit executes the order instantly, so make sure this is not the case. OrderInfo info = new OrderInfo(id, Symbol, orderType, OrderStateEnum.Submitted, volume, price, null, null, null, null, null, null, null, null, null, null, string.Empty, null); order.AdoptInfo(info); } provider.TradeEntities.AddOrder(order); return id; }
public void Dispose() { _manager = null; _orderProvider = null; _dataDelivery = null; }
/// <summary> /// /// </summary> protected override bool OnExecuteMarketBalanced(ISourceOrderExecution provider, int volumeModification, decimal? desiredPrice, decimal? slippage, TimeSpan timeOut, out PositionExecutionInfo executionInfo, out string operationResultMessage) { if (_manipulateExistingOrders == false) { return base.OnExecuteMarketBalanced(provider, volumeModification, desiredPrice, slippage, timeOut, out executionInfo, out operationResultMessage); } OrderTypeEnum orderType = OrderTypeEnum.BUY_MARKET; if (volumeModification < 0) { orderType = OrderTypeEnum.SELL_MARKET; volumeModification = Math.Abs(volumeModification); } executionInfo = PositionExecutionInfo.Empty; int originalVolumeModification = volumeModification; List<KeyValuePair<double, decimal>> closePrices = new List<KeyValuePair<double, decimal>>(); bool suitableOrdersAvailable; ActiveOrder orderSelected = ObtainManipulationOrder(provider, GetReverseOrderType(orderType), Math.Abs(originalVolumeModification), out suitableOrdersAvailable); if (orderSelected != null && volumeModification > 0) { if (volumeModification >= orderSelected.CurrentVolume) { int orderVolume = orderSelected.CurrentVolume; if (orderSelected.Close(slippage, null)) { volumeModification -= orderVolume; if (orderSelected.ClosePrice.HasValue) { closePrices.Add(new KeyValuePair<double, decimal>(orderVolume, orderSelected.ClosePrice.Value)); } else { SystemMonitor.Error("Order [{" + orderSelected.Id + "}] closed but close price not assigned."); } } else { ReleaseManipulationOrder(orderSelected); operationResultMessage = "Failed to close corresponding reverse active order."; return false; } } else { if (orderSelected.DecreaseVolume(volumeModification, slippage, null)) { volumeModification = 0; } } ReleaseManipulationOrder(orderSelected); orderSelected = null; } if (suitableOrdersAvailable && volumeModification > 0 && originalVolumeModification == volumeModification) {// Complete failure to close anything, and there are some suitable. executionInfo = PositionExecutionInfo.Empty; operationResultMessage = "Suitable reverse market orders are available, but currently manipulated, so hedging rules forbid reverse orders placement at this moment."; return false; } if (volumeModification > 0) {// We need to execute one more in the reverse direction. PositionExecutionInfo marketExecutionInfo; string tmp; string executionResult = ExecuteMarket(orderType, volumeModification, null, slippage, null, null, timeOut, out marketExecutionInfo, out tmp); if (string.IsNullOrEmpty(executionResult) == false) {// Success. volumeModification -= (int)marketExecutionInfo.VolumeExecuted; if (marketExecutionInfo.ExecutedPrice.HasValue) { closePrices.Add(new KeyValuePair<double, decimal>(marketExecutionInfo.VolumeExecuted, marketExecutionInfo.ExecutedPrice.Value)); } else { SystemMonitor.Error("MarketExecutionInfo for a valid execution [{" + executionResult + "}] does not have ExecutedPrice assigned."); } } else { operationResultMessage = tmp; return false; } } // Calculate the close price, combination from the operations. decimal closePrice = 0; double totalVolume = 0; if (FinancialHelper.CalculateAveragePrice(closePrices, out closePrice, out totalVolume) == false) { SystemMonitor.Error("Failed to calculate average price for market balanced execution."); closePrice = 0; } if (volumeModification > 0) {// Failure. if (originalVolumeModification == volumeModification) {// Complete failure. executionInfo = PositionExecutionInfo.Empty; operationResultMessage = "Failed to execute market operation."; return false; } else {// Partial execution success. executionInfo = new PositionExecutionInfo(Guid.NewGuid().ToString(), _dataDelivery.SourceId, provider.SourceId, Symbol, orderType, closePrice, originalVolumeModification, originalVolumeModification - volumeModification, DateTime.Now, PositionExecutionInfo.ExecutionResultEnum.PartialSuccess); } } else {// Success. executionInfo = new PositionExecutionInfo(Guid.NewGuid().ToString(), _dataDelivery.SourceId, provider.SourceId, Symbol, orderType, closePrice, originalVolumeModification, originalVolumeModification, DateTime.Now, PositionExecutionInfo.ExecutionResultEnum.Success); } operationResultMessage = string.Empty; return true; }
/// <summary> /// /// </summary> public bool SetInitialParameters(ISourceManager manager, ISourceOrderExecution provider, ISourceDataDelivery delivery) { //SystemMonitor.CheckError(_provider == null, "OrderExecutionProvider already assigned."); _manager = manager; _provider = provider; _delivery = delivery; if (_provider == null) { SystemMonitor.Warning("Failed to properly initialize entity keeper."); } return true; }
public void Dispose() { _manager = null; _provider = null; _delivery = null; }
///// <summary> ///// Will try to asynchronously reverse the given execution info position part. ///// Similar to the ExecuteMarketReverse baseMethod, only this is not synchronous. ///// </summary> //public virtual string SubmitReverse(PositionExecutionInfo orderInfo, decimal? slippage, bool manipulateExistingOrders, out string operationResultMessage) //{ // if (orderInfo.IsEmpty || orderInfo.Result != PositionExecutionInfo.ExecutionResultEnum.Success) // { // operationResultMessage = "Execution info not properly assigned for reversal."; // return string.Empty; // } // OrderTypeEnum orderType = OrderTypeEnum.UNKNOWN; // if (orderInfo.OrderType == OrderTypeEnum.BUY_MARKET) // { // orderType = OrderTypeEnum.SELL_MARKET; // } // else if (orderInfo.OrderType == OrderTypeEnum.SELL_MARKET) // { // orderType = OrderTypeEnum.BUY_MARKET; // } // else // { // operationResultMessage = "Only market position can be reversed."; // SystemMonitor.OperationError(operationResultMessage); // return string.Empty; // } // return Submit(orderType, (int)orderInfo.ExecutedVolume, // null, slippage, null, null, manipulateExistingOrders, out operationResultMessage); //} ///// <summary> ///// Will try to synchronously execute a reverse of the given execution info. ///// This is a suitable replacement for a specific "order close", i.e. allowing ///// you to reverse a specific previous execution on this position. ///// </summary> ///// <param name="orderInfo"></param> ///// <param name="allowExistingActiveOrdersManipulation">Is the operation allowed to close a matching existing order, or should we always open a new one. This is suitable for Active orders brokers, that dissallow hedged orders at the same time.</param> ///// <returns></returns> //public virtual string ExecuteMarketReverse(PositionExecutionInfo orderInfo, decimal? slippage, TimeSpan timeOut, bool manipulateExistingOrders, // out PositionExecutionInfo newExecutionInfo, out string operationResultMessage) //{ // newExecutionInfo = PositionExecutionInfo.Empty; // if (orderInfo.IsEmpty == false && orderInfo.Result == PositionExecutionInfo.ExecutionResultEnum.Success) // { // OrderTypeEnum orderType = OrderTypeEnum.UNKNOWN; // if (orderInfo.OrderType == OrderTypeEnum.BUY_MARKET) // { // orderType = OrderTypeEnum.SELL_MARKET; // } // else if (orderInfo.OrderType == OrderTypeEnum.SELL_MARKET) // { // orderType = OrderTypeEnum.BUY_MARKET; // } // else // { // operationResultMessage = "Only market position can be reversed."; // SystemMonitor.OperationError(operationResultMessage); // return string.Empty; // } // return ExecuteMarket(orderType, (int)orderInfo.ExecutedVolume, null, slippage, null, null, timeOut, out newExecutionInfo, out operationResultMessage); // } // else // { // operationResultMessage = "Can not reverse execution info with result [" + orderInfo.Result.ToString() + "], no action taken."; // SystemMonitor.OperationError(operationResultMessage); // return string.Empty; // } //} /// <summary> /// /// </summary> protected virtual bool OnExecuteMarketBalanced(ISourceOrderExecution provider, int volumeModification, decimal? desiredPrice, decimal? slippage, TimeSpan timeOut, out PositionExecutionInfo executionInfo, out string operationResultMessage) { OrderTypeEnum orderType = OrderTypeEnum.BUY_MARKET; if (volumeModification < 0) { orderType = OrderTypeEnum.SELL_MARKET; } return string.IsNullOrEmpty(ExecuteMarket(orderType, Math.Abs(volumeModification), desiredPrice, slippage, null, null, timeOut, out executionInfo, out operationResultMessage)) == false; }
/// <summary> /// /// </summary> public void Initialize(ISessionDataProvider dataProvider, ISourceOrderExecution orderExecutionProvider) { if (dataProvider == null) { return; } lock (this) { _dataProvider = dataProvider; if (_dataProvider != null) { _dataProvider.CurrentDataBarProviderChangedEvent += new DataProviderUpdateDelegate(_dataProvider_CurrentDataBarProviderChangedEvent); CurrentDataBarProvider = _dataProvider.DataBars; if (_dataProvider.Quotes != null) { _dataProvider.Quotes.QuoteUpdateEvent += new QuoteProviderUpdateDelegate(Quotes_QuoteUpdateEvent); } } _orderExecutionProvider = orderExecutionProvider; if (_orderExecutionProvider != null) { IOrderSink executor = _orderExecutionProvider; if (executor != null) { executor.OrdersUpdatedEvent += new OrdersUpdateDelegate(executor_OrderUpdatedEvent); } ITradeEntityManagement management = _orderExecutionProvider.TradeEntities; if (management != null) { management.OrdersAddedEvent += new OrderManagementOrdersUpdateDelegate(management_OrdersAddedEvent); management.OrdersRemovedEvent += new OrderManagementOrdersUpdateDelegate(management_OrdersRemovedEvent); management.OrdersUpdatedEvent += new OrderManagementOrdersUpdateTypeDelegate(management_OrderUpdatedEvent); } } ComponentResourceManager resources = new ComponentResourceManager(typeof(ProviderTradeChartSeries)); _imageDown = ((Image)(resources.GetObject("imageDown"))); _imageUp = ((Image)(resources.GetObject("imageUp"))); _imageCross = ((Image)(resources.GetObject("imageCross"))); _buyDashedPen.DashPattern = new float[] { 5, 5 }; _buyDashedPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom; _priceLevelPen.DashPattern = new float[] { 3, 3 }; _priceLevelPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom; _sellDashedPen.DashPattern = new float[] { 5, 5 }; _sellDashedPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom; } }
/// <summary> /// /// </summary> protected abstract string OnSubmit(ISourceOrderExecution provider, OrderTypeEnum orderType, int volume, decimal? price, decimal? slippage, decimal? takeProfit, decimal? stopLoss, out string operationResultMessage);
public void UnInitialize() { lock (this) { _ordersArrows.Clear(); GeneralHelper.FireAndForget(SelectedOrderChangedEvent, _selectedOrder, null); _selectedOrder = null; CurrentDataBarProvider = null; if (_dataProvider != null) { if (_dataProvider.Quotes != null) { _dataProvider.Quotes.QuoteUpdateEvent += new QuoteProviderUpdateDelegate(Quotes_QuoteUpdateEvent); } _dataProvider.CurrentDataBarProviderChangedEvent -= new DataProviderUpdateDelegate(_dataProvider_CurrentDataBarProviderChangedEvent); _dataProvider = null; } if (_orderExecutionProvider != null) { IOrderSink executor = _orderExecutionProvider; ITradeEntityManagement management = _orderExecutionProvider.TradeEntities; if (executor != null) { executor.OrdersUpdatedEvent -= new OrdersUpdateDelegate(executor_OrderUpdatedEvent); } if (management != null) { management.OrdersAddedEvent -= new OrderManagementOrdersUpdateDelegate(management_OrdersAddedEvent); management.OrdersRemovedEvent -= new OrderManagementOrdersUpdateDelegate(management_OrdersRemovedEvent); management.OrdersUpdatedEvent -= new OrderManagementOrdersUpdateTypeDelegate(management_OrderUpdatedEvent); } _orderExecutionProvider = null; } _buyDashedPen.Dispose(); _sellDashedPen.Dispose(); } }
/// <summary> /// /// </summary> protected override string OnSubmit(ISourceOrderExecution provider, OrderTypeEnum orderType, int volume, decimal? price, decimal? slippage, decimal? takeProfit, decimal? stopLoss, out string operationResultMessage) { SystemMonitor.CheckError(provider.SupportsActiveOrderManagement, "Wrong position type for this provider."); IQuoteProvider quotes = _manager.ObtainQuoteProvider(_dataDelivery.SourceId, Symbol); ActiveOrder order = new ActiveOrder(_manager, provider, quotes, _dataDelivery.SourceId, Symbol, true); price = ProcessPrice(quotes, orderType, price); string id = provider.SubmitOrder(provider.DefaultAccount.Info, order, _info.Symbol, orderType, volume, slippage, price, takeProfit, stopLoss, string.Empty, out operationResultMessage); if (string.IsNullOrEmpty(id)) { return string.Empty; } OrderInfo info = new OrderInfo(id, Symbol, orderType, OrderStateEnum.Submitted, volume, price, null, null, null, null, null, null, null, null, null, null, string.Empty, null); order.AdoptInfo(info); provider.TradeEntities.AddOrder(order); return id; }
public virtual void Dispose() { //if (_tradeEntities != null) //{ // _tradeEntities.UnInitialize(); // _tradeEntities = null; //} if (_statistics != null) { _statistics.Dispose(); _statistics = null; } _dataDelivery = null; _manager = null; if (_provider != null) { _provider.AccountInfoUpdateEvent -= new AccountInfoUpdateDelegate(_provider_AccountInfoUpdateEvent); _provider.OperationalStateChangedEvent -= new OperationalStateChangedDelegate(_provider_OperationalStatusChangedEvent); _provider = null; } }
/// <summary> /// Initialize execution account with its owner provider. /// </summary> /// <param name="session"></param> public bool SetInitialParameters(ISourceManager manager, ISourceOrderExecution orderExecutionProvider, ISourceDataDelivery dataDelivery) { SystemMonitor.CheckError(_provider == null, "Order account already initialized."); _manager = manager; //why is the provider not ready _provider = orderExecutionProvider; _dataDelivery = dataDelivery; SystemMonitor.CheckWarning(_manager != null && _provider != null && _dataDelivery != null, "Account not properly initialized."); return true; }
/// <summary> /// /// </summary> ActiveOrder ObtainManipulationOrder(ISourceOrderExecution provider, OrderTypeEnum orderType, int minVolume, out bool suitableOrdersAvailable) { suitableOrdersAvailable = false; lock (provider.TradeEntities) { foreach (ActiveOrder activeOrder in provider.TradeEntities.GetOrdersByStateUnsafe(OrderStateEnum.Executed)) { if (activeOrder.Symbol == Symbol && minVolume <= activeOrder.CurrentVolume && (activeOrder.Type == orderType)) {// Found a opposing order, close it. suitableOrdersAvailable = true; lock (_activeSelectedOrders) { if (_activeSelectedOrders.Contains(activeOrder) == false) {// Only if this order is not currently processed, take it for processing. _activeSelectedOrders.Add(activeOrder); return activeOrder; } } } } } return null; }
public bool RemoveProvider(ISourceOrderExecution provider) { bool result = _providers.Remove(provider); UpdateUI(); return result; }
/// <summary> /// /// </summary> protected abstract string OnExecuteMarket(ISourceOrderExecution provider, OrderTypeEnum orderType, int volume, decimal? price, decimal? slippage, decimal? takeProfit, decimal? stopLoss, TimeSpan timeOut, out PositionExecutionInfo executionInfo, out string operationResultMessage);