private bool ValidateChargeAccount(ChargeAccount chargeAccounts)
{
if (chargeAccounts.Amount < 0)
{
return(false);
}
return(true);
}
private bool ValidateMinAmount(ChargeAccount chargeAcc, decimal amount)
{
if (amount >= 10 && amount <= chargeAcc.Amount)
{
return(true);
}
return(false);
}
public async Task <ActionResult <MessageModel> > GetPayOffInfo(ClaimsPrincipal currentUser, string username)
{
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
CreditResponseModel creditResponseModel = new CreditResponseModel();
UserAccResponseModel userCredits = new UserAccResponseModel();
if (userAuthenticate == null)
{
responseMessage.Message = "User not found!";
return(StatusCode(404, responseMessage));
}
else
{
ChargeAccount chargeAcc = await dbContext.ChargeAccounts.FirstOrDefaultAsync(x => x.UserId == userAuthenticate.Id);
bool hasDeleted = false;
foreach (var creditRef in dbContext.Credits.Where(x => x.UserId == userAuthenticate.Id))
{
var credit = creditRef;
if (credit == null)
{
responseMessage.Message = "You don't have a Credit";
return(StatusCode(400, responseMessage));
}
await GetCreditPayOff(credit, username);
if (credit.CreditAmountLeft == 0 && credit.CreditAmount > 0)
{
CreditRequestModel requestModel = new CreditRequestModel();
requestModel.Credit = credit;
requestModel.Username = username;
responseMessage.Message = "You have payed your Credit!";
await DeleteCreditFromPayOff(credit, chargeAcc);
hasDeleted = true;
}
}
await dbContext.SaveChangesAsync();
if (hasDeleted)
{
responseMessage.Message = ($"Successfully payed montly pay off! Credit payed successfully! The left amount from the credit is transfered to Bank Account with Iban: {chargeAcc.Iban}");
return(StatusCode(200, responseMessage));
}
responseMessage.Message = "Successfully payed montly pay off!";
return(StatusCode(200, responseMessage));
}
}
responseMessage.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseMessage));
}
private bool ValidateChargeAccount(ChargeAccount chargeAcc, decimal amount)
{
if (chargeAcc != null && chargeAcc.Amount > amount)
{
return(true);
}
else
{
return(false);
}
}
public async Task <ActionResult <MessageModel> > AddMoney(CreditRequestModel requestModel, ClaimsPrincipal currentUser, string username)
{
//credit amount
var credit = requestModel.Credit;
var amount = requestModel.Amount;
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
Credit creditsExists = null;
ChargeAccount bankAccounts = requestModel.ChargeAccount;
ChargeAccount bankAccExists = null;
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
if (userAuthenticate != null)
{
try
{
creditsExists = await dbContext.Credits.FirstOrDefaultAsync(x => x.Iban == credit.Iban);
}
catch (NullReferenceException)
{
responseMessage.Message = "Credit not found";
return(StatusCode(404, responseMessage));
}
}
else
{
responseMessage.Message = "User not found!";
return(StatusCode(404, responseMessage));
}
if (creditsExists != null)
{
try
{
bankAccExists = dbContext.ChargeAccounts.FirstOrDefault(x => x.Iban == bankAccounts.Iban);
return(await ValidateDepositAmountAndCredit(userAuthenticate, creditsExists, currentUser, amount, bankAccExists));
}
catch (NullReferenceException)
{
responseMessage.Message = "Invalid Charge Account! Iban not found!";
return(StatusCode(404, responseMessage));
}
}
else
{
responseMessage.Message = "Credit 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> > AddMoney(WalletRequestModel requestModel, ClaimsPrincipal currentUser, string username)
{
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
var amount = requestModel.Amount;
Wallet wallet = requestModel.Wallet;
Wallet walletExists = null;
ChargeAccount chargeAccount = requestModel.ChargeAccount;
ChargeAccount chargeAccountExists = null;
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
if (userAuthenticate != null)
{
try
{
walletExists = await dbContext.Wallets.FirstOrDefaultAsync(x => x.Iban == wallet.Iban);
if (walletExists != null)
{
chargeAccountExists = await dbContext.ChargeAccounts.FirstOrDefaultAsync(x => x.Iban == chargeAccount.Iban);
if (walletExists.CardExpirationDate < DateTime.Now)
{
responseMessage.Message = "Wallet Card is expired";
return(StatusCode(406, responseMessage));
}
return(await ValidateDepositAmountAndBankAccount(userAuthenticate, currentUser, walletExists, amount, chargeAccountExists, _transactionsService));
}
else
{
responseMessage.Message = "Wallet not found! Invalid Iban!";
return(StatusCode(404, responseMessage));
}
}
catch (NullReferenceException)
{
responseMessage.Message = "Wallet or Bank account not found! Check Iban!";
return(StatusCode(404, responseMessage));
}
}
else
{
responseMessage.Message = "User not found!";
return(StatusCode(404, responseMessage));
}
}
responseMessage.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseMessage));
}
public void accountTest()
{
var raveConfig = new RaveConfig(PbKey, ScKey, false);
var accountc = new ChargeAccount(raveConfig);
var Payload = new AccountParams(PbKey, ScKey, "customer", "customer", "*****@*****.**", "0690000031", 1000, "044", "NGN", "MC-0292920");
var chargeResponse = accountc.Charge(Payload).Result;
if (chargeResponse.Data.Status == "success-pending-validation")
{
Payload.Otp = "12345";
chargeResponse = accountc.Charge(Payload).Result;
}
// ValidateAccountCharge(chargeResponse.Data.FlwRef);
Assert.IsNotNull(chargeResponse.Data);
Assert.AreEqual("success", chargeResponse.Status);
}
private async Task <ActionResult <MessageModel> > GetCreditPayOff(Credit credit, string username)
{
while (DateTime.Now >= credit.PaymentDate)
{
if (credit.Instalment <= credit.Amount)
{
credit.Amount = credit.Amount - credit.Instalment;
credit.CreditAmountLeft = credit.CreditAmountLeft - credit.Instalment;
credit.PaymentDate = credit.PaymentDate.AddMonths(1);
responseMessage.Message = "Credit instalment payed off successfully from Credit Account!";
return(StatusCode(200, responseMessage));
}
else
{
int count = 1;
var chargeAccountsCollection = dbContext.ChargeAccounts.Where(x => x.UserId == dbContext.Users.FirstOrDefault(z => z.Username == username).Id);
foreach (var chargeAccountReff in chargeAccountsCollection)
{
ChargeAccount chargeAccount = chargeAccountReff;
if (credit.Instalment <= chargeAccount.Amount)
{
chargeAccount.Amount = chargeAccount.Amount - credit.Instalment;
credit.CreditAmountLeft = credit.CreditAmountLeft - credit.Instalment;
credit.PaymentDate = credit.PaymentDate.AddMonths(1);
await dbContext.SaveChangesAsync();
responseMessage.Message = "Credit instalment payed off successfully from Charge Account!";
return(StatusCode(200, responseMessage));
}
else
{
if (count > chargeAccountsCollection.Count())
{
responseMessage.Message = "You don't have enough money to pay off Your instalment! Come to our office as soon as possible to discuss what happens from now on!";
return(StatusCode(406, responseMessage));
}
count++;
}
}
}
}
return(null);
}
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(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> > 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));
}
public async Task <ActionResult <MessageModel> > DepositMoney(ChargeAccount bankAccount, Deposit deposit, ClaimsPrincipal currentUser, string username, decimal amount)
{
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
ChargeAccount bankAccounts = null;
Deposit depositsExist = null;
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
if (userAuthenticate != null)
{
try
{
bankAccounts = await dbContext.ChargeAccounts.FirstOrDefaultAsync(x => x.Iban == bankAccount.Iban);
depositsExist = await dbContext.Deposits.FirstOrDefaultAsync(x => x.Iban == deposit.Iban);
}
catch (NullReferenceException)
{
responseModel.Message = "Invalid Iban for Charge Account or Deposit! Please check Iban";
return(StatusCode(400, responseModel));
}
}
else
{
responseModel.Message = "User not found!";
return(StatusCode(404, responseModel));
}
if (bankAccounts != null && depositsExist != null)
{
try
{
if (ValidateDepositAmountChargeAccount(amount))
{
bankAccounts.Amount = bankAccounts.Amount + amount;
depositsExist.Amount = depositsExist.Amount - amount;
await dbContext.SaveChangesAsync();
Transaction transactions = new Transaction();
transactions.RecieverAccountInfo = bankAccounts.Iban;
transactions.SenderAccountInfo = depositsExist.Iban;
await _transactionsService.CreateTransaction(userAuthenticate, currentUser, amount, transactions, "Depositing money Deposit Account -> Charge Account");
responseModel.Message = "Money deposited succesfully!";
return(StatusCode(200, responseModel));
}
responseModel.Message = "Invalid deposit amount!";
return(StatusCode(400, responseModel));
}
catch (NullReferenceException)
{
responseModel.Message = "Charge Account or Deposit not found! Invalid Iban!";
return(StatusCode(404, responseModel));
}
}
else
{
responseModel.Message = "Charge Account or Deposit not found! Invalid Iban!";
return(StatusCode(404, responseModel));
}
}
responseModel.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseModel));
}
private async Task <ActionResult> ValidateDepositAmountAndCredit(User userAuthenticate, Credit creditExists, ClaimsPrincipal currentUser, decimal amount, ChargeAccount bankAccount)
{
if (amount < 0)
{
responseMessage.Message = "Invalid payment amount!";
return(StatusCode(400, responseMessage));
}
else if (amount == 0)
{
responseMessage.Message = "Put amount more than 0.00lv";
return(StatusCode(400, responseMessage));
}
else
{
if (bankAccount != null && bankAccount.Amount > amount)
{
creditExists.Amount = creditExists.Amount + amount;
bankAccount.Amount = bankAccount.Amount - amount;
Transaction transaction = new Transaction();
transaction.SenderAccountInfo = bankAccount.Iban;
transaction.RecieverAccountInfo = creditExists.Iban;
await _transactionsService.CreateTransaction(userAuthenticate, currentUser, amount, transaction, $"Depositing money in Credit Account");
await dbContext.SaveChangesAsync();
}
else if (bankAccount.Amount < amount)
{
responseMessage.Message = "You don't have enough money in Charge account!";
return(StatusCode(406, responseMessage));
}
else if (bankAccount == null)
{
responseMessage.Message = "You don't have a Charge account";
return(StatusCode(400, responseMessage));
}
}
responseMessage.Message = $"Succesfully deposited {amount} leva.";
return(StatusCode(200, responseMessage));
}
private async Task <ActionResult <MessageModel> > DeleteCreditFromPayOff(Credit credit, ChargeAccount chargeAccount)
{
chargeAccount.Amount += credit.Amount;
responseMessage.Message = ($"Credit payed successfully! The left amount from the credit is transfered to Bank Account with Iban: {chargeAccount.Iban}");
dbContext.Remove(credit);
return(StatusCode(200, responseMessage));
}
public async Task <ActionResult <MessageModel> > CreateDebitCard(ClaimsPrincipal currentUser, string username, ChargeAccount bankAccount, Card card)
{
string role = "";
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);
Card cardExists = null;
ChargeAccount bankAccountExists = null;
if (userAuthenticate != null)
{
try
{
bankAccountExists = await dbContext.ChargeAccounts.FirstOrDefaultAsync(x => x.Iban == bankAccount.Iban);
if (bankAccountExists == null)
{
responseMessage.Message = "No Bank Account found! Invalid Iban!";
return(StatusCode(404, responseMessage));
}
cardExists = await dbContext.Cards.FirstOrDefaultAsync(x => x.ChargeAccountId == bankAccountExists.Id);
}
catch (NullReferenceException)
{
responseMessage.Message = "No Bank Account found! Invalid Iban!";
return(StatusCode(404, responseMessage));
}
}
if (cardExists == null)
{
try
{
if (ValidateUser(userAuthenticate))
{
if (card == null)
{
card = new Card();
}
card.ChargeAccountId = bankAccountExists.Id;
card.CardNumber = GenerateCardInfo.GenerateNumber(11);
var CVV = GenerateCardInfo.GenerateCVV(3);
card.Cvv = _BCrypt.HashPassword(CVV);
card.CardExpirationDate = DateTime.Now.AddMonths(60);
dbContext.Add(card);
await dbContext.SaveChangesAsync();
responseMessage.Message = "Debit Card created succesfully!";
return(StatusCode(200, responseMessage));
}
else if (ValidateUser(userAuthenticate) == false)
{
responseMessage.Message = "User not found!";
return(StatusCode(404, responseMessage));
}
}
catch (NullReferenceException)
{
responseMessage.Message = "User not found!";
return(StatusCode(404, responseMessage));
}
}
responseMessage.Message = "User already has a Debit Card!";
return(StatusCode(400, responseMessage));
}
else
{
responseMessage.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseMessage));
}
}
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> > AddMoney(DepositRequestModel requestModel, ClaimsPrincipal currentUser, string username)
{
User userAuthenticate = null;
Deposit deposit = requestModel.Deposit;
Deposit depositExists = null;
ChargeAccount chargeAccount = requestModel.ChargeAccount;
ChargeAccount chargeAccountExists = null;
var amount = requestModel.Amount;
try
{
userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
}
catch (NullReferenceException)
{
responseMessage.Message = "User not found";
return(StatusCode(400, responseMessage));
}
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
if (userAuthenticate != null)
{
try
{
depositExists = await dbContext.Deposits.FirstOrDefaultAsync(x => x.Iban == deposit.Iban);
if (depositExists != null)
{
chargeAccountExists = await dbContext.ChargeAccounts.FirstOrDefaultAsync(x => x.Iban == chargeAccount.Iban);
if (amount < 0)
{
responseMessage.Message = "Invalid payment amount!";
return(StatusCode(400, responseMessage));
}
else if (amount == 0)
{
responseMessage.Message = "Put amount more than 0.00lv";
return(StatusCode(400, responseMessage));
}
else
{
if (chargeAccountExists != null && chargeAccount.Amount > amount)
{
deposit.Amount = deposit.Amount + amount;
deposit.PaymentDate = DateTime.Now.AddMonths(6);
chargeAccount.Amount = chargeAccount.Amount - amount;
Transaction transaction = new Transaction();
transaction.SenderAccountInfo = $"User {userAuthenticate.FirstName} {userAuthenticate.LastName}";
transaction.RecieverAccountInfo = depositExists.Iban;
await dbContext.SaveChangesAsync();
await _transactionsService.CreateTransaction(userAuthenticate, currentUser, amount, transaction, "Added money - Bank Account - Deposit account");
}
else if (chargeAccountExists == null)
{
responseMessage.Message = "Charge Account Iban is invalid!";
return(StatusCode(400, responseMessage));
}
else if (chargeAccountExists.Amount < amount)
{
responseMessage.Message = "You don't have enough money in Bank Account!";
return(StatusCode(406, responseMessage));
}
}
responseMessage.Message = $"Succesfully deposited {amount} leva.";
return(StatusCode(200, responseMessage));
}
else
{
responseMessage.Message = "Invalid Iban! Deposit not found";
return(StatusCode(404, responseMessage));
}
}
catch (NullReferenceException)
{
responseMessage.Message = "Invalid Iban! Deposit not found";
return(StatusCode(404, responseMessage));
}
}
else
{
responseMessage.Message = "User 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> > 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));
}
