public decimal ComputeTotalInEuro()
{
decimal totalInEuro = 0;
var exchangeService = new ExchangeService();
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
IQueryable <UserBankAccount> userBankAccounts = from u in ctx.UserBankAccounts
where u.UserId == currentUser.UserId
select u;
var totalAccounts = userBankAccounts.ToList();
CurrencyRate exchangeEurRate;
foreach (var account in totalAccounts)
{
if (Enum.TryParse(account.Currency, out Currency currentCurrency))
{
exchangeEurRate = exchangeService.GetConversionRate(currentCurrency, new Currency[] { Currency.EUR }).FirstOrDefault();
if (exchangeEurRate != null)
{
totalInEuro += account.Amount * exchangeEurRate.Rate;
}
}
}
return(totalInEuro);
}
}
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 decimal CalculateProfit()
{
decimal totalProfit = 0;
ExchangeService exchangeService = new ExchangeService();
CurrencyRate changeRate = new CurrencyRate();
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
List <CurrencyRate> rates = exchangeService.GetConversionRate(Currency.EUR, new Currency[] { Currency.EUR, Currency.ETH, Currency.LTC, Currency.BTC, Currency.EOS });
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
IQueryable <UserBankAccount> userBankAccounts = from u in ctx.UserBankAccounts
where u.UserId == currentUser.UserId && u.Currency == Currency.EUR.ToString()
select u;
UserBankAccount eurAccount = userBankAccounts.FirstOrDefault();
try
{
List <UserTransaction> userTransactions = eurAccount.FromTransaction.Where(a => a.FromAccountId != a.ToAccountId && a.ToAccount.UserId == currentUser.UserId).ToList();
foreach (var tr in userTransactions)
{
changeRate = rates.FirstOrDefault(a => a.Currency.ToString() == tr.ToAccount.Currency);
totalProfit += tr.Amount * tr.CurrencyRate - tr.Amount * changeRate.Rate;
}
}
catch
{
totalProfit = 0;
}
}
return(totalProfit);
}
public ActionResult Wallet()
{
var exchangeService = new ExchangeService();
var walletsList = new List <WalletViewModel>();
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
IQueryable <UserBankAccount> userBankAccounts = from u in ctx.UserBankAccounts
where u.UserId == currentUser.UserId
select u;
//List<Cryptowallet.Models.TransactionViewModel> exchange = Model.Where(t => t.FromUser == t.ToUser && t.FromCurrency != t.ToCurrency).ToList();
//List<UserTransaction> userTransactions = userBankAccounts.Where(u => ).ToList();
//Transaction transaction
var bankAccounts = userBankAccounts.ToList();
foreach (var account in userBankAccounts)
{
Enum.TryParse(account.Currency, out Currency currentCurrency);
walletsList.Add(new WalletViewModel
{
AccountId = account.AccountId,
Amount = account.Amount,
Currency = account.Currency,
CustomAverage = exchangeService.GenerateCustomAverage(currentCurrency, Currency.EUR)
});
}
return(View(walletsList));
}
}
public ActionResult MyTransactions()
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
UserBankAccount myAccount = ctx.UserBankAccounts.FirstOrDefault(a => a.UserId == currentUser.UserId);
IQueryable <UserTransaction> userTransactions = from u in ctx.UserTransactions
where u.FromAccountId == myAccount.AccountId || u.ToAccountId == myAccount.AccountId
select u;
return(View(userTransactions.ToList()));
}
}
public ActionResult Profil()
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
ProfilViewModel profilViewModel = new ProfilViewModel();
profilViewModel.Email = currentUser.Email;
profilViewModel.Username = currentUser.Name;
return(View(profilViewModel));
}
}
public ActionResult Send(SendViewModel viewModel)
{
if (ModelState.IsValid)
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
SetupSendViewModel(viewModel);
UserBankAccount fromAccount = ctx.UserBankAccounts.FirstOrDefault(a => a.AccountId == viewModel.SenderAccountId && a.UserId == currentUser.UserId);
UserBankAccount toAccount = ctx.UserBankAccounts.AsNoTracking().FirstOrDefault(u => u.User.Email == viewModel.ReciverName && u.Currency == fromAccount.Currency);
if (viewModel.Amount > fromAccount.Amount)
{
ModelState.AddModelError("", "Insuficient funds");
}
else if (toAccount == null)
{
ModelState.AddModelError("", "Reciver don`t have an account in this currency or doesn`t exist");
}
else
{
fromAccount.Amount -= viewModel.Amount;
toAccount.Amount += viewModel.Amount;
ctx.SaveChanges();
UserTransaction userTransaction = new UserTransaction
{
Amount = viewModel.Amount,
FromAccountId = fromAccount.AccountId,
ToAccountId = toAccount.AccountId,
CurrencyRate = 0,
TransactionDate = DateTime.Now
};
ctx.UserTransactions.Add(userTransaction);
ctx.SaveChanges();
ViewBag.successMessage = "Transaction successful";
return(View(viewModel));
}
}
}
return(View(viewModel));
}
// GET: BankAccounts
public ActionResult Index()
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
List <UserBankAccount> userBankAccounts = ctx.UserBankAccounts.Where(b => b.UserId == currentUser.UserId).ToList();
List <BankAccountViewModel> accountViewModels = userBankAccounts.Select(a => new BankAccountViewModel
{
AccountID = a.AccountId,
Amount = a.Amount,
Currency = a.Currency
}).ToList();
return(View(accountViewModels));
}
}
public ActionResult _TotalPartial()
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
ExchangeService exchangeService = new ExchangeService();
List <UserBankAccount> userBankAccounts = ctx.UserBankAccounts.Where(b => b.UserId == currentUser.UserId).ToList();
List <CurrencyRate> rates = exchangeService.GetConversionRate(Currency.EUR, new Currency[] { Currency.EUR, Currency.ETH, Currency.LTC, Currency.BTC, Currency.EOS });
decimal total = 0;
foreach (var account in userBankAccounts)
{
decimal value = account.Amount * decimal.Parse(rates.Where(a => a.Currency.ToString() == account.Currency).ToString());
total += value;
}
}
return(View());
}
private void SetupSendViewModel(SendViewModel viewModel)
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
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.SenderAccounts.AddRange(accounts.Select(a => new SelectListItem
{
Value = a.AccountID.ToString(),
Text = a.Currency
}));
}
}
public ActionResult Deposit(DepositViewModel viewModel)
{
if (ModelState.IsValid)
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
UserBankAccount eurAccount = ctx.UserBankAccounts.FirstOrDefault(a => a.Currency == "EUR" && a.UserId == currentUser.UserId);
if (eurAccount == null)
{
eurAccount = new UserBankAccount
{
Currency = "EUR",
UserId = currentUser.UserId,
Amount = 0
};
ctx.UserBankAccounts.Add(eurAccount);
}
eurAccount.Amount += viewModel.Amount;
ctx.SaveChanges();
UserTransaction userTransaction = new UserTransaction
{
Amount = viewModel.Amount,
FromAccountId = eurAccount.AccountId,
ToAccountId = eurAccount.AccountId,
CurrencyRate = 0,
TransactionDate = DateTime.Now
};
ctx.UserTransactions.Add(userTransaction);
ctx.SaveChanges();
}
return(RedirectToAction("Wallet"));
}
return(View(viewModel));
}
public ActionResult RegisterUser(RegisterViewModel viewModel)
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
///de facut LOG IN
User newUser = ctx.Users.FirstOrDefault(a => a.Email == viewModel.Email);
if (ModelState.IsValid)
{
if (newUser != null)
{
ModelState.AddModelError("", "Already exists an user with this email");
return(View(viewModel));
}
if (viewModel.Password != viewModel.ConfirmPassword)
{
ModelState.AddModelError("", "Your password and confirm password doesn`t match");
return(View(viewModel));
}
newUser = new User
{
Email = viewModel.Email,
Name = viewModel.Name,
Password = viewModel.Password
};
ctx.Users.Add(newUser);
ctx.SaveChanges();
LoginViewModel login = new LoginViewModel
{
Username = newUser.Email,
Password = newUser.Password
};
return(RedirectToAction("Index", "Home"));
}
return(View(newUser));
}
}
public ActionResult Transactions()
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
List <UserBankAccount> currentUserBankAccounts = ctx.UserBankAccounts.Where(u => u.UserId == currentUser.UserId).ToList();
List <int> currentUserAccountIds = currentUserBankAccounts.Select(b => b.AccountId).ToList();
List <UserTransaction> currentUserTransactions = ctx.UserTransactions.Where(t => currentUserAccountIds.Contains(t.ToAccountId) ||
currentUserAccountIds.Contains(t.FromAccountId)).ToList();
List <TransactionViewModel> viewModel = currentUserTransactions.Select(a => new TransactionViewModel
{
Amount = a.Amount,
dateTime = a.TransactionDate,
Rate = a.CurrencyRate,
FromUser = a.FromAccount.User.Email,
ToUser = a.ToAccount.User.Email,
FromCurrency = a.FromAccount.Currency,
ToCurrency = a.ToAccount.Currency
}).ToList();
return(View(viewModel));
}
}
public ActionResult Login(LoginViewModel viewModel)
{
if (ModelState.IsValid)
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
CryptowalletDb.Domain.User user = ctx.Users.FirstOrDefault(u => u.Email == viewModel.Username && u.Password == viewModel.Password);
if (user != null)
{
FormsAuthentication.SetAuthCookie(viewModel.Username, true);
return(RedirectToAction("Profil", "BankAccounts"));
}
else
{
ModelState.AddModelError("", "Incorrect user or password");
return(View(viewModel));
}
}
}
else
{
return(View(viewModel));
}
}
private ActionResult Sell(ExchangeViewModel exchangeViewModel)
{
CurrencyRate changeRate = new CurrencyRate();
int transactionType;
if (Enum.TryParse(exchangeViewModel.toCurrency, out Currency currentCurrency))
{
if (ModelState.IsValid)
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
ExchangeService exchangeService = new ExchangeService();
var sellingAccount = ctx.UserBankAccounts.FirstOrDefault(a => a.Currency == currentCurrency.ToString() && a.UserId == currentUser.UserId);
if (sellingAccount == null)
{
ModelState.AddModelError("", "Inexistent account");
switch (TempData["TransactionType"])
{
case "Buy":
transactionType = 1;
break;
case "Sell":
transactionType = 0;
break;
default:
transactionType = 0;
break;
}
return(MakeTransactions(transactionType, currentCurrency));
}
List <CurrencyRate> rates = exchangeService.GetConversionRate(currentCurrency, new Currency[] { Currency.EUR });
changeRate = rates.FirstOrDefault(a => a.Currency == Currency.EUR);
if (exchangeViewModel.Amount > sellingAccount.Amount)
{
ModelState.AddModelError("", "Insuficient funds");
//return RedirectToAction("MakeTransactions", new { transactionType = 1 });
switch (TempData["TransactionType"])
{
case "Buy":
transactionType = 1;
break;
case "Sell":
transactionType = 0;
break;
default:
transactionType = 0;
break;
}
return(MakeTransactions(transactionType, currentCurrency));
}
UserBankAccount euroBankAccount = ctx.UserBankAccounts.FirstOrDefault(a => a.Currency == Currency.EUR.ToString() && a.UserId == currentUser.UserId);
euroBankAccount.Amount += exchangeViewModel.Amount * changeRate.Rate;
sellingAccount.Amount -= exchangeViewModel.Amount;
ctx.SaveChanges();
UserTransaction userTransaction = new UserTransaction
{
Amount = exchangeViewModel.Amount,
FromAccountId = sellingAccount.AccountId,
ToAccountId = euroBankAccount.AccountId,
CurrencyRate = changeRate.Rate,
TransactionDate = DateTime.Now
};
ctx.UserTransactions.Add(userTransaction);
ctx.SaveChanges();
}
return(View(exchangeViewModel));
}
}
else
{
ModelState.AddModelError("", "Invalid Currency");
switch (TempData["TransactionType"])
{
case "Buy":
transactionType = 1;
break;
case "Sell":
transactionType = 0;
break;
default:
transactionType = 0;
break;
}
return(MakeTransactions(transactionType, currentCurrency));
}
return(RedirectToAction("Wallet"));
}
public ActionResult Exchange(ExchangeViewModel viewModel)
{
SetupExchangeViewModel(viewModel);
CurrencyRate changeRate = new CurrencyRate();
if (ModelState.IsValid)
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
ExchangeService exchangeService = new ExchangeService();
Enum.TryParse(viewModel.fromCurrency, out Currency fromCurrency);
List <CurrencyRate> rates = exchangeService.GetConversionRate(fromCurrency, new Currency[] { Currency.EUR, Currency.ETH, Currency.LTC, Currency.BTC, Currency.EOS });
// List<CurrencyRate> rate =e.GetConversionRate(Currency.BTC, new Currency[] { Currency.EUR, Currency.USD, Currency.GBP });
changeRate = rates.FirstOrDefault(a => a.Currency.ToString() == viewModel.toCurrency);
UserBankAccount bankAccount = ctx.UserBankAccounts.FirstOrDefault(a => a.Currency == viewModel.toCurrency && a.UserId == currentUser.UserId);
UserBankAccount fromBankAccount = ctx.UserBankAccounts.FirstOrDefault(a => a.Currency == viewModel.fromCurrency && a.UserId == currentUser.UserId);
if (fromBankAccount.Amount < viewModel.Amount)
{
ModelState.AddModelError("", "Insuficient funds");
return(View(viewModel));
}
if (bankAccount == null)
{
bankAccount = new UserBankAccount
{
Currency = viewModel.toCurrency,
UserId = currentUser.UserId,
Amount = 0,
};
ctx.UserBankAccounts.Add(bankAccount);
}
bankAccount.Amount += viewModel.Amount * changeRate.Rate;
fromBankAccount.Amount -= viewModel.Amount;
ctx.SaveChanges();
UserTransaction userTransaction = new UserTransaction
{
Amount = viewModel.Amount,
FromAccountId = fromBankAccount.AccountId,
ToAccountId = bankAccount.AccountId,
CurrencyRate = changeRate.Rate,
TransactionDate = DateTime.Now
};
ctx.UserTransactions.Add(userTransaction);
ctx.SaveChanges();
ViewBag.successMessage = "Transaction successful";
}
return(View(viewModel));
}
return(View(viewModel));
}
