Ejemplo n.º 1
0
        private void ProcessOrder(OEC.API.Order order, long trasactionId)
        {
            if (order == null)
            {
                throw new ArgumentNullException(nameof(order));
            }

            if (trasactionId == 0)
            {
                throw new ArgumentOutOfRangeException(nameof(trasactionId));
            }

            var execMsg = new ExecutionMessage
            {
                OriginalTransactionId = trasactionId,
                OrderId       = order.ID,
                Side          = order.Side.ToStockSharp(),
                ExecutionType = ExecutionTypes.Order,
                ServerTime    = order.States.Current.Timestamp.ApplyTimeZone(TimeHelper.Est),
                OrderType     = order.Type.ToStockSharp(),
                Volume        = order.Quantity,
                PortfolioName = order.Account.Name,
                SecurityId    = new SecurityId
                {
                    SecurityCode = order.Contract.Symbol,
                    BoardCode    = order.Route == null ? order.Contract.Exchange.Name : order.Route.Name,
                },
                Comment    = order.Comments,
                OrderPrice = order.Contract.Cast(order.Price) ?? 0,
            };

            var currVersion = order.Versions.Current;

            switch (currVersion.Flags)
            {
            case OrderFlags.FOK:
                execMsg.TimeInForce = TimeInForce.MatchOrCancel;
                break;

            case OrderFlags.IOC:
                execMsg.TimeInForce = TimeInForce.CancelBalance;
                break;

            case OrderFlags.GTC:
                execMsg.TimeInForce = TimeInForce.PutInQueue;
                //execMsg.ExpiryDate = DateTimeOffset.MaxValue;
                break;
            }

            if (currVersion.End != OEC.API.Version.MaximumEnd)
            {
                execMsg.ExpiryDate = currVersion.End.ApplyTimeZone(TimeHelper.Est);
            }

            if (execMsg.OrderType == OrderTypes.Conditional)
            {
                var condition = new OpenECryOrderCondition();
                execMsg.Condition = condition;

                switch (order.Type)
                {
                case OrderType.StopLimit:
                    condition.StopType  = OpenECryStopType.StopLimit;
                    condition.StopPrice = order.Contract.Cast(order.Price);
                    execMsg.OrderPrice  = order.Contract.Cast(order.Price2) ?? 0;
                    break;

                case OrderType.Stop:
                    condition.StopType  = OpenECryStopType.StopMarket;
                    condition.StopPrice = order.Contract.Cast(order.Price);
                    //execMsg.Price = 0;
                    break;

                case OrderType.TrailingStopLoss:
                case OrderType.TrailingStopLimit:
                    //execMsg.Price = 0;
                    var stopType = order.Type == OrderType.TrailingStopLimit ? OpenECryStopType.TrailingStopLimit : OpenECryStopType.TrailingStopMarket;

                    var eqtsData = currVersion.ExtData as EquityTrailingStopData;
                    if (eqtsData != null)
                    {
                        condition.StopType       = stopType;
                        condition.Delta          = eqtsData.Amount.ToDecimal();
                        condition.IsPercentDelta = eqtsData.IsPercentAmount;
                        condition.TriggerType    = eqtsData.TriggerType.ToStockSharp();
                        condition.StopPrice      = order.Contract.Cast(order.Price);
                    }
                    else
                    {
                        var tsData = currVersion.ExtData as OEC.API.TrailingStopData;

                        if (tsData != null)
                        {
                            condition.StopType       = stopType;
                            condition.Delta          = tsData.Delta.ToDecimal();
                            condition.ReferencePrice = tsData.ReferencePrice.ToDecimal();
                            condition.StopPrice      = order.Contract.Cast(order.Price);
                        }
                    }

                    break;

                default:
                    throw new ArgumentOutOfRangeException(LocalizedStrings.Str1849Params.Put(order.Type));
                }
            }

            switch (order.CurrentState)
            {
            case OrderState.Accepted:
            {
                execMsg.OrderState  = OrderStates.Pending;
                execMsg.OrderStatus = OrderStatus.Accepted;
                break;
            }

            case OrderState.Held:
            {
                execMsg.OrderState  = OrderStates.Pending;
                execMsg.OrderStatus = OrderStatus.ReceiveByServer;
                break;
            }

            case OrderState.Sent:
            {
                execMsg.OrderState  = OrderStates.Pending;
                execMsg.OrderStatus = OrderStatus.SentToServer;
                break;
            }

            case OrderState.Suspended:
            {
                break;
            }

            case OrderState.Rejected:
            {
                execMsg.OrderState  = OrderStates.Failed;
                execMsg.OrderStatus = OrderStatus.RejectedBySystem;
                execMsg.Error       = new InvalidOperationException(order.States.Current.Comments);

                break;
            }

            case OrderState.Working:
            {
                //execMsg.ExtensionInfo[_keyExchangeOrderId] = order.Versions.Current.Command.ExchangeOrderID;

                execMsg.OrderState  = OrderStates.Active;
                execMsg.OrderStatus = OrderStatus.Accepted;

                execMsg.Balance = order.Quantity - order.Fills.TotalQuantity;

                break;
            }

            case OrderState.Completed:
            {
                execMsg.OrderState = OrderStates.Done;

                if (order.IsFilled)
                {
                    execMsg.Balance = 0;
                }
                else
                {
                    execMsg.Balance = order.Quantity - order.Fills.TotalQuantity;
                }

                break;
            }

            case OrderState.Cancelled:
            {
                execMsg.OrderState = OrderStates.Done;
                execMsg.Balance    = order.Quantity - order.Fills.TotalQuantity;

                break;
            }

            case OrderState.None:
            {
                break;
            }

            case OrderState.Unknown:
            {
                break;
            }

            default:
                throw new OpenECryException(LocalizedStrings.Str2557Params.Put(order.CurrentState));
            }

            SendOutMessage(execMsg);
        }
		private void ProcessOrder(OEC.API.Order order, long trasactionId)
		{
			if (order == null)
				throw new ArgumentNullException(nameof(order));

			if (trasactionId == 0)
				throw new ArgumentOutOfRangeException(nameof(trasactionId));

			var execMsg = new ExecutionMessage
			{
				OriginalTransactionId = trasactionId,
				OrderId = order.ID,
				Side = order.Side.ToStockSharp(),
				ExecutionType = ExecutionTypes.Transaction,
				ServerTime = order.States.Current.Timestamp.ApplyTimeZone(TimeHelper.Est),
				OrderType = order.Type.ToStockSharp(),
				OrderVolume = order.Quantity,
				PortfolioName = order.Account.Name,
				SecurityId = new SecurityId
				{
					SecurityCode = order.Contract.Symbol,
					BoardCode = order.Route == null ? order.Contract.Exchange.Name : order.Route.Name,
				},
				Comment = order.Comments,
				OrderPrice = order.Contract.Cast(order.Price) ?? 0,
			};

			var currVersion = order.Versions.Current;

			switch (currVersion.Flags)
			{
				case OrderFlags.FOK:
					execMsg.TimeInForce = TimeInForce.MatchOrCancel;
					break;
				case OrderFlags.IOC:
					execMsg.TimeInForce = TimeInForce.CancelBalance;
					break;
				case OrderFlags.GTC:
					execMsg.TimeInForce = TimeInForce.PutInQueue;
					//execMsg.ExpiryDate = DateTimeOffset.MaxValue;
					break;
			}

			if (currVersion.End != OEC.API.Version.MaximumEnd)
				execMsg.ExpiryDate = currVersion.End.ApplyTimeZone(TimeHelper.Est);

			if (execMsg.OrderType == OrderTypes.Conditional)
			{
				var condition = new OpenECryOrderCondition();
				execMsg.Condition = condition;

				switch (order.Type)
				{
					case OrderType.StopLimit:
						condition.StopType = OpenECryStopType.StopLimit;
						condition.StopPrice = order.Contract.Cast(order.Price);
						execMsg.OrderPrice = order.Contract.Cast(order.Price2) ?? 0;
						break;
					case OrderType.Stop:
						condition.StopType = OpenECryStopType.StopMarket;
						condition.StopPrice = order.Contract.Cast(order.Price);
						//execMsg.Price = 0;
						break;
					case OrderType.TrailingStopLoss:
					case OrderType.TrailingStopLimit:
						//execMsg.Price = 0;
						var stopType = order.Type == OrderType.TrailingStopLimit ? OpenECryStopType.TrailingStopLimit : OpenECryStopType.TrailingStopMarket;

						var eqtsData = currVersion.ExtData as EquityTrailingStopData;
						if (eqtsData != null)
						{
							condition.StopType = stopType;
							condition.Delta = eqtsData.Amount.ToDecimal();
							condition.IsPercentDelta = eqtsData.IsPercentAmount;
							condition.TriggerType = eqtsData.TriggerType.ToStockSharp();
							condition.StopPrice = order.Contract.Cast(order.Price);
						}
						else
						{
							var tsData = currVersion.ExtData as OEC.API.TrailingStopData;

							if (tsData != null)
							{
								condition.StopType = stopType;
								condition.Delta = tsData.Delta.ToDecimal();
								condition.ReferencePrice = tsData.ReferencePrice.ToDecimal();
								condition.StopPrice = order.Contract.Cast(order.Price);
							}
						}

						break;
					default:
						throw new ArgumentOutOfRangeException(LocalizedStrings.Str1849Params.Put(order.Type));
				}
			}

			switch (order.CurrentState)
			{
				case OrderState.Accepted:
				{
					execMsg.OrderState = OrderStates.Pending;
					execMsg.OrderStatus = OrderStatus.Accepted;
					break;
				}
				case OrderState.Held:
				{
					execMsg.OrderState = OrderStates.Pending;
					execMsg.OrderStatus = OrderStatus.ReceiveByServer;
					break;
				}
				case OrderState.Sent:
				{
					execMsg.OrderState = OrderStates.Pending;
					execMsg.OrderStatus = OrderStatus.SentToServer;
					break;
				}
				case OrderState.Suspended:
				{
					break;
				}
				case OrderState.Rejected:
				{
					execMsg.OrderState = OrderStates.Failed;
					execMsg.OrderStatus = OrderStatus.RejectedBySystem;
					execMsg.Error = new InvalidOperationException(order.States.Current.Comments);

					break;
				}
				case OrderState.Working:
				{
					//execMsg.ExtensionInfo[_keyExchangeOrderId] = order.Versions.Current.Command.ExchangeOrderID;

					execMsg.OrderState = OrderStates.Active;
					execMsg.OrderStatus = OrderStatus.Accepted;

					execMsg.Balance = order.Quantity - order.Fills.TotalQuantity;

					break;
				}
				case OrderState.Completed:
				{
					execMsg.OrderState = OrderStates.Done;

					if (order.IsFilled)
					{
						execMsg.Balance = 0;
					}
					else
					{
						execMsg.Balance = order.Quantity - order.Fills.TotalQuantity;
					}

					break;
				}
				case OrderState.Cancelled:
				{
					execMsg.OrderState = OrderStates.Done;
					execMsg.Balance = order.Quantity - order.Fills.TotalQuantity;

					break;
				}
				case OrderState.None:
				{
					break;
				}
				case OrderState.Unknown:
				{
					break;
				}
				default:
					throw new OpenECryException(LocalizedStrings.Str2557Params.Put(order.CurrentState));
			}

			SendOutMessage(execMsg);
		}