//need username
public async Task <ActionResult <MessageModel> > DeleteBankAccount(DepositRequestModel requestModel)
{
//need username and deposit
var currentUser = HttpContext.User;
return(await _depositService.DeleteDeposit(currentUser, requestModel));
}
public async Task<ActionResult<MessageModel>> WithDrawMoney(DepositRequestModel requestModel)
{
//need from deposit(IBAN), BankAcc(IBAN),Username,Amount
var currentUser = HttpContext.User;
string username = currentUser.Claims.FirstOrDefault(currentUser => currentUser.Type == "Username").Value;
return await _depositService.WithdrawMoney(requestModel, currentUser, username);
}
public async Task <ActionResult <MessageModel> > WithdrawMoney(DepositRequestModel requestModel, ClaimsPrincipal currentUser, string username)
{
var userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
var amount = requestModel.Amount;
Deposit deposit = requestModel.Deposit;
Deposit depositExists = null;
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
if (userAuthenticate != null)
{
try
{
depositExists = await dbContext.Deposits.FirstOrDefaultAsync(x => x.Iban == deposit.Iban);
if (depositExists != null)
{
depositExists.Amount = depositExists.Amount - amount;
depositExists.PaymentDate = DateTime.Now.AddMonths(depositExists.TermOfPayment);
await dbContext.SaveChangesAsync();
Transaction transaction = new Transaction();
transaction.SenderAccountInfo = depositExists.Iban;
transaction.RecieverAccountInfo = $"{userAuthenticate.FirstName} {userAuthenticate.LastName}";
await _transactionsService.CreateTransaction(userAuthenticate, currentUser, amount, transaction, $"Withdrawing {amount}");
responseMessage.Message = "Money withdrawed successfully!";
return(StatusCode(200, responseMessage));
}
else
{
responseMessage.Message = "Deposit not found! Iban invalid!";
return(StatusCode(404, responseMessage));
}
}
catch (NullReferenceException)
{
responseMessage.Message = "Deposit not found! Iban invalid!";
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));
}
// GET: Deposit
public async Task <ActionResult> Index()
{
DepositRequestModel depositRequest = new DepositRequestModel();
var cardsFromDb = await _creditCardService.GetAllCreditCardsAsync(IdentityHelper.CurrentUserId);
foreach (CreditCardViewModel creditCard in cardsFromDb)
{
depositRequest.CreditCardItems.Add(
new SelectListItem
{
Value = creditCard.Id.ToString(),
Text = $"Card Number: {creditCard.Number}"
}
);
}
return(View(depositRequest));
}
public async Task <ActionResult> Index(DepositRequestModel model)
{
var user = await _userService.GetUserByIdAsync(IdentityHelper.CurrentUserId, IdentityHelper.CurrentUserId);
if (user != null)
{
DepositViewModel deposit = new DepositViewModel();
deposit.CreditCardId = model.Deposit.CreditCardId;
deposit.Amount = model.Deposit.Amount;
var res = await _depositService.CreateDepositAsync(deposit, user);
if (res)
{
return(RedirectToAction("Success", "Response", new { message = "successful" }));
}
}
return(RedirectToAction("Error", "Response", new { message = "Error when process " }));
}
public async Task <ActionResult <MessageModel> > DeleteDeposit(ClaimsPrincipal currentUser, DepositRequestModel requestModel)
{
string role = "";
var username = requestModel.Username;
Deposit deposit = requestModel.Deposit;
Deposit depositExists = 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
{
depositExists = await dbContext.Deposits.FirstOrDefaultAsync(x => x.Iban == deposit.Iban);
}
catch (NullReferenceException)
{
responseMessage.Message = "User doesn't have a Deposit";
return(StatusCode(400, responseMessage));
}
}
if (user == null)
{
responseMessage.Message = "User not found!";
return(StatusCode(404, responseMessage));
}
else if (depositExists == null)
{
responseMessage.Message = "User doesn't have a Deposit";
return(StatusCode(400, responseMessage));
}
dbContext.Deposits.Remove(depositExists);
await dbContext.SaveChangesAsync();
responseMessage.Message = $"Succsesfully deleted {user.Username} Deposit!";
return(StatusCode(200, responseMessage));
}
else
{
responseMessage.Message = "You are not authorized to do such actions";
return(StatusCode(403, responseMessage));
}
}
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> > CreateDeposit(ClaimsPrincipal currentUser, DepositRequestModel requestModel)
{
string role = "";
var username = requestModel.Username;
Deposit deposit = requestModel.Deposit;
if (currentUser.HasClaim(c => c.Type == "Roles"))
{
string userRole = currentUser.Claims.FirstOrDefault(currentUser => currentUser.Type == "Roles").Value;
role = userRole;
}
if (role == "Admin")
{
User userAuthenticate = null;
try
{
userAuthenticate = await dbContext.Users.FirstOrDefaultAsync(x => x.Username == username);
}
catch (NullReferenceException)
{
responseMessage.Message = "User not found";
return(StatusCode(404, responseMessage));
}
if (userAuthenticate != null)
{
try
{
if (dbContext.Deposits.Where(x => x.UserId == userAuthenticate.Id).Count() < 6)
{
if (ValidateUser(userAuthenticate) && ValidateDeposits(deposit))
{
deposit.Iban = IBANGenerator.GenerateIBANInVitoshaBank("Deposit", dbContext);
if (deposit.TermOfPayment == 3 || deposit.TermOfPayment == 6 || deposit.TermOfPayment == 12 || deposit.TermOfPayment == 1)
{
deposit.PaymentDate = DateTime.Now.AddMonths(deposit.TermOfPayment);
deposit.Divident = CalculateDivident.GetDividentPercent(deposit.Amount, deposit.TermOfPayment);
deposit.UserId = userAuthenticate.Id;
await dbContext.AddAsync(deposit);
await dbContext.SaveChangesAsync();
SendEmail(userAuthenticate.Email);
responseMessage.Message = "Deposit created succesfully";
return(StatusCode(200, responseMessage));
}
else
{
responseMessage.Message = "Deposit Term of paymet must be 1, 3, 6 or 12 months";
return(StatusCode(400, responseMessage));
}
}
else if (ValidateUser(userAuthenticate) == false)
{
responseMessage.Message = "User not found";
return(StatusCode(404, responseMessage));
}
else if (ValidateDeposits(deposit) == false)
{
responseMessage.Message = "Invalid payment amount!";
return(StatusCode(400, responseMessage));
}
else
{
return(null);
}
}
else
{
responseMessage.Message = "User already has the maximum of 5 Deposits!";
return(StatusCode(400, responseMessage));
}
}
catch (NullReferenceException)
{
responseMessage.Message = "Invalid credentials";
return(StatusCode(400, responseMessage));
}
}
else
{
responseMessage.Message = "User not found";
return(StatusCode(404, responseMessage));
}
}
else
{
responseMessage.Message = "You are not authorized to do such actions";
return(StatusCode(403, responseMessage));
}
}
//need Deposit(amount, term of payment), username
public async Task <ActionResult <MessageModel> > CreateDeposit(DepositRequestModel requestModel)
{
var currentUser = HttpContext.User;
return(await _depositService.CreateDeposit(currentUser, requestModel));
}
