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);
}
