public async Task <ActionResult <MessageModel> > Withdraw(CreditRequestModel requestModel)
{
var currentUser = HttpContext.User;
string username = currentUser.Claims.FirstOrDefault(currentUser => currentUser.Type == "Username").Value;
return(await _creditService.Withdraw(requestModel, currentUser, username, "User in ATM"));
}
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));
}
public async Task <ActionResult <MessageModel> > DeleteCredit(CreditRequestModel requestModel, ClaimsPrincipal currentUser)
{
string role = "";
var username = requestModel.Username;
var credit = requestModel.Credit;
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);
Credit creditsExists = null;
if (user != null)
{
try
{
creditsExists = await dbContext.Credits.FirstOrDefaultAsync(x => x.Iban == credit.Iban);
}
catch (NullReferenceException)
{
responseMessage.Message = "Credit not found";
return(StatusCode(404, responseMessage));
}
}
if (user == null)
{
responseMessage.Message = "User not found!";
return(StatusCode(404, responseMessage));
}
else if (creditsExists == null)
{
responseMessage.Message = "User deosn't have a credit!";
return(StatusCode(400, responseMessage));
}
dbContext.Credits.Remove(creditsExists);
await dbContext.SaveChangesAsync();
responseMessage.Message = "Credit deleted successfully!";
return(StatusCode(200, responseMessage));
}
else
{
responseMessage.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseMessage));
}
}
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));
}
//need username
public async Task <ActionResult <MessageModel> > DeleteCredit(CreditRequestModel requestModel)
{
var currentUser = HttpContext.User;
return(await _creditService.DeleteCredit(requestModel, currentUser));
}
public async Task <ActionResult <MessageModel> > CreateCredit(ClaimsPrincipal currentUser, CreditRequestModel requestModel)
{
string role = "";
string username = requestModel.Username;
Credit credit = requestModel.Credit;
int period = requestModel.Period;
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.Credits.Where(x => x.UserId != userAuthenticate.Id).Count() < 3)
{
if (ValidateUser(userAuthenticate) && ValidateCredit(credit))
{
credit.Iban = IBANGenerator.GenerateIBANInVitoshaBank("Credit", dbContext);
credit.Interest = 6.9m;
credit.CreditAmount = CalculateInterest.CalculateCreditAmount(credit.Amount, period, credit.Interest);
credit.Instalment = CalculateInterest.CalculateInstalment(credit.CreditAmount, credit.Interest, period);
credit.CreditAmountLeft = credit.CreditAmount;
credit.PaymentDate = DateTime.Now.AddMonths(1);
credit.UserId = userAuthenticate.Id;
await dbContext.AddAsync(credit);
await dbContext.SaveChangesAsync();
SendEmail(userAuthenticate.Email);
responseMessage.Message = "Credit created succesfully!";
return(StatusCode(200, responseMessage));
}
else if (ValidateUser(userAuthenticate) == false)
{
responseMessage.Message = "User not found!";
return(StatusCode(404, responseMessage));
}
else if (ValidateCredit(credit) == false)
{
responseMessage.Message = "Don't put negative value!";
return(StatusCode(400, responseMessage));
}
}
}
responseMessage.Message = "User already has 3 active credits!";
return(StatusCode(400, responseMessage));
}
else
{
responseMessage.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseMessage));
}
}
public async Task <ActionResult <MessageModel> > Withdraw(CreditRequestModel requestModel, ClaimsPrincipal currentUser, string username, string reciever)
{
//credit amount
var credit = requestModel.Credit;
var amount = requestModel.Amount;
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
Credit creditExists = null;
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
if (userAuthenticate != null)
{
try
{
creditExists = 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 (creditExists != null)
{
try
{
if (ValidateDepositAmountBankAccount(amount) && ValidateCredit(creditExists) && ValidateMinAmount(creditExists, amount))
{
creditExists.Amount = creditExists.Amount - amount;
Transaction transactions = new Transaction();
transactions.SenderAccountInfo = credit.Iban;
transactions.RecieverAccountInfo = reciever;
await _transactionsService.CreateTransaction(userAuthenticate, currentUser, amount, transactions, $"Withdrawing {amount} leva");
await dbContext.SaveChangesAsync();
responseMessage.Message = $"Succesfully withdrawed {amount} leva.";
return(StatusCode(200, responseMessage));
}
else if (ValidateDepositAmountBankAccount(amount) == false)
{
responseMessage.Message = "Invalid payment amount!";
return(StatusCode(400, responseMessage));
}
else if (ValidateCredit(creditExists) == false)
{
responseMessage.Message = "You don't have enough money in Credit Account!";
return(StatusCode(406, responseMessage));
}
else if (ValidateMinAmount(creditExists, amount) == false)
{
responseMessage.Message = "The amount is bigger than Credit Account's amount!";
return(StatusCode(406, responseMessage));
}
}
catch (NullReferenceException)
{
responseMessage.Message = "Iban Invalid! Credit not found";
return(StatusCode(404, responseMessage));
}
}
else
{
responseMessage.Message = "Iban Invalid! 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> > SimulatePurchase(CreditRequestModel requestModel, ClaimsPrincipal currentUser, string username)
{
//amount credit product reciever
var credit = requestModel.Credit;
decimal amount = requestModel.Amount;
var product = requestModel.Product;
var reciever = requestModel.Reciever;
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
Credit creditExists = null;
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
if (userAuthenticate != null)
{
try
{
creditExists = 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 (creditExists != null)
{
try
{
if (ValidateCreditAmount(amount, creditExists) && ValidateCredit(creditExists))
{
creditExists.Amount = creditExists.Amount - amount;
Transaction transaction = new Transaction();
transaction.SenderAccountInfo = creditExists.Iban;
transaction.RecieverAccountInfo = reciever;
await _transactionsService.CreateTransaction(userAuthenticate, currentUser, amount, transaction, $"Purchasing {product}");
await dbContext.SaveChangesAsync();
responseMessage.Message = $"Succesfully purhcased {product}.";
return(StatusCode(200, responseMessage));
}
else if (ValidateCreditAmount(amount, credit) == false)
{
responseMessage.Message = "Invalid payment amount!";
return(StatusCode(400, responseMessage));
}
else if (ValidateCredit(creditExists) == false)
{
responseMessage.Message = "You don't have enough money in Charge account!";
return(StatusCode(406, responseMessage));
}
}
catch (NullReferenceException)
{
responseMessage.Message = "Iban Invalid! Credit not found";
return(StatusCode(404, responseMessage));
}
}
else
{
responseMessage.Message = "Invalid Credit! Iban not found!";
return(StatusCode(404, responseMessage));
}
}
responseMessage.Message = "You are not autorized to do such actions!";
return(StatusCode(403, responseMessage));
}
