public void Test_AllTransactionsSuccessful() { var transactionManager = new TransactionManager(); var suesAccount = new Account("Sue Smith", 0); var deposit = new Deposit(suesAccount, 100); transactionManager.AddTransaction(deposit); // Command has been added to the queue, but not executed. Assert.True(transactionManager.HasPendingTransactions); Assert.Equal(0, suesAccount.Balance); // This executes the commands. transactionManager.ProcessPendingTransactions(); Assert.False(transactionManager.HasPendingTransactions); Assert.Equal(100, suesAccount.Balance); // Add a withdrawal, apply it, and verify the balance changed. var withdrawal = new Withdraw(suesAccount, 50); transactionManager.AddTransaction(withdrawal); transactionManager.ProcessPendingTransactions(); Assert.False(transactionManager.HasPendingTransactions); Assert.Equal(50, suesAccount.Balance); }
private static void Main(string[] args) { // Invoker TransactionManager transactionManager = new TransactionManager(); // Receiver Account myAccount = new Account("Rajiv Ranjan", 100000); Account hisAccount = new Account("Ribha Singh", 25000); PrintStatement(myAccount, hisAccount); // Command Deposit deposit = new Deposit(myAccount, 100); Transfer transfer = new Transfer(myAccount, hisAccount, 25000); // Add commans to transaction manager (invoker) transactionManager.AddTransaction(deposit); transactionManager.AddTransaction(transfer); // Execute commands transactionManager.ProcessPendingTransactions(); Console.WriteLine("\n************** After Transaction *********************"); PrintStatement(myAccount, hisAccount); Console.Read(); }
public void Test_AllTransactionsSuccessful() { TransactionManager transactionManager = new TransactionManager(); Account suesAccount = new Account("Sue Smith", 0); Deposit deposit = new Deposit(suesAccount, 100); transactionManager.AddTransaction(deposit); // Command is added to the queue, but not executed Assert.IsTrue(transactionManager.HasPendingTransactions); Assert.AreEqual(0, suesAccount.Balance); //This executes the commands transactionManager.ProcessPendingTransactions(); Assert.IsFalse(transactionManager.HasPendingTransactions); Assert.AreEqual(100, suesAccount.Balance); // Add a withdrawal, apply, and verify the balance changed Withdraw withdrawal = new Withdraw(suesAccount, 50); transactionManager.AddTransaction(withdrawal); transactionManager.ProcessPendingTransactions(); Assert.IsFalse(transactionManager.HasPendingTransactions); Assert.AreEqual(50, suesAccount.Balance); }
public void Test_OverdraftRemainsInPendingTransactions() { TransactionManager transactionManager = new TransactionManager(); //Create an account with a balance of 75 Account bobsAccount = new Account("Bob Jones", 75); // The first command is a withdrawal that is larger than the account's balance // Command will not execute, because of the check in Withdraw.Execute // The deposit will be successful transactionManager.AddTransaction(new Withdraw(bobsAccount, 100)); transactionManager.AddTransaction(new Deposit(bobsAccount, 75)); transactionManager.ProcessPendingTransactions(); // The Withdrawal of 100 is not complete because there was not enough money in the account. // Therefore, it is still pending Assert.IsTrue(transactionManager.HasPendingTransactions); Assert.AreEqual(150, bobsAccount.Balance); // The pending transactions (the withdrawal of 100), should execute now transactionManager.ProcessPendingTransactions(); Assert.IsFalse(transactionManager.HasPendingTransactions); Assert.AreEqual(50, bobsAccount.Balance); }
public void Test_AllTransactionsSuccessful() { TransactionManager transactionManager = new TransactionManager(); Account anniesAccount = new Account("Annie", 0); Deposit deposit = new Deposit(1, anniesAccount, 100); transactionManager.AddTransaction(deposit); // Command has been added to the queue, but not yet executed Assert.IsTrue(transactionManager.HasPendingTransactions); Assert.AreEqual(anniesAccount.Balance, 0); // This executes the commands transactionManager.ProcessPendingTransactions(); Assert.IsFalse(transactionManager.HasPendingTransactions); Assert.AreEqual(anniesAccount.Balance, 100); // Add a withdrawal, apply it and check the balance changed Withdraw withdraw = new Withdraw(2, anniesAccount, 50); transactionManager.AddTransaction(withdraw); transactionManager.ProcessPendingTransactions(); Assert.IsFalse(transactionManager.HasPendingTransactions); Assert.AreEqual(anniesAccount.Balance, 50); // Test the Undo transactionManager.UndoTransactionNumber(2); Assert.IsFalse(transactionManager.HasPendingTransactions); Assert.AreEqual(anniesAccount.Balance, 100); }
public static void Test_OverdraftRemainsInPendingTransactions() { var transactionManager = new TransactionManager(); // Create an account with a balance of 75 var bobsAccount = new Account("Bob Jones", 75); // The first command is a withdrawal that is larger than the account's balance. // It will not be executed, because of the check in Withdraw.Execute. // The deposit will be successful. transactionManager.AddTransaction(new Withdraw(1, bobsAccount, 100)); transactionManager.AddTransaction(new Deposit(2, bobsAccount, 75)); transactionManager.ProcessPendingTransactions(); // The withdrawal of 100 was not completed, // because there was not enough money in the account. // So, it is still pending. Console.WriteLine("Transaction Manager has pending transactions? {0}", transactionManager.HasPendingTransactions); Console.WriteLine("Bob's account balance: {0}", bobsAccount.Balance); // The pending transactions (the withdrawal of 100), should execute now. transactionManager.ProcessPendingTransactions(); Console.WriteLine("Transaction Manager has pending transactions? {0}", transactionManager.HasPendingTransactions); Console.WriteLine("Bob's account balance: {0}", bobsAccount.Balance); // Test the undo transactionManager.UndoTransactionNumber(2); // The undo failed, because there is not enough money in the account to undo a deposit of 75 Console.WriteLine("Transaction Manager has pending transactions? {0}", transactionManager.HasPendingTransactions); Console.WriteLine("Bob's account balance: {0}", bobsAccount.Balance); transactionManager.UndoTransactionNumber(1); // The previous undo (for transaction ID 2) is still pending. // But, we successfully undid transaction ID 1. Console.WriteLine("Transaction Manager has pending transactions? {0}", transactionManager.HasPendingTransactions); Console.WriteLine("Bob's account balance: {0}", bobsAccount.Balance); // This should re-do the failed undo for transaction ID 2 transactionManager.ProcessPendingTransactions(); Console.WriteLine("Transaction Manager has pending transactions? {0}", transactionManager.HasPendingTransactions); Console.WriteLine("Bob's account balance: {0}", bobsAccount.Balance); }
public void AddTransactionParametrsTest() { var clientManagerMock = Substitute.For <IClientManager>(); var blockOfSharesRepositoryMock = Substitute.For <IBlockOfSharesRepository>(); var clientRepositoryMock = Substitute.For <IClientRepository>(); var sharesRepositoryMock = Substitute.For <ISharesRepository>(); var transactionRepositoryMock = Substitute.For <ITransactionRepository>(); var sut = new TransactionManager( clientManagerMock, blockOfSharesRepositoryMock, clientRepositoryMock, sharesRepositoryMock, transactionRepositoryMock); int sellerID = 3; int buyerID = 5; int shareID = 9; int shareAmount = 1; // Act sut.AddTransaction(sellerID, buyerID, shareID, shareAmount); // Asserts transactionRepositoryMock.Received(1).Insert(Arg.Is <Transaction>(t => t.BuyerID == buyerID && t.SellerID == sellerID && t.ShareID == shareID && t.Amount == shareAmount)); }
public int AddBalanceByTransaction(Transaction transaction) { TransactionManager transactionManager = new TransactionManager(); User userToAddBalance = GetUserByUserId(transaction.OperatedToUserId); double?newBalance = userToAddBalance.AccountBalance + transaction.Amount; string sql = "UPDATE [User] " + "SET AccountBalance = @accountBalance " + "Where Id = @id"; Command = new SqlCommand(sql, Connection); Command.Parameters.AddWithValue("@accountBalance", newBalance); Command.Parameters.AddWithValue("@id", userToAddBalance.Id); Connection.Open(); int rowEffected = Command.ExecuteNonQuery(); Connection.Close(); if (rowEffected >= 0) { transactionManager.AddTransaction(transaction); } return(rowEffected); }
public void AddTransactionTest() { var clientManagerMock = Substitute.For <IClientManager>(); var blockOfSharesRepositoryMock = Substitute.For <IBlockOfSharesRepository>(); var clientRepositoryMock = Substitute.For <IClientRepository>(); var sharesRepositoryMock = Substitute.For <ISharesRepository>(); var transactionRepositoryMock = Substitute.For <ITransactionRepository>(); var sut = new TransactionManager( clientManagerMock, blockOfSharesRepositoryMock, clientRepositoryMock, sharesRepositoryMock, transactionRepositoryMock); var transaction = new Transaction { SellerID = 3, BuyerID = 5, ShareID = 9, Amount = 1 }; // Act sut.AddTransaction(transaction); // Asserts transactionRepositoryMock.Received(1).Insert(Arg.Is <Transaction>(transaction)); }
public void Test_OverdraftRemainsInPendingtransactions() { TransactionManager transactionManager = new TransactionManager(); // Create an account with a balance of 75 Account bobsAccount = new Account("Bob", 75); // The first command is a withdrawal larger than the account's balance // It will not be executed, because of the check in Withdraw.Execute // The deposit will be successful transactionManager.AddTransaction(new Withdraw(1, bobsAccount, 100)); transactionManager.AddTransaction(new Deposit(2, bobsAccount, 75)); transactionManager.ProcessPendingTransactions(); // The withdrawal of 100 was not completed // because there was not eough money in the account // So, it is still pending Assert.IsTrue(transactionManager.HasPendingTransactions); Assert.AreEqual(bobsAccount.Balance, 150); // The pending transactions (the withdrawal of 100) should execute now transactionManager.ProcessPendingTransactions(); Assert.IsFalse(transactionManager.HasPendingTransactions); Assert.AreEqual(bobsAccount.Balance, 50); // Test the Undo transactionManager.UndoTransactionNumber(2); // The Undo failed, because there is not enough money on the account to undo Assert.IsTrue(transactionManager.HasPendingTransactions); Assert.AreEqual(bobsAccount.Balance, 50); transactionManager.UndoTransactionNumber(1); // The previous Undo (for transaction ID 2) is still pending // But we successfully undid transaction ID 1 Assert.IsTrue(transactionManager.HasPendingTransactions); Assert.AreEqual(bobsAccount.Balance, 150); // This should re-do the failed Undo for transaction ID 2 transactionManager.ProcessPendingTransactions(); Assert.IsFalse(transactionManager.HasPendingTransactions); Assert.AreEqual(bobsAccount.Balance, 75); }
public static void Test_AllTransactionsSuccessful() { var transactionManager = new TransactionManager(); var suesAccount = new Account("Sue Smith", 0); var deposit = new Deposit(1, suesAccount, 100); transactionManager.AddTransaction(deposit); // Command has been added to the queue, but not executed. Console.WriteLine("Transaction Manager has pending transactions? {0}", transactionManager.HasPendingTransactions); Console.WriteLine("Sue's account balance: {0}", suesAccount.Balance); // This executes the commands. transactionManager.ProcessPendingTransactions(); Console.WriteLine("Transaction Manager has pending transactions? {0}", transactionManager.HasPendingTransactions); Console.WriteLine("Sue's account balance: {0}", suesAccount.Balance); // Add a withdrawal, apply it, and verify the balance changed. var withdrawal = new Withdraw(2, suesAccount, 50); transactionManager.AddTransaction(withdrawal); transactionManager.ProcessPendingTransactions(); Console.WriteLine("Transaction Manager has pending transactions? {0}", transactionManager.HasPendingTransactions); Console.WriteLine("Sue's account balance: {0}", suesAccount.Balance); // Test the undo transactionManager.UndoTransactionNumber(2); Console.WriteLine("Transaction Manager has pending transactions? {0}", transactionManager.HasPendingTransactions); Console.WriteLine("Sue's account balance: {0}", suesAccount.Balance); }
public void Test_Transfer() { TransactionManager transactionManager = new TransactionManager(); Account checking = new Account("Mike Brown", 1000); Account savings = new Account("Mike Brown", 100); transactionManager.AddTransaction(new Transfer(checking, savings, 750)); transactionManager.ProcessPendingTransactions(); Assert.AreEqual(250, checking.Balance); Assert.AreEqual(850, savings.Balance); }
public void LogTransaction(string customerId, string title, decimal newAvailableAmount, TransactionDTO transactionDTO) { var transaction = new Transaction(); transaction.CustomerId = customerId; transaction.DebitProductId = transactionDTO.DebitProductId; transaction.CreditProductId = transactionDTO.CreditProductId; transaction.Amount = transactionDTO.Amount; transaction.TransactionType = "debit"; transaction.Beneficiary = transactionDTO.Beneficiary; transaction.Bank = transactionDTO.Bank; transaction.Currency = transactionDTO.Currency; transaction.Title = title; transaction.NewBalance = newAvailableAmount; transaction.Date = transactionDTO.IsAsap ? DateTime.Now : transactionDTO.Date; transactionManager.AddTransaction(transaction); }
public void DepositAccountCheckBalanceAndThenWithdraw_AllTransactionsSuccessful() { // Create Account with Balance 0 var initialAccount1 = new Account() { Balance = 0, AccountGuid = Guid.NewGuid() }; // Add a deposit reqest of 100 to that account _transactionManager.AddTransaction(new Deposit(initialAccount1, 100)); // Pre-check : transactionManager Should have pending transactions at this point Assert.IsTrue(_transactionManager.HasPendingTransactions()); // Account Balance Should be 0 at this point Assert.AreEqual(initialAccount1.Balance, 0); // Run ProcessPendingTransactions() to process Pending TransactionRequests _transactionManager.ProcessPendingTransactions(); // Check : there should not be any pending Transactions now Assert.IsFalse(_transactionManager.HasPendingTransactions()); // Check balance of the account which should be 100 now Assert.AreEqual(initialAccount1.Balance, 100); // Create a Withdraw of 50 on that account _transactionManager.AddTransaction(new Withdraw(initialAccount1, 50)); // Perform a ProcessPendingTransactions() to process this _transactionManager.ProcessPendingTransactions(); // check : No pending Transactions at this point Assert.IsFalse(_transactionManager.HasPendingTransactions()); // Check balance: should be 100-50 =50 Assert.AreEqual(initialAccount1.Balance, 50); }
protected void AddNewTransaction(TransactionStrings data, int entry) { try { Date date = new Date(data.GetDate()); Account sender = accounts.GetAccount(data.GetSender()); Account recipient = accounts.GetAccount(data.GetRecipient()); Money amount = new Money(data.GetAmount()); Transaction transaction = new Transaction(date, sender, recipient, data.GetNarrative(), amount); transactions.AddTransaction(transaction); } catch (ArgumentException ae) { WriteErrorToConsoleFirstTime(); LogBadFormatTransaction(entry, ae.Message); } }
public void Test_Transfert() { TransactionManager transactionManager = new TransactionManager(); Account checking = new Account("Charlie", 1000); Account savings = new Account("Dimitri", 100); transactionManager.AddTransaction(new Transfert(1, checking, savings, 750)); transactionManager.ProcessPendingTransactions(); Assert.AreEqual(checking.Balance, 250); Assert.AreEqual(savings.Balance, 850); // Test the Undo transactionManager.UndoTransactionNumber(1); Assert.IsFalse(transactionManager.HasPendingTransactions); Assert.AreEqual(checking.Balance, 1000); Assert.AreEqual(savings.Balance, 100); }
public void Test_Transfer() { TransactionManager transactionManager = new TransactionManager(); Account checking = new Account("Mike Brown", 1000); Account savings = new Account("Mike Brown", 100); transactionManager.AddTransaction(new Transfer(1, checking, savings, 750)); transactionManager.ProcessPendingTransactions(); Assert.AreEqual(250, checking.Balance); Assert.AreEqual(850, savings.Balance); // Undo the transfer, and check the account balances. transactionManager.UndoTransactionNumber(1); Assert.IsFalse(transactionManager.HasPendingTransactions); Assert.AreEqual(1000, checking.Balance); Assert.AreEqual(100, savings.Balance); }
public void DepositAccountCheckBalanceAndThenWithdraw_AllTransactionsSuccessful() { Account sumonAccount = new Account("Sumon", 0); Deposit deposit = new Deposit(sumonAccount, 100); _transactionManager.AddTransaction(deposit); Assert.IsTrue(_transactionManager.HasPendingTransactions); Assert.AreEqual(0, sumonAccount.Balance); _transactionManager.ProcessPendingTransactions(); Assert.IsFalse(_transactionManager.HasPendingTransactions); Assert.AreEqual(100, sumonAccount.Balance); Withdraw withdrawal = new Withdraw(sumonAccount, 50); _transactionManager.AddTransaction(withdrawal); _transactionManager.ProcessPendingTransactions(); Assert.IsFalse(_transactionManager.HasPendingTransactions); Assert.AreEqual(50, sumonAccount.Balance); }
public object CreateNewTransaction(string transactionName) { var provider = (ICustomErrorPagesEFDataProvider)this.DataProvider; if (string.IsNullOrEmpty(transactionName)) { return(this.GetContext(provider)); } string id = GetScopeId(provider); var scope = TransactionManager.GetTransaction <object>(transactionName, id); if (scope == null) { var context = this.GetContext(provider); context.BeginTransaction(); TransactionManager.AddTransaction(transactionName, id, this, context); scope = context; } return(scope); }
public static void Test_Transfer() { var random = new Random(); var transactionManager = new TransactionManager(); var checking = new Account("Mike Brown", 1000); var savings = new Account("Mike Brown", 100); transactionManager.AddTransaction(new Transfer(random.Next(), checking, savings, 750)); transactionManager.ProcessPendingTransactions(); Console.WriteLine("Mike Brown's checking account balance: {0}", checking.Balance); Console.WriteLine("Bob's savings account balance: {0}", savings.Balance); // Undo the transfer, and check the account balances. transactionManager.UndoTransactionNumber(1); Console.WriteLine("Transaction Manager has pending transactions? {0}", transactionManager.HasPendingTransactions); Console.WriteLine("Mike Brown's checking account balance: {0}", checking.Balance); Console.WriteLine("Bob's savings account balance: {0}", savings.Balance); }
private static void CreateTransaction() { if (AccountList.Count != 0) { var transactionManager = new TransactionManager(); Account account = null; while (account == null) { Console.WriteLine(Translator.GetTranslation("ChooseAccount")); var accountName = Console.ReadLine(); if (AccountList.Any(x => x.Name.ToLower() == accountName.ToLower())) { account = AccountList.SingleOrDefault(x => x.Name.ToLower() == accountName.ToLower()); } } // Get transaction type while (true) { Console.WriteLine(Translator.GetTranslation("TransactionType")); var type = Console.ReadLine(); if (type.ToLower().Equals("transfer")) { Account accountToTransferTo = null; while (accountToTransferTo == null) { Console.WriteLine(Translator.GetTranslation("ChooseAccount")); var accountName = Console.ReadLine(); if (AccountList.Any(x => x.Name.ToLower() == accountName.ToLower())) { accountToTransferTo = AccountList.SingleOrDefault(x => x.Name.ToLower() == accountName.ToLower()); } } Console.WriteLine(Translator.GetTranslation("AmountToTransfer")); var amount = Convert.ToDouble(Console.ReadLine()); var transfer = new Transfer(account, accountToTransferTo, amount); transactionManager.AddTransaction(transfer); Console.WriteLine(Translator.GetTranslation("TransactionPrice") + account.TransactionStrategy.GetTransactionFee() + '$'); Console.WriteLine(Translator.GetTranslation("TransactionComplete")); var complete = (Console.ReadKey().KeyChar == 'y') ? true : false; Console.WriteLine(); if (complete) { transactionManager.ProcessTransactions(); } SeeAccounts(); break; } else if (type.ToLower().Equals("deposit")) { Console.WriteLine(Translator.GetTranslation("AmountToDeposit")); var amount = Convert.ToDouble(Console.ReadLine()); var deposit = new Deposit(account, amount); transactionManager.AddTransaction(deposit); Console.WriteLine(Translator.GetTranslation("TransactionPrice") + account.TransactionStrategy.GetTransactionFee() + '$'); Console.WriteLine(Translator.GetTranslation("TransactionComplete")); var complete = (Console.ReadKey().KeyChar == 'y') ? true : false; Console.WriteLine(); if (complete) { transactionManager.ProcessTransactions(); } SeeAccounts(); break; } } } else { Console.WriteLine(Translator.GetTranslation("AccountMissing")); } }
/// <summary> /// Programme très simple qui n'a qu'un seul but : Implémenter le command Design pattern. /// Main est ici le Client qui va faire appel à l'invoker (transactionmanager) pour exécuter des Command /// qui vont agir sur le business Object (account) /// </summary> /// <param name="args"></param> static void Main(string[] args) { try { bool continuer = true; TransactionManager transactionManager = new TransactionManager(); Account compteGeoffrey = new Account("Geoffrey", 20000); Account compteLorena = new Account("Lorena", 5000); // Ajout d'une commande : ITransaction commande; Console.WriteLine("Geoffrey a " + compteGeoffrey.Balance + "et Lorena a " + compteLorena.Balance); while (continuer) { Console.WriteLine("Choisir une commande : W/D/T"); var cle = Console.ReadKey(); switch (cle.KeyChar) { case 'w': Console.WriteLine("Ajout commande Withdraw sur compte Geoffrey de 500"); commande = new WithdrawCommand(compteGeoffrey, 500); break; case 'd': Console.WriteLine("Deposit sur compte Lorena de 300"); commande = new DepositCommand(compteLorena, 300); break; case 't': Console.WriteLine("Transfert de Lorena vers Geoffrey de 400"); commande = new TransferCommand(compteLorena, compteGeoffrey, 400); break; default: throw new Exception(); } transactionManager.AddTransaction(commande); Console.WriteLine("Geoffrey a " + compteGeoffrey.Balance + "et Lorena a " + compteLorena.Balance); Console.WriteLine("Executer les commandes ? (y/n)"); var executer = Console.ReadKey(); if (executer.KeyChar == 'y') { transactionManager.ProcessPendingTransactions(); } Console.WriteLine("Geoffrey a " + compteGeoffrey.Balance + "et Lorena a " + compteLorena.Balance); Console.WriteLine("Quitter ?(y/n)"); var quitter = Console.ReadKey(); if (quitter.KeyChar == 'y') { continuer = false; } } } catch { Console.WriteLine("Mauvais input, programme fait à l'arrache dans le seul but d'implémenter le Command Design pattern, respecter la casse."); Console.ReadKey(); } }
private void BtnSave_Click(object sender, EventArgs e) { //check if fields are blank if (txtTransactionName.Text == "") { MessageBox.Show("You need to enter a Transaction Name"); txtTransactionName.Focus(); return; } if (cmbTransactionType.SelectedItem == null) { MessageBox.Show("You need to Select a Type"); cmbTransactionType.Focus(); return; } if (numAmount.Value == 0.00m) { MessageBox.Show("Amount Value needs to be above 0.00"); numAmount.Focus(); return; } //create objects var transaction = new Transaction(); transaction.Name = txtTransactionName.Text; transaction.Date = dtpDate.Value.ToString("yyyy-MM-dd"); transaction.Type = cmbTransactionType.SelectedItem.ToString(); // create object for amount value depentent on transaction type if (cmbTransactionType.SelectedIndex == 0) //Income { transaction.Amount = numAmount.Value.ToString(); } else //Expense { decimal newAmount = numAmount.Value * -1; transaction.Amount = newAmount.ToString(); } //save record if (editMode == true) { _transactionManager.EditTransaction(transaction, _transactionIndex); this.Close(); } else { int transactionCount = _transactionManager.TransactionList.Count; var newList = _transactionManager.AddTransaction(transaction); if (newList.Count > transactionCount) { MessageBox.Show("New Transaction Added."); this.Close(); } else { MessageBox.Show("Add Failed."); this.Close(); } } }