private async Task ProcessMessageAsync(IndexTickPrice message)
        {
            try
            {
                if (!message.Ask.HasValue)
                {
                    throw new InvalidOperationException($"IndexTickPrice doesn't have 'ask' price: {message.ToJson()}");
                }

                var index = CreateIndex(message, message.AssetPair);

                Index shortIndex = null;

                bool isShort = !string.IsNullOrWhiteSpace(message.ShortIndexName);

                if (isShort)
                {
                    shortIndex = CreateIndex(message, message.ShortIndexName);
                }

                await _indexHandler.HandleIndexAsync(index, shortIndex);

                _log.InfoWithDetails("Index price handled", message);
            }
            catch (Exception exception)
            {
                _log.ErrorWithDetails(exception, "An error occurred while processing index tick price", message);
                throw;
            }
        }
        public async Task Handle(IndexTickPrice indexTickPrice)
        {
            var assetId = MapIndexNameToAssetId(indexTickPrice.AssetPair);

            try
            {
                await Update(assetId);
            }
            catch (Exception ex)
            {
                _log.Warning("", ex);
            }
        }
        private Index CreateIndex(IndexTickPrice message, string name)
        {
            if (!message.Ask.HasValue)
            {
                return(null);
            }

            var index = new Index(name, message.Ask.Value, message.Source, message.Timestamp,
                                  message.AssetsInfo
                                  .Select(o => new AssetWeight(o.AssetId, o.Weight, o.Price, o.IsDisabled))
                                  .ToArray());

            return(index);
        }
        private async Task ProcessMessageAsync(IndexTickPrice message)
        {
            try
            {
                var index = new Index(message.AssetPair, message.Ask, message.Source, message.Timestamp,
                                      message.AssetsInfo
                                      .Select(o => new AssetWeight(o.AssetId, o.Weight, o.Price, o.IsDisabled))
                                      .ToArray());

                await _indexHandler.HandleIndexAsync(index);

                _log.InfoWithDetails("Index price handled", message);
            }
            catch (Exception exception)
            {
                _log.ErrorWithDetails(exception, "An error occurred while processing index tick price", message);
                throw;
            }
        }
        private async Task ProcessMessageAsync(IndexTickPrice tickPrice)
        {
            _log.Info($"Received '{tickPrice.Source}' tick price.");

            await _indicesFacadeService.Handle(tickPrice);
        }