Account Field
Inheritance: StringField
        /// <summary>
        /// Creates a FIX4.4 OrderCancelRequest message for Forexware
        /// </summary>
        /// <param name="order"></param>
        /// <returns></returns>
        public QuickFix.FIX44.OrderCancelRequest OrderCancelRequest(Order order)
        {
            QuickFix.FIX44.OrderCancelRequest orderCancelRequest = new QuickFix.FIX44.OrderCancelRequest();

            QuickFix.Fields.ClOrdID clOrdId = new QuickFix.Fields.ClOrdID(DateTime.Now.ToString(("yyMMddHmsfff")));
            orderCancelRequest.SetField(clOrdId);

            QuickFix.Fields.OrigClOrdID origClOrdId = new QuickFix.Fields.OrigClOrdID(order.OrderID);
            orderCancelRequest.SetField(origClOrdId);

            var account = new QuickFix.Fields.Account(_account);

            orderCancelRequest.SetField(account);

            QuickFix.Fields.Symbol symbol = new QuickFix.Fields.Symbol(order.Security.Symbol);
            orderCancelRequest.SetField(symbol);

            //set order side
            if (order.OrderSide == Constants.OrderSide.BUY)
            {
                orderCancelRequest.Set(new Side(Side.BUY));
            }
            else if (order.OrderSide == Constants.OrderSide.SELL)
            {
                orderCancelRequest.Set(new Side(Side.SELL));
            }

            QuickFix.Fields.TransactTime transactTime = new QuickFix.Fields.TransactTime(order.OrderDateTime);
            orderCancelRequest.SetField(transactTime);

            //QuickFix.Fields.Product product = new QuickFix.Fields.Product(FixCommon.Constants.Product.Currency);
            //orderCancelRequest.SetField(product);

            return(orderCancelRequest);
        }
Esempio n. 2
0
        /// <summary>
        /// Creates a FIX4.4 OrderCancelRequest message for Fxcm
        /// </summary>
        /// <param name="order"></param>
        /// <returns></returns>
        public QuickFix.FIX44.OrderCancelRequest OrderCancelRequest(Order order)
        {
            char orderSide = default(char);

            if (order.OrderSide == Constants.OrderSide.BUY)
            {
                orderSide = Side.BUY;
            }
            else if (order.OrderSide == Constants.OrderSide.SELL)
            {
                orderSide = Side.SELL;
            }

            if (orderSide.Equals(default(char)))
            {
                _logger.Error("Invalid Order Side", _type.FullName, "OrderCancelRequest");
                return(null);
            }

            QuickFix.FIX44.OrderCancelRequest orderCancelRequest = new QuickFix.FIX44.OrderCancelRequest();

            QuickFix.Fields.OrderID orderId = new QuickFix.Fields.OrderID(order.BrokerOrderID);
            orderCancelRequest.SetField(orderId);

            QuickFix.Fields.OrigClOrdID origClOrdId = new QuickFix.Fields.OrigClOrdID(order.OrderID);
            orderCancelRequest.SetField(origClOrdId);

            QuickFix.Fields.ClOrdID clOrdId = new QuickFix.Fields.ClOrdID(DateTime.Now.ToString(("yyMMddHmsfff")));
            orderCancelRequest.SetField(clOrdId);

            var account = new QuickFix.Fields.Account(_account);

            orderCancelRequest.SetField(account);

            QuickFix.Fields.Symbol symbol = new QuickFix.Fields.Symbol(order.Security.Symbol);
            orderCancelRequest.SetField(symbol);


            QuickFix.Fields.Side side = new QuickFix.Fields.Side(orderSide);
            orderCancelRequest.SetField(side);

            QuickFix.Fields.TransactTime transactTime = new QuickFix.Fields.TransactTime(order.OrderDateTime);
            orderCancelRequest.SetField(transactTime);

            QuickFix.Fields.Product product = new QuickFix.Fields.Product(FixCommon.Constants.Product.Currency);
            orderCancelRequest.SetField(product);

            return(orderCancelRequest);
        }
Esempio n. 3
0
        private static OrderData TranslateOrderImpl(Symbol symbol,
                                                    Side side,
                                                    OrdType ordType,
                                                    OrderQty orderQty,
                                                    Price price,
                                                    ClOrdID clOrdID,
                                                    Account account)
        {
            switch (ordType.getValue())
            {
                case OrdType.LIMIT:
                    if (price.Obj == 0)
                        throw new IncorrectTagValue(price.Tag);

                    break;

                    //case OrdType.MARKET: break;

                default:
                    throw new IncorrectTagValue(ordType.Tag);
            }

            return new OrderData
                {
                    MarketSide = TranslateFixFields.Translate(side),
                    Symbol = symbol.getValue(),
                    OrderType = TranslateFixFields.Translate(ordType),
                    Quantity = orderQty.getValue(),
                    Price = price.getValue(),
                    ClOrdID = clOrdID.getValue(),
                    Account =
                        account == null
                            ? TradingAccount.None
                            : new TradingAccount(account.getValue())
                };
        }
Esempio n. 4
0
 public void Set(QuickFix.Fields.Account val) 
 { 
     this.Account = val;
 }
 public bool IsSet(QuickFix.Fields.Account val)
 {
     return(IsSetAccount());
 }
 public QuickFix.Fields.Account Get(QuickFix.Fields.Account val)
 {
     GetField(val);
     return(val);
 }
 public void Set(QuickFix.Fields.Account val)
 {
     this.Account = val;
 }
Esempio n. 8
0
 public void set(QuickFix.Fields.Account field)
 {
     SetField(field);
 }
        /// <summary>
        /// Creates a FIX4.4 NewOrderSingle message for Forexware
        /// </summary>
        /// <param name="order"></param>
        /// <returns></returns>
        public QuickFix.FIX44.NewOrderSingle NewOrderSingle(Order order)
        {
            var newOrderSingle = new QuickFix.FIX44.NewOrderSingle();

            var clOrdId = new QuickFix.Fields.ClOrdID(order.OrderID);

            newOrderSingle.SetField(clOrdId);

            var handlInst = new QuickFix.Fields.HandlInst(HandlInst.AUTOMATED_EXECUTION_ORDER_PRIVATE);

            newOrderSingle.SetField(handlInst);

            //set order side
            if (order.OrderSide == Constants.OrderSide.BUY)
            {
                newOrderSingle.Set(new Side(Side.BUY));
            }
            else if (order.OrderSide == Constants.OrderSide.SELL)
            {
                newOrderSingle.Set(new Side(Side.SELL));
            }

            var symbol = new QuickFix.Fields.Symbol(order.Security.Symbol);

            newOrderSingle.SetField(symbol);

            var transactTime = new QuickFix.Fields.TransactTime(order.OrderDateTime);

            newOrderSingle.SetField(transactTime);

            var orderQty = new QuickFix.Fields.OrderQty(order.OrderSize);

            newOrderSingle.SetField(orderQty);

            //limit, market and stop orders are supported.
            if (order.GetType() == typeof(LimitOrder))
            {
                newOrderSingle.Set(new OrdType(OrdType.LIMIT));
                newOrderSingle.Set(new Price(((LimitOrder)order).LimitPrice));
            }
            else if (order.GetType() == typeof(MarketOrder))
            {
                newOrderSingle.Set(new OrdType(OrdType.MARKET));
            }
            else if (order.GetType() == typeof(StopOrder))
            {
                newOrderSingle.Set(new OrdType(OrdType.STOP));

                // set StopPX field
                // TODO: add StopPx field
            }

            var account = new QuickFix.Fields.Account(_account);

            newOrderSingle.SetField(account);

            if (order.GetType() == typeof(LimitOrder) || order.GetType() == typeof(StopOrder))
            {
                var tif = new QuickFix.Fields.TimeInForce(FixCommon.Converter.ConvertTif.GetFixValue(order.OrderTif));
                newOrderSingle.SetField(tif);
            }

            return(newOrderSingle);
        }
Esempio n. 10
0
        /// <summary>
        /// Creates a FIX4.4 NewOrderSingle message for Fxcm
        /// </summary>
        /// <param name="order"></param>
        /// <returns></returns>
        public QuickFix.FIX44.NewOrderSingle NewOrderSingle(Order order)
        {
            var newOrderSingle = new QuickFix.FIX44.NewOrderSingle();

            var clOrdId = new QuickFix.Fields.ClOrdID(order.OrderID);

            newOrderSingle.SetField(clOrdId);

            var account = new QuickFix.Fields.Account(_account);

            newOrderSingle.SetField(account);

            //var noTradingSession = new QuickFix.Fields.NoTradingSessions(1);
            //newOrderSingle.SetField(noTradingSession);

            // Create a new Trading Session Group
            QuickFix.FIX44.NewOrderSingle.NoTradingSessionsGroup noTradingSession = new QuickFix.FIX44.NewOrderSingle.NoTradingSessionsGroup();
            {
                var tradingSessionId = new QuickFix.Fields.TradingSessionID(_tradeTargetCompId);
                noTradingSession.SetField(tradingSessionId);

                var tradingSessionSubId = new QuickFix.Fields.TradingSessionSubID(_tradeTargetSubId);
                noTradingSession.SetField(tradingSessionSubId);

                newOrderSingle.AddGroup(noTradingSession);
            }

            var securityType = new QuickFix.Fields.SecurityType(FixCommon.Constants.SecurityType.ForeignExchangeContract);

            newOrderSingle.SetField(securityType);

            var symbol = new QuickFix.Fields.Symbol(order.Security.Symbol);

            newOrderSingle.SetField(symbol);

            var product = new QuickFix.Fields.Product(FixCommon.Constants.Product.Currency);

            newOrderSingle.SetField(product);

            //set order side
            if (order.OrderSide == Constants.OrderSide.BUY)
            {
                newOrderSingle.Set(new Side(Side.BUY));
            }
            else if (order.OrderSide == Constants.OrderSide.SELL)
            {
                newOrderSingle.Set(new Side(Side.SELL));
            }

            var transactTime = new QuickFix.Fields.TransactTime(order.OrderDateTime);

            newOrderSingle.SetField(transactTime);

            var orderQty = new QuickFix.Fields.OrderQty(order.OrderSize);

            newOrderSingle.SetField(orderQty);

            //var minQty = new QuickFix.Fields.MinQty(order.OrderSize);
            //newOrderSingle.SetField(minQty);

            //only limit and market orders are supported.
            if (order.GetType() == typeof(LimitOrder))
            {
                newOrderSingle.Set(new OrdType(OrdType.LIMIT));
                newOrderSingle.Set(new Price(((LimitOrder)order).LimitPrice));

                var tif = new QuickFix.Fields.TimeInForce(FixCommon.Converter.ConvertTif.GetFixValue(order.OrderTif));
                newOrderSingle.SetField(tif);
            }
            else if (order.GetType() == typeof(MarketOrder))
            {
                newOrderSingle.Set(new OrdType(OrdType.MARKET));
            }

            //var maxShow = new QuickFix.Fields.MaxShow(order.OrderSize);
            //newOrderSingle.SetField(maxShow);

            //var execInst = new QuickFix.Fields.ExecInst(ExecInst.BEST_EXECUTION);
            //newOrderSingle.SetField(execInst);

            var currency = new QuickFix.Fields.Currency(order.OrderCurrency);

            newOrderSingle.SetField(currency);

            //var handlInst = new QuickFix.Fields.HandlInst(HandlInst.AUTOMATED_EXECUTION_ORDER_PRIVATE);
            //newOrderSingle.SetField(handlInst);

            return(newOrderSingle);
        }
Esempio n. 11
0
        /// <summary>
        /// Creates a FIX4.2 NewOrderSingle message for Redi
        /// </summary>
        /// <param name="order"></param>
        /// <returns></returns>
        public QuickFix.FIX42.NewOrderSingle NewOrderSingle(Order order)
        {
            var newOrderSingle = new QuickFix.FIX42.NewOrderSingle();

            var clOrdId = new QuickFix.Fields.ClOrdID(order.OrderID);

            newOrderSingle.SetField(clOrdId);

            if (!string.IsNullOrEmpty(_account))
            {
                var account = new QuickFix.Fields.Account(_account);
                newOrderSingle.SetField(account);
            }

            var currency = new QuickFix.Fields.Currency(order.OrderCurrency);

            newOrderSingle.SetField(currency);

            var handlInst = new QuickFix.Fields.HandlInst(HandlInst.AUTOMATED_EXECUTION_ORDER_PRIVATE);

            newOrderSingle.SetField(handlInst);

            //only limit and market orders are supported.
            if (order.GetType() == typeof(LimitOrder))
            {
                var execInst = new QuickFix.Fields.ExecInst("h");
                newOrderSingle.SetField(execInst);

                newOrderSingle.Set(new OrdType(OrdType.LIMIT));
                newOrderSingle.Set(new Price(((LimitOrder)order).LimitPrice));
            }
            else if (order.GetType() == typeof(MarketOrder))
            {
                newOrderSingle.Set(new OrdType(OrdType.MARKET));
            }

            var orderQty = new QuickFix.Fields.OrderQty(order.OrderSize);

            newOrderSingle.SetField(orderQty);

            var exDestination = new QuickFix.Fields.ExDestination(";");

            newOrderSingle.SetField(exDestination);

            var country = new QuickFix.Fields.DeliverToLocationID("1");

            newOrderSingle.SetField(country);

            var side = new QuickFix.Fields.Side(Convert.ToChar(order.OrderSide));

            newOrderSingle.SetField(side);

            var symbol = new QuickFix.Fields.Symbol(order.Security.Symbol);

            newOrderSingle.SetField(symbol);

            var tif = new QuickFix.Fields.TimeInForce(FixCommon.Converter.ConvertTif.GetFixValue(order.OrderTif));

            newOrderSingle.SetField(tif);

            var transactTime = new QuickFix.Fields.TransactTime(order.OrderDateTime);

            newOrderSingle.SetField(transactTime);

            return(newOrderSingle);
        }