public ActionResult Withdraw(CheckingAccount checkingAccount)
{
if (ModelState.IsValid)
{
CheckingTransactionsController c = new CheckingTransactionsController();
CheckingTransaction transaction;
var withdrawAmount = checkingAccount.Balance;
checkingAccount.Balance = (double)TempData["CheckingBalance"];
if (withdrawAmount > checkingAccount.Balance)
{
return(RedirectToAction("WithdrawDenied", new { id = checkingAccount.CustomerId }));
}
else
{
checkingAccount.Balance -= withdrawAmount;
transaction = c.CreateTransaction(checkingAccount.CustomerId, checkingAccount.Id, withdrawAmount, "Withdraw");
db.CheckingTransaction.Add(transaction);
db.Entry(checkingAccount).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", new { id = checkingAccount.CustomerId }));
}
}
ViewBag.CustomerId = new SelectList(db.Customers, "Id", "FirstName", checkingAccount.CustomerId);
return(RedirectToAction("Index", new { id = checkingAccount.CustomerId }));
}
public IActionResult NewBankAccount(AccountDetails account)
{
if (ModelState.IsValid)
{
BankDBContext db = new BankDBContext();
int accNum = 0;
var nextAccountNumber = (from num in db.NextAccountNumber
select num).Last();
accNum = 1 + nextAccountNumber.NextId;
account.AccountNumber = accNum;
db.AccountDetails.Add(account);
db.SaveChanges();
NextAccountNumber nextId = new NextAccountNumber();
nextId.NextId = accNum;
db.NextAccountNumber.Add(nextId);
db.SaveChanges();
ViewBag.data = accNum;
return(View("Confirmation"));
}
else
{
return(View());
}
}
public IActionResult PayeeAdd(Benficiarys ben)
{
ben.CreatedDate = DateTime.Now;
ben.Status = true;
if (string.IsNullOrEmpty(ben.Payee_Name))
{
ModelState.AddModelError("Payee Name", "Payee Name field is required");
}
if (string.IsNullOrEmpty(ben.Payee_Contact))
{
ModelState.AddModelError("contact", "contact field is required");
}
if (string.IsNullOrEmpty(ben.Bnak_name))
{
ModelState.AddModelError("Bankname", "Bank name field is required");
}
if (ModelState.IsValid)
{
_db.Benficiarys.Add(ben);
_db.SaveChanges();
return(RedirectToAction("Payees", "Home"));
}
return(View());
}
public void InitDBContext()
{
var accounts = Enumerable.Range(1, 3)
.Select(i => new Account {
AccountNo = "BK10" + i.ToString(), CustomerName = $"Smith{i} Baren{i}", LocalCurrencyCode = "GBP", AccountBalance = 0.00
});
_bankDBContext.Accounts.AddRange(accounts);
int changed = _bankDBContext.SaveChanges();
}
public ActionResult Edit([Bind(Include = "Id,AccountId,CustomerId,DateOfTransaction,Amount")] BusinessTransaction businessTransaction)
{
if (ModelState.IsValid)
{
db.Entry(businessTransaction).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(businessTransaction));
}
public int AddDetail(Customer cust)
{
if (db != null)
{
db.Customers.Add(cust);
db.SaveChanges();
return(1);
}
return(0);
}
public int AddDetail(BranchDetails details)
{
if (db != null)
{
db.Branches.Add(details);
db.SaveChanges();
return(details.CustomerId);
}
return(0);
}
public ActionResult Create([Bind(Include = "Id,AccountOneId,AccountTwoId")] Transfer transfer)
{
if (ModelState.IsValid)
{
db.Transfers.Add(transfer);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(transfer));
}
public ActionResult Create([Bind(Include = "CustomerId,FirstName,LastName,Email,loanAmount")] Customer customer)
{
if (ModelState.IsValid)
{
db.Customers.Add(customer);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(customer));
}
public ActionResult Create([Bind(Include = "LoanId,Amount,CustomerId,Active")] Loan loan)
{
if (ModelState.IsValid)
{
loan.Active = true;
db.Loans.Add(loan);
db.SaveChanges();
return(RedirectToAction("Index", new { id = loan.CustomerId }));
}
ViewBag.CustomerId = new SelectList(db.Customers, "Id", "FirstName", loan.CustomerId);
return(View(loan));
}
public ActionResult Create([Bind(Include = "Id,AccountId,CustomerId,DateOfTransaction,Amount")] CheckingTransaction checkingTransaction)
{
if (ModelState.IsValid)
{
db.CheckingTransaction.Add(checkingTransaction);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.AccountId = new SelectList(db.CheckingAccounts, "Id", "Id", checkingTransaction.AccountId);
ViewBag.CustomerId = new SelectList(db.Customers, "Id", "FirstName", checkingTransaction.CustomerId);
return(View(checkingTransaction));
}
public IActionResult Registration(Registration re)
{
if (ModelState.IsValid)
{
_db.RegistrationTable.Add(re);
_db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "Add All Fields");
}
return(View());
}
public List <Customer> deleteCustomer(string nID)
{
var db = new BankDBContext();
try
{
DbCustomer deleteCustomer = db.Customers.FirstOrDefault(pk => pk.NID.Equals(nID));
if (deleteCustomer == null)
{
return(null);
}
IEnumerable <DbAccount> accounts = db.Accounts.Where(a => a.NID.Equals(nID)).ToList();
IEnumerable <DbRegisteredPayment> registeredPayments;
IEnumerable <DbIssuedPayment> issuedPayments;
foreach (DbAccount account in accounts)
{
registeredPayments = db.RegisteredPayments.Where(rp => rp.customerAccountNumber.Equals(account.accountNumber)).ToList();
issuedPayments = db.IssuedPayments.Where(ip => ip.customerAccountNumber.Equals(account.accountNumber)).ToList();
foreach (DbRegisteredPayment rp in registeredPayments)
{
db.RegisteredPayments.Remove(rp);
db.SaveChanges();
}
foreach (DbIssuedPayment ip in issuedPayments)
{
db.IssuedPayments.Remove(ip);
db.SaveChanges();
}
db.Accounts.Remove(account);
db.SaveChanges();
}
db.Customers.Remove(deleteCustomer);
db.SaveChanges();
return(db.Customers.Select(c => new Customer()
{
nID = c.NID,
firstName = c.firstName,
lastName = c.lastName
})
.ToList());
}
catch (Exception e)
{
BankCustomerDAL.errorReport(e.ToString());
return(null);
}
}
public bool registerPayment(RegisteredPayment payment)
{
using (var db = new BankDBContext())
{
try
{
db.RegisteredPayments.Add(new DbRegisteredPayment()
{
customerAccountNumber = payment.cutomerAccountNumber,
targetAccountNumber = payment.targetAccountNumber,
amount = payment.amount,
customerAccountNumberFK = db.Accounts.FirstOrDefault(
a => a.accountNumber.Equals(payment.cutomerAccountNumber)),
paymentDate = payment.paymentDate,
receiverName = payment.receiverName
});
db.SaveChanges();
return(true);
}
catch (Exception e)
{
errorReport(e.ToString());
return(false);
}
}
}
public async Task ExecuteCommand()
{
//Check if the currency of deposit is not same as Account curency
if (_currencyCode != _account.LocalCurrencyCode)
{
double rate = await _exchangeRate.GetExchangeRate(_account.LocalCurrencyCode, _currencyCode);
_amount *= rate;
}
_account.AccountBalance += _amount;
Transaction transaction = new Transaction
{
account = (Account)_account,
DateTime = DateTime.Now,
Credit = _amount,
Reference = _reference,
Balance = _account.AccountBalance,
};
_context.Transactions.Add(transaction);
_context.SaveChanges();
IsCommandCompleted = true;
}
public bool Transfer(int sourceId, int destinationId, decimal amount, string note, int charge)
{
var db = new BankDBContext();
if (db.AccountHolders.Find(sourceId).Balance < amount)
{
return(false);
}
var user = db.AccountHolders.SingleOrDefault(user => user.Id == sourceId);
if (user == null)
{
return(false);
}
try
{
decimal txnCharge = (amount * charge) / 100;
Transaction txn = CreateTransaction(sourceId, destinationId, amount, note);
db.Transactions.Add(txn);
user.Balance -= (amount + txnCharge);
db.AccountHolders.Find(destinationId).Balance += amount;
db.SaveChanges();
}
catch (Exception)
{
return(false);
}
return(true);
}
public bool Withdrawal(decimal amount, int sourceAccountNumber, string note)
{
var db = new BankDBContext();
if (db.AccountHolders.Find(sourceAccountNumber).Balance < amount)
{
return(false);
}
var user = db.AccountHolders.SingleOrDefault(user => user.Id == sourceAccountNumber);
if (user == null)
{
return(false);
}
try
{
Transaction transaction = CreateTransaction(sourceAccountNumber, sourceAccountNumber, -amount, note);
db.Transactions.Add(transaction);
user.Balance -= amount;
db.SaveChanges();
}
catch (Exception)
{
return(false);
}
return(true);
}
public bool Deposite(decimal amount, int sourceAccountNumber)
{
var db = new BankDBContext();
if (amount <= 0)
{
return(false);
}
var user = db.AccountHolders.SingleOrDefault(user => user.Id == sourceAccountNumber);
if (user == null)
{
return(false);
}
try
{
Transaction txn = CreateTransaction(sourceAccountNumber, sourceAccountNumber, amount, "Money deposited");
db.Transactions.Add(txn);
user.Balance += amount;
db.SaveChanges();
}
catch (Exception)
{
return(false);
}
return(true);
}
public bool adminEditCustomer(Customer customer)
{
using (var db = new BankDBContext())
{
try
{
DbCustomer dbcustomer = db.Customers.FirstOrDefault(c => c.NID == customer.nID);
if (dbcustomer != null)
{
dbcustomer.firstName = customer.firstName;
dbcustomer.lastName = customer.lastName;
string salt = BankCustomerDAL.generateSalt();
string passwordAndSalt = customer.password + salt;
byte[] hashedpassword = BankCustomerDAL.generateHash(passwordAndSalt);
dbcustomer.password = hashedpassword;
dbcustomer.salt = salt;
db.SaveChanges();
return(true);
}
}
catch (Exception e)
{
BankCustomerDAL.errorReport(e.ToString());
return(false);
}
return(false);
}
}
public bool AddNewCurrency(string symbol, string name, decimal exchangeRate)
{
if (exchangeRate == 0)
{
return(false);
}
if (name.Length < 3 || symbol.Length != 3)
{
return(false);
}
Currency currency = new Currency()
{
Symbol = symbol,
Name = name,
ExchangeRate = exchangeRate,
IsDefault = false,
};
var db = new BankDBContext();
db.Currencies.Add(currency);
db.SaveChanges();
return(true);
}
public bool adminRegisterCustomer(Customer inCustomer)
{
try
{
var newCustomer = new DbCustomer()
{
firstName = inCustomer.firstName,
lastName = inCustomer.lastName,
NID = inCustomer.nID
};
var db = new BankDBContext();
string salt = BankCustomerDAL.generateSalt();
string passwordAndSalt = inCustomer.password + salt;
byte[] hashedpassword = BankCustomerDAL.generateHash(passwordAndSalt);
newCustomer.password = hashedpassword;
newCustomer.salt = salt;
db.Customers.Add(newCustomer);
db.SaveChanges();
return(true);
}
catch (Exception e)
{
BankCustomerDAL.errorReport(e.ToString());
return(false);
}
}
public bool registerDirectPayment(IssuedPayment payment)
{
using (var db = new BankDBContext())
{
try
{
db.IssuedPayments.Add(new DbIssuedPayment()
{
customerAccountNumber = payment.cutomerAccountNumber,
targetAccountNumber = payment.targetAccountNumber,
amount = payment.amount,
customerAccountNumberFK = db.Accounts.FirstOrDefault(
a => a.accountNumber.Equals(payment.cutomerAccountNumber)),
issuedDate = payment.issuedDate,
receiverName = payment.receiverName
});
DbAccount targetAccount = db.Accounts.FirstOrDefault(
a => a.accountNumber.Equals(payment.targetAccountNumber));
targetAccount.balance -= payment.amount;
DbAccount customerAccount = db.Accounts.FirstOrDefault(
a => a.accountNumber.Equals(payment.cutomerAccountNumber));
customerAccount.balance += payment.amount;
db.SaveChanges();
return(true);
}
catch (Exception e)
{
errorReport(e.ToString());
return(false);
}
}
}
private void Btn_Go_Click(object sender, EventArgs e)
{
using (BankDBContext bankDBContext = new BankDBContext())
{
var a = bankDBContext.Users.ToList();
foreach (var item in a)
{
if (TxbPassportNumber.Text == item.PasportNumber)
{
int.TryParse(TxbAmount.Text, out int amount);
if (amount != 0)
{
bankDBContext.CreditInfos.Add(new CreditInfo()
{
Amount = Convert.ToDouble(TxbAmount.Text),
DateCredit = dateTimePickerDateCredit.Value,
UserId = item.Id
});
bankDBContext.SaveChanges();
}
}
}
}
}
public bool editPayment(RegisteredPayment payment)
{
using (var db = new BankDBContext())
{
DbRegisteredPayment regPayment = db.RegisteredPayments.
FirstOrDefault(rp => rp.id == payment.id);
if (regPayment != null)
{
try
{
regPayment.customerAccountNumber = payment.cutomerAccountNumber;
regPayment.targetAccountNumber = payment.targetAccountNumber;
regPayment.amount = payment.amount;
regPayment.paymentDate = payment.paymentDate;
db.SaveChanges();
return(true);
}
catch (Exception e)
{
errorReport(e.ToString());
return(false);
}
}
return(false);
}
}
public List <Account> newAccount(string nID)
{
string newAccountNumber = generateBankAccountNumber();
var db = new BankDBContext();
/*if (db.isAccountAlreadyPresent(newAccountNumber))
* {
*
* }
*/
var accountNew = new DbAccount()
{
accountNumber = "0539" + newAccountNumber,
balance = 0,
NID = nID
};
try
{
db.Accounts.Add(accountNew);
db.SaveChanges();
return(db.Accounts.
Where(a => a.NID.Equals(nID)).Select(a => new Account()
{
accountNumber = a.accountNumber,
balance = a.balance,
nID = a.NID
}).ToList());
}
catch (Exception e)
{
BankCustomerDAL.errorReport(e.ToString());
return(null);
}
}
public bool RevertTransaction(string transactionId)
{
try
{
var db = new BankDBContext();
var transaction = db.Transactions.SingleOrDefault(txn => txn.TxnId == transactionId);
if (transaction == null || transaction.IsRevereted == true)
{
return(false);
}
db.Transactions.Find(transactionId).IsRevereted = true;
if (transaction.SourceId != transaction.DestinationId)
{
db.AccountHolders.Find(transaction.SourceId).Balance += transaction.Amount;
db.AccountHolders.Find(transaction.DestinationId).Balance -= transaction.Amount;
}
else
{
db.AccountHolders.Find(transaction.SourceId).Balance -= transaction.Amount;
}
db.SaveChanges();
}
catch (Exception)
{
return(false);
}
return(true);
}
public void InsertAccount(Account account)
{
using (var ctx = new BankDBContext())
{
ctx.Accounts.Add(account);
ctx.SaveChanges();
}
}
public void InsertDeposit(Deposit deposit)
{
using (var ctx = new BankDBContext())
{
ctx.Deposits.Add(deposit);
ctx.SaveChanges();
}
}
public void InsertClient(Client client)
{
using (var ctx = new BankDBContext())
{
ctx.Clients.Add(client);
ctx.SaveChanges();
}
}
public int CreateAccountHolder(AccountHolder accountHolder)
{
try
{
_context.AccountHolders.Add(accountHolder);
_context.SaveChanges();
return(accountHolder.Id);
}
catch (Exception ea)
{
Console.WriteLine($"err2: {ea.Message}");
}
return(0);
}
