コード例 #1
0
        public List <FutureQuotation> GetAllFutureQuotation()
        {
            using (var conn = QuotationPublisher.Publisher.GetNeedDisposedConnection())
            {
                if (conn == null)
                {
                    return(null);
                }

                string key = string.Format("{0}:{1}", futureQuotSource.ToFormatString(), QuotationDataType.Quotation.ToFormatString());

                var rtnBytes = (conn as RedisClient).HVals(key);
                if (rtnBytes == null)
                {
                    return(null);
                }

                List <FutureQuotation> rtn = new List <FutureQuotation>();
                foreach (var rtnByte in rtnBytes)
                {
                    FutureQuotation quotInfo = JsonSerializer.BytesToObject <FutureQuotation>(rtnByte);
                    rtn.Add(quotInfo);
                }
                return(rtn);
            }
        }
コード例 #2
0
        public void UpdateFutureQuotation(FutureQuotation quotInfo)
        {
            byte[] quotInfoBytes = JsonSerializer.ObjectToBytes <FutureQuotation>(quotInfo);
            string stkId         = quotInfo.stkId;
            string key           = string.Format("{0}:{1}", futureQuotSource.ToFormatString(), QuotationDataType.Quotation.ToFormatString());

            QuotationPublisher.Publisher.Update(key, stkId, quotInfoBytes);
        }
コード例 #3
0
 public void UpdateFutureQuotation(FutureQuotation quotInfo)
 {
     byte[] quotInfoBytes = JsonSerializer.ObjectToBytes<FutureQuotation>(quotInfo);
     string stkId = quotInfo.stkId;
     string key = string.Format("{0}:{1}", futureQuotSource.ToFormatString(), QuotationDataType.Quotation.ToFormatString());
     QuotationPublisher.Publisher.Update(key, stkId, quotInfoBytes);
 }
コード例 #4
0
 public void Enqueue(FutureQuotation quotInfo, bool isRealtimeQuotation, string clientId = null)
 {
     EnqueueData(quotInfo, isRealtimeQuotation, clientId);
 }
コード例 #5
0
 private void SetFutureQuotationProperty(FutureQuotation quotInfo, QuotV5.Binary.RealtimeStatus status)
 {
     quotInfo.stkId = status.Status.SecurityID;
 }
コード例 #6
0
        private void SetFutureQuotationProperty(FutureQuotation quotInfo, QuotV5.Binary.QuotSnapCommonInfo quotSnapCommonInfo)
        {
            quotInfo.stkId = quotSnapCommonInfo.SecurityID;

            quotInfo.stkStatus = null;
            if (!string.IsNullOrEmpty(quotSnapCommonInfo.TradingPhaseCode) && quotSnapCommonInfo.TradingPhaseCode.Length > 1)
            {
                string flag = quotSnapCommonInfo.TradingPhaseCode.Substring(1, 1);
                if (flag == "0")
                    quotInfo.stkStatus = "LIST";
                else if (flag == "1")
                    quotInfo.stkStatus = "PAUSE";
            }

            quotInfo.exchTotalKnockAmt = quotSnapCommonInfo.TotalValueTrade / 10000;
            quotInfo.exchTotalKnockQty = quotSnapCommonInfo.TotalVolumeTrade / 100;
               // quotInfo.preClosePrice = quotSnapCommonInfo.PrevClosePx;
            quotInfo.lastModifyTime = quotSnapCommonInfo.OrigTime;
        }
コード例 #7
0
        private void SetFutureQuotationProperty(FutureQuotation quotInfo, QuotV5.Binary.QuotSnap300111 quotSnap)
        {
            SetFutureQuotationProperty(quotInfo, quotSnap.CommonInfo);

            if (quotSnap.ExtInfo != null && quotSnap.ExtInfo.MDEntries != null && quotSnap.ExtInfo.MDEntries.Length > 0)
            {

                foreach (var mdEntry in quotSnap.ExtInfo.MDEntries)
                {
                    if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.BuyPrice)
                    {
                        if (mdEntry.Entry.MDPriceLevel == 1)
                        {
                            quotInfo.buy1 = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                            quotInfo.buyAmt1 = mdEntry.Entry.MDEntrySize/qtyTimes;
                        }
                        else if (mdEntry.Entry.MDPriceLevel == 2)
                        {
                            quotInfo.buy2 = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                            quotInfo.buyAmt2 = mdEntry.Entry.MDEntrySize / qtyTimes;
                        }
                        else if (mdEntry.Entry.MDPriceLevel == 3)
                        {
                            quotInfo.buy3 = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                            quotInfo.buyAmt3 = mdEntry.Entry.MDEntrySize / qtyTimes;
                        }
                        else if (mdEntry.Entry.MDPriceLevel == 4)
                        {
                            quotInfo.buy4 = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                            quotInfo.buyAmt4 = mdEntry.Entry.MDEntrySize / qtyTimes;
                        }
                        else if (mdEntry.Entry.MDPriceLevel == 5)
                        {
                            quotInfo.buy5 = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                            quotInfo.buyAmt5 = mdEntry.Entry.MDEntrySize / qtyTimes;
                        }

                    }
                    else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.SellPrice)
                    {
                        if (mdEntry.Entry.MDPriceLevel == 1)
                        {
                            quotInfo.sell1 = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                            quotInfo.sellAmt1 = mdEntry.Entry.MDEntrySize / qtyTimes;
                        }
                        else if (mdEntry.Entry.MDPriceLevel == 2)
                        {
                            quotInfo.sell2 = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                            quotInfo.sellAmt2 = mdEntry.Entry.MDEntrySize / qtyTimes;
                        }
                        else if (mdEntry.Entry.MDPriceLevel == 3)
                        {
                            quotInfo.sell3 = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                            quotInfo.sellAmt3 = mdEntry.Entry.MDEntrySize / qtyTimes;
                        }
                        else if (mdEntry.Entry.MDPriceLevel == 4)
                        {
                            quotInfo.sell4 = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                            quotInfo.sellAmt4 = mdEntry.Entry.MDEntrySize / qtyTimes;
                        }
                        else if (mdEntry.Entry.MDPriceLevel == 5)
                        {
                            quotInfo.sell5 = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                            quotInfo.sellAmt5 = mdEntry.Entry.MDEntrySize / qtyTimes;
                        }
                    }

                    else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.HighPrice)
                    {
                        quotInfo.highestPrice = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                    }
                    else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.KnockPrice)
                    {
                        quotInfo.newPrice = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                    }
                    else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.LowPrice)
                    {
                        quotInfo.lowestPrice = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                    }
                    else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.OpenPrice)
                    {
                        quotInfo.openPrice = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                    }
                    else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.MaxOrderPrice)
                    {
                        quotInfo.maxOrderPrice = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                    }
                    else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.MinOrderPrice)
                    {
                        quotInfo.minOrderPrice = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                    }
                    else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.SettlePrice)
                    {
                        quotInfo.settlementPrice = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                    }
                    else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.OpenPosition)
                    {
                        quotInfo.openPosition = (decimal)mdEntry.Entry.MDEntryPx / mdEntryPxTimes;
                    }
                    //else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.IOPV)
                    //{

                    //}
                    //else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.BuySummary)
                    //{

                    //}
                    //else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.SellSummary)
                    //{

                    //}

                    //else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.PriceEarningRatio1)
                    //{

                    //}
                    //else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.PriceEarningRatio2)
                    //{

                    //}
                    //else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.Diff1)
                    //{

                    //}
                    //else if (mdEntry.Entry.MDEntryType == QuotV5.Binary.QuotSnapExtInfo300111.MDEntryType.Diff2)
                    //{

                    //}

                }
            }
        }
コード例 #8
0
 private void SetFutureQuotationProperty(FutureQuotation quotInfo, QuotV5.StaticInfo.SecurityCloseMD securityCloseMD)
 {
     quotInfo.stkId = securityCloseMD.SecurityID;
     quotInfo.exchTotalKnockAmt = securityCloseMD.TotalValueTrade;
     quotInfo.exchTotalKnockQty = (Int64)securityCloseMD.TotalVolumeTrade;
     quotInfo.closePrice = securityCloseMD.ClosePx;
 }
コード例 #9
0
        private void SetFutureQuotationProperty(FutureQuotation quotInfo, QuotV5.StaticInfo.DerivativeAuctionParams derivativeAuctionParams)
        {
            quotInfo.stkId = derivativeAuctionParams.SecurityID;
            quotInfo.buyMaxLimitOrderQty = (int)derivativeAuctionParams.BuyQtyUpperLimit;
            quotInfo.sellMaxLimitOrderQty = (int)derivativeAuctionParams.SellQtyUpperLimit;
            quotInfo.buyMaxMarketOrderQty = quotInfo.buyMaxLimitOrderQty;
            quotInfo.sellMaxMarketOrderQty = quotInfo.sellMaxMarketOrderQty;

            quotInfo.orderPriceUnit = derivativeAuctionParams.PriceTick;
            quotInfo.maxOrderPrice = derivativeAuctionParams.RisePrice;
            quotInfo.minOrderPrice = derivativeAuctionParams.FallPrice;
            quotInfo.marketMakerFlag = derivativeAuctionParams.MarketMakerFlag;
            quotInfo.currMargin = derivativeAuctionParams.SellMargin;
            quotInfo.minBuyQtyTimes = (int)derivativeAuctionParams.BuyQtyUnit;
            quotInfo.minSellQtyTimes = (int)derivativeAuctionParams.SellQtyUnit;
            quotInfo.preCurrMargin = derivativeAuctionParams.LastSellMargin;
            quotInfo.marketMakerFlag = derivativeAuctionParams.MarketMakerFlag;
        }
コード例 #10
0
        private void SetFutureQuotationProperty(FutureQuotation quotInfo, QuotV5.StaticInfo.OptionSecuirtyInfo securityInfo)
        {
            quotInfo.stkId = securityInfo.CommonInfo.SecurityID;
            quotInfo.stkName = securityInfo.CommonInfo.Symbol;
            quotInfo.preClosePrice = securityInfo.CommonInfo.PrevClosePx;
            quotInfo.basicExchId = null;
            quotInfo.basicStkId = securityInfo.CommonInfo.UnderlyingSecurityID;
            quotInfo.contractTimes = (int)securityInfo.Params.ContractUnit;
            Date lastTradeDay = Date.FromYMMDD(securityInfo.Params.LastTradeDay);
            DateTime lastTradeDate = lastTradeDay.ToDateTime();
            quotInfo.deliveryYear = lastTradeDay.Year;
            quotInfo.deliveryMonth = lastTradeDay.Month;
            quotInfo.listDate = securityInfo.CommonInfo.ListDate;
            quotInfo.firstTrdDate = quotInfo.listDate;
            quotInfo.lastTrdDate = securityInfo.Params.LastTradeDay;
            quotInfo.matureDate = securityInfo.Params.LastTradeDay;
            quotInfo.lastSettleDate = securityInfo.Params.LastTradeDay;

            quotInfo.preSettlementPrice = securityInfo.Params.PrevClearingPrice;
            quotInfo.preClosePrice = securityInfo.CommonInfo.PrevClosePx;
            quotInfo.strikePrice = securityInfo.Params.ExercisePrice;
            quotInfo.optionType = securityInfo.Params.CallOrPut;
            quotInfo.exerciseDate = securityInfo.Params.ExerciseBeginDate;
            quotInfo.adjustedFlag = securityInfo.Params.Adjusted;
            quotInfo.adjustNum = securityInfo.Params.AdjuestTimes;

            quotInfo.isinCode = securityInfo.CommonInfo.ISIN;

            if (securityInfo.CommonInfo.SecurityType == QuotV5.StaticInfo.SecurityType.股票期权)
            {
                quotInfo.F_productId= "SO";
            }
            else
            {
                quotInfo.F_productId = "EO";
            }
        }
コード例 #11
0
        private void ProcessStaticInfo(QuotV5.StaticInfo.DerivativeAuctionParams securityInfo)
        {
            RawStaticInfoSnap.DerivativeAuctionParams[securityInfo.SecurityID] = securityInfo;
            FutureQuotation preQuotInfo = null;
            FutureQuotation newQuotInfo = null;

            if (ProcessedDataSnap.FutureQuotation.TryGetValue(securityInfo.SecurityID, out preQuotInfo))
            {
                newQuotInfo = preQuotInfo.Clone();
                SetFutureQuotationProperty(newQuotInfo, securityInfo);
            }
            else
            {
                newQuotInfo = new FutureQuotation();
                SetFutureQuotationProperty(newQuotInfo, securityInfo);
            }

            if (newQuotInfo != null)
            {
                ProcessedDataSnap.FutureQuotation[newQuotInfo.stkId] = newQuotInfo;
                quotRepository.UpdateFutureQuotation(newQuotInfo);

            }
        }
コード例 #12
0
        private void ProcessStaticInfo(QuotV5.StaticInfo.SecurityInfoBase securityInfo)
        {
            RawStaticInfoSnap.SecurityInfo[securityInfo.CommonInfo.SecurityID] = securityInfo;

            if (securityInfo is QuotV5.StaticInfo.OptionSecuirtyInfo)
            {
                QuotV5.StaticInfo.OptionSecuirtyInfo optionSecurityInfo = securityInfo as QuotV5.StaticInfo.OptionSecuirtyInfo;
                FutureQuotation preFutureQuotation = null;
                FutureQuotation newFutureQuotation = null;
                if (ProcessedDataSnap.FutureQuotation.TryGetValue(securityInfo.CommonInfo.SecurityID, out preFutureQuotation))
                {
                    newFutureQuotation = preFutureQuotation.Clone();
                    SetFutureQuotationProperty(newFutureQuotation, optionSecurityInfo);
                }
                else
                {
                    newFutureQuotation = new FutureQuotation();
                    SetFutureQuotationProperty(newFutureQuotation, optionSecurityInfo);
                }

                if (newFutureQuotation != null)
                {
                    ProcessedDataSnap.FutureQuotation[newFutureQuotation.stkId] = newFutureQuotation;
                    quotRepository.UpdateFutureQuotation(newFutureQuotation);

                }
            }
            else
            {

                StockInfo preStockInfo = null;
                StockInfo newStockInfo = null;

                if (ProcessedDataSnap.StockInfo.TryGetValue(securityInfo.CommonInfo.SecurityID, out preStockInfo))
                {
                    newStockInfo = preStockInfo.Clone();
                    SetStockInfoProperty(newStockInfo, securityInfo);
                }
                else
                {
                    newStockInfo = new StockInfo();
                    SetStockInfoProperty(newStockInfo, securityInfo);
                }

                if (newStockInfo != null)
                {
                    ProcessedDataSnap.StockInfo[newStockInfo.stkId] = newStockInfo;
                    quotRepository.UpdateBasicInfo(newStockInfo);

                }
            }
        }
コード例 #13
0
        private void ProcessMarketData(QuotV5.Binary.QuotSnap300111 quotSnap, DateTime receiveTime)
        {
            RawQuotationInfoSnap.QuotSnap300111[quotSnap.CommonInfo.SecurityID] = quotSnap;
            if (quotSnap.CommonInfo.MDStreamID == QuotV5.Binary.QuotSnap300111.MDStreamID.Option)
            {
                FutureQuotation preQuotInfo = null;
                FutureQuotation newQuotInfo = null;
                if (ProcessedDataSnap.FutureQuotation.TryGetValue(quotSnap.CommonInfo.SecurityID, out preQuotInfo))
                {
                    newQuotInfo = preQuotInfo.Clone();
                    QuotV5.StaticInfo.SecurityInfoBase securityInfo = null;
                    if (RawStaticInfoSnap.SecurityInfo.TryGetValue(quotSnap.CommonInfo.SecurityID, out securityInfo))
                        SetFutureQuotationProperty(newQuotInfo, securityInfo as QuotV5.StaticInfo.OptionSecuirtyInfo);

                    SetFutureQuotationProperty(newQuotInfo, quotSnap);
                }
                else
                {
                    newQuotInfo = new FutureQuotation();

                    QuotV5.StaticInfo.SecurityInfoBase securityInfo = null;
                    if (RawStaticInfoSnap.SecurityInfo.TryGetValue(quotSnap.CommonInfo.SecurityID, out securityInfo))
                        SetFutureQuotationProperty(newQuotInfo, securityInfo as QuotV5.StaticInfo.OptionSecuirtyInfo);

                    QuotV5.Binary.RealtimeStatus status = null;
                    if (RawQuotationInfoSnap.RealtimeStatus.TryGetValue(quotSnap.CommonInfo.SecurityID, out status))
                        SetFutureQuotationProperty(newQuotInfo, status);

                    SetFutureQuotationProperty(newQuotInfo, quotSnap);
                }
                if (newQuotInfo != null)
                {

                    ProcessedDataSnap.FutureQuotation[newQuotInfo.stkId] = newQuotInfo;
                    quotRepository.UpdateFutureQuotation(newQuotInfo);
                    if (quotPublisher != null)
                        quotPublisher.Enqueue(newQuotInfo, true);
                }

            }
            else
            {
                StockQuotation preQuotInfo = null;
                StockQuotation newQuotInfo = null;
                if (ProcessedDataSnap.StockQuotation.TryGetValue(quotSnap.CommonInfo.SecurityID, out preQuotInfo))
                {
                    newQuotInfo = preQuotInfo.Clone();
                    QuotV5.StaticInfo.SecurityInfoBase securityInfo = null;
                    if (RawStaticInfoSnap.SecurityInfo.TryGetValue(quotSnap.CommonInfo.SecurityID, out securityInfo))
                        SetStockQuotationProperty(newQuotInfo, securityInfo);

                    SetStockQuotationProperty(newQuotInfo, quotSnap);
                }
                else
                {
                    newQuotInfo = new StockQuotation();

                    QuotV5.StaticInfo.SecurityInfoBase securityInfo = null;
                    if (RawStaticInfoSnap.SecurityInfo.TryGetValue(quotSnap.CommonInfo.SecurityID, out securityInfo))
                        SetStockQuotationProperty(newQuotInfo, securityInfo);

                    QuotV5.Binary.RealtimeStatus status = null;
                    if (RawQuotationInfoSnap.RealtimeStatus.TryGetValue(quotSnap.CommonInfo.SecurityID, out status))
                        SetStockQuotationProperty(newQuotInfo, status);

                    SetStockQuotationProperty(newQuotInfo, quotSnap);
                }
                if (newQuotInfo != null)
                {
                    newQuotInfo.receiveTime = DatetimeToLong(receiveTime);
                    ProcessedDataSnap.StockQuotation[newQuotInfo.stkId] = newQuotInfo;
                    quotRepository.UpdateStockQuotation(newQuotInfo);
                    if (quotPublisher != null)
                        quotPublisher.Enqueue(newQuotInfo, true);
                }
            }
        }