public void ApplyDOMUpdate(IProduct product, KaiTrade.Interfaces.IPXUpdate update)
        {
            try
            {

                KaiTrade.Interfaces.IDOM dom = _mnemonicDOM[product.Mnemonic];
                if (dom == null)
                {
                    // must have a least a price
                    decimal? initPx = null;
                    if (update.BidPrice.HasValue)
                    {
                        initPx = update.BidPrice;
                    }
                    else if (update.OfferPrice.HasValue)
                    {
                        initPx = update.OfferPrice;
                    }
                    else if (update.TradePrice.HasValue)
                    {
                        initPx = update.TradePrice;
                    }
                    if (initPx.HasValue)
                    {
                        dom = GetProductDOM(product, initPx.Value);

                    }
                }
                dom.Update(update);

            }
            catch
            {
            }
        }

 public void SetRangeType(KaiTrade.Interfaces.TSRangeType rangeType)
 {
     foreach (TSQueryGroupTSDataSet dataSet in TsQueryGroup.TSDataSet)
     {
         dataSet.RangeType = (byte) rangeType;
     }
 }

        public CancelRequestData(crrType type, KaiTrade.Interfaces.ICancelOrderRequest cancelRequest)
        {
            _cancelRequest = cancelRequest;
            if(_cancelRequest == null)
            {
                Exception myE = new Exception("a non null cancel request must be supplied");
                throw myE;
            }

            Mnemonic = cancelRequest.Mnemonic;

            _lastChangeTicks = DateTime.Now.Ticks;

            if(_cancelRequest.ClOrdID.Length == 0 )
            {
                Exception myE = new Exception("a clordid must be specified on a cancelOrder");
                throw myE;
            }
            if (_cancelRequest.OrigClOrdID.Length == 0)
            {
                Exception myE = new Exception("a original clordid must be specified on a cancelOrder");
                throw myE;
            }
            ClOrdID = cancelRequest.ClOrdID;
            OrigClOrdID = cancelRequest.OrigClOrdID;
            CRRType = crrType.cancel;
        }

        public void UpdateVenue(KaiTrade.Interfaces.IVenue myVenue)
        {
            try
                {
                    using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
                    {
                        var venue = db.Venues.Where(s => s.Name == myVenue.Name).FirstOrDefault();
                        venue.AccountNumber = myVenue.AccountNumber;
                        venue.Code = myVenue.Code;
                        venue.DataFeedVenue = myVenue.DataFeedVenue;
                        venue.DefaultCFICode = myVenue.DefaultCFICode;
                        venue.DefaultCurrencyCode = myVenue.DefaultCurrencyCode;
                        venue.DefaultSecurityExchange = myVenue.DefaultSecurityExchange;
                        venue.DriverCode = myVenue.DriverCode;
                        venue.TargetVenue = myVenue.TargetVenue;
                        venue.UseSymbol = myVenue.UseSymbol;

                        db.SubmitChanges();
                    }

                }
                catch (Exception myE)
                {

                    m_Log.Error("Update Venue", myE);
                }
        }

 /// <summary>
 /// Gets the curve values contained in a TSItem
 /// </summary>
 /// <returns>
 /// The curve value.
 /// </returns>
 /// <param name='tsItem'>
 /// Ts item.
 /// </param>
 public static K2DataObjects.CurveValue[] GetCurveValue(KaiTrade.Interfaces.ITSItem tsItem)
 {
     if (tsItem.CurveValues.Length > 0)
     {
         K2DataObjects.CurveValue[] curveVals = new K2DataObjects.CurveValue[tsItem.CurveValues.Length];
         int i = 0;
         foreach (var parm in tsItem.CurveValues)
         {
             try
             {
                 K2DataObjects.CurveValue cv = new K2DataObjects.CurveValue();
                 cv.Mnemonic = tsItem.Mnemonic;
                 cv.HeaderID = parm.ParameterName;
                 cv.TimeStamp = tsItem.TimeStamp.Ticks;
                 cv.ItemType = (int)tsItem.ItemType;
                 cv.ItemSize = 1;
                 cv.RequestID = "1";
                 cv.Value = decimal.Parse(parm.ParameterValue);
                 curveVals[i++] = cv;
             }
             catch (Exception ex)
             {
             }
         }
         return curveVals;
     }
     return null;
 }

 public void PriceUpdate(KaiTrade.Interfaces.IPXUpdate pxUpdate)
 {
     if (_priceHandler != null)
     {
         _priceHandler.ApplyPriceUpdate(pxUpdate);
     }
 }

 public void ProductUpdate(string updateType, KaiTrade.Interfaces.IProduct product)
 {
     if (product != null)
     {
         string jsonData = JsonConvert.SerializeObject(product);
         rmqHelper.Publish("", product);
     }
 }

 public void OnBarUpdate(string requestID, KaiTrade.Interfaces.ITSItem[] bars)
 {
     if (bars.Length > 0)
     {
         //rmqHelper.Publish("IBM", tsi);
         rmqPub.Publish("", bars);
     }
 }

 private void addProductPriceFile(string filepath, KaiTrade.Interfaces.IProduct prod, int interval, bool runRealTime, bool repeatOnEnd, bool playOnSubscribe)
 {
     try
     {
         m_Simulator.AddPriceFile(prod.Mnemonic, filepath, interval, runRealTime, repeatOnEnd, playOnSubscribe);
     }
     catch (Exception myE)
     {
     }
 }

 /// <summary>
 /// Add/replace a publisher to the manager
 /// </summary>
 /// <param name="myPub"></param>
 public void Add(KaiTrade.Interfaces.Publisher myPub)
 {
     if(m_PublisherMap.ContainsKey(myPub.TopicID()))
     {
         m_PublisherMap[myPub.TopicID()] = myPub;
     }
     else
     {
         m_PublisherMap.Add(myPub.TopicID(), myPub);
     }
 }

        /// <summary>
        /// Get a trade given the order
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        public KaiTrade.Interfaces.ITrade GetTrade(KaiTrade.Interfaces.IOrder o)
        {
            K2DS.K2TradeDS tradeDS = new K2DS.K2TradeDS();
            IEnumerable<K2DataObjects.Trade> trades = tradeDS.GetTrade((o as K2DataObjects.Order));

            foreach(K2DataObjects.Trade t in trades)
            {
                return t;
            }
            return null;
        }

 public void InsertFill(KaiTrade.Interfaces.IFill f)
 {
     try
     {
         K2DS.K2TradeDS tradeDS = new K2DS.K2TradeDS();
         tradeDS.InsertFill(f as K2DataObjects.Fill,true);
     }
     catch (Exception myE)
     {
     }
 }

 public void InsertOrder(KaiTrade.Interfaces.IOrder o)
 {
     try
     {
         K2DS.K2OrderDS orderDS = new K2DS.K2OrderDS();
         orderDS.InsertOrder(o as K2DataObjects.Order, true);
     }
     catch (Exception myE)
     {
         m_Log.Error("InsertOrder", myE);
     }
 }

 private void recordMessage(KaiTrade.Interfaces.IMessage message)
 {
     if (_messages == null)
     {
         _messages = new Dictionary<string, List<KaiTrade.Interfaces.IMessage>>();
     }
     if (!_messages.ContainsKey(message.Label))
     {
         _messages.Add(message.Label, new List<KaiTrade.Interfaces.IMessage>());
     }
     _messages[message.Label].Add(message);
 }

 public PXUpdateBase(KaiTrade.Interfaces.IProduct myProduct)
 {
     try
     {
         m_DataArray = new decimal?[KaiTrade.Interfaces.PXFields.MAXPXFIELDS];
         throw new Exception("Not Implimemnted");
         //this.From(myProduct.Mnemonic, myProduct.L1PX);
     }
     catch
     {
     }
 }

        public void Publish(string routingKey, KaiTrade.Interfaces.ITSItem[] tsBars)
        {
            try
            {
                routingKey = KaiTrade.Interfaces.MQRoutingKeyPrefix.TSBAR + routingKey;
                string jsonData = Newtonsoft.Json.JsonConvert.SerializeObject(tsBars);
                byte[] messageBody = Encoding.UTF8.GetBytes(jsonData);
                Publish(KaiTrade.Interfaces.MQExchanges.DEFAULT, KaiTrade.Interfaces.MQType.TSBAR, routingKey, messageBody);

            }
            catch (Exception myE)
            {
            }
        }

        /// <summary>
        /// Reject a cancel request
        /// </summary>
        /// <param name="myReq"></param>
        public static string DoRejectModReq(KaiTrade.Interfaces.IModifyOrderRequst mod, string orderID, KaiTrade.Interfaces.CxlRejReason myReason, string myReasonText)
        {
            KaiTrade.Interfaces.IRequestCancelRejectResponse cxl = new K2DataObjects.RequestCancelRejectResponse();
            cxl.OrderID = orderID;
            cxl.ClOrdID = mod.ClOrdID;
            cxl.OrdStatus = KaiTrade.Interfaces.OrderStatus.REJECTED;
            cxl.OrigClOrdID = mod.OrigClOrdID;
            cxl.CxlRejResponseTo = KaiTrade.Interfaces.CxlRejResponseTo.Modify;
            cxl.ReasonText = myReasonText;
            cxl.TransactTime = DateTime.Now;
            cxl.CxlRejReason = myReason;

            // send our response message back to the clients of the adapter
            return JsonConvert.SerializeObject(cxl);
        }

        public void AddVenue(KaiTrade.Interfaces.IVenue myVenue)
        {
            try
                {
                    using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
                    {
                        var venue = (K2DataObjects.TradeVenue)myVenue;
                        db.Venues.InsertOnSubmit(venue);

                        db.SubmitChanges();
                    }
                }
                catch (Exception myE)
                {

                    m_Log.Error("Add Venue", myE);
                }
        }

 /// <summary>
 /// Gets the price bar from a ITSItem, TSItem is data returned from a driver
 /// that connects to the prices source CQG, IB,  etc
 /// </summary>
 /// <returns>
 /// The price bar.
 /// </returns>
 /// <param name='tsItem'>
 /// Ts item.
 /// </param>
 public static K2DataObjects.PriceBar GetPriceBar(KaiTrade.Interfaces.ITSItem tsItem)
 {
     K2DataObjects.PriceBar bar = new K2DataObjects.PriceBar();
     bar.High = (decimal) tsItem.High;
     bar.AskVolume = (decimal)tsItem.AskVolume;
     bar.Avg = (decimal)tsItem.Avg;
     bar.BidVolume = (decimal)tsItem.BidVolume;
     bar.Close = (decimal)tsItem.Close;
     bar.Low = (decimal)tsItem.Low;
     bar.Mnemonic = tsItem.Mnemonic;
     bar.Open = (decimal)tsItem.Open;
     bar.Volume = (decimal)tsItem.Volume;
     bar.TimeStamp = tsItem.TimeStamp.Ticks;
     bar.ItemType = (int)tsItem.ItemType;
     bar.ItemSize = 1;
     bar.RequestID = "1";
     return bar;
 }

        public void DeleteVenue(KaiTrade.Interfaces.IVenue myVenue)
        {
            try
                {
                    using (K2DataObjects.DataContext db = Factory.Instance().GetDSContext())
                    {
                        var venue = db.Venues.Where(s => s.Name == myVenue.Name).FirstOrDefault();
                        db.Venues.DeleteOnSubmit(venue);
                        db.SubmitChanges();
                    }

                }
                catch (Exception myE)
                {

                    m_Log.Error("Delete Venue", myE);
                }
        }