Ejemplo n.º 1
0
 public void ProcessNews(QuickFix.Message msg, SessionID sessionID)
 {
     if (msg.IsSetField(QuickFix.Fields.Tags.Headline) && (msg.GetString(QuickFix.Fields.Tags.Headline) == "STOPME"))
     {
         if (this.StopMeEvent != null)
             StopMeEvent();
     }
     else
         Echo(msg, sessionID);
 }
        /// <summary>
        /// Helper Method to process data from message for updating positions
        /// </summary>
        /// <param name="message"></param>
        /// <param name="session"></param>
        private void posTableUpdate(QuickFix.FIX42.Message message, SessionID session)
        {
            string MGT = null;
            string acct = null;

            string SecEx = null;
            string symbol = null;
            string secID = null;
            string gateway = null;

            int tradesize = 0;
            char side = char.MinValue;
            decimal price = 0.00M;

            bool OK2Update = true;

            try
            {
                QuickFix.Fields.SenderSubID subID = new QuickFix.Fields.SenderSubID();
                if (message.Header.IsSetField(subID))
                {
                    MGT = message.Header.GetField(subID).getValue();
                }
                else
                { OK2Update = false; }

                QuickFix.Fields.Account a = new QuickFix.Fields.Account();
                if (message.IsSetField(a))
                {
                    acct = message.GetField(a).getValue();
                }
                else
                { OK2Update = false; }

                QuickFix.Fields.SecurityExchange se = new QuickFix.Fields.SecurityExchange();
                if (message.IsSetField(se))
                {
                    SecEx = message.GetField(se).getValue();
                }
                else
                { OK2Update = false; }

                QuickFix.Fields.Symbol s = new QuickFix.Fields.Symbol();
                if (message.IsSetField(s))
                {
                    symbol = message.GetField(s).getValue();
                }
                else
                { OK2Update = false; }

                QuickFix.Fields.SecurityID sid = new QuickFix.Fields.SecurityID();
                if (message.IsSetField(sid))
                {
                    secID = message.GetField(sid).getValue();
                }
                else
                { OK2Update = false; }

                QuickFix.Fields.ExchangeGateway eg = new Fields.ExchangeGateway();
                if (message.IsSetField(eg))
                {
                    gateway = message.GetField(eg).getValue();
                }
                else
                { OK2Update = false; }

                QuickFix.Fields.LastShares q = new QuickFix.Fields.LastShares();
                if (message.IsSetField(q))
                {
                    tradesize = (int)message.GetField(q).getValue();
                }

                QuickFix.Fields.Side bs = new QuickFix.Fields.Side();
                if (message.IsSetField(bs))
                {
                    side = message.GetField(bs).getValue();
                }
                else
                {
                    if (tradesize < 0)
                    {
                        tradesize = Math.Abs(tradesize);
                        side = QuickFix.Fields.Side.SELL;
                    }
                    else
                    { side = QuickFix.Fields.Side.BUY; }
                }

                QuickFix.Fields.LastPx fill = new QuickFix.Fields.LastPx();
                if (message.IsSetField(fill))
                {
                    price = message.GetField(fill).getValue();
                }

                if (OK2Update)
                {
                                 //MGT, acct, SecEx, symbol, secID, tradesize, side, price, gateway
                    updatePosition(MGT, acct, SecEx, symbol, secID, tradesize, side, price, gateway);
                }
                else
                {
                    updateDisplay("Position not updated by following message");
                    ProcessMessage(message, session);
                }
            }
            catch (Exception ex)
            {
                updateDisplay("QuickFIX Error");
                log.WriteLog("MGT: " + MGT);
                log.WriteLog("acct: " + acct);
                log.WriteLog("SecEx: " + SecEx);
                log.WriteLog("symbol: " + symbol);
                log.WriteLog("secID: " + secID);
                log.WriteLog("tradesize: " + tradesize.ToString());
                log.WriteLog("side: " + side.ToString());
                log.WriteLog("price: " + price.ToString());
                log.WriteLog("gateway: " + gateway);

                log.WriteLog("Start Exception--------------------");
                log.WriteLog("Source: " + ex.Source);
                log.WriteLog("Message: " + ex.Message);
                log.WriteLog("TargetSite: " + ex.TargetSite);
                log.WriteLog("InnerException: " + ex.InnerException);
                log.WriteLog("HelpLink: " + ex.HelpLink);
                log.WriteLog("Data: " + ex.Data);
                log.WriteLog("StackTrace: " + ex.StackTrace);
                log.WriteLog("Stop Exception details-------------");

            }
        }
        /// <summary>
        /// Simply parse out message data on the mainForm ListBox control and into a LOG file
        /// </summary>
        /// <param name="message"></param>
        /// <param name="sessionID"></param>
        public void ProcessMessage(QuickFix.Message message, QuickFix.SessionID sessionID)
        {
            try
            {
                updateDisplay(string.Format("{0} {1}", DateTime.Now.ToString("hh:mm:ss.fff"), message.GetType().FullName));

                foreach (int i in message.FieldOrder)
                {
                    updateDisplay(string.Format("TAG: {0} = {1}", i, message.GetField(i) ));
                }

                if (message.IsSetField(QuickFix.Fields.Tags.NoGateways))
                { updateDisplay("NoGateways"); }

                if (message.IsSetField(QuickFix.Fields.Tags.NoGatewayStatus))
                { updateDisplay("NoGatewayStatus"); }

                if (message.IsSetField(QuickFix.Fields.Tags.NoMDEntries))
                { updateDisplay("NoMDEntries"); }

                if (message.IsSetField(QuickFix.Fields.Tags.NoMDEntryTypes))
                { updateDisplay("NoMDEntryTypes"); }

            }
            catch (Exception ex)
            {
                updateDisplay("QuickFIX Error");
                log.WriteLog(ex.ToString());
            }
        }
        //receive contract parameters
        public void OnMessage(QuickFix.FIX42.SecurityDefinition message, QuickFix.SessionID session)
        {
            //parseMessage(message, session);

            string SecEx = null;
            string symbol = null;
            string secID = null;

            try
            {
                QuickFix.Fields.SecurityExchange se = new QuickFix.Fields.SecurityExchange();
                if (message.IsSetField(se))
                { SecEx = message.GetField(se).ToString(); }

                QuickFix.Fields.Symbol s = new QuickFix.Fields.Symbol();
                if (message.IsSetField(s))
                { symbol = message.GetField(s).ToString(); }

                QuickFix.Fields.SecurityID sid = new QuickFix.Fields.SecurityID();
                if (message.IsSetField(sid))
                { secID = message.GetField(sid).ToString(); }

                string cur = null;
                decimal exPtVal = 0.00M;

                QuickFix.Fields.ExchPointValue epv = new QuickFix.Fields.ExchPointValue();
                if (message.IsSetField(epv))
                { exPtVal = message.GetField(epv).getValue(); }

                QuickFix.Fields.Currency ccy = new QuickFix.Fields.Currency();
                if (message.IsSetField(ccy))
                { cur = message.GetField(ccy).getValue(); }

                updateSecurity(SecEx, symbol, secID, cur, exPtVal);
            }
            catch (Exception ex)
            {
                updateDisplay("QuickFIX Error");
                log.WriteLog(ex.ToString());
            }
        }
        //Receive market data
        public void OnMessage(QuickFix.FIX42.MarketDataSnapshotFullRefresh message, SessionID session)
        {
            decimal _bidPrice = 0.00M;
            decimal _askPrice = 0.00M;

            try
            {
                QuickFix.Group noMDEntriesGrp = new QuickFix.FIX42.MarketDataSnapshotFullRefresh.NoMDEntriesGroup();

                for (int grpIndex = 1; grpIndex <= message.GetInt(QuickFix.Fields.Tags.NoMDEntries); grpIndex += 1)
                {
                    noMDEntriesGrp = message.GetGroup(grpIndex, QuickFix.Fields.Tags.NoMDEntries);

                    if (noMDEntriesGrp.IsSetField(QuickFix.Fields.Tags.BidPx))
                    {
                        _bidPrice = QuickFix.Fields.Converters.DecimalConverter.Convert(noMDEntriesGrp.GetField(QuickFix.Fields.Tags.BidPx));
                    }

                    if (noMDEntriesGrp.IsSetField(QuickFix.Fields.Tags.OfferPx))
                    {
                        _askPrice = QuickFix.Fields.Converters.DecimalConverter.Convert(noMDEntriesGrp.GetField(QuickFix.Fields.Tags.OfferPx));
                    }

                }

                string SecEx = null;
                string symbol = null;
                string secID = null;

                QuickFix.Fields.SecurityExchange se = new QuickFix.Fields.SecurityExchange();
                if (message.IsSetField(se))
                { SecEx = message.GetField(se).ToString(); }

                QuickFix.Fields.Symbol s = new QuickFix.Fields.Symbol();
                if (message.IsSetField(s))
                { symbol = message.GetField(s).ToString(); }

                QuickFix.Fields.SecurityID sid = new QuickFix.Fields.SecurityID();
                if (message.IsSetField(sid))
                { secID = message.GetField(sid).ToString(); }

                updatePrices(SecEx, symbol, secID, _bidPrice, _askPrice);
            }
            catch (Exception ex)
            {
                updateDisplay(string.Format("QuickFIX Error: {0}", System.Reflection.MethodBase.GetCurrentMethod().Name));
                log.WriteLog(string.Format("{0} : {1}", System.Reflection.MethodBase.GetCurrentMethod().Name, ex.ToString()));
            }
        }
        //receive fills, working orders, order rejects
        public void OnMessage(QuickFix.FIX42.ExecutionReport message, QuickFix.SessionID session)
        {
            //parseMessage(message, session);
            try
            {
                QuickFix.Fields.ExecType et = new QuickFix.Fields.ExecType();
                QuickFix.Fields.ExecTransType ett = new QuickFix.Fields.ExecTransType();
                QuickFix.Fields.ClOrdID coid = new QuickFix.Fields.ClOrdID();

                //Friday, December 11, 2009 10:29:27 AM Added parentheses to encapsulate OR
                //remove hold on orders if order was rejected
                if (message.IsSetField(coid) &&
                    (message.GetField(et).getValue() == QuickFix.Fields.ExecType.FILL ||
                    message.GetField(et).getValue() == QuickFix.Fields.ExecType.REJECTED))
                {
                    updateOrderMgmt(message.GetField(coid).getValue().ToString());
                }
                //end modified code

                if (message.IsSetField(et))
                {
                    //capture fill to update position
                    if ((message.GetField(et).getValue() == QuickFix.Fields.ExecType.FILL ||
                         message.GetField(et).getValue() == QuickFix.Fields.ExecType.PARTIAL_FILL) &&
                         message.MultiLegReportingType.getValue() != QuickFix.Fields.MultiLegReportingType.MULTI_LEG_SECURITY)
                    {
                        updateDisplay("execution received");
                        posTableUpdate(message, session);

                    }

                    //capture working orders and cancel for flatten
                    if (message.GetField(et).getValue() == QuickFix.Fields.ExecType.RESTATED &&
                        message.GetField(ett).getValue() == QuickFix.Fields.ExecTransType.STATUS)
                    {

                        string MGT = null;
                        QuickFix.Fields.SenderSubID subID = new QuickFix.Fields.SenderSubID();
                        if (message.Header.IsSetField(subID))
                        {
                            MGT = message.Header.GetField(subID).ToString();
                            orderCancel(MGT, message.OrderID.ToString());
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                updateDisplay("QuickFIX Error");
                log.WriteLog(ex.ToString());

            }
        }