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); }