public async Task <ActionResult <MessageModel> > CreateBankAccount(ChargeAccountRequestModel requestModel)
{
//need username, BankAccount(amount)
var currentUser = HttpContext.User;
return(await _chargeAccountService.CreateChargeAccount(currentUser, requestModel, _debitCardService));
}
public async Task <ActionResult <MessageModel> > Withdraw(ChargeAccountRequestModel requestModel)
{
var currentUser = HttpContext.User;
string username = currentUser.Claims.FirstOrDefault(currentUser => currentUser.Type == "Username").Value;
return(await _chargeAccService.Withdraw(requestModel, currentUser, username));
}
public async Task <ActionResult <MessageModel> > DeleteBankAccount(ChargeAccountRequestModel requestModel)
{
//need username
var currentUser = HttpContext.User;
return(await _chargeAccountService.DeleteBankAccount(currentUser, requestModel));
}
public async Task <ActionResult <MessageModel> > DepositInBankAcc(ChargeAccountRequestModel requestModel)
{
//amount = 0.50M;
var currentUser = HttpContext.User;
string username = currentUser.Claims.FirstOrDefault(currentUser => currentUser.Type == "Username").Value;
return(await _chargeAccService.DepositMoney(requestModel.ChargeAccount, requestModel.Deposit, currentUser, username, requestModel.Amount));
}
//need BankAccount(IBAN), username, amount
public async Task <ActionResult <MessageModel> > AddMoneyInBankAccount(ChargeAccountRequestModel requestModel)
{
var currentUser = HttpContext.User;
return(await _chargeAccountService.AddMoney(requestModel, currentUser, requestModel.Username));
}
public async Task <ActionResult <MessageModel> > Withdraw(string cardNumber, string CVV, DateTime expireDate, ClaimsPrincipal currentUser, string username, decimal amount, string reciever, /*ITransactionService _transactionService*/ IChargeAccountsService _chargeAccService)
{
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
ChargeAccount bankAccountsExists = null;
Card cardsExists = null;
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
if (userAuthenticate != null)
{
try
{
cardsExists = await dbContext.Cards.FirstOrDefaultAsync(x => x.CardNumber == cardNumber);
if (_BCrypt.AuthenticateDebitCardCVV(CVV, cardsExists))
{
if (cardsExists == null)
{
responseMessage.Message = "Debit Card not found";
return(StatusCode(404, responseMessage));
}
bankAccountsExists = await dbContext.ChargeAccounts.FirstOrDefaultAsync(x => x.Card == cardsExists);
}
else
{
responseMessage.Message = "Invalid Credentials";
return(StatusCode(400, responseMessage));
}
}
catch (NullReferenceException)
{
responseMessage.Message = "Debit Card not found";
return(StatusCode(404, responseMessage));
}
}
else
{
responseMessage.Message = "User not found!";
return(StatusCode(404, responseMessage));
}
if (bankAccountsExists != null)
{
try
{
if (cardsExists.CardExpirationDate < DateTime.Now)
{
responseMessage.Message = "Debit Card is expired";
return(StatusCode(406, responseMessage));
}
ChargeAccountRequestModel requestModel = new ChargeAccountRequestModel();
requestModel.ChargeAccount = bankAccountsExists;
requestModel.Amount = amount;
requestModel.Reciever = reciever;
await _chargeAccService.Withdraw(requestModel, currentUser, username);
responseMessage.Message = "Withdraw successfull";
return(StatusCode(200, responseMessage));
}
catch (NullReferenceException)
{
responseMessage.Message = "Bank Account not found";
return(StatusCode(404, responseMessage));
}
}
else if (bankAccountsExists == null)
{
responseMessage.Message = "Bank Account not found";
return(StatusCode(404, responseMessage));
}
}
responseMessage.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseMessage));
}
public async Task <ActionResult <MessageModel> > DeleteBankAccount(ClaimsPrincipal currentUser, ChargeAccountRequestModel requestModel)
{
string role = "";
var username = requestModel.Username;
ChargeAccount chargeAcc = requestModel.ChargeAccount;
ChargeAccount chargeAccExists = null;
Card cardExists = null;
Credit creditExists = null;
UserAccount userChargeAcc = null;
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
string userRole = currentUser.Claims.FirstOrDefault(currentUser => currentUser.Type == "Roles").Value;
role = userRole;
}
if (role == "Admin")
{
var user = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
if (user != null)
{
try
{
chargeAccExists = await dbContext.ChargeAccounts.FirstOrDefaultAsync(x => x.Iban == chargeAcc.Iban);
cardExists = await dbContext.Cards.FirstOrDefaultAsync(x => x.ChargeAccountId == chargeAccExists.Id);
creditExists = await dbContext.Credits.FirstOrDefaultAsync(x => x.UserId == user.Id);
userChargeAcc = await dbContext.UserAccounts.FirstOrDefaultAsync(x => x.ChargeAccountId == chargeAccExists.Id);
}
catch (NullReferenceException)
{
responseModel.Message = "Charge Account not found! Iban Invalid!";
return(StatusCode(404, responseModel));
}
}
if (user == null)
{
responseModel.Message = "User not found";
return(StatusCode(404, responseModel));
}
if (chargeAccExists == null)
{
responseModel.Message = "User doesn't have a Charge Account";
return(StatusCode(400, responseModel));
}
if (cardExists != null)
{
dbContext.Cards.Remove(cardExists);
await dbContext.SaveChangesAsync();
}
if (creditExists != null)
{
responseModel.Message = "You can't delete Charge account if you have an existing credit!";
return(StatusCode(406, responseModel));
}
dbContext.ChargeAccounts.Remove(chargeAccExists);
await dbContext.SaveChangesAsync();
dbContext.UserAccounts.Remove(userChargeAcc);
await dbContext.SaveChangesAsync();
responseModel.Message = $"Succsesfully deleted {user.Username} Charge Account and Debit Card!";
return(StatusCode(200, responseModel));
}
else
{
responseModel.Message = "You are not authorized to do such actions";
return(StatusCode(403, responseModel));
}
}
public async Task <ActionResult <MessageModel> > CreateChargeAccount(ClaimsPrincipal currentUser, ChargeAccountRequestModel requestModel, IDebitCardsService _debitCardService)
{
string role = "";
var username = requestModel.Username;
ChargeAccount chargeAcc = requestModel.ChargeAccount;
BCryptPasswordHasher _BCrypt = new BCryptPasswordHasher();
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
string userRole = currentUser.Claims.FirstOrDefault(currentUser => currentUser.Type == "Roles").Value;
role = userRole;
}
if (role == "Admin")
{
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
if (userAuthenticate != null)
{
if (dbContext.ChargeAccounts.Where(x => x.UserId == userAuthenticate.Id).Count() < 10)
{
try
{
if (ValidateUser(userAuthenticate) && ValidateChargeAccount(chargeAcc))
{
chargeAcc.UserId = userAuthenticate.Id;
chargeAcc.Iban = IBANGenerator.GenerateIBANInVitoshaBank("ChargeAccount", dbContext);
await dbContext.AddAsync(chargeAcc);
await dbContext.SaveChangesAsync();
Card card = new Card();
await _debitCardService.CreateDebitCard(currentUser, username, chargeAcc, card);
SendEmail(userAuthenticate.Email, _config);
responseModel.Message = "Charge Account created succesfully";
return(StatusCode(201, responseModel));
}
else if (ValidateUser(userAuthenticate) == false)
{
responseModel.Message = "User not found!";
return(StatusCode(404, responseModel));
}
else if (ValidateChargeAccount(chargeAcc) == false)
{
responseModel.Message = "Invalid parameteres!";
return(StatusCode(400, responseModel));
}
}
catch (NullReferenceException)
{
responseModel.Message = "Invalid parameteres!";
return(StatusCode(400, responseModel));
}
}
responseModel.Message = "User already has 10 Charge Accounts!";
return(StatusCode(400, responseModel));
}
else
{
responseModel.Message = "User not found!";
return(StatusCode(404, responseModel));
}
}
else
{
responseModel.Message = "You are not authorized to do such actions";
return(StatusCode(403, responseModel));
}
}
public async Task <ActionResult <MessageModel> > Withdraw(ChargeAccountRequestModel requestModel, ClaimsPrincipal currentUser, string username)
{
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
var amount = requestModel.Amount;
ChargeAccount chargeAcc = requestModel.ChargeAccount;
ChargeAccount chargeAccExists = null;
ChargeAccountResponseModel chargeAccResponseModel = new ChargeAccountResponseModel();
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
if (userAuthenticate != null)
{
try
{
chargeAccExists = await dbContext.ChargeAccounts.FirstOrDefaultAsync(x => x.Iban == chargeAcc.Iban);
if (chargeAccExists != null)
{
if (ValidateDepositAmountChargeAccount(amount) && ValidateChargeAccount(chargeAcc, amount) && ValidateMinAmount(chargeAcc, amount))
{
chargeAcc.Amount = chargeAcc.Amount - amount;
Transaction transactions = new Transaction();
transactions.SenderAccountInfo = chargeAcc.Iban;
transactions.RecieverAccountInfo = $"{userAuthenticate.FirstName} {userAuthenticate.LastName}";
await _transactionsService.CreateTransaction(userAuthenticate, currentUser, amount, transactions, $"Withdrawing {amount} leva");
await dbContext.SaveChangesAsync();
responseModel.Message = $"Succesfully withdrawed {amount} leva.";
return(StatusCode(200, responseModel));
}
else if (ValidateDepositAmountChargeAccount(amount) == false)
{
responseModel.Message = "Invalid payment amount!";
return(StatusCode(400, responseModel));
}
else if (ValidateChargeAccount(chargeAcc, amount) == false)
{
responseModel.Message = "You don't have enough money in Charge Account!";
return(StatusCode(406, responseModel));
}
else if (ValidateMinAmount(chargeAcc, amount) == false)
{
responseModel.Message = "Min amount is 10 leva!";
return(StatusCode(406, responseModel));
}
}
else
{
responseModel.Message = "Charge Account not found! Iban Invalid!";
return(StatusCode(404, responseModel));
}
}
catch (NullReferenceException)
{
responseModel.Message = "Charge Account not found! Iban Invalid!";
return(StatusCode(404, responseModel));
}
}
else
{
responseModel.Message = "User not found!";
return(StatusCode(404, responseModel));
}
}
responseModel.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseModel));
}
public async Task <ActionResult <MessageModel> > AddMoney(ChargeAccountRequestModel requestModel, ClaimsPrincipal currentUser, string username)
{
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
var amount = requestModel.Amount;
ChargeAccount chargeAcc = requestModel.ChargeAccount;
ChargeAccount chargeAccExists = null;
string role = "";
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
string userRole = currentUser.Claims.FirstOrDefault(currentUser => currentUser.Type == "Roles").Value;
role = userRole;
}
if (role == "Admin")
{
if (userAuthenticate != null)
{
try
{
chargeAccExists = await dbContext.ChargeAccounts.FirstOrDefaultAsync(x => x.Iban == chargeAcc.Iban);
if (chargeAccExists != null)
{
if (ValidateDepositAmountChargeAccount(amount))
{
chargeAcc.Amount = chargeAcc.Amount + amount;
await dbContext.SaveChangesAsync();
Transaction transactions = new Transaction();
transactions.SenderAccountInfo = $"User {userAuthenticate.FirstName} {userAuthenticate.LastName}";
transactions.RecieverAccountInfo = chargeAcc.Iban;
await _transactionsService.CreateTransaction(userAuthenticate, currentUser, amount, transactions, "Depositing money in Charge Account");
responseModel.Message = $"Succesfully deposited {amount} leva in Charge Account.";
return(StatusCode(200, responseModel));
}
responseModel.Message = "Invalid money amount!";
return(StatusCode(400, responseModel));
}
else
{
responseModel.Message = "Charge Account not found! Iban Invalid!";
return(StatusCode(404, responseModel));
}
}
catch (NullReferenceException)
{
responseModel.Message = "Charge Account not found! Iban Invalid!";
return(StatusCode(404, responseModel));
}
}
else
{
responseModel.Message = "User not found!";
return(StatusCode(404, responseModel));
}
}
responseModel.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseModel));
}
public async Task <ActionResult <MessageModel> > SimulatePurchase(ChargeAccountRequestModel requestModel, ClaimsPrincipal currentUser, string username)
{
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
var product = requestModel.Product;
var reciever = requestModel.Reciever;
var amount = requestModel.Amount;
ChargeAccount chargeAcc = requestModel.ChargeAccount;
ChargeAccount chargeAccExists = null;
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
if (userAuthenticate != null)
{
try
{
chargeAccExists = await dbContext.ChargeAccounts.FirstOrDefaultAsync(x => x.Iban == chargeAcc.Iban);
if (chargeAccExists != null && ValidateDepositAmountChargeAccount(amount) && ValidateChargeAccount(chargeAccExists, amount))
{
chargeAcc.Amount = chargeAcc.Amount - amount;
Transaction transactions = new Transaction();
transactions.SenderAccountInfo = chargeAccExists.Iban;
transactions.RecieverAccountInfo = reciever;
await _transactionsService.CreateTransaction(userAuthenticate, currentUser, amount, transactions, $"Purchasing {product} with Charge Account");
await dbContext.SaveChangesAsync();
responseModel.Message = $"Succesfully purhcased {product}.";
return(StatusCode(200, responseModel));
}
else if (chargeAccExists == null)
{
responseModel.Message = "Charge Account not found! Invalid Iban";
return(StatusCode(404, responseModel));
}
else if (ValidateDepositAmountChargeAccount(amount) == false)
{
responseModel.Message = "Invalid payment amount!";
return(StatusCode(400, responseModel));
}
else if (ValidateChargeAccount(chargeAccExists, amount) == false)
{
responseModel.Message = "You don't have enough money in Charge account!";
return(StatusCode(406, responseModel));
}
}
catch (NullReferenceException)
{
responseModel.Message = "Charge Account not found! Invalid Iban";
return(StatusCode(404, responseModel));
}
}
else
{
responseModel.Message = "User not found";
return(StatusCode(404, responseModel));
}
}
responseModel.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseModel));
}
