Пример #1
0
        public Task StartAsync(CancellationToken cancellationToken)
        {
            _cleanup = _cache
                       .AsObservableCache()
                       .Connect()
                       .FilterAndSuppressRemoved(trade => trade.Status == TradeStatus.Filled)
                       .Subscribe(changes =>
            {
                foreach (var change in changes)
                {
                    Scheduler.Default.Schedule(async() =>
                    {
                        try
                        {
                            var trade = await _repository.GetById <Trade>(change.Current.EntityId);

                            if (TradeServiceReferential.Rand.Next(1, 10) == 1)
                            {
                                var tradeRejectedEvent = new ComplianceRejectTrade()
                                {
                                    ComplianceService = _configuration.Id
                                };


                                await _repository.Apply(trade, tradeRejectedEvent);
                            }
                            else
                            {
                                var counterparty = TradeServiceReferential.Counterparties.Random();
                                var price        = TradeServiceReferential.Assets.FirstOrDefault(asset => asset.Name == trade.Asset).Price;

                                await Task.Delay(1000);

                                var bookTradeEvent = new BookTrade()
                                {
                                    ComplianceService = _configuration.Id
                                };

                                await _repository.Apply(trade, bookTradeEvent);
                            }
                        }
                        catch (Exception ex)
                        {
                            this.LogInformation($"Exception while handling trade {change}", ex);
                        }
                    });
                }
            });

            return(Task.CompletedTask);
        }
        public Task StartAsync(CancellationToken cancellationToken)
        {
            _cleanup = _cache
                       .AsObservableCache()
                       .Connect()
                       .WhereReasonsAreNot(ChangeReason.Remove)
                       .Subscribe(async changes =>
            {
                foreach (var trade in changes)
                {
                    await _tradeEventHubService.Current.Proxy.RaiseChange(trade);
                }
            });

            return(Task.CompletedTask);
        }
        public Task StartAsync(CancellationToken cancellationToken)
        {
            var generationDisposable = Observable.Interval(TimeSpan.FromSeconds(1))
                                       .Subscribe(async _ =>
            {
                try
                {
                    var requestResult = await _tradeService.CreateTrade(new TradeCreationRequest()
                    {
                        Asset    = TradeServiceReferential.Assets.Random().Name,
                        Currency = "EUR",
                        Volume   = TradeServiceReferential.Rand.Next(10, 50),
                        Way      = TradeWay.Buy
                    });

                    this.LogInformation($"Trade Request - {requestResult.TradeId}");
                }
                catch (Exception ex) {
                    this.LogError(ex);
                }
            });


            var observerDisposable = _cache
                                     .AsObservableCache()
                                     .Connect()
                                     .WhereReasonsAreNot(ChangeReason.Remove)
                                     .Subscribe(changes =>
            {
                foreach (var change in changes)
                {
                    this.LogInformation($"Handle trade {change.Current}");
                }
            });


            _cleanup.Add(generationDisposable);
            _cleanup.Add(observerDisposable);


            return(Task.CompletedTask);
        }
Пример #4
0
        public Task StartAsync(CancellationToken cancellationToken)
        {
            _cleanup = _cache
                       .AsObservableCache()
                       .Connect()
                       .FilterAndSuppressRemoved(trade => trade.Status == TradeStatus.Created)
                       .Subscribe(changes =>
            {
                foreach (var change in changes)
                {
                    Scheduler.Default.Schedule(async() =>
                    {
                        try
                        {
                            var trade = await _repository.GetById <Trade>(change.Current.EntityId);

                            if (TradeServiceReferential.Rand.Next(1, 10) == 1)
                            {
                                var tradeRejectedEvent = new MarketRejectTrade()
                                {
                                    MarketService = _configuration.Id,
                                };

                                await _repository.Apply(trade, tradeRejectedEvent);
                            }
                            else
                            {
                                var counterparty = TradeServiceReferential.Counterparties.Random();

                                var price = await _priceService.GetPrice(change.Current.Asset);

                                if (counterparty == TradeServiceReferential.HighLatencyCounterparty)
                                {
                                    await Task.Delay(5000);
                                }
                                else
                                {
                                    await Task.Delay(1000);
                                }

                                var fillTradeEvent = new FillTrade()
                                {
                                    Counterparty  = counterparty,
                                    Price         = price.Value,
                                    Date          = DateTime.Now,
                                    MarketService = _configuration.Id,
                                    Marketplace   = TradeServiceReferential.Markets.Random().Name,
                                };


                                await _repository.Apply(trade, fillTradeEvent);
                            }
                        }
                        catch (Exception ex)
                        {
                            this.LogInformation($"Exception while handling trade {change}", ex);
                        }
                    });
                }
            });

            return(Task.CompletedTask);
        }
Пример #5
0
 public Task <IEnumerable <ITrade> > GetAllTrades()
 {
     return(Task.FromResult(_cache.AsObservableCache().Items.Select(trade => trade).Cast <ITrade>()));
 }