private void ObserveAccount()
        {
            var accountObservable = Observable.FromEventPattern <AccountEventArgs>(
                eventHandler => AccountViewModel.OnAccountNotification += eventHandler,
                eventHandler => AccountViewModel.OnAccountNotification -= eventHandler)
                                    .Select(eventPattern => eventPattern.EventArgs);

            accountObservableSubscription = accountObservable.Subscribe(args =>
            {
                if (args.HasException)
                {
                    TradeViewModelException(args);
                }
                else if (args.AccountEventType.Equals(AccountEventType.LoggedIn) ||
                         args.AccountEventType.Equals(AccountEventType.LoggedOut))
                {
                    TradeViewModel.SetAccount(args.Value);
                    OrdersViewModel.SetAccount(args.Value).FireAndForget();
                }
                else if (args.AccountEventType.Equals(AccountEventType.UpdateOrders))
                {
                    TradeViewModel.Touch();
                    OrdersViewModel.UpdateOrders(args.Value).FireAndForget();
                }
                else if (args.AccountEventType.Equals(AccountEventType.SelectedAsset))
                {
                    TradeViewModel.SetSymbol(args.SelectedAsset);
                }
            });
        }
        public async Task SetAccount_NullAccount()
        {
            // Arrange
            var exchangeApi      = ExchangeServiceHelper.GetExchangeService();
            var exchangeService  = new WpfExchangeService(exchangeApi);
            var accountViewModel = new OrdersViewModel(exchangeService, new DebugLogger());

            var account = new Account(new Interface.Model.AccountInfo {
                User = new Interface.Model.User()
            })
            {
                ApiKey    = "apikey",
                ApiSecret = "apisecret"
            };

            accountViewModel.Account = account;
            foreach (var order in TestHelper.Orders)
            {
                accountViewModel.Orders.Add(order.GetViewOrder());
            }

            //Act
            await accountViewModel.SetAccount(null);

            // Assert
            Assert.IsNull(accountViewModel.Account);
            Assert.IsTrue(accountViewModel.Orders.Count().Equals(0));
        }
        public async Task SetAccount_NewAccount()
        {
            // Arrange
            var exchangeApi      = ExchangeServiceHelper.GetExchangeService();
            var exchangeService  = new WpfExchangeService(exchangeApi);
            var accountViewModel = new OrdersViewModel(exchangeService, new DebugLogger());

            var account = new Account(new Interface.Model.AccountInfo {
                User = new Interface.Model.User()
            })
            {
                ApiKey    = "apikey",
                ApiSecret = "apisecret"
            };

            //Act
            await accountViewModel.SetAccount(account);

            // Assert
            Assert.AreEqual(accountViewModel.Account, account);
            foreach (var order in TestHelper.Orders)
            {
                Assert.IsNotNull(accountViewModel.Orders.SingleOrDefault(o => o.ClientOrderId.Equals(order.ClientOrderId)));
            }
        }
Example #4
0
        private void ObserveAccount()
        {
            var accountObservable = Observable.FromEventPattern <AccountEventArgs>(
                eventHandler => AccountViewModel.OnAccountNotification += eventHandler,
                eventHandler => AccountViewModel.OnAccountNotification -= eventHandler)
                                    .Select(eventPattern => eventPattern.EventArgs);

            accountSubscription = accountObservable.Subscribe(async args =>
            {
                if (args.HasException)
                {
                    NotificationsAdd(new Message {
                        MessageType = MessageType.Error, Text = args.Message, TextVerbose = args.Exception.ToString()
                    });
                }
                else if (args.AccountEventType.Equals(AccountEventType.LoggedIn))
                {
                    await OrdersViewModel.SetAccount(args.Value);
                }
                else if (args.AccountEventType.Equals(AccountEventType.UpdateOrders))
                {
                    await OrdersViewModel.UpdateOrders(args.Value);
                }
                else if (!string.IsNullOrWhiteSpace(args.Message))
                {
                    NotificationsAdd(new Message {
                        MessageType = MessageType.Info, Text = args.Message
                    });
                }
            });
        }
        public async Task SetAccount_OverrideAccount()
        {
            // Arrange
            var exchangeApi      = ExchangeServiceHelper.GetExchangeService();
            var exchangeService  = new WpfExchangeService(exchangeApi);
            var accountViewModel = new OrdersViewModel(exchangeService, new DebugLogger());

            var firstAccount = new Account(new Interface.Model.AccountInfo {
                User = new Interface.Model.User()
            })
            {
                ApiKey    = "apikey",
                ApiSecret = "apisecret"
            };

            accountViewModel.Account = firstAccount;
            var firstorder = new Order {
                ClientOrderId = "test123", Symbol = "ETHBTC"
            };

            accountViewModel.Orders.Add(firstorder);

            var newAccount = new Account(new Interface.Model.AccountInfo {
                User = new Interface.Model.User()
            })
            {
                ApiKey    = "newapikey",
                ApiSecret = "newapisecret"
            };

            // Act
            await accountViewModel.SetAccount(newAccount);

            // Assert
            Assert.IsTrue(accountViewModel.Account.ApiKey.Equals(newAccount.ApiKey));
            foreach (var order in TestHelper.Orders)
            {
                Assert.IsNotNull(accountViewModel.Orders.SingleOrDefault(o => o.ClientOrderId.Equals(order.ClientOrderId)));
            }
        }