public void Initialize(ExchangeViewModel vm) { viewModel = vm; filter = new TreeModelFilter(store, null) { VisibleFunc = FilterSmallAssets }; nodeview1.Model = filter; viewModel.BalanceManager.Balances.CollectionChanged += Balances_CollectionChanged; GLib.Timeout.Add(2000, () => { TreeIter iter; var result = store.GetIterFirst(out iter); while (result) { var value = store.GetValue(iter, 0); store.SetValue(iter, 0, value); result = store.IterNext(ref iter); } if (viewModel.BalanceManager.TotalBtc > decimal.Zero) { colTotalBtc.Title = $"BTC ({viewModel.BalanceManager.TotalBtc.ToString("N3")})"; colTotalUsd.Title = $"USD ({viewModel.BalanceManager.TotalUsd.ToString("N0")})"; } return(true); }); }
public void Initialize(ExchangeViewModel vm) { viewModel = vm; nodeview1.Model = store; viewModel.RecentTrades.CollectionChanged += RecentTrades_CollectionChanged; viewModel.PropertyChanged += ViewModel_PropertyChanged; }
public async Task <IActionResult> Exchange(ExchangeViewModel viewModel) { string userEmail = _httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier); await _transactionApplicationService.Exchange(userEmail, viewModel); return(Ok()); }
public IHttpActionResult Update([FromBody] ExchangeViewModel exchange) { var dbExchange = _dbSet.Exchanges.FirstOrDefault(e => e.Id == exchange.Id); if (dbExchange == null) { return(NotFound()); } var inputCurr = _dbSet.Currencies.FirstOrDefault(c => c.Name == exchange.InputCurrency); var outputCurr = _dbSet.Currencies.FirstOrDefault(c => c.Name == exchange.OutputCurrency); if (inputCurr == null || outputCurr == null) { return(NotFound()); } dbExchange.DateTime = exchange.DateTime; dbExchange.InputAmount = exchange.InputAmount; dbExchange.OutputAmount = exchange.OutputAmount; dbExchange.InputCurrency = inputCurr; dbExchange.OutputCurrency = outputCurr; _dbSet.SaveChanges(); return(Ok()); }
private void SetupExchangeViewModel(ExchangeViewModel viewModel) { using (CryptowalletDbContext ctx = new CryptowalletDbContext()) { List <string> currencys = Enum.GetValues(typeof(Currency)) .Cast <Currency>() .Select(v => v.ToString()) .ToList(); User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name); List <BankAccountViewModel> accounts = ctx.UserBankAccounts.Where(a => a.UserId == currentUser.UserId).Select(u => new BankAccountViewModel { AccountID = u.AccountId, Amount = u.Amount, Currency = u.Currency }).ToList(); viewModel.FromCurrencyList.AddRange(accounts.Select(a => new SelectListItem { Value = a.Currency, Text = a.Currency })); viewModel.ToCurrencyList.AddRange(currencys.Select(a => new SelectListItem { Value = a, Text = a })); } }
public ActionResult Exchange() { ExchangeViewModel viewModel = new ExchangeViewModel(); SetupExchange(viewModel); return(View(viewModel)); }
private void InitializeComponent(IEnergy energy = null) { AvaloniaXamlLoader.Load(this); DataContext = new ExchangeViewModel(energy) { Close = Close }; }
public void Initialize(ExchangeViewModel vm) { viewModel = vm; nodeview1.Model = store; viewModel.OrderBook.CollectionChanged += OrderBook_CollectionChanged; viewModel.PropertyChanged += ViewModel_PropertyChanged; UpdateEntriesCountUI(viewModel.OrderBookMaxItemCount); }
public async Task <object> Post([FromBody] ExchangeViewModel model) { MessageBase2 result = new MessageBase2(); ExchangeDto dto = ConvertHelper.ChangeType <ExchangeDto>(model); await _exchangeService.AddAsync(dto); return(result); }
public async Task <object> PutUpdate(int id, [FromBody] ExchangeViewModel model) { MessageBase2 result = new MessageBase2(); ExchangeDto dto = ConvertHelper.ChangeType <ExchangeDto>(model); await _exchangeService.UpdateAsync(id, dto); return(result); }
public void Initialize(ExchangeViewModel vm) { viewModel = vm; sorted = new TreeModelSort(store); sorted.SetSortFunc(0, SortBySymbol); sorted.SetSortFunc(4, SortByDistance); sorted.SetSortColumnId(4, SortType.Ascending); nodeview1.Model = sorted; viewModel.MarketSummaries.CollectionChanged += MarketSummaries_CollectionChanged; }
public DashboardEntryViewModel(ExchangeViewModel exchangeViewModel, DashboardViewModel dashboardViewModel, MainViewModel mainViewModel) : base(exchangeViewModel.Exchange) { this.ExchangeViewModel = exchangeViewModel; this.MainViewModel = mainViewModel; this.DashboardViewModel = dashboardViewModel; this.Ticker = new TickerViewModel(Exchange); this.Header = exchangeViewModel.Header; _updateController.Register(String.Format("{0}DashboardTicker", Exchange.Name), Ticker.Update, 10, true, true); MainViewModel.TimerSeconds.Tick += TimerSecondsOnTick; }
public virtual void Initialize(ExchangeViewModel vm) { viewModel = vm; marketsummary1.Initialize(viewModel); publictrades1.Initialize(viewModel); orderbook1.Initialize(viewModel); privatetrades1.Initialize(viewModel); transfersDeposits.Initialize(viewModel, TransferType.Deposit); transfersWithdrawals.Initialize(viewModel, TransferType.Withdrawal); funds1.Initialize(viewModel); }
public void Initialize(ExchangeViewModel vm, TransferType tt) { viewModel = vm; nodeview1.Model = store; if (tt == TransferType.Deposit) { viewModel.Deposits.CollectionChanged += Transfers_CollectionChanged; } else { viewModel.Withdrawals.CollectionChanged += Transfers_CollectionChanged; } }
public ActionResult <string> GrantWish([FromBody] ExchangeViewModel exchange) { try { _logger.LogInformation("Received patch Wish Grant request"); _wishServices.GrantWish(_mapper.Map <Exchange>(exchange)); return(Ok("OK")); } catch (Exception exception) { _logger.LogError(exception, exception.Message); return(new StatusCodeResult(500)); } }
public IActionResult Exchange(int offset = 0, int limit = 20, DateTime?startDate = null, DateTime?endDate = null, string orderStatus = null, string notOrderStatus = null, bool csv = false) { var user = GetUser(required: true).Result; var startUnixTimestamp = 0L; var endUnixTimestamp = 0L; if (startDate.HasValue) { startDate = StartOfDay(startDate.Value); startUnixTimestamp = DateTimeToUnix(startDate.Value); } if (endDate.HasValue) { endDate = EndOfDay(endDate.Value); endUnixTimestamp = DateTimeToUnix(endDate.Value); } if (csv) { var deals = ViaSql.ExchangeDeals(_logger, _settings.MySql.Host, _settings.MySql.Database, _settings.MySql.User, _settings.MySql.Password, startUnixTimestamp, endUnixTimestamp); var stream = new MemoryStream(); var streamWriter = new StreamWriter(stream); streamWriter.AutoFlush = true; using (var csvWriter = new CsvWriter(streamWriter, System.Globalization.CultureInfo.InvariantCulture)) { csvWriter.Configuration.RegisterClassMap <DealMap>(); csvWriter.WriteRecords(deals); return(File(stream.GetBuffer(), "application/octet-stream", "exchange.csv")); } } else { var deals = ViaSql.ExchangeDeals(_logger, _settings.MySql.Host, _settings.MySql.Database, _settings.MySql.User, _settings.MySql.Password, startUnixTimestamp, endUnixTimestamp, offset, limit); var count = ViaSql.ExchangeDealsCount(_logger, _settings.MySql.Host, _settings.MySql.Database, _settings.MySql.User, _settings.MySql.Password, startUnixTimestamp, endUnixTimestamp); var model = new ExchangeViewModel { User = user, Deals = deals, Offset = offset, Limit = limit, StartDate = startDate, EndDate = endDate, Count = count, AssetSettings = _settings.Assets, }; return(View(model)); } }
public async Task Exchange(string userEmail, ExchangeViewModel viewModel) { var user = await _userService.GetUserByEmail(userEmail); var product = _productService.GetById(viewModel.ProductId); var transaction = new Transaction { Company = product.Company, Product = product, DotzCost = viewModel.DotzCost, Wallet = user.Wallet }; _transactionService.Exchange(transaction); }
public ActionResult MakeTransactions(ExchangeViewModel exchangeViewModel) { ViewBag.successMessage = "Transaction successful"; switch (TempData["TransactionType"]) { case "Buy": return(Buy(exchangeViewModel)); case "Sell": return(Sell(exchangeViewModel)); default: return(null); } }
public async Task <IActionResult> Exchange() { ExchangeViewModel exchange = new ExchangeViewModel(); using (var httpClient = new HttpClient()) { using (var response = await httpClient.GetAsync("https://api.coinlore.net/api/exchange/?id=5")) { string apiResponse = await response.Content.ReadAsStringAsync(); exchange = JsonSerializer.Deserialize <ExchangeViewModel>(apiResponse); } } return(View(exchange)); }
public CreateExchangeAccountViewModel(IEnumerable <ExchangeViewModel> exchangeList, ExchangeViewModel selectedExchange) { Activator = new ViewModelActivator(); CloseDialog = new Interaction <Unit, bool>(); Exchanges = exchangeList; Exchange = selectedExchange; this.WhenActivated(disposables => { var canSubmit = this.WhenAnyValue(x => x.Name, x => x.ApiKey, x => x.ApiSecret, (x, y, z) => !string.IsNullOrWhiteSpace(x) && y != null && z != null); Submit = ReactiveCommand.Create(SubmitImpl, canSubmit).DisposeWith(disposables); }); }
public void Initialize(ExchangeViewModel vm) { viewModel = vm; filter = new TreeModelFilter(store, null) { VisibleFunc = FilterSymbols }; sorted = new TreeModelSort(filter); sorted.SetSortFunc(0, SortBySymbol); sorted.SetSortFunc(2, SortByPrice); sorted.SetSortFunc(3, SortByPriceChangePercent); sorted.SetSortFunc(4, SortByVolume); sorted.SetSortColumnId(4, SortType.Ascending); nodeview1.Model = sorted; viewModel.MarketSummaries.CollectionChanged += MarketSummaries_CollectionChanged; }
public MainViewModel() { Tabs = new ObservableCollection <ViewModelBase>(); SettingsViewModel = new ExchangeSettingsViewModel(_exchangeManager); SettingsService = SettingsViewModel.SettingsService; Exchanges = new ObservableCollection <ExchangeViewModel>(); if (!DesignerProperties.GetIsInDesignMode(new DependencyObject())) { CommandToolBarViewModel = new CommandToolBarViewModel(this, _exchangeManager, SettingsViewModel); RequestViewModel = new RequestViewModel(this, ExchangeManager); AddressViewModel = new AddressViewModel(_exchangeManager, this); OrderNotificationWindowViewModel = new OrderNotificationWindowViewModel(this, _exchangeManager); OrderNotificationWindow = new OrderNotificationWindow { DataContext = OrderNotificationWindowViewModel }; ExchangeLoader.LoadExchanges(ExchangeManager); // Exchanges foreach (var exchangeBase in ExchangeManager.Exchanges) { var exchangeViewModel = new ExchangeViewModel(this, exchangeBase); Exchanges.Add(exchangeViewModel); } // Tabs DashboardViewModel = new DashboardViewModel(ExchangeManager, this); Tabs.Add(DashboardViewModel); foreach (var exchange in Exchanges) { Tabs.Add(exchange); } Tabs.Add(AddressViewModel); Tabs.Add(RequestViewModel); Tabs.Add(SettingsViewModel); CreateTimer(); } }
public ActionResult MakeTransactions(int transactionType, Currency currency) { var exchangeModel = new ExchangeViewModel(); switch (transactionType) { case 0: ViewBag.Title = "Sell"; break; case 1: ViewBag.Title = "Buy"; break; } exchangeModel.toCurrency = currency.ToString(); return(View(exchangeModel)); }
private void SetupExchange(ExchangeViewModel viewModel) { using (CryptoWalletDbContext ctx = new CryptoWalletDbContext()) { User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name); List <UserBankAccount> currentUserAccounts = ctx.UserBankAccounts.Where(b => b.UserId == currentUser.UserId).ToList(); List <BankAccountViewModel> accountsViewModels = currentUserAccounts.Select(a => new BankAccountViewModel { AccountId = a.AccountId, Amount = a.Amount, Currency = a.Currency }).ToList(); viewModel.Accounts.AddRange(accountsViewModels.Select(a => new SelectListItem { Value = a.AccountId.ToString(), Text = a.Currency })); } }
public IActionResult Exchange(Area district, string exchange) { var model = new ExchangeViewModel() { SelectedDistrict = district, Exchanges = repository.Exchanges.Where(x => x.Area == district).OrderBy(x => x.Abb).ToList(), SelectedExchange = repository.Exchanges.Where(x => x.Abb == exchange && x.Area == district).Select(x => new Exchange() { Id = x.Id, Abb = x.Abb, Name = x.Name, CreatedOn = x.CreatedOn, ModifiedOn = x.ModifiedOn, Area = x.Area, IsSite = x.IsSite, Username = x.Username, Providence = x.Providence, NetworkElements = x.NetworkElements.Select(y => new NetworkElement() { Model = y.Model, Name = y.Name, InstalledCapacity = y.InstalledCapacity, Manufacturer = y.Manufacturer, NetworkType = y.NetworkType, Remark = y.Remark, UsedCapacity = y.UsedCapacity, Type = y.Type, Owner = y.Owner, Parent = new NetworkElement() { Name = y.Parent.Name } }).ToList() }).FirstOrDefault(), Miscs = repository.Miscs.OrderBy(x => x.Name).ToArray() }; return(View(nameof(Exchange), model)); }
public IHttpActionResult Add([FromBody] ExchangeViewModel exchange) { var inputCurr = _dbSet.Currencies.FirstOrDefault(c => c.Name == exchange.InputCurrency); var outputCurr = _dbSet.Currencies.FirstOrDefault(c => c.Name == exchange.OutputCurrency); if (inputCurr == null || outputCurr == null) { return(NotFound()); } _dbSet.Exchanges.Add(new Exchange() { DateTime = exchange.DateTime, InputAmount = exchange.InputAmount, OutputAmount = exchange.OutputAmount, InputCurrency = inputCurr, OutputCurrency = outputCurr }); _dbSet.SaveChanges(); return(Ok()); }
public async Task <ActionResult> Index() { // /api/currencies string url = "http://localhost:54362/api/currencies"; var client = new HttpClient(); var response = await client.GetAsync(url); response.EnsureSuccessStatusCode(); var data = await response.Content.ReadAsStringAsync(); var currencies = JsonConvert.DeserializeObject <IEnumerable <CurrencyViewModel> >(data); var vmExchange = new ExchangeViewModel(); vmExchange.Currencies = new SelectList(currencies, "CurrencyCode", "CurrencyCode"); TempData["Currencies"] = vmExchange.Currencies; TempData.Keep(); return(View(vmExchange)); }
public ActionResult Create(ExchangeViewModel exchangeViewModel) { //var errors = ModelState.Values.SelectMany(v => v.Errors); if (ModelState.IsValid) { int userId = Com.Cos.Common.Public.GetLoginUid(); Com.Cos.Models.Exchange exchange = new Cos.Models.Exchange { UserId = userId.ToString(), Title = exchangeViewModel.Title, ItemName = exchangeViewModel.ItemName, ItemCharacter = exchangeViewModel.ItemCharacter, Constitute = exchangeViewModel.Constitute, Source = exchangeViewModel.Source, Price = exchangeViewModel.Price, ClassId = exchangeViewModel.ClassId, Describe = exchangeViewModel.Describe, //Valuation1 = exchangeViewModel.Valuation1, //Valuation2 = exchangeViewModel.Valuation2, //Valuation3 = exchangeViewModel.Valuation3, //Certificate = exchangeViewModel.Certificate, ImgList = exchangeViewModel.ImgList, Cover = exchangeViewModel.Cover, AddTime = DateTime.Now, Status = 1 }; exchange = _exchangeService.Add(exchange); if (exchange.Id > 0) { return(Json(Public.MessageJson(1, "发布成功"))); } return(Json(Public.MessageJson(0, "修改失败"))); } return(PartialView("_PartialCreate", exchangeViewModel)); }
public async Task <ActionResult> Index(ExchangeViewModel model) { // /api/exchange string url = $"http://localhost:54362/api/exchange?currency={model.Currency}&amount={model.Amount}"; var client = new HttpClient(); var response = await client.GetAsync(url); response.EnsureSuccessStatusCode(); var data = await response.Content.ReadAsStringAsync(); var vmExchange = JsonConvert.DeserializeObject <ExchangeViewModel>(data); ModelState["ValueExchange"].Value = new ValueProviderResult(vmExchange.ValueExchange, "New Value", CultureInfo.CurrentCulture); ModelState["CalculatedValue"].Value = new ValueProviderResult(vmExchange.CalculatedValue, "New Value", CultureInfo.CurrentCulture); vmExchange.Currencies = (SelectList)TempData["Currencies"]; TempData.Keep(); return(View(vmExchange)); }
public ActionResult Exchange(ExchangeViewModel viewModel) { if (ModelState.IsValid) { using (CryptoWalletDbContext ctx = new CryptoWalletDbContext()) { User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name); UserBankAccount fromAccount = ctx.UserBankAccounts.FirstOrDefault(x => x.AccountId.ToString() == viewModel.CurrencyFrom); UserBankAccount toAccount = ctx.UserBankAccounts.FirstOrDefault(x => x.AccountId.ToString() == viewModel.CurrencyTo); if (toAccount == null) { ModelState.AddModelError("", "Invalid to currency."); SetupExchange(viewModel); return(View(viewModel)); } if (fromAccount == null) { ModelState.AddModelError("", "Invalid from currency."); SetupExchange(viewModel); return(View(viewModel)); } if (fromAccount.AccountId == toAccount.AccountId) { ModelState.AddModelError("", "Selected currencies are the same."); SetupExchange(viewModel); return(View(viewModel)); } if (fromAccount.Amount < viewModel.Amount) { ModelState.AddModelError("", "Insufficient funds."); SetupExchange(viewModel); return(View(viewModel)); } Currency currencyFrom = (Currency)Enum.Parse(typeof(Currency), fromAccount.Currency, true); Currency currencyTo = (Currency)Enum.Parse(typeof(Currency), toAccount.Currency, true); ExchangeService echangeService = new ExchangeService(); List <CurrencyRate> rates = echangeService.GetConversionRate(currencyFrom, new Currency[] { currencyTo }); viewModel.Rate = rates[0].Rate; fromAccount.Amount -= viewModel.Amount; toAccount.Amount += (viewModel.Amount * viewModel.Rate); UserTransaction userTransaction = new UserTransaction { FromAccountId = fromAccount.AccountId, ToAccountId = toAccount.AccountId, FromAccount = fromAccount, ToAccount = toAccount, Amount = viewModel.Amount, CurrencyRate = viewModel.Rate * (decimal)1.0000000, TransactionDate = DateTime.Now }; ctx.UserTransactions.Add(userTransaction); ctx.SaveChanges(); return(RedirectToAction("Transactions")); } } else { SetupExchange(viewModel); return(View(viewModel)); } }
public void Sorting() { this.SelectedExchange = null; }
private void Save(SaveEvent saveEvent) { this.entityService.ExecuteAsync( () => this.entityService.Create(this.Exchange.Model()), () => { this.Exchange = new ExchangeViewModel(this.eventAggregator); }, string.Format(Message.EntityAddedFormatString, "Exchange"), this.eventAggregator); }
public void OnNavigatedFrom(NavigationContext navigationContext) { this.eventAggregator.Unsubscribe<SaveEvent>(this.Save); this.eventAggregator.Unsubscribe<EntitySelectedEvent>(this.EntitySelected); this.Exchange = new ExchangeViewModel(this.eventAggregator); }