Esempio n. 1
0
        /// <summary>
        /// Save settings.
        /// </summary>
        /// <param name="storage">Settings storage.</param>
        public override void Save(SettingsStorage storage)
        {
            base.Save(storage);

            storage.SetValue("Level1Address", Level1Address.To <string>());
            storage.SetValue("Level2Address", Level2Address.To <string>());
            storage.SetValue("LookupAddress", LookupAddress.To <string>());
            storage.SetValue("AdminAddress", AdminAddress.To <string>());
            storage.SetValue("DerivativeAddress", DerivativeAddress.To <string>());

            storage.SetValue("IsDownloadSecurityFromSite", IsDownloadSecurityFromSite);
            storage.SetValue("SecuritiesFile", SecuritiesFile);

            storage.SetValue("SecurityTypesFilter", SecurityTypesFilter.Select(t => t.To <string>()).Join(","));
            storage.SetValue("Level1Columns", Level1Columns.Select(c => c.Name).Join(","));
        }
        private IEnumerable <Message> ToSecurityUpdateMessage(string value)
        {
            var parts = value.SplitByComma();

            var index = 0;

            var secCode    = parts[index++];
            var exchangeId = int.Parse(parts[index++], NumberStyles.HexNumber);
            var tradeBoard = parts[index++].To <int?>();
            var bidBoard   = parts[index++].To <int?>();
            var askBoard   = parts[index++].To <int?>();

            var l1Messages = new[] { exchangeId, tradeBoard, bidBoard, askBoard }
            .Where(id => id != null)
            .Select(id => id.Value)
            .Distinct()
            .ToDictionary(boardId => boardId, boardId => new Level1ChangeMessage
            {
                SecurityId = CreateSecurityId(secCode, boardId)
            });

            DateTime?lastTradeDate   = null;
            TimeSpan?lastTradeTime   = null;
            decimal? lastTradePrice  = null;
            decimal? lastTradeVolume = null;
            long?    lastTradeId     = null;

            var types = new HashSet <Level1Fields>(Enumerator.GetValues <Level1Fields>());
            var messageContentsIndex = Level1Columns.IndexOf(Level1ColumnRegistry.MessageContents);

            if (messageContentsIndex != -1)
            {
                types.Exclude(parts[messageContentsIndex + index]);
            }

            if (tradeBoard == null)
            {
                types.Remove(Level1Fields.LastTradeId);
                types.Remove(Level1Fields.LastTradeTime);
                types.Remove(Level1Fields.LastTradePrice);
                types.Remove(Level1Fields.LastTradeVolume);
            }

            if (bidBoard == null)
            {
                types.Remove(Level1Fields.BestBidTime);
                types.Remove(Level1Fields.BestBidPrice);
                types.Remove(Level1Fields.BestBidVolume);
            }

            if (askBoard == null)
            {
                types.Remove(Level1Fields.BestAskTime);
                types.Remove(Level1Fields.BestAskPrice);
                types.Remove(Level1Fields.BestAskVolume);
            }

            foreach (var column in Level1Columns)
            {
                var colValue = parts[index++];

                if (colValue.IsEmpty())
                {
                    continue;
                }

                //colValue = colValue.To(column.Type);

                switch (column.Field)
                {
                case IQFeedLevel1Column.DefaultField:
                {
                    var typedColValue = column.Convert(colValue);

                    if (typedColValue != null)
                    {
                        l1Messages[exchangeId].AddValue(column.Name, typedColValue);
                    }

                    break;
                }

                case Level1Fields.LastTradeId:
                    if (types.Contains(column.Field))
                    {
                        lastTradeId = colValue.To <long?>();

                        if (lastTradeId != null && lastTradeId != 0)
                        {
                            l1Messages[tradeBoard.Value].Add(column.Field, lastTradeId.Value);
                        }
                    }
                    break;

                case Level1Fields.LastTradeTime:
                    if (types.Contains(column.Field))
                    {
                        if (column == Level1ColumnRegistry.LastDate)
                        {
                            lastTradeDate = colValue.TryToDateTime(column.Format);
                        }
                        else if (column == Level1ColumnRegistry.LastTradeTime)
                        {
                            lastTradeTime = column.ConvertToTimeSpan(colValue);
                        }

                        if (lastTradeDate.HasValue && lastTradeTime.HasValue)
                        {
                            var l1Msg = l1Messages[tradeBoard.Value];
                            l1Msg.ServerTime = (lastTradeDate.Value + lastTradeTime.Value).ApplyTimeZone(TimeHelper.Est);
                            l1Msg.Add(Level1Fields.LastTradeTime, l1Msg.ServerTime);
                        }
                    }
                    break;

                case Level1Fields.LastTradePrice:
                case Level1Fields.LastTradeVolume:
                    if (types.Contains(column.Field))
                    {
                        var decValue = colValue.To <decimal?>();

                        l1Messages[tradeBoard.Value].TryAdd(column.Field, decValue);

                        if (column == Level1ColumnRegistry.LastTradePrice)
                        {
                            lastTradePrice = decValue;
                        }
                        else                                // if (column == SessionHolder.Level1ColumnRegistry.LastTradeVolume)
                        {
                            lastTradeVolume = decValue;
                        }
                    }
                    break;

                case Level1Fields.BestBidTime:
                    if (types.Contains(column.Field))
                    {
                        var typedColValue = column.ConvertToTimeSpan(colValue);

                        if (typedColValue != null)
                        {
                            var l1Msg = l1Messages[bidBoard.Value];
                            l1Msg.ServerTime = (DateTime.Today + typedColValue.Value).ApplyTimeZone(TimeHelper.Est);
                            l1Msg.Add(Level1Fields.BestBidTime, l1Msg.ServerTime);
                        }
                    }
                    break;

                case Level1Fields.BestBidPrice:
                case Level1Fields.BestBidVolume:
                    if (types.Contains(column.Field))
                    {
                        l1Messages[bidBoard.Value].TryAdd(column.Field, colValue.To <decimal?>());
                    }
                    break;

                case Level1Fields.BestAskTime:
                    if (types.Contains(column.Field))
                    {
                        var typedColValue = column.ConvertToTimeSpan(colValue);

                        if (typedColValue != null)
                        {
                            var l1Msg = l1Messages[askBoard.Value];
                            l1Msg.ServerTime = (DateTime.Today + typedColValue.Value).ApplyTimeZone(TimeHelper.Est);
                            l1Msg.Add(Level1Fields.BestAskTime, l1Msg.ServerTime);
                        }
                    }
                    break;

                case Level1Fields.BestAskPrice:
                case Level1Fields.BestAskVolume:
                    if (types.Contains(column.Field))
                    {
                        l1Messages[askBoard.Value].TryAdd(column.Field, colValue.To <decimal?>());
                    }
                    break;

                case Level1Fields.OpenInterest:
                case Level1Fields.OpenPrice:
                case Level1Fields.HighPrice:
                case Level1Fields.LowPrice:
                case Level1Fields.ClosePrice:
                case Level1Fields.SettlementPrice:
                case Level1Fields.VWAP:
                    if (types.Contains(column.Field))
                    {
                        l1Messages[exchangeId].TryAdd(column.Field, colValue.To <decimal?>());
                    }
                    break;

                default:
                    if (types.Contains(column.Field))
                    {
                        var typedColValue = column.Convert(colValue);

                        if (typedColValue != null)
                        {
                            l1Messages[exchangeId].Add(column.Field, typedColValue);
                        }
                    }
                    break;
                }
            }

            foreach (var l1Msg in l1Messages.Values)
            {
                if (l1Msg.Changes.Count <= 0)
                {
                    continue;
                }

                yield return(new SecurityMessage {
                    SecurityId = l1Msg.SecurityId
                });

                if (l1Msg.ServerTime.IsDefault())
                {
                    l1Msg.ServerTime = CurrentTime.Convert(TimeHelper.Est);
                }

                yield return(l1Msg);
            }

            if (!types.Contains(Level1Fields.LastTrade) || !lastTradeDate.HasValue || !lastTradeTime.HasValue ||
                !lastTradeId.HasValue || !lastTradePrice.HasValue || !lastTradeVolume.HasValue)
            {
                yield break;
            }

            yield return(new ExecutionMessage
            {
                SecurityId = l1Messages[tradeBoard.Value].SecurityId,
                TradeId = lastTradeId.Value,
                ServerTime = (lastTradeDate.Value + lastTradeTime.Value).ApplyTimeZone(TimeHelper.Est),
                TradePrice = lastTradePrice.Value,
                Volume = lastTradeVolume.Value,
                ExecutionType = ExecutionTypes.Tick,
            });
        }