public MarketDataObservable(CurrencyPair currencyPair, OcDispatcher backgroundOcDispatcher)
            {
                var spread  = currencyPair.DefaultSpread;
                var midRate = currencyPair.InitialPrice;
                var bid     = midRate - (spread * currencyPair.PipSize);
                var offer   = midRate + (spread * currencyPair.PipSize);
                var initial = new MarketData(currencyPair.Code, bid, offer);

                var currentPrice = initial;

                Value = currentPrice;

                var random = new Random();

                //for a given period, move prices by up to 5 pips
                _recurringAction = new RecurringAction(() =>
                {
                    int pips = random.Next(1, 5);
                    //move up or down between 1 and 5 pips
                    var adjustment        = Math.Round(pips * currencyPair.PipSize, currencyPair.DecimalPlaces);
                    MarketData marketData = random.NextDouble() > 0.5
                                                ? currentPrice + adjustment
                                                : currentPrice - adjustment;

                    backgroundOcDispatcher.Invoke(() =>
                                                  Value = marketData);
                }, () => TimeSpan.FromSeconds(1 / (double)currencyPair.TickFrequency));
            }
Exemple #2
0
        public TradeAgeUpdateJob(Dispatcher dispatcher, ITradeService tradeService)
        {
            _recurringAction = new RecurringAction(() =>
            {
                Trade[] trades = null;

                dispatcher.Invoke(() =>
                {
                    trades = tradeService.All.ToArray();
                });

                foreach (IEnumerable <Trade> tradesSlice in trades.Split(300))
                {
                    dispatcher.Invoke(() =>
                    {
                        foreach (Trade trade in tradesSlice)
                        {
                            TimeSpan diff = DateTime.Now.Subtract(trade.Timestamp);

                            TimePeriod age =
                                diff.TotalSeconds <= 60 ? TimePeriod.LastMinute
                                                                : diff.TotalMinutes <= 60 ? TimePeriod.LastHour
                                                                : TimePeriod.Older;

                            trade.Age = age;

                            if (diff.TotalSeconds > 30)
                            {
                                trade.Expired = true;
                            }
                        }
                    });
                }
            }, () => TimeSpan.FromSeconds(1));
        }
Exemple #3
0
        protected void Application_Start()
        {
            var builder = new ContainerBuilder();

            AutofacConfig.Register(builder);
            builder.RegisterControllers(typeof(MvcApplication).Assembly);
            var container = builder.Build();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            _heartbeatAction = new RecurringAction(() => Task.Run(async() =>
            {
                using (var client = new HttpClient())
                {
                    foreach (var path in AppGetUrlPaths)
                    {
                        var url = $"{AppUrl.AppBasePath.Value}/{path}";
                        await client.GetAsync(url).ConfigureAwait(false);
                    }
                }
            }), TimeSpan.FromMinutes(5));

            // for clearing old files that Azure publish misses
            //Directory
            //	.EnumerateFiles(AppDomain.CurrentDomain.BaseDirectory, "about.txt", SearchOption.AllDirectories)
            //	.ForEach(File.Delete);

            // INFO FOR DATABASE:
            //using (var connection = new SqlConnection(
            //        "Server=tcp:YOUR_SERVER_NAME_HERE.database.windows.net,1433;Database=AdventureWorksLT;User ID=YOUR_LOGIN_NAME_HERE;Password=YOUR_PASSWORD_HERE;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"
            //        ))
            //{
            //    connection.Open();
            //    Console.WriteLine("Connected successfully.");

            //    Console.WriteLine("Press any key to finish...");
            //    Console.ReadKey(true);
            //}
        }
        public TradeService(ILogger logger, TradeGenerator tradeGenerator, OcDispatcher backgroundOcDispatcher)
        {
            _logger                 = logger;
            _tradeGenerator         = tradeGenerator;
            _backgroundOcDispatcher = backgroundOcDispatcher;

            All  = new ObservableCollection <Trade>(_tradeGenerator.Generate(5_000, true));
            Live = All.Filtering(t => t.Status == TradeStatus.Live).For(_consumer);

            var random = new Random();

            TimeSpan RandomInterval() => TimeSpan.FromMilliseconds(random.Next(2500, 5000));

            // create a random number of trades at a random interval
            RecurringAction tradeEmitter = new RecurringAction(() =>
            {
                var number = random.Next(1, 5);
                var trades = _tradeGenerator.Generate(number);

                foreach (Trade trade in trades)
                {
                    _backgroundOcDispatcher.Invoke(() => All.Add(trade));
                }
            }, RandomInterval);

            List <Trade> closedTrades = new List <Trade>();
            //close a random number of trades at a random interval
            RecurringAction tradeCloser = new RecurringAction(() =>
            {
                var number = random.Next(1, 2);
                for (int i = 1; i <= number; i++)
                {
                    _backgroundOcDispatcher.Invoke(() =>
                    {
                        Trade trade          = All[random.Next(0, All.Count - 1)];
                        trade.Status         = TradeStatus.Closed;
                        trade.CloseTimestamp = DateTime.Now;
                        closedTrades.Add(trade);
                    });
                }
            }, RandomInterval);


            //expire closed items from the cache to avoid unbounded data
            RecurringAction tradeRemover = new RecurringAction(() =>
            {
                _backgroundOcDispatcher.Invoke(() =>
                {
                    for (var index = closedTrades.Count - 1; index >= 0; index--)
                    {
                        Trade closedTrade = closedTrades[index];
                        if ((DateTime.Now - closedTrade.CloseTimestamp).Minutes >= 1)
                        {
                            All.Remove(closedTrade);
                            closedTrades.RemoveAt(index);
                        }
                    }
                });
            }, () => TimeSpan.FromMinutes(1));



            //log changes
            OcDispatcher logPropertyChangedOcDispatcher = new OcDispatcher();

            LogChanges(logPropertyChangedOcDispatcher);

            _cleanup = new CompositeDisposable(
                _consumer, tradeEmitter, tradeCloser, logPropertyChangedOcDispatcher, tradeRemover);
        }