示例#1
0
        public static String InsertData_dom(String tableName, CQGInstrument instrument, int depth, uint groupID, bool isNew, string userName, out double askPrice, out int askVol, out double bidPrice, out int bidVol, DateTime serverTime)
        {
            var newTable = "DM_" + tableName.Substring(3, tableName.Length - 3).ToUpper();

            String symbol = instrument.FullName;
            String query  = "INSERT IGNORE INTO `" + newTable + "`";

            query += "(`Symbol`,`Depth`,`DOMBid`,`DOMAsk`,`DOMBidVol`,`DOMAskVol`,`Trade`,`TradeVol`,`Time`, `TimeLocal`,GroupID, UserName)";
            String runQuery      = "";
            int    balancedDepth = (instrument.DOMAsks.Count < instrument.DOMBids.Count)
                                    ? instrument.DOMAsks.Count
                                    : instrument.DOMBids.Count;

            askPrice = 0;
            askVol   = 0;
            bidPrice = 0;
            bidVol   = 0;
            for (int index = 0; ((index < balancedDepth) && (index < depth)); index++)
            {
                //query += "(`symbol`,`depth`,`DOMBid`,`DOMAsk`,`DOMBidVol`,`DOMAskVol`,`Trade`,`TradeVol`,`ts`)";
                CQGQuote domAsk = instrument.DOMAsks[index];
                CQGQuote domBid = instrument.DOMBids[index];

                runQuery += query + " VALUES('" + symbol + "'," + Convert.ToString(index + 1) + ",";
                runQuery += domBid.Price.ToString("G", CultureInfo.InvariantCulture) + ",";
                runQuery += domAsk.Price.ToString("G", CultureInfo.InvariantCulture) + ",";
                runQuery += domBid.Volume.ToString("G", CultureInfo.InvariantCulture) + ",";
                runQuery += domAsk.Volume.ToString("G", CultureInfo.InvariantCulture) + ",";
                runQuery += instrument.Trade.Price.ToString("G", CultureInfo.InvariantCulture) + ",";
                runQuery += instrument.Trade.Volume.ToString("G", CultureInfo.InvariantCulture) + ",";
                runQuery += "'" + serverTime.ToString("yyyy/MM/dd H:mm:ss.fff", CultureInfo.InvariantCulture) + "',";
                runQuery += "'" + DateTime.Now.ToString("yyyy/MM/dd H:mm:ss.fff", CultureInfo.InvariantCulture) + "',";
                runQuery += Convert.ToString(groupID) + ",";
                runQuery += "'" + userName + "');";

                if (index == 0)
                {
                    askPrice = domAsk.Price;
                    askVol   = domAsk.Volume;
                    bidPrice = domBid.Price;
                    bidVol   = domBid.Volume;
                }
            }
            //instrument.
            return(runQuery);
        }
示例#2
0
        private void CQG_InstrumentChanged(CQGInstrument instrument, CQGQuotes quotes,
                                           CQGInstrumentProperties instrumentProperties)
        {
            if (!_tickTable.ContainsKey(instrument.FullName))
            {
                return;
            }

            lock (_waitingLocker)
            {
                if (_subscribedSymbols.Exists(oo => oo == instrument.FullName))
                {
                    _subscribedSymbols.Remove(instrument.FullName);
                    if (SymbolSubscribed != null)
                    {
                        SymbolSubscribed(new List <string> {
                            instrument.FullName
                        }, GetDepthForSymbol(instrument.FullName));
                    }
                }

                var tickData = _tickTable[instrument.FullName];

                if (!tickData.IsCanceled)
                {
                    tickData.TickCount = 0;
                    foreach (CQGQuote item in quotes)
                    {
                        CQGQuote tick = item;

                        tickData.IsNewTrade = tick.Name == "Trade";
                        switch (tick.Name)
                        {
                        case "Ask":
                        {
                            tickData.AskPrice    = tick.Price;
                            tickData.AskVolume   = tick.Volume;
                            tickData.TradePrice  = 0;
                            tickData.TradeVolume = 0;
                            break;
                        }

                        case "Bid":
                        {
                            tickData.BidPrice    = tick.Price;
                            tickData.BidVolume   = tick.Volume;
                            tickData.TradePrice  = 0;
                            tickData.TradeVolume = 0;
                            break;
                        }

                        case "Trade":
                        {
                            tickData.TradePrice  = tick.Price;
                            tickData.TradeVolume = tick.Volume;
                            break;
                        }
                        }
                        tickData.TickCount++;
                    }

                    if (tickData.TickCount > 0)
                    {
                        var quoteList = (from CQGQuote item in quotes
                                         where item.Name == "Ask" ||
                                         item.Name == "Bid" ||
                                         item.Name == "Trade"
                                         select item).ToList();
                        quoteList.OrderBy(quote => quote.ServerTimestamp);
                        if (quoteList.Any())
                        {
                            tickData.Timestamp = quoteList.Last().ServerTimestamp;
                            tickData.TickType  = quoteList.Last().Name;
                        }
                        else
                        {
                            tickData.Timestamp = instrument.ServerTimestamp;
                        }

                        if (tickData.Timestamp < DateTime.Now.AddDays(-1))
                        {
                            return;
                        }
                        if (_onSymbolsList.Contains(instrument.FullName))
                        {
                            //DatabaseManager.AddToBuffer(query, false, tickData);
                            if (_allowedSymbols.ContainsKey(tickData.SymbolName) ||
                                !DatabaseManager.CurrentDbIsShared)
                            {
                                if (DatabaseManager.CurrentDbIsShared && tickData.Timestamp < _allowedSymbols[tickData.SymbolName])
                                {
                                    return;
                                }
                                DatabaseManager.InsertTickts(tickData.TableName, tickData.SymbolName,
                                                             tickData.BidPrice,
                                                             tickData.BidVolume,
                                                             tickData.AskPrice, tickData.AskVolume,
                                                             tickData.TradePrice,
                                                             tickData.TradeVolume,
                                                             tickData.IsNewTrade, tickData.Timestamp,
                                                             ++tickData.GroupID,
                                                             _userName, tickData.TickType);
                            }
                        }
                    }
                }
                else
                {
                    RemoveSymbol(instrument.FullName);
                    return;
                }
                _tickTable[instrument.FullName] = tickData;
            }
        }
示例#3
0
        /// <summary>
        /// publish a quote for the given mnemonic
        /// </summary>
        /// <param name="myMnemonic">mnemonic/subject key</param>
        /// <param name="instrument">CQG instrument that has changed</param>
        private void publishTradeUpdate(string myMnemonic, CQGInstrument instrument, CQGQuote quote)
        {
            try
            {
                L1PriceSupport.PXUpdateBase pxupdate = new L1PriceSupport.PXUpdateBase(m_ID);
                pxupdate.Mnemonic = myMnemonic;
                pxupdate.DriverTag = "T";
                pxupdate.UpdateType = KaiTrade.Interfaces.PXUpdateType.trade;
                if (instrument.Bid.IsValid)
                {
                    pxupdate.BidSize = instrument.Bid.Volume;
                    pxupdate.BidPrice = (decimal)instrument.Bid.Price;
                    pxupdate.Ticks = instrument.Bid.ServerTimestamp.Ticks;
                }
                if (instrument.Ask.IsValid)
                {
                    pxupdate.OfferSize = instrument.Ask.Volume;
                    pxupdate.OfferPrice = (decimal)instrument.Ask.Price;
                    pxupdate.Ticks = instrument.Ask.ServerTimestamp.Ticks;
                }

                pxupdate.TradePrice = (decimal)quote.Price;
                pxupdate.ServerTicks = quote.ServerTimestamp.Ticks;

                if (quote.HasVolume)
                {
                    pxupdate.TradeVolume = quote.Volume;
                }

                ApplyPriceUpdate(pxupdate);
            }
            catch (Exception myE)
            {
                log.Error("publishTradeUpdate", myE);
            }
        }
示例#4
0
        static void Cel_InstrumentChanged(CQGInstrument instrument, CQGQuotes quotes, CQGInstrumentProperties cqg_instrument_properties)
        {
            var symbolData = _symbolsInProgress.Find(oo => oo.Name == instrument.FullName);

            if (symbolData == null)
            {
                return;
            }


            lock (_waitingLocker)
            {
                var tickData = symbolData.TickData;

                tickData.TickCount = 0;
                foreach (CQGQuote item in quotes)
                {
                    CQGQuote tick = item;

                    tickData.IsNewTrade = tick.Name == "Trade";
                    switch (tick.Name)
                    {
                    case "Ask":
                    {
                        tickData.AskPrice    = tick.Price;
                        tickData.AskVolume   = tick.Volume;
                        tickData.TradePrice  = 0;
                        tickData.TradeVolume = 0;
                        break;
                    }

                    case "Bid":
                    {
                        tickData.BidPrice    = tick.Price;
                        tickData.BidVolume   = tick.Volume;
                        tickData.TradePrice  = 0;
                        tickData.TradeVolume = 0;
                        break;
                    }

                    case "Trade":
                    {
                        tickData.TradePrice  = tick.Price;
                        tickData.TradeVolume = tick.Volume;
                        break;
                    }
                    }
                    tickData.TickCount++;
                }

                if (tickData.TickCount > 0)
                {
                    var quoteList = (from CQGQuote item in quotes
                                     where item.Name == "Ask" ||
                                     item.Name == "Bid" ||
                                     item.Name == "Trade"
                                     select item).ToList();
                    quoteList.OrderBy(quote => quote.ServerTimestamp);
                    if (quoteList.Any())
                    {
                        tickData.Timestamp = quoteList.Last().ServerTimestamp;
                        tickData.TickType  = quoteList.Last().Name;
                    }
                    else
                    {
                        tickData.Timestamp = instrument.ServerTimestamp;
                    }
                    var query = QueryBuilder.InsertData(tickData.TableName, tickData.SymbolName,
                                                        tickData.BidPrice,
                                                        tickData.BidVolume,
                                                        tickData.AskPrice, tickData.AskVolume,
                                                        tickData.TradePrice,
                                                        tickData.TradeVolume,
                                                        tickData.IsNewTrade, tickData.Timestamp,
                                                        ++tickData.GroupID,
                                                        _userName, tickData.TickType);
                    if (tickData.Timestamp < DateTime.Now.AddDays(-1))
                    {
                        return;
                    }

                    ClientDatabaseManager.AddToBuffer(query, false, tickData);
                    if (!ClientDatabaseManager.CurrentDbIsShared || symbolData.CanInsert)
                    {
                        //todo if (DatabaseManager.CurrentDbIsShared && tickData.Timestamp < _allowedSymbols[tickData.SymbolName])return;
                        ClientDatabaseManager.RunSQLLive(query, "InsertData", instrument.FullName);
                    }
                }

                symbolData.TickData = tickData;
            }
        }