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 Account SelectAccount(int clientId)
{
using (var ctx = new BankDBContext())
{
return(ctx.Accounts.Where(x => x.ClientId == clientId).FirstOrDefault());
}
}
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 Setup()
{
_config = program.InitConfiguration();
//Account to create
_account = new Account()
{
AccountNo = "AC345",
CustomerName = "Smith1 Barens1",
LocalCurrencyCode = "GBP"
};
//Db Set up
var connection = _config["ConnectionString:BankDb"];
var builder = new DbContextOptionsBuilder <BankDBContext>()
.UseSqlServer(connection);
_bankDBContext = new BankDBContext(builder.Options);
//Delete If exists
ClearDbData();
//Set up DB
InitDBContext();
_exchangeRate = new ExchangeRate(_config);
//_bankDBContext.Accounts
}
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 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 Department SelectDepartment(int id)
{
using (var ctx = new BankDBContext())
{
return(ctx.Departments.Where(x => x.Id == id).FirstOrDefault());
}
}
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);
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, BankDBContext db)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
db.Database.EnsureCreated();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
}
public Account findAccount(string accNumber)
{
var db = new BankDBContext();
try
{
var foundAccount = db.Accounts.FirstOrDefault(pk => pk.accountNumber.Equals(accNumber));
System.Diagnostics.Debug.WriteLine("TEST DAL FINDACCOUNT: " + foundAccount.accountNumber);
if (foundAccount == null)
{
return(null);
}
else
{
var account = new Account()
{
accountNumber = foundAccount.accountNumber,
balance = foundAccount.balance,
nID = foundAccount.NID
};
return(account);
}
}
catch (Exception e)
{
BankCustomerDAL.errorReport(e.ToString());
return(null);
}
}
public Customer findCustomer(string nID)
{
var db = new BankDBContext();
try
{
var foundCustomer = db.Customers.FirstOrDefault(pk => pk.NID.Equals(nID));
if (foundCustomer == null)
{
return(null);
}
else
{
var customer = new Customer()
{
nID = foundCustomer.NID,
firstName = foundCustomer.firstName,
lastName = foundCustomer.lastName
};
return(customer);
}
}
catch (Exception e)
{
BankCustomerDAL.errorReport(e.ToString());
return(null);
}
}
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 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 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 RegisteredPayment findRegisteredPayment(int id)
{
using (var db = new BankDBContext())
{
try
{
DbRegisteredPayment dbPayment = db.RegisteredPayments.FirstOrDefault(
p => p.id == id);
if (dbPayment == null)
{
return(null);
}
RegisteredPayment rp = new RegisteredPayment()
{
id = dbPayment.id,
cutomerAccountNumber = dbPayment.customerAccountNumber,
targetAccountNumber = dbPayment.targetAccountNumber,
amount = dbPayment.amount,
paymentDate = dbPayment.paymentDate,
receiverName = dbPayment.receiverName
};
return(rp);
}
catch (Exception e)
{
return(null);
}
}
}
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 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);
}
}
}
public string getRegisteredPaymentAccount(int id)
{
using (var db = new BankDBContext())
{
return(db.RegisteredPayments.FirstOrDefault(p => p.id == id).customerAccountNumberFK.accountNumber);
}
}
public List <RegisteredPayment> getRegisteredPayments(string accountNumber)
{
using (var db = new BankDBContext())
{
try
{
List <RegisteredPayment> registeredPayments = new List <RegisteredPayment>();
IEnumerable <DbRegisteredPayment> dbRegisteredPayments = db.RegisteredPayments.
Where(a => a.customerAccountNumber.Equals(accountNumber)).ToList();
foreach (DbRegisteredPayment regPayment in dbRegisteredPayments)
{
registeredPayments.Add(new RegisteredPayment()
{
id = regPayment.id,
cutomerAccountNumber = regPayment.customerAccountNumber,
targetAccountNumber = regPayment.targetAccountNumber,
amount = regPayment.amount,
paymentDate = regPayment.paymentDate,
receiverName = regPayment.receiverName
});
}
return(registeredPayments);
}
catch (Exception e)
{
errorReport(e.ToString());
return(null);
}
}
}
public List <Account> getCustomerAccounts(string nid)
{
try
{
using (var db = new BankDBContext())
{
List <Account> accounts = new List <Account>();
List <DbAccount> dbAccounts = db.Accounts.Where(a => a.NID.Equals(nid)).ToList();
foreach (DbAccount dba in dbAccounts)
{
accounts.Add(new Account()
{
accountNumber = dba.accountNumber,
balance = dba.balance,
nID = dba.NID
});
}
return(accounts);
}
}
catch (Exception e)
{
return(null);
}
}
public CreateAccount(IAccount account, BankDBContext context)
{
_account = account;
_context = context;
IsCommandCompleted = false;
}
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 void Setup()
{
var cust = new List <Customer>
{
new Customer {
CustomerId = 1, Name = "Dummy1", Address = "Dummy Address 1", DOB = new DateTime(1996 - 10 - 29), AdharCardNo = "12345", PhoneNo = "1122334455", Email = "*****@*****.**", AccountType = "Savings", Balance = 5000
},
new Customer {
CustomerId = 2, Name = "Dummy2", Address = "Dummy Address 2", DOB = new DateTime(1997 - 02 - 29), AdharCardNo = "12346", PhoneNo = "1122334466", Email = "*****@*****.**", AccountType = "Current", Balance = 6000
},
new Customer {
CustomerId = 3, Name = "Dummy3", Address = "Dummy Address 3", DOB = new DateTime(1999 - 11 - 29), AdharCardNo = "12347", PhoneNo = "1122334477", Email = "*****@*****.**", AccountType = "Savings", Balance = 7000
},
new Customer {
CustomerId = 4, Name = "Dummy4", Address = "Dummy Address 4", DOB = new DateTime(1998 - 09 - 29), AdharCardNo = "12348", PhoneNo = "1122334488", Email = "*****@*****.**", AccountType = "Current", Balance = 8000
}
};
var loandata = cust.AsQueryable();
var mockSet = new Mock <DbSet <Customer> >();
mockSet.As <IQueryable <Customer> >().Setup(m => m.Provider).Returns(loandata.Provider);
mockSet.As <IQueryable <Customer> >().Setup(m => m.Expression).Returns(loandata.Expression);
mockSet.As <IQueryable <Customer> >().Setup(m => m.ElementType).Returns(loandata.ElementType);
mockSet.As <IQueryable <Customer> >().Setup(m => m.GetEnumerator()).Returns(loandata.GetEnumerator());
var mockContext = new Mock <BankDBContext>();
mockContext.Setup(c => c.Customers).Returns(mockSet.Object);
db = mockContext.Object;
}
public BankConstants.LoginStatus LoginUser(User inputUser)
{
try
{
var db = new BankDBContext();
var accountHolder = from acc in db.AccountHolders
where acc.User.Name == inputUser.Name && acc.User.Password == inputUser.Password
select acc;
if (accountHolder != null)
{
return(BankConstants.LoginStatus.AccountHolder);
}
else
{
var employee = from emp in db.Employees
where emp.User.Name == inputUser.Name && emp.User.Password == inputUser.Password
select emp;
if (employee != null)
{
return(BankConstants.LoginStatus.Employee);
}
else
{
return(BankConstants.LoginStatus.UserNotFound);
}
}
}
catch (Exception)
{
return(BankConstants.LoginStatus.Error);
}
}
public void Setup()
{
var branch = new List <BranchDetails>
{
new BranchDetails {
BranchId = 1, CustomerId = 1, Location = "Dummy Location 1", IFSC = "12345"
},
new BranchDetails {
BranchId = 2, CustomerId = 2, Location = "Dummy Location 2", IFSC = "12347"
},
new BranchDetails {
BranchId = 4, CustomerId = 2, Location = "Dummy Location 2", IFSC = "12347"
}
};
var branchdata = branch.AsQueryable();
var mockSet = new Mock <DbSet <BranchDetails> >();
mockSet.As <IQueryable <BranchDetails> >().Setup(m => m.Provider).Returns(branchdata.Provider);
mockSet.As <IQueryable <Customer> >().Setup(m => m.Expression).Returns(branchdata.Expression);
mockSet.As <IQueryable <BranchDetails> >().Setup(m => m.ElementType).Returns(branchdata.ElementType);
mockSet.As <IQueryable <BranchDetails> >().Setup(m => m.GetEnumerator()).Returns(branchdata.GetEnumerator());
var mockContext = new Mock <BankDBContext>();
mockContext.Setup(d => d.Branches).Returns(mockSet.Object);
db = mockContext.Object;
}
public IActionResult SelectAccount(string accNo)
{
int AccNo = Convert.ToInt32(accNo);
BankDBContext db = new BankDBContext();
var error = (from acc in db.OnlineAccounts
where acc.AccountNumber == AccNo
select acc).ToList();
AccountDetails account = (from acc in db.AccountDetails
where acc.AccountNumber == AccNo
select acc).FirstOrDefault();
ViewBag.data = account;
if (error.Count != 0)
{
List <AccountDetails> values = (from acc in db.AccountDetails
where acc.Ssn == account.Ssn
select acc).ToList();
ViewBag.err = "Online Account for account number " + AccNo + " already exists";
return(View(values));
}
return(View("CreateOnlineAccount"));
}
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 void InsertClient(Client client)
{
using (var ctx = new BankDBContext())
{
ctx.Clients.Add(client);
ctx.SaveChanges();
}
}
public Withdraw(Account account, double amount, string reference, BankDBContext context)
{
_account = account;
_amount = amount;
_context = context;
_reference = reference;
IsCommandCompleted = false;
}
