public ActionResult _Destroy([DataSourceRequest]DataSourceRequest request, BankExt model)
{
string Msg = "";
try
{
BankRepository modelRepo = new BankRepository();
if (modelRepo.Delete(model, ref Msg, this) == false)
{
return this.Json(new DataSourceResult { Errors = Msg });
}
}
catch (Exception ex)
{
string hostName1 = Dns.GetHostName();
string GetUserIPAddress = Dns.GetHostByName(hostName1).AddressList[0].ToString();
string PageName = Convert.ToString(Session["PageName"]);
//string GetUserIPAddress = GetUserIPAddress1();
using (BaseRepository baseRepo = new BaseRepository())
{
//BizContext BizContext1 = new BizContext();
BizApplication.AddError(baseRepo.BizDB, PageName, ex.Message, ex.StackTrace, DateTime.Now, GetUserIPAddress);
}
Session["PageName"] = "";
string error = ErrorHandling.HandleException(ex);
return this.Json(new DataSourceResult { Errors = error });
}
return Json(request);
}
public override void CreateChildViews(View parent, Bundle bundle)
{
base.CreateChildViews(parent, bundle);
bankRepository = Resolve<BankRepository>();
SetTitle(Resource.String.receive_cheque);
SetupBankViews(parent);
SetupChequeNumber(parent);
SetupDueDate(parent);
}
public UnitOfWork(INavyAccountDbContext context)
{
this.context = context;
Users = new UserRepository(context);
Menus = new MenuRepository(context);
RoleMenus = new RoleMenuRepository(context);
MenuGroups = new MenuGroupRepository(context);
UserRoles = new UserRoleRepository(context);
FundType = new FundTypeRepo(context);
actType = new AccountTypeRepository(context);
balSheet = new BalanceSheetRepository(context);
mainAccount = new MainAccountRepository(context);
accountChart = new ChartRepository(context);
subtype = new SubTypeRepository(context);
fundTypeCode = new FundTypeRepository(context);
loanType = new LoanTypeRepo(context);
rank = new RankRepo(context);
person = new PersonRepo(context);
beneficiary = new BeneficiaryRepo(context);
bank = new BankRepository(context);
pfundrate = new PfFundRateRepository(context);
contribution = new NPFContributionRepository(context);
loanRegisterRepository = new LoanRegisterRepository(context);
register = new InvestmentRegisterRepository(context);
loanStatus = new LoanStatusRepository(context);
schedule = new LoanScheduleRepository(context);
balance = new TrialBalanceRepository(context);
accountHistory = new AccountHistoryRepository(context);
npf_Ledgers = new LedgerRepositoy(context);
report = new TrialBalanceReportRepository(context);
history = new TrialBalanceHistoryRepository(context);
pf_loandisc = new LoandiscRepo(context);
loanPerRank = new LoanPerRankRepository(context);
claimregister = new ClaimRepository(context);
npfHistories = new FinancialDocRepo(context);
trail = new AuditRailRepository(context);
npf_contrdisc = new ContrRepo(context);
surplus = new SurplusRepository(context);
cam = new ClaimTypeRepository(context);
navip = new NavipRepository(context);
loantypereview = new LoanTypeReviewRepo(context);
}
public async Task CreateTransactionAsync_ShouldReturnTransactionResultFromCreateBankTransactionResponse()
{
//Arrange
var bankTransactionRequest = GetBankTransactionObject();
var createBankTransactionResponse = GetCreateBankTransactionResponse();
var expectedTransactionResult =
GetTransactionResultFromCreateBankTransactionResponse(createBankTransactionResponse);
_bankHttpClientMock.Setup(x => x.CreateTransactionAsync(It.IsAny <CreateBankTransactionRequest>()))
.ReturnsAsync(createBankTransactionResponse);
var sut = new BankRepository(_bankHttpClientMock.Object, _mapper);
//Act
var result = await sut.CreateTransactionAsync(bankTransactionRequest);
//Assert
result.Should().BeEquivalentTo(expectedTransactionResult);
}
public void VerifyDepositWorks()
{
var testAccount = new Account(1, new Customer(), 3000);
BankRepository.AddAccount(testAccount);
var account = BankRepository.GetAccount(1);
var amountToDeposit = 3000;
var transaction = new DepositWithrawVM {
AccountNumber = account.Id, Amount = amountToDeposit
};
var expected = account.Balance + amountToDeposit;
Bank.Deposit(transaction);
var actual = BankRepository.GetAccount(1).Balance;
Assert.Equal(expected, actual);
}
public void VerifyInsufficientFundsWorks()
{
var testAccount = new Account(4, new Customer(), 7000);
BankRepository.AddAccount(testAccount);
var account = BankRepository.GetAccount(4);
var amountToWithraw = 8000;
var transaction = new DepositWithrawVM {
AccountNumber = account.Id, Amount = amountToWithraw
};
var expected = 7000;
Bank.Withraw(transaction);
var actual = BankRepository.GetAccount(4).Balance;
Assert.Equal(expected, actual);
}
public void SuccessfullTransfer()
{
var accountSender = Customer.Accounts.First();
var accountReceiver = Customer.Accounts.Last();
decimal transferAmount = 500M;
var expectedBalanceOnSenderAccount = 4500M;
var expectedBalanceOnReceiverAccount = 5500M;
var expectedMsg = $"Successfully transferred {transferAmount} from account {accountSender.AccountId}. " +
$"Current balance on accounts: {accountSender.AccountId} = {accountSender.Balance}. " +
$"{accountReceiver.AccountId} = {accountReceiver.Balance}";
BankRepository.AddAccounts(Customer.Accounts);
var result = BankRepository.Transfer(accountSender.AccountId, accountReceiver.AccountId, transferAmount);
Assert.Equal(result, expectedMsg);
Assert.Equal(expectedBalanceOnSenderAccount, accountSender.Balance);
Assert.Equal(expectedBalanceOnReceiverAccount, accountReceiver.Balance);
}
public void WithdrawalMoreMoneyThanBalanceTest()
{
//Arrange
BankRepository bankRepository = new BankRepository();
BankService bankService = new BankService(bankRepository);
Customer oneCustomer = bankRepository.GetAllCustomers().First();
Account account = oneCustomer.AccountList.First();
decimal amount = 100;
decimal expectedResult = account.Balance;
//Act
bankService.Withdrawal(account.AccountNumber, account.Balance + amount);
//Assert
decimal result = account.Balance;
Assert.AreEqual(expectedResult, result);
}
public void TestDeposit_Success()
{
BankRepository repo = new BankRepository();
Account TestAccount = new Account
{
AccountNumber = 0,
Balance = 1000m,
Customer = new Customer {
Name = "Testman", CustomerID = 0
}
};
decimal depositAmount = 1000m;
repo.Accounts.Add(TestAccount);
string result = repo.Deposit(TestAccount.AccountNumber, depositAmount);
Assert.Equal("Success", result);
Assert.Equal(2000m, TestAccount.Balance);
}
public IActionResult Index(int FromAccountId, int ToAccountId, decimal Amount)
{
BankRepository bank = BankRepository.Instance;
ResponseMessage Message = new ResponseMessage();
var accFrom = bank.Accounts.Where(a => a.AccountNumber == FromAccountId).FirstOrDefault();
var accTo = bank.Accounts.Where(a => a.AccountNumber == ToAccountId).FirstOrDefault();
if (accFrom != null && accTo != null)
{
Message = accFrom.TransferMoney(accTo, Amount);
return(View(Message));
}
else
{
Message.Success = false;
Message.Message = "Något av kontona finns inte";
return(View(Message));
}
}
public void TransferToSuccess()
{
int AccountID = 1;
int AccountID2 = 2;
int Cash = 7000;
var AccountFrom = BankRepository.GetAccountById(AccountID);
var AccountTo = BankRepository.GetAccountById(AccountID2);
AccountFrom.Cash = 10000;
AccountTo.Cash = 0;
AccountFrom.TransferFromThis(AccountTo.AccountID, Cash);
int expected = 7000;
int actual = AccountTo.Cash;
Assert.Equal(expected, actual);
}
public void TestWithdrawal_Deny()
{
BankRepository repo = new BankRepository();
Account TestAccount = new Account
{
AccountNumber = 0,
Balance = 1000m,
Customer = new Customer {
Name = "Testman", CustomerID = 0
}
};
decimal withdrawalAmount = 2000m;
repo.Accounts.Add(TestAccount);
string result = repo.Withdraw(TestAccount.AccountNumber, withdrawalAmount);
Assert.Equal("Insufficient balance", result);
Assert.Equal(1000m, TestAccount.Balance);
}
public void Should_Not_Allow_Transfer_When_Not_Not_Enough_Money()
{
//Arrange
var bankRepository = new BankRepository();
var bankService = new BankService(bankRepository);
var fromAccount = bankRepository.Accounts.First();
var toAccount = bankRepository.Accounts.Last();
decimal balanceToTransfer = fromAccount.Balance + 1;
decimal fromAccountBalanceBefore = fromAccount.Balance;
decimal toAccountBalanceBefore = toAccount.Balance;
//Act
var result = bankService.Transfer(fromAccount.Id, toAccount.Id, balanceToTransfer);
//Assert
Assert.False(result);
Assert.Equal(fromAccountBalanceBefore, fromAccount.Balance);
Assert.Equal(toAccountBalanceBefore, toAccount.Balance);
}
public async Task <IActionResult> UpdatebillPay(int billPayID, int from_account, decimal amount, string schedule_date, int Period)
{
BillPay billPay = await _context.BillPay.FindAsync(billPayID);
if (amount <= 0)
{
ModelState.AddModelError(nameof(amount), "Amount must be positive.");
}
if (amount.HasMoreThanTwoDecimalPlaces())
{
ModelState.AddModelError(nameof(amount), "Amount cannot have more than 2 decimal places.");
}
if (!ModelState.IsValid)
{
ViewBag.Amount = amount;
return(RedirectToAction(nameof(ShowModifyBillPay)));
}
try
{
var BankObj = new BankRepository(_context);
var postId = await BankObj.UpdateBillPay(billPayID, from_account, amount, schedule_date, Period, false);
if (postId > 0)
{
return(RedirectToAction(nameof(Index)));
}
else
{
ViewBag.ErrorTitle = "UpdateBillPay Page Post";
ViewBag.ErrorMessage = "404: Update Bill Pay page not found...";
return(View("Error"));
}
}
catch (Exception)
{
ViewBag.ErrorTitle = "UpdateBillPay Page Post";
ViewBag.ErrorMessage = "404: Update Bill Pay page not found...";
return(View("Error"));
}
}
public IActionResult Transfer(TransferViewModel model)
{
if (ModelState.IsValid)
{
if (model.FromAccountNumber == model.ToAccountNumber)
{
TempData["response"] = "Du kan inte överföra mellan samma konto";
return(View(model));
}
BankRepository repo = new BankRepository();
Account from = repo.GetAccount(model.FromAccountNumber);
Account to = repo.GetAccount(model.ToAccountNumber);
if (from == null || to == null)
{
if (from == null)
{
TempData["fromNull"] = $"Kontonummret {model.FromAccountNumber} kunde inte hittas";
}
if (to == null)
{
TempData["toNull"] = $"Kontonummret {model.ToAccountNumber} kunde inte hittas";
}
return(View(model));
}
bool transferSuccess = from.Transfer(to, model.Amount);
if (transferSuccess)
{
TempData["response"] = $"Överföring genomförd! Konto nr:{from.AccountNumber} summa: {from.Balance} Konto nr:{to.AccountNumber} summa: {to.Balance}";
}
else
{
TempData["response"] = $"Du kan inte överföra mer pengar än det finns på kontot! Konto nr:{from.AccountNumber} summa: {from.Balance}";
}
}
return(View(model));
}
public void Transfer_Between_Accounts_Are_Successful()
{
BankRepository bankRepository = new BankRepository();
BankService bankService = new BankService(bankRepository);
Customer fromCustomer = bankRepository.GetAllCustomers().First();
Customer toCustomer = bankRepository.GetAllCustomers().Last();
Account fromAccount = fromCustomer.AccountList.First();
Account toAccount = toCustomer.AccountList.First();
decimal sum = 500;
var expectedBalanceOnFromAccount = fromAccount.Balance - sum;
var expectedBalanceOnToAccont = toAccount.Balance + sum;
// Act
var isSuccess = bankService.Transfer(fromAccount.AccountNumber, toAccount.AccountNumber, sum, out string message);
// Assert
Assert.AreEqual(expectedBalanceOnFromAccount, fromAccount.Balance);
Assert.AreEqual(expectedBalanceOnToAccont, toAccount.Balance);
}
public void AfterWithrawalAccountShouldHaveUpdatedBalanceTest()
{
BankRepository bankRepository = new BankRepository();
BankService bankService = new BankService(bankRepository);
Customer oneCustomer = bankRepository.GetAllCustomers().First();
Account account = oneCustomer.AccountList.First();
//Arrange
decimal currentBalance = account.Balance;
decimal amount = 100;
decimal expectedResult = currentBalance - amount;
//Act
bankService.Withdrawal(account.AccountNumber, amount);
//Assert
var result = account.Balance;
Assert.AreEqual(expectedResult, result);
}
public void Transfer_Too_Low_Balance_Test()
{
Account recieve = new Account();
{
recieve.AccountId = 13019;
recieve.Balance = 5000;
}
Account transfer = new Account();
{
transfer.AccountId = 13019;
transfer.Balance = 1000;
}
BankRepository _bankRepo = new BankRepository();
bool expected = false;
bool actual = _bankRepo.PerformTransfer(recieve, transfer, 2000);
Assert.Equal(expected, actual);
}
public IActionResult TransferMoney(TransferViewModel vm)
{
if (!ModelState.IsValid)
{
vm.Message = "Failed to transfer, please check your inputs.";
return(View("TransferMoney", vm));
}
;
var acc = BankRepository.GetAccountFromAccountNumber(vm.FromAccountId);
if (acc == null)
{
vm.Message = "Wrong account information. No accounts found with account number: " + vm.FromAccountId;
}
else
{
vm.Message = BankRepository.GetAccountFromAccountNumber(vm.FromAccountId).Transfer(vm.ToAccountId, vm.Amount);
}
return(View("TransferMoney", vm));
}
public void TestCorrectWithEmptyResult()
{
var bank1 = new Bank {
Name = "Name1"
};
var dataSet = new List <Bank>
{
bank1,
new Bank {
Name = "Name2"
}
}.AsQueryable();
var unitOfWorkMock = UnitOfWorkMock(dataSet);
var bankRepository = new BankRepository(unitOfWorkMock.Object);
var resultAwaiter = bankRepository.FindByNameAsync("Not have that bank").GetAwaiter();
var result = resultAwaiter.GetResult();
Assert.IsNull(result);
}
public void TransferHigherAmount_Test()
{
Account account1 = new Account();
{
account1.Accountnumber = 12345;
account1.Balance = 1259;
}
Account account2 = new Account();
{
account2.Accountnumber = 23456;
account2.Balance = 22998.4;
}
BankRepository bankRepository = new BankRepository();
var expected = false;
var actual = bankRepository.TransferBetweenAccounts(8000, account1, account2);
Assert.Equal(expected, actual);
}
public void TestNullableInputArgument()
{
var bank1 = new Bank {
Name = "Name1"
};
var dataSet = new List <Bank>
{
bank1,
new Bank {
Name = "Name2"
}
}.AsQueryable();
var unitOfWorkMock = UnitOfWorkMock(dataSet);
var bankRepository = new BankRepository(unitOfWorkMock.Object);
var resultAwaiter = bankRepository.FindByNameAsync(null).GetAwaiter();
var result = resultAwaiter.GetResult();
Assert.IsNull(result);
}
public async Task <IActionResult> Deposit(int id, decimal amount)
{
Account account = await _context.Accounts.FindAsync(id);
if (amount <= 0)
{
ModelState.AddModelError(nameof(amount), "Amount must be positive.");
}
if (amount.HasMoreThanTwoDecimalPlaces())
{
ModelState.AddModelError(nameof(amount), "Amount cannot have more than 2 decimal places.");
}
if (!ModelState.IsValid)
{
ViewBag.Amount = amount;
return(View(account));
}
try
{
var BankObj = new BankRepository(_context);
var postId = await BankObj.Deposit(account, amount);
if (postId > 0)
{
return(RedirectToAction(nameof(Index)));
}
else
{
return(NotFound());
}
}
catch (Exception)
{
ViewBag.ErrorTitle = "Deposit Post.";
ViewBag.ErrorMessage = "Error in Deposit form. Plaese try again...";
return(View("Error"));
}
}
public async Task <IActionResult> UpdatebillPay(int billPayID, int AccountNumber, decimal amount, string schedule_date, int Period, bool IsBlocked)
{
BillPay billPay = await _context.BillPay.FindAsync(billPayID);
if (amount <= 0)
{
ModelState.AddModelError(nameof(amount), "Amount must be positive.");
}
if (amount.HasMoreThanTwoDecimalPlaces())
{
ModelState.AddModelError(nameof(amount), "Amount cannot have more than 2 decimal places.");
}
if (!ModelState.IsValid)
{
ViewBag.Amount = amount;
//return View(account);
return(RedirectToAction(nameof(ShowModifyBillPay)));
}
try
{
var BankObj = new BankRepository(_context);
var postId = await BankObj.UpdateBillPay(billPayID, AccountNumber, amount, schedule_date, Period, IsBlocked);
if (postId > 0)
{
//return Ok(postId);
//return RedirectToAction(nameof(Index));
return(RedirectToAction("Index", "Admin"));
}
else
{
return(NotFound());
}
}
catch (Exception)
{
return(BadRequest());
}
}
public static void Main(string[] args)
{
var services = new ServiceCollection();
services.AddDbContext <AccountContext>(builder => builder.UseSqlServer(Constants.ConnectionString));
var serviceProvider = services.BuildServiceProvider();
BankRepository repository = new BankRepository(serviceProvider.GetService <AccountContext>());
List <Account> accounts = repository.GetAccounts().Result;
Console.WriteLine("1 - create Account; 2 - Exit");
string command = Console.ReadLine();
switch (int.Parse(command))
{
case 1:
{
Console.WriteLine("Inter Name");
string name = Console.ReadLine();
Console.WriteLine("Inter Percentage");
string percentage = Console.ReadLine();
repository.CreateAccount(new Account {
Name = name, Percentage = int.Parse(percentage)
});
}
break;
case 2: break;
}
foreach (var a in accounts)
{
Console.WriteLine(a.Name);
}
Console.ReadKey();
}
public void PrintAllBanks()
{
BankRepository bankRepository = new BankRepository();
var bankCustomer = bankRepository.GetTransactionsFromBankCustomersAccounts();
foreach (var bC in bankCustomer)
{
Console.WriteLine(bC.ToString());
foreach (var c in bC.Customer)
{
Console.WriteLine(c.ToString());
foreach (var cAccount in c.Account)
{
Console.WriteLine($"\t{cAccount.ToString()}");
foreach (var trn in cAccount.Transaction)
{
Console.WriteLine($"\t{trn.ToString()}");
}
}
}
}
}
public IActionResult Deposit(TransactionVM model)
{
var repo = BankRepository.Instance();
if (ModelState.IsValid)
{
try
{
var account = repo.GetAccount(model.AccountNum);
repo.Deposit(account, model.Amount);
var accountVM = AccountVM.Create(account);
return(View("TransactionSuccess", accountVM));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
}
return(View("Index", model));
}
public void TransferInsufficiantFunds()
{
var testAccount = new Account(11, new Customer(), 1000);
BankRepository.AddAccount(testAccount);
var testAccount2 = new Account(12, new Customer(), 1000);
BankRepository.AddAccount(testAccount2);
var transfer = new TransferVM
{
FromAccountNumber = 11,
ToAccountNumber = 12,
Amount = 1001
};
Bank.Transfer(transfer);
var expected = 1000;
var actual = BankRepository.GetAccount(11).Balance;
Assert.Equal(expected, actual);
}
public void VerifyTransferDestination()
{
var testAccount = new Account(9, new Customer(), 1000);
BankRepository.AddAccount(testAccount);
var testAccount2 = new Account(10, new Customer(), 1000);
BankRepository.AddAccount(testAccount2);
var transfer = new TransferVM
{
FromAccountNumber = 9,
ToAccountNumber = 10,
Amount = 1000
};
Bank.Transfer(transfer);
var expected = 2000;
var actual = BankRepository.GetAccount(10).Balance;
Assert.Equal(expected, actual);
}
public IActionResult Index(int FromAccountId, int ToAccountId, int Amount)
{
TransferViewModel vm = new TransferViewModel();
var fromAccount = BankRepository.GetAccountById(FromAccountId);
if (fromAccount != null)
{
vm.ResponseClass = fromAccount.TransferFromThis(ToAccountId, Amount);
if (vm.ResponseClass.Success)
{
ModelState.Clear();
}
}
else
{
vm.ResponseClass.Message = $"Kontonummer {FromAccountId} hittades ej";
}
return(View(vm));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
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();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
var customers = AddCustomers();
BankRepository.AddCustomers(customers);
var allAccounts = new List <Account>();
foreach (var c in customers)
{
foreach (var account in c.Accounts)
{
allAccounts.Add(account);
}
}
BankRepository.AddAccounts(allAccounts);
}
public async Task CreateTransactionAsync_ShouldCreateTransactionWithCorrectRequestMapping()
{
//Arrange
var bankTransactionRequest = GetBankTransactionObject();
var createBankTransactionRequest =
GetCreateBankTransactionRequestFromBankTransaction(bankTransactionRequest);
var createBankTransactionResponse = GetCreateBankTransactionResponse();
var passedCreateTransactionRequest = new CreateBankTransactionRequest();
_bankHttpClientMock.Setup(x => x.CreateTransactionAsync(It.IsAny <CreateBankTransactionRequest>()))
.ReturnsAsync(createBankTransactionResponse)
.Callback <CreateBankTransactionRequest>(x => passedCreateTransactionRequest = x);
var sut = new BankRepository(_bankHttpClientMock.Object, _mapper);
//Act
await sut.CreateTransactionAsync(bankTransactionRequest);
//Assert
passedCreateTransactionRequest.Should().BeEquivalentTo(createBankTransactionRequest);
_bankHttpClientMock.Verify(x => x.CreateTransactionAsync(passedCreateTransactionRequest), Times.Once);
}
public ActionResult _Read([DataSourceRequest]DataSourceRequest request)
{
BankRepository modelRepo = new BankRepository();
DataSourceResult result = modelRepo.GetBankDetails().ToDataSourceResult(request);
return Json(result);
}
