From 31f5cc7dc73383fe780e42336c21c3cbcc080cf7 Mon Sep 17 00:00:00 2001 From: wesley Date: Tue, 24 Oct 2017 13:26:18 -0400 Subject: [PATCH 1/8] saving --- pom.xml | 15 +++++ src/main/java/ATM.java | 47 +++++++++++++++ src/main/java/Account.java | 41 +++++++++++++ src/main/java/AccountFactory.java | 15 +++++ src/main/java/Main.java | 6 +- src/main/java/User.java | 48 +++++++++++++++ src/main/java/UserFactory.java | 2 + src/test/java/tests.java | 98 +++++++++++++++++++++++++++++++ 8 files changed, 271 insertions(+), 1 deletion(-) create mode 100644 src/main/java/ATM.java create mode 100644 src/main/java/Account.java create mode 100644 src/main/java/AccountFactory.java create mode 100644 src/main/java/User.java create mode 100644 src/main/java/UserFactory.java create mode 100644 src/test/java/tests.java diff --git a/pom.xml b/pom.xml index 9901415..36086c5 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,21 @@ io.zipcoder project-2-atm 1.0-SNAPSHOT + jar + interfaces-1 + http://maven.apache.org + + UTF-8 + + + + + junit + junit + 4.12 + test + + \ No newline at end of file diff --git a/src/main/java/ATM.java b/src/main/java/ATM.java new file mode 100644 index 0000000..dbf99b1 --- /dev/null +++ b/src/main/java/ATM.java @@ -0,0 +1,47 @@ +import java.util.ArrayList; + +public class ATM { + + private static ATM theInstance = new ATM(); + + private ATM() { + } + + public static ATM getInstance() { + return theInstance; + } + + + private ArrayList allUsers = new ArrayList(); + private int numOfAccounts = 0; + + public int returnAllUsersSize() { + return allUsers.size(); + } + + public int returnNewAccountNum() { + numOfAccounts++; + return numOfAccounts; + } + + public void addUser() { + String userName = "wes"; + String password = "password"; + User newUser = new User(userName, password); + allUsers.add(newUser); + + } + + public String findUser(String userNmae){ + Account currentUser = allUsers.get(0); + + + return ""; + + } +/* + public void findAccountIndex(String userName, String password) { + //User user = allUsers.get(0); + } +*/ +} diff --git a/src/main/java/Account.java b/src/main/java/Account.java new file mode 100644 index 0000000..b1a0f5a --- /dev/null +++ b/src/main/java/Account.java @@ -0,0 +1,41 @@ + + +public class Account { + private int accountNum; + private double accountBalance; + private char accountType; + + ATM atm = new ATM(); + + Account(){ + + } + Account(int accountNum){ + this.accountNum = accountNum; + } + + public void setAccountNum(){ + this.accountNum = atm.returnNewAccountNum(); + //return accountNum; + } + public int getAccountNum(){ + return accountNum; + } + public void setBalance(double balanceGiven){ + accountBalance = balanceGiven; + } + + public double getBalance(){ + return accountBalance; + } + + public void setType(char type){ + accountType = type; + } + + public char getType(){ + return accountType; + } + +} + diff --git a/src/main/java/AccountFactory.java b/src/main/java/AccountFactory.java new file mode 100644 index 0000000..d34f644 --- /dev/null +++ b/src/main/java/AccountFactory.java @@ -0,0 +1,15 @@ +public class AccountFactory { + private char accountType; + private int accountNum; + private double accountType + + AccountFactory(char accountType){ + this.accountType = accountType; + account.setAccountNum(); + double randomBalamce = Math.random()*100; + account.setBalance(randomBalamce); + account.setType(accountType); + } + + +} diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 05e41a9..83d36c9 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -1,9 +1,13 @@ + + /** * Created by iyasuwatts on 10/17/17. */ public class Main { public static void main(String[] args){ - + + } + } diff --git a/src/main/java/User.java b/src/main/java/User.java new file mode 100644 index 0000000..f5dd3e8 --- /dev/null +++ b/src/main/java/User.java @@ -0,0 +1,48 @@ +import java.util.ArrayList; + +public class User { + + ATM atm = ATM.getInstance(); + + private String userName; + private String password; + + private ArrayList accountsArray = new ArrayList(); + + + + + User(String userName,String password){ + this.userName = userName; + this.password = password; + } + + public void setUserName(String userName){ + this.userName = userName; + } + public String getUserName(){ + return userName; + } + public void setUserPassword(String password){ + this.password = password; + } + public String getUserPassword(){ + return password; + } + + public Object addAccount(char accountType){ + + AccountFactory newAccount = new AccountFactory(accountType); + + accountsArray.add(newAccount); + return newAccount; + } + + public void goToAccount(int accountNum){ + + } + + + + +} diff --git a/src/main/java/UserFactory.java b/src/main/java/UserFactory.java new file mode 100644 index 0000000..b09ee4a --- /dev/null +++ b/src/main/java/UserFactory.java @@ -0,0 +1,2 @@ +public class UserFactory { +} diff --git a/src/test/java/tests.java b/src/test/java/tests.java new file mode 100644 index 0000000..94ba873 --- /dev/null +++ b/src/test/java/tests.java @@ -0,0 +1,98 @@ +import org.junit.Assert; +import org.junit.Test; + +public class tests { + ATM atm = new ATM(); + User user = new User(); + Account account = new Account(); + + @Test + public void addUserTest(){ + int expected = 1; + atm.addUser(); + int actual = atm.returnAllUsersSize(); + Assert.assertEquals(expected,actual); + + } + + @Test + public void findUserTest(){ + + } + + @Test + public void UserNameTest(){ + String expected = "wes"; + + user.setUserName("wes"); + String actual = user.getUserName(); + + Assert.assertEquals(expected,actual); + } + + @Test + public void UserPasswordTest(){ + String expected = "password"; + + user.setUserPassword("password"); + String actual = user.getUserPassword(); + + Assert.assertEquals(expected,actual); + } + + + @Test + public void addAccountTest(){ + + //int expected = 1; + char expected = 'c'; + + Object newAccountObject = user.addAccount('c'); + + + //int actual = user.returnAccountLength(); + char actual = ; + + Assert.assertEquals(expected,actual); + } + + + @Test + public void AccountBalanceTest(){ + + double expected = 500; + + account.setBalance(500); + + double actual = account.getBalance(); + + Assert.assertEquals(expected,actual,0); + + } + + @Test + public void AccountIndexTest(){ + int expected = 1; + + user.addAccount('c'); + user.addAccount('s'); + int actual = user.findAccountIndex(1); + + Assert.assertEquals(expected,actual); + + } + + @Test + public void addedAccountBalanceTest(){ + char expected = 'c'; + + user.addAccount('c'); + //char actual = ; + + //int actual = user.returnAccountLength(); + + //Assert.assertEquals(expected,actual); + } + + +} From 7dd253ea6ca9f2776e61de1eed86f9af7a854037 Mon Sep 17 00:00:00 2001 From: wesley Date: Tue, 24 Oct 2017 18:50:00 -0400 Subject: [PATCH 2/8] saving again --- src/main/java/ATM.java | 46 +++++--- src/main/java/Account.java | 9 +- src/main/java/AccountFactory.java | 3 +- src/main/java/Console.java | 174 ++++++++++++++++++++++++++++++ src/main/java/Main.java | 6 +- src/main/java/User.java | 93 +++++++++++++--- src/main/java/UserFactory.java | 1 + src/test/java/tests.java | 168 +++++++++++++++++++++++------ 8 files changed, 430 insertions(+), 70 deletions(-) create mode 100644 src/main/java/Console.java diff --git a/src/main/java/ATM.java b/src/main/java/ATM.java index dbf99b1..9c9e13d 100644 --- a/src/main/java/ATM.java +++ b/src/main/java/ATM.java @@ -11,7 +11,6 @@ public static ATM getInstance() { return theInstance; } - private ArrayList allUsers = new ArrayList(); private int numOfAccounts = 0; @@ -24,24 +23,45 @@ public int returnNewAccountNum() { return numOfAccounts; } - public void addUser() { - String userName = "wes"; - String password = "password"; + public void addUser(String userName,String password) { User newUser = new User(userName, password); allUsers.add(newUser); } - public String findUser(String userNmae){ - Account currentUser = allUsers.get(0); - - - return ""; + public User EnterUser(String userName,String password){ + int index = -1; + User currentUser; + for(int i = 0;i= 0) { + currentUser = (User) allUsers.get(index); + }else{ + currentUser = null; + } + return currentUser; } -/* - public void findAccountIndex(String userName, String password) { - //User user = allUsers.get(0); + + public boolean UserExist(String userName,String password) { + int index = -1; + User currentUser; + boolean userExist = false; + for (int i = 0; i < allUsers.size(); i++) { + currentUser = (User) allUsers.get(i); + if (userName.equalsIgnoreCase(currentUser.getUserName()) && + password.equalsIgnoreCase(currentUser.getUserPassword())) { + index = i; + } + } + if (index >= 0) { + userExist = true; + } + return userExist; } -*/ } diff --git a/src/main/java/Account.java b/src/main/java/Account.java index b1a0f5a..52064e6 100644 --- a/src/main/java/Account.java +++ b/src/main/java/Account.java @@ -5,22 +5,19 @@ public class Account { private double accountBalance; private char accountType; - ATM atm = new ATM(); + ATM atm = ATM.getInstance(); Account(){ - - } - Account(int accountNum){ - this.accountNum = accountNum; } public void setAccountNum(){ this.accountNum = atm.returnNewAccountNum(); - //return accountNum; } + public int getAccountNum(){ return accountNum; } + public void setBalance(double balanceGiven){ accountBalance = balanceGiven; } diff --git a/src/main/java/AccountFactory.java b/src/main/java/AccountFactory.java index d34f644..f616b3c 100644 --- a/src/main/java/AccountFactory.java +++ b/src/main/java/AccountFactory.java @@ -1,4 +1,5 @@ public class AccountFactory { +/* private char accountType; private int accountNum; private double accountType @@ -11,5 +12,5 @@ public class AccountFactory { account.setType(accountType); } - +*/ } diff --git a/src/main/java/Console.java b/src/main/java/Console.java new file mode 100644 index 0000000..9afd6ed --- /dev/null +++ b/src/main/java/Console.java @@ -0,0 +1,174 @@ +import java.util.Scanner; + +public class Console { + ATM atm = ATM.getInstance(); + Scanner scan = new Scanner(System.in); + + public void frontPage(){ + System.out.println("Welcome\n 1) New User\n 2) Login\n-1) Exit"); + switch(scan.nextInt()){ + case 1: + addUser(); + break; + case 2: + loginPage(); + break; + default: + return; + } + } + + public void userPage(User user){ + System.out.println("Welcome back"+user.getUserName()+ + "\n 1) Check balance of account\n 2) Withdraw from account\n 3) Deposit to account"+ + "\n 4) Transfer from one account to another\n 5) Print account transaction history"+ + "\n 6) Close account\n 7) Add new account\n-1) Back"); + switch(scan.nextInt()){ + case 1: + balancePrint(user); + break; + case 2: + withdrawPrint(user); + break; + case 3: + depositPrint(user); + break; + case 4: + transferPrint(user); + break; + case 5: + + break; + case 6: + closeAccount(user); + break; + case 7: + addAccount(user); + break; + default: + frontPage(); + } + } + + public void closeAccount(User user){ + Account account = enterAccount(user); + if(user.removeAccount(account.getAccountNum())){ + System.out.println("Account removed"); + userPage(user); + }else{ + System.out.println("Account can not be closed"); + userPage(user); + } + } + + public void transferPrint(User user){ + System.out.println("From account"); + Account fromAccount = enterAccount(user); + System.out.println("to account"); + Account toAccount = enterAccount(user); + double amount = scan.nextDouble(); + if(user.transfer(amount,fromAccount,toAccount)){ + System.out.println("Transfer made"); + userPage(user); + }else{ + System.out.println("Transfer not possible"); + userPage(user); + } + + + } + + public void depositPrint(User user){ + Account account = enterAccount(user); + System.out.println("Deposit amount >>"); + double amount = scan.nextDouble(); + if(user.deposit(amount,account)){ + System.out.println("Deposit made"); + userPage(user); + }else{ + System.out.println("Deposit not possible"); + userPage(user); + } + } + + public void withdrawPrint(User user){ + Account account = enterAccount(user); + System.out.println("Withdraw amount >>"); + double amount = scan.nextDouble(); + if(user.withdraw(amount,account)){ + System.out.println("Withdraw made"); + userPage(user); + }else{ + System.out.println("Withdraw not possible"); + userPage(user); + } + } + + public void balancePrint(User user){ + Account account = enterAccount(user); + System.out.println("Account : "+account.getAccountNum()+"\nBalance : "+ account.getBalance()); + } + + public Account enterAccount(User user){ + System.out.println("Account number >> "); + int input = scan.nextInt(); + Account account; + if(user.AccountExist(input)){ + account = user.EnterAccount(input); + //accountPage(account); + }else{ + System.out.println("Account does not exist"); + account = null; + userPage(user); + } + return account; + } + + public void addUser(){ + System.out.println("New user Name >>"); + String userName = scan.next(); + System.out.println("New password >>"); + String password = scan.next(); + atm.addUser(userName,password); + } + + public void loginPage(){ + System.out.println("User Name >>"); + String userName = scan.next(); + System.out.println("Password >>"); + String password = scan.next(); + if(atm.UserExist(userName,password)) { + User user = atm.EnterUser(userName, password); + userPage(user); + }else{ + System.out.println("User does not exist"); + frontPage(); + } + } + + public void addAccount(User user){ + System.out.println("What type of account?\n 1) Checkings\n 2)Savings\n 3) Investment"); + char accountType; + switch(scan.nextInt()){ + case 1: + accountType = 'c'; + break; + case 2: + accountType = 's'; + break; + case 3: + accountType = 'i'; + break; + default: + accountType = 'x'; + if(accountType!= 'x') { + user.addAccount(accountType); + System.out.println("Account added"); + } + userPage(user); + + } + } + + +} diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 83d36c9..538f921 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -1,4 +1,4 @@ - +import java.util.Scanner; /** * Created by iyasuwatts on 10/17/17. @@ -6,8 +6,10 @@ public class Main { public static void main(String[] args){ + Console console = new Console(); + console.frontPage(); + } - } } diff --git a/src/main/java/User.java b/src/main/java/User.java index f5dd3e8..a28a6c3 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -1,48 +1,109 @@ import java.util.ArrayList; public class User { - - ATM atm = ATM.getInstance(); - private String userName; private String password; - private ArrayList accountsArray = new ArrayList(); - - - - User(String userName,String password){ + User(String userName, String password) { this.userName = userName; this.password = password; } - public void setUserName(String userName){ + + public void setUserName(String userName) { this.userName = userName; } - public String getUserName(){ + public String getUserName() { return userName; } - public void setUserPassword(String password){ + public void setUserPassword(String password) { this.password = password; } - public String getUserPassword(){ + public String getUserPassword() { return password; } - public Object addAccount(char accountType){ + public int accountsArraySize(){ + return accountsArray.size(); + } + + public void addAccount(char accountType) { - AccountFactory newAccount = new AccountFactory(accountType); + Account newAccount = new Account(); + newAccount.setType(accountType); + newAccount.setBalance(0); + newAccount.setAccountNum(); accountsArray.add(newAccount); - return newAccount; + //return newAccount; } - public void goToAccount(int accountNum){ + public boolean removeAccount(int accountNum){ + boolean removedAccount = false; + Account removeAccount = EnterAccount(accountNum); + if(removeAccount.getBalance() == 0){ + accountsArray.remove(removeAccount); + removedAccount = true; + } + return removedAccount; + } + + public boolean AccountExist(int accountNum) { + int index = -1; + boolean accountExist = false; + Account currentAccount; + for (int i = 0; i < accountsArray.size(); i++) { + currentAccount = (Account) accountsArray.get(i); + if (currentAccount.getAccountNum() == accountNum) { + index = i; + } + } + if (index >= 0) { + accountExist = true; + } + return accountExist; + } + public Account EnterAccount(int accountNum) { + int index = -1; + Account currentAccount; + for (int i = 0; i < accountsArray.size(); i++) { + currentAccount = (Account) accountsArray.get(i); + if (currentAccount.getAccountNum() == accountNum) { + index = i; + } + } + if (index >= 0) { + currentAccount = (Account) accountsArray.get(index); + }else { + currentAccount = null; + } + + return currentAccount; } + public boolean withdraw(double amount,Account account){ + boolean withdrawMade = false; + double currentBalance = account.getBalance(); + if(currentBalance > amount){ + withdrawMade = true; + account.setBalance(currentBalance-amount); + } + return withdrawMade; + } + + public boolean deposit(double amount, Account account){ + double currentBalance = account.getBalance(); + account.setBalance(currentBalance+amount); + return true; + } + + public boolean transfer(double amount,Account fromAccount,Account toAccount){ + return withdraw(amount,fromAccount) && deposit(amount,toAccount); + } + } diff --git a/src/main/java/UserFactory.java b/src/main/java/UserFactory.java index b09ee4a..e81ab5c 100644 --- a/src/main/java/UserFactory.java +++ b/src/main/java/UserFactory.java @@ -1,2 +1,3 @@ public class UserFactory { + } diff --git a/src/test/java/tests.java b/src/test/java/tests.java index 94ba873..d94251f 100644 --- a/src/test/java/tests.java +++ b/src/test/java/tests.java @@ -2,56 +2,124 @@ import org.junit.Test; public class tests { - ATM atm = new ATM(); - User user = new User(); - Account account = new Account(); + ATM atm = ATM.getInstance(); + + + @Test public void addUserTest(){ int expected = 1; - atm.addUser(); + atm.addUser("wes","password"); int actual = atm.returnAllUsersSize(); Assert.assertEquals(expected,actual); } @Test - public void findUserTest(){ + public void UserExistTest(){ + atm.addUser("wes","password"); + boolean expected1 = true; + boolean expected2 = false; + boolean actual1 = atm.UserExist("wes","password"); + boolean actual2 = atm.UserExist("bob","password"); + + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); } + @Test public void UserNameTest(){ - String expected = "wes"; + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + String expected1 = "wes"; + String expected2 = "bob"; - user.setUserName("wes"); - String actual = user.getUserName(); + String actual1 = currentUser.getUserName(); + currentUser.setUserName("bob"); + String actual2 = currentUser.getUserName(); - Assert.assertEquals(expected,actual); + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); } @Test public void UserPasswordTest(){ - String expected = "password"; + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + String expected1 = "password"; + String expected2 = "newPassword"; - user.setUserPassword("password"); - String actual = user.getUserPassword(); + String actual1 = currentUser.getUserPassword(); + currentUser.setUserPassword("newPassword"); + String actual2 = currentUser.getUserPassword(); - Assert.assertEquals(expected,actual); + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); } @Test public void addAccountTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + currentUser.addAccount('c'); + int expected = 1; - //int expected = 1; - char expected = 'c'; + int actual = currentUser.accountsArraySize(); + Assert.assertEquals(expected,actual); + } + + @Test + public void removeAccountTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + currentUser.addAccount('c'); + currentUser.addAccount('s'); + + boolean expected1 = true; + int expected2 = 1; + boolean expected3 = false; + + boolean actual1 = currentUser.removeAccount(1); + int actual2 = currentUser.accountsArraySize(); + Account currentAccount = currentUser.EnterAccount(2); + currentAccount.setBalance(50); + boolean actual3 = currentUser.removeAccount(2); + + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); + Assert.assertEquals(expected3,actual3); + + + } - Object newAccountObject = user.addAccount('c'); + @Test + public void accountExistTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + currentUser.addAccount('c'); + boolean expected1 = true; + boolean expected2 = false; + + boolean actual1 = currentUser.AccountExist(1); + boolean actual2 = currentUser.AccountExist(3); + + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); + } + @Test + public void EnterAccountTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + currentUser.addAccount('c'); + Account currentAccount = currentUser.EnterAccount(1); + char expected = 'c'; - //int actual = user.returnAccountLength(); - char actual = ; + char actual = currentAccount.getType(); Assert.assertEquals(expected,actual); } @@ -59,39 +127,75 @@ public void addAccountTest(){ @Test public void AccountBalanceTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + currentUser.addAccount('c'); + Account currentAccount = currentUser.EnterAccount(1); double expected = 500; - account.setBalance(500); + currentAccount.setBalance(500); - double actual = account.getBalance(); + double actual = currentAccount.getBalance(); Assert.assertEquals(expected,actual,0); } @Test - public void AccountIndexTest(){ - int expected = 1; + public void depositTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + currentUser.addAccount('s'); + Account currentAccount = currentUser.EnterAccount(1); - user.addAccount('c'); - user.addAccount('s'); - int actual = user.findAccountIndex(1); + double expected = 100; - Assert.assertEquals(expected,actual); + currentUser.deposit(100,currentAccount); + + double actual = currentAccount.getBalance(); + Assert.assertEquals(expected,actual,0); } @Test - public void addedAccountBalanceTest(){ - char expected = 'c'; + public void withdrawTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + currentUser.addAccount('s'); + Account currentAccount = currentUser.EnterAccount(1); + currentAccount.setBalance(100); + + double expected = 50; + currentUser.withdraw(50,currentAccount); + + double actual = currentAccount.getBalance(); + + Assert.assertEquals(expected,actual,0); + + } + + @Test + public void transferTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + currentUser.addAccount('s'); + currentUser.addAccount('c'); + Account firstAccount = currentUser.EnterAccount(1); + Account secondAccount = currentUser.EnterAccount(2); + firstAccount.setBalance(100); + + double expected1 = 75; + double expected2 = 25; + + currentUser.transfer(25,firstAccount,secondAccount); - user.addAccount('c'); - //char actual = ; + double actual1 = firstAccount.getBalance(); + double actual2 = secondAccount.getBalance(); - //int actual = user.returnAccountLength(); + Assert.assertEquals(expected1,actual1,0); + Assert.assertEquals(expected2,actual2,0); - //Assert.assertEquals(expected,actual); } From 67a6b5c292fa392bc6d3a2482da473bedef853c3 Mon Sep 17 00:00:00 2001 From: wesley Date: Tue, 24 Oct 2017 21:07:18 -0400 Subject: [PATCH 3/8] saving9pm --- src/main/java/ATM.java | 2 +- src/main/java/Account.java | 11 ++- src/main/java/Console.java | 197 ++++++++++++++++++++++++++----------- src/main/java/User.java | 11 ++- src/test/java/tests.java | 20 +++- 5 files changed, 174 insertions(+), 67 deletions(-) diff --git a/src/main/java/ATM.java b/src/main/java/ATM.java index 9c9e13d..20210ee 100644 --- a/src/main/java/ATM.java +++ b/src/main/java/ATM.java @@ -55,7 +55,7 @@ public boolean UserExist(String userName,String password) { for (int i = 0; i < allUsers.size(); i++) { currentUser = (User) allUsers.get(i); if (userName.equalsIgnoreCase(currentUser.getUserName()) && - password.equalsIgnoreCase(currentUser.getUserPassword())) { + password.equals(currentUser.getUserPassword())) { index = i; } } diff --git a/src/main/java/Account.java b/src/main/java/Account.java index 52064e6..3aa012f 100644 --- a/src/main/java/Account.java +++ b/src/main/java/Account.java @@ -1,14 +1,23 @@ - +import java.util.ArrayList; public class Account { private int accountNum; private double accountBalance; private char accountType; + private double[] accountHistory = new double[3]; ATM atm = ATM.getInstance(); Account(){ } + public double[] getAccountHistory(){ + return accountHistory; + } + public void addToAccountHistory(double amount){ + accountHistory[0] = accountHistory[1]; + accountHistory[1] = accountHistory[2]; + accountHistory[2] = amount; + } public void setAccountNum(){ this.accountNum = atm.returnNewAccountNum(); diff --git a/src/main/java/Console.java b/src/main/java/Console.java index 9afd6ed..5a05305 100644 --- a/src/main/java/Console.java +++ b/src/main/java/Console.java @@ -1,11 +1,12 @@ +import java.util.ArrayList; import java.util.Scanner; public class Console { ATM atm = ATM.getInstance(); Scanner scan = new Scanner(System.in); - public void frontPage(){ - System.out.println("Welcome\n 1) New User\n 2) Login\n-1) Exit"); + protected void frontPage(){ + System.out.print("\nWelcome\n 1) New User\n 2) Login\n 0) Exit\n"); switch(scan.nextInt()){ case 1: addUser(); @@ -13,16 +14,18 @@ public void frontPage(){ case 2: loginPage(); break; - default: + case 0: return; + default: + frontPage(); } } - public void userPage(User user){ - System.out.println("Welcome back"+user.getUserName()+ + private void userPage(User user){ + System.out.print( "\n 1) Check balance of account\n 2) Withdraw from account\n 3) Deposit to account"+ "\n 4) Transfer from one account to another\n 5) Print account transaction history"+ - "\n 6) Close account\n 7) Add new account\n-1) Back"); + "\n 6) Close account\n 7) Add new account\n 8) User settings\n 0) Logout\n"); switch(scan.nextInt()){ case 1: balancePrint(user); @@ -37,7 +40,7 @@ public void userPage(User user){ transferPrint(user); break; case 5: - + historyPrint(user); break; case 6: closeAccount(user); @@ -45,130 +48,206 @@ public void userPage(User user){ case 7: addAccount(user); break; - default: + case 8: + userSettingPage(user); + break; + case 0: frontPage(); + break; + default: + userPage(user); + } + } + + private void userSettingPage(User user){ + System.out.println("\nUser Setting\n 1) Change user name\n 2) Change password\n 3) Look at all accounts\n 0) Back"); + switch(scan.nextInt()){ + case 1: + changeUserNamePage(user); + break; + case 2: + changePasswordPage(user); + break; + case 3: + //lookAtAccount(user); + break; + case 0: + userPage(user); + break; + default: + userSettingPage(user); } } + private void changePasswordPage(User user){ + System.out.print("Current password >> "); + String input = scan.next(); + if(input.equalsIgnoreCase(user.getUserPassword())){ + System.out.print("New password >> "); + input = scan.next(); + user.setUserPassword(input); + System.out.print("Password changed"); + }else{ + System.out.print("Incorrect password"); + } + userSettingPage(user); + } - public void closeAccount(User user){ + private void changeUserNamePage(User user){ + System.out.print("Current user name >> "); + String input = scan.next(); + if(input.equalsIgnoreCase(user.getUserName())){ + System.out.print("New user name >> "); + input = scan.next(); + user.setUserName(input); + System.out.print("User name changed\n"); + }else{ + System.out.print("Incorrect user name"); + } + userSettingPage(user); + } + + private void historyPrint(User user){ + Account account = enterAccount(user); + double transaction; + double[] history = account.getAccountHistory(); + System.out.println("Most recent at the bottom"); + for(int i = 0;i0){ + System.out.println("Deposit : "+transaction); + } + } + userPage(user); + } + + private void closeAccount(User user){ Account account = enterAccount(user); if(user.removeAccount(account.getAccountNum())){ - System.out.println("Account removed"); + System.out.print("Account removed"); userPage(user); }else{ - System.out.println("Account can not be closed"); + System.out.print("Account can not be closed"); userPage(user); } } - public void transferPrint(User user){ - System.out.println("From account"); + private void transferPrint(User user){ + System.out.print("From account\n"); Account fromAccount = enterAccount(user); - System.out.println("to account"); + System.out.print("To account\n"); Account toAccount = enterAccount(user); + System.out.print("How much would you like to transfer >> "); double amount = scan.nextDouble(); if(user.transfer(amount,fromAccount,toAccount)){ - System.out.println("Transfer made"); + System.out.print("Transfer made\n"); userPage(user); }else{ - System.out.println("Transfer not possible"); + System.out.print("Transfer not possible\n"); userPage(user); } - + } - public void depositPrint(User user){ + private void depositPrint(User user){ Account account = enterAccount(user); - System.out.println("Deposit amount >>"); + System.out.print("Deposit amount >> "); double amount = scan.nextDouble(); if(user.deposit(amount,account)){ - System.out.println("Deposit made"); + System.out.print("Deposit made\n"); userPage(user); }else{ - System.out.println("Deposit not possible"); + System.out.print("Deposit not possible\n"); userPage(user); } } - public void withdrawPrint(User user){ + private void withdrawPrint(User user){ Account account = enterAccount(user); - System.out.println("Withdraw amount >>"); + System.out.print("Withdraw amount >> "); double amount = scan.nextDouble(); if(user.withdraw(amount,account)){ - System.out.println("Withdraw made"); + System.out.print("Withdraw made\n"); userPage(user); }else{ - System.out.println("Withdraw not possible"); + System.out.print("Withdraw not possible\n"); userPage(user); } } - public void balancePrint(User user){ + private void balancePrint(User user){ Account account = enterAccount(user); - System.out.println("Account : "+account.getAccountNum()+"\nBalance : "+ account.getBalance()); + System.out.print("\nAccount : "+account.getAccountNum()+"\nBalance : "+ account.getBalance()+"\n"); + userPage(user); } - public Account enterAccount(User user){ - System.out.println("Account number >> "); + private Account enterAccount(User user){ + System.out.print("Account number >> "); int input = scan.nextInt(); Account account; if(user.AccountExist(input)){ account = user.EnterAccount(input); //accountPage(account); }else{ - System.out.println("Account does not exist"); + System.out.print("Account does not exist"); account = null; userPage(user); } return account; } - public void addUser(){ - System.out.println("New user Name >>"); + private void addAccount(User user){ + System.out.print("What type of account?\n 1) Checking\n 2) Savings\n 3) Investment\n"); + char accountType; + switch(scan.nextInt()) { + case 1: + accountType = 'c'; + break; + case 2: + accountType = 's'; + break; + case 3: + accountType = 'i'; + break; + default: + accountType = 'x'; + } + if(accountType!= 'x') { + int accountNum = user.addAccount(accountType); + System.out.print("Account added\nNew account number : "+accountNum+"\n"); + } + userPage(user); + } + + + private void addUser(){ + System.out.print("New user Name >> "); String userName = scan.next(); - System.out.println("New password >>"); + System.out.print("New password >> "); String password = scan.next(); atm.addUser(userName,password); + System.out.print("\nNew user added\n"); + frontPage(); } - public void loginPage(){ - System.out.println("User Name >>"); + private void loginPage(){ + System.out.print("User Name >> "); String userName = scan.next(); - System.out.println("Password >>"); + System.out.print("Password >> "); String password = scan.next(); if(atm.UserExist(userName,password)) { User user = atm.EnterUser(userName, password); + System.out.println("\nWelcome back "+user.getUserName()); userPage(user); }else{ - System.out.println("User does not exist"); + System.out.print("User does not exist"); frontPage(); } } - public void addAccount(User user){ - System.out.println("What type of account?\n 1) Checkings\n 2)Savings\n 3) Investment"); - char accountType; - switch(scan.nextInt()){ - case 1: - accountType = 'c'; - break; - case 2: - accountType = 's'; - break; - case 3: - accountType = 'i'; - break; - default: - accountType = 'x'; - if(accountType!= 'x') { - user.addAccount(accountType); - System.out.println("Account added"); - } - userPage(user); - } - } } diff --git a/src/main/java/User.java b/src/main/java/User.java index a28a6c3..6bea7de 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -10,7 +10,6 @@ public class User { this.password = password; } - public void setUserName(String userName) { this.userName = userName; } @@ -23,12 +22,11 @@ public void setUserPassword(String password) { public String getUserPassword() { return password; } - public int accountsArraySize(){ return accountsArray.size(); } - public void addAccount(char accountType) { + public int addAccount(char accountType) { Account newAccount = new Account(); newAccount.setType(accountType); @@ -36,7 +34,7 @@ public void addAccount(char accountType) { newAccount.setAccountNum(); accountsArray.add(newAccount); - //return newAccount; + return newAccount.getAccountNum(); } public boolean removeAccount(int accountNum){ @@ -81,14 +79,16 @@ public Account EnterAccount(int accountNum) { } return currentAccount; + } public boolean withdraw(double amount,Account account){ boolean withdrawMade = false; double currentBalance = account.getBalance(); - if(currentBalance > amount){ + if(currentBalance >= amount){ withdrawMade = true; + account.addToAccountHistory(amount*-1); account.setBalance(currentBalance-amount); } return withdrawMade; @@ -97,6 +97,7 @@ public boolean withdraw(double amount,Account account){ public boolean deposit(double amount, Account account){ double currentBalance = account.getBalance(); account.setBalance(currentBalance+amount); + account.addToAccountHistory(amount); return true; } diff --git a/src/test/java/tests.java b/src/test/java/tests.java index d94251f..0380ffe 100644 --- a/src/test/java/tests.java +++ b/src/test/java/tests.java @@ -5,7 +5,7 @@ public class tests { ATM atm = ATM.getInstance(); - +/* @Test public void addUserTest(){ @@ -198,5 +198,23 @@ public void transferTest(){ } + @Test + public void accountHistoryTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes","password"); + currentUser.addAccount('s'); + Account account = currentUser.EnterAccount(1); + currentUser.deposit(50,account); + double expected = 50; + double firstPlace = account.getAccountHistory()[0]; + double actual = firstPlace; + + Assert.assertEquals(expected,actual,0); + + + + } + */ + } From 3152208c123538cecd3582760cf5325075c029c6 Mon Sep 17 00:00:00 2001 From: wesley Date: Wed, 25 Oct 2017 16:41:57 -0400 Subject: [PATCH 4/8] saving --- src/main/java/ATM.java | 69 ++++--- src/main/java/Account.java | 48 ++--- src/main/java/AccountFactory.java | 16 -- src/main/java/CheckingAccount.java | 2 + src/main/java/Console.java | 294 +++++++++++++++++---------- src/main/java/InvestmentAccount.java | 2 + src/main/java/SavingAccount.java | 7 + src/main/java/User.java | 77 ++++--- src/main/java/UserFactory.java | 3 - src/test/java/tests.java | 227 +++++++++++++++------ 10 files changed, 457 insertions(+), 288 deletions(-) delete mode 100644 src/main/java/AccountFactory.java create mode 100644 src/main/java/CheckingAccount.java create mode 100644 src/main/java/InvestmentAccount.java create mode 100644 src/main/java/SavingAccount.java delete mode 100644 src/main/java/UserFactory.java diff --git a/src/main/java/ATM.java b/src/main/java/ATM.java index 20210ee..e56aa1f 100644 --- a/src/main/java/ATM.java +++ b/src/main/java/ATM.java @@ -1,6 +1,8 @@ import java.util.ArrayList; public class ATM { + private ArrayList allUsers = new ArrayList(); + private int numOfAccounts = 0; private static ATM theInstance = new ATM(); @@ -11,57 +13,60 @@ public static ATM getInstance() { return theInstance; } - private ArrayList allUsers = new ArrayList(); - private int numOfAccounts = 0; + void addUser(String userName, String password) { + User newUser = new User(userName, password); + allUsers.add(newUser); + } - public int returnAllUsersSize() { + int returnAllUsersSize() { return allUsers.size(); } - public int returnNewAccountNum() { + int returnNewAccountNum() { numOfAccounts++; return numOfAccounts; } - public void addUser(String userName,String password) { - User newUser = new User(userName, password); - allUsers.add(newUser); - - } - - public User EnterUser(String userName,String password){ - int index = -1; + boolean UserExist(String userName) { + boolean userExist = false; User currentUser; - for(int i = 0;i= 0) { - currentUser = (User) allUsers.get(index); - }else{ - currentUser = null; - } - return currentUser; - + return userExist; } - public boolean UserExist(String userName,String password) { - int index = -1; + int UserIndex(String userName){ + int index = 0; User currentUser; - boolean userExist = false; for (int i = 0; i < allUsers.size(); i++) { currentUser = (User) allUsers.get(i); - if (userName.equalsIgnoreCase(currentUser.getUserName()) && - password.equals(currentUser.getUserPassword())) { - index = i; + if (userName.equalsIgnoreCase(currentUser.getUserName())) { + return i; } } - if (index >= 0) { - userExist = true; + return index; + } + + boolean UserNameAndPasswordCorrect(String userName, String password) { + User currentUser; + String userPassword; + boolean userCorrect = false; + if(UserExist(userName)){ + currentUser = EnterUser(userName); + userPassword= currentUser.getUserPassword(); + userCorrect = (password.equals(userPassword)); } - return userExist; + return userCorrect; + } + + User EnterUser(String userName) { + int index = UserIndex(userName); + User currentUser = (User) allUsers.get(index); + return currentUser; } + } diff --git a/src/main/java/Account.java b/src/main/java/Account.java index 3aa012f..43f37e7 100644 --- a/src/main/java/Account.java +++ b/src/main/java/Account.java @@ -1,46 +1,46 @@ import java.util.ArrayList; -public class Account { +public /*abstract*/ class Account { private int accountNum; private double accountBalance; - private char accountType; - private double[] accountHistory = new double[3]; + private String accountType; + private ArrayList accountHistory = new ArrayList(); ATM atm = ATM.getInstance(); - Account(){ - } - public double[] getAccountHistory(){ - return accountHistory; - } - public void addToAccountHistory(double amount){ - accountHistory[0] = accountHistory[1]; - accountHistory[1] = accountHistory[2]; - accountHistory[2] = amount; + Account(){} + + void setBalance(double balanceGiven){ + accountBalance = balanceGiven; } - public void setAccountNum(){ - this.accountNum = atm.returnNewAccountNum(); + double getBalance(){ + return accountBalance; } - public int getAccountNum(){ - return accountNum; + void setType(String type){ + accountType = type; + } + String getType(){ + return accountType; } - public void setBalance(double balanceGiven){ - accountBalance = balanceGiven; + + + void setAccountNum(){ + this.accountNum = atm.returnNewAccountNum(); } - public double getBalance(){ - return accountBalance; + int getAccountNum(){ + return accountNum; } - public void setType(char type){ - accountType = type; + ArrayList getAccountHistory(){ + return accountHistory; } - public char getType(){ - return accountType; + void addToAccountHistory(String newTransaction){ + accountHistory.add(newTransaction); } } diff --git a/src/main/java/AccountFactory.java b/src/main/java/AccountFactory.java deleted file mode 100644 index f616b3c..0000000 --- a/src/main/java/AccountFactory.java +++ /dev/null @@ -1,16 +0,0 @@ -public class AccountFactory { -/* - private char accountType; - private int accountNum; - private double accountType - - AccountFactory(char accountType){ - this.accountType = accountType; - account.setAccountNum(); - double randomBalamce = Math.random()*100; - account.setBalance(randomBalamce); - account.setType(accountType); - } - -*/ -} diff --git a/src/main/java/CheckingAccount.java b/src/main/java/CheckingAccount.java new file mode 100644 index 0000000..d4ca04e --- /dev/null +++ b/src/main/java/CheckingAccount.java @@ -0,0 +1,2 @@ +public class CheckingAccount { +} diff --git a/src/main/java/Console.java b/src/main/java/Console.java index 5a05305..6fe1801 100644 --- a/src/main/java/Console.java +++ b/src/main/java/Console.java @@ -5,9 +5,11 @@ public class Console { ATM atm = ATM.getInstance(); Scanner scan = new Scanner(System.in); - protected void frontPage(){ + void frontPage() { System.out.print("\nWelcome\n 1) New User\n 2) Login\n 0) Exit\n"); - switch(scan.nextInt()){ + + int inputNum = catchErrorInput(); + switch (inputNum) { case 1: addUser(); break; @@ -17,16 +19,25 @@ protected void frontPage(){ case 0: return; default: - frontPage(); + System.out.println("Not a valid input"); + //frontPage(); } } - private void userPage(User user){ + private int catchErrorInput() { + int output; + while (! scan.hasNextInt()) + output = scan.nextInt(); + output = scan.nextInt(); + return output; + } + + private void userPage(User user) { System.out.print( - "\n 1) Check balance of account\n 2) Withdraw from account\n 3) Deposit to account"+ - "\n 4) Transfer from one account to another\n 5) Print account transaction history"+ - "\n 6) Close account\n 7) Add new account\n 8) User settings\n 0) Logout\n"); - switch(scan.nextInt()){ + "\n 1) Check balance of account\n 2) Withdraw from account\n 3) Deposit to account" + + "\n 4) Transfer from one account to another\n 5) Print account transaction history" + + "\n 6) Close account\n 7) Add new account\n 8) User settings\n 0) Logout\n"); + switch (scan.nextInt()) { case 1: balancePrint(user); break; @@ -59,9 +70,9 @@ private void userPage(User user){ } } - private void userSettingPage(User user){ - System.out.println("\nUser Setting\n 1) Change user name\n 2) Change password\n 3) Look at all accounts\n 0) Back"); - switch(scan.nextInt()){ + private void userSettingPage(User user) { + System.out.println("\nUser Settings\n 1) Change user name\n 2) Change password\n 3) Look at all accounts\n 0) Back"); + switch (scan.nextInt()) { case 1: changeUserNamePage(user); break; @@ -69,7 +80,7 @@ private void userSettingPage(User user){ changePasswordPage(user); break; case 3: - //lookAtAccount(user); + printAccounts(user); break; case 0: userPage(user); @@ -78,119 +89,219 @@ private void userSettingPage(User user){ userSettingPage(user); } } - private void changePasswordPage(User user){ - System.out.print("Current password >> "); - String input = scan.next(); - if(input.equalsIgnoreCase(user.getUserPassword())){ - System.out.print("New password >> "); - input = scan.next(); - user.setUserPassword(input); - System.out.print("Password changed"); - }else{ - System.out.print("Incorrect password"); + + private void transferPrint(User user) { + System.out.println("Transfer funds\n 1) Transfer to own account\n 2) Transfer to other users account\n 0) Back"); + switch (scan.nextInt()) { + case 1: + selfTransfer(user); + break; + case 2: + otherUserTransfer(user); + break; + case 0: + userPage(user); + break; + default: + transferPrint(user); } - userSettingPage(user); } - private void changeUserNamePage(User user){ - System.out.print("Current user name >> "); - String input = scan.next(); - if(input.equalsIgnoreCase(user.getUserName())){ - System.out.print("New user name >> "); - input = scan.next(); - user.setUserName(input); - System.out.print("User name changed\n"); - }else{ - System.out.print("Incorrect user name"); + private void addAccount(User user) { + System.out.print("What type of account?\n 1) Checking\n 2) Savings\n 3) Investment\n"); + String accountType; + int input = Integer.parseInt(scan.next()); + ; + switch (input) { + case 1: + accountType = "Checking "; + break; + case 2: + accountType = "Savings "; + break; + case 3: + accountType = "Investment"; + break; + case 0: + userPage(user); + default: + addAccount(user); + accountType = "x"; + } + if (!"x".equals(accountType)) { + int accountNum = user.addAccount(accountType); + System.out.print("Account added\nNew account number : " + accountNum + "\n"); + } + userPage(user); + } + + public void printAccounts(User user) { + ArrayList accounts = user.getAccountsArray(); + for (Object account : accounts) { + printAccountInfo((Account) account); } userSettingPage(user); } - private void historyPrint(User user){ + public void printAccountInfo(Account account) { + String accountType = account.getType(); + int accountNum = account.getAccountNum(); + double accountBalance = account.getBalance(); + System.out.println("Account type : " + accountType + "\tAccount number : " + accountNum + "\t\tAccount balance\t: " + accountBalance); + } + + private void historyPrint(User user) { Account account = enterAccount(user); - double transaction; - double[] history = account.getAccountHistory(); + ArrayList history = account.getAccountHistory(); System.out.println("Most recent at the bottom"); - for(int i = 0;i0){ - System.out.println("Deposit : "+transaction); - } + for (Object transaction : history) { + System.out.println((String) transaction); } userPage(user); } - private void closeAccount(User user){ - Account account = enterAccount(user); - if(user.removeAccount(account.getAccountNum())){ - System.out.print("Account removed"); - userPage(user); - }else{ - System.out.print("Account can not be closed"); + private void otherUserTransfer(User user) { + System.out.println("From account"); + Account fromAccount = enterAccount(user); + System.out.println("User to transfer to"); + User toUser = enterUser(); + Account toAccount = enterAccount(toUser); + System.out.print("How mush would you like to transfer >> "); + double amount = scan.nextDouble(); + if (user.withdraw(amount, fromAccount) && toUser.deposit(amount, toAccount)) { + System.out.println("Transfer made"); + } + userPage(user); + } + + private User enterUser() { + User toUser = null; + System.out.print("User name >> "); + String toUserString = scan.next(); + if (atm.UserExist(toUserString)) { + toUser = atm.EnterUser(toUserString); + } + return toUser; + } + + private void loginPage() { + System.out.print("LOGIN PAGE\n"); + System.out.print("User Name >> "); + String userName = scan.next(); + System.out.print("Password >> "); + String password = scan.next(); + if (atm.UserNameAndPasswordCorrect(userName, password)) { + User user = atm.EnterUser(userName); + System.out.println("\nWelcome back " + user.getUserName()); userPage(user); + } else { + if (atm.UserExist(userName)) { + System.out.print("Incorrect password\n"); + } else { + System.out.print("User does not exist\n"); + } + frontPage(); } } - private void transferPrint(User user){ + + private void selfTransfer(User user) { System.out.print("From account\n"); Account fromAccount = enterAccount(user); System.out.print("To account\n"); Account toAccount = enterAccount(user); System.out.print("How much would you like to transfer >> "); double amount = scan.nextDouble(); - if(user.transfer(amount,fromAccount,toAccount)){ + if (user.transfer(amount, fromAccount, toAccount)) { System.out.print("Transfer made\n"); userPage(user); - }else{ + } else { System.out.print("Transfer not possible\n"); userPage(user); } - } - private void depositPrint(User user){ + + private void changePasswordPage(User user) { + System.out.print("Current password >> "); + String input = scan.next(); + if (input.equalsIgnoreCase(user.getUserPassword())) { + System.out.print("New password >> "); + input = scan.next(); + user.setUserPassword(input); + System.out.print("Password changed"); + } else { + System.out.print("Incorrect password"); + } + userSettingPage(user); + } + + private void changeUserNamePage(User user) { + System.out.print("Current user name >> "); + String input = scan.next(); + if (input.equalsIgnoreCase(user.getUserName())) { + System.out.print("New user name >> "); + input = scan.next(); + user.setUserName(input); + System.out.print("User name changed\n"); + } else { + System.out.print("Incorrect user name"); + } + userSettingPage(user); + } + + private void closeAccount(User user) { + Account account = enterAccount(user); + if (user.removeAccount(account.getAccountNum())) { + System.out.print("Account removed"); + userPage(user); + } else { + System.out.print("Account is not empty"); + userPage(user); + } + } + + + private void depositPrint(User user) { Account account = enterAccount(user); System.out.print("Deposit amount >> "); double amount = scan.nextDouble(); - if(user.deposit(amount,account)){ + if (user.deposit(amount, account)) { System.out.print("Deposit made\n"); userPage(user); - }else{ + } else { System.out.print("Deposit not possible\n"); userPage(user); } } - private void withdrawPrint(User user){ + private void withdrawPrint(User user) { Account account = enterAccount(user); System.out.print("Withdraw amount >> "); double amount = scan.nextDouble(); - if(user.withdraw(amount,account)){ + if (user.withdraw(amount, account)) { System.out.print("Withdraw made\n"); userPage(user); - }else{ + } else { System.out.print("Withdraw not possible\n"); userPage(user); } } - private void balancePrint(User user){ + private void balancePrint(User user) { Account account = enterAccount(user); - System.out.print("\nAccount : "+account.getAccountNum()+"\nBalance : "+ account.getBalance()+"\n"); + System.out.print("\nAccount : " + account.getAccountNum() + "\nBalance : " + account.getBalance() + "\n"); userPage(user); } - private Account enterAccount(User user){ + private Account enterAccount(User user) { System.out.print("Account number >> "); int input = scan.nextInt(); Account account; - if(user.AccountExist(input)){ + if (user.AccountExist(input)) { account = user.EnterAccount(input); - //accountPage(account); - }else{ + } else { System.out.print("Account does not exist"); account = null; userPage(user); @@ -198,56 +309,19 @@ private Account enterAccount(User user){ return account; } - private void addAccount(User user){ - System.out.print("What type of account?\n 1) Checking\n 2) Savings\n 3) Investment\n"); - char accountType; - switch(scan.nextInt()) { - case 1: - accountType = 'c'; - break; - case 2: - accountType = 's'; - break; - case 3: - accountType = 'i'; - break; - default: - accountType = 'x'; - } - if(accountType!= 'x') { - int accountNum = user.addAccount(accountType); - System.out.print("Account added\nNew account number : "+accountNum+"\n"); - } - userPage(user); - } - - - private void addUser(){ + private void addUser() { System.out.print("New user Name >> "); String userName = scan.next(); System.out.print("New password >> "); String password = scan.next(); - atm.addUser(userName,password); - System.out.print("\nNew user added\n"); - frontPage(); - } - - private void loginPage(){ - System.out.print("User Name >> "); - String userName = scan.next(); - System.out.print("Password >> "); - String password = scan.next(); - if(atm.UserExist(userName,password)) { - User user = atm.EnterUser(userName, password); - System.out.println("\nWelcome back "+user.getUserName()); - userPage(user); - }else{ - System.out.print("User does not exist"); - frontPage(); + if (atm.UserExist(userName)) { + System.out.println("\nUser name already exist"); + } else { + atm.addUser(userName, password); + System.out.print("\nNew user added\n"); } + frontPage(); } - - } diff --git a/src/main/java/InvestmentAccount.java b/src/main/java/InvestmentAccount.java new file mode 100644 index 0000000..147762e --- /dev/null +++ b/src/main/java/InvestmentAccount.java @@ -0,0 +1,2 @@ +public class InvestmentAccount { +} diff --git a/src/main/java/SavingAccount.java b/src/main/java/SavingAccount.java new file mode 100644 index 0000000..4c43316 --- /dev/null +++ b/src/main/java/SavingAccount.java @@ -0,0 +1,7 @@ +public class SavingAccount extends Account { + private String accountType = "Savings"; + String getType(){ + return accountType; + } + +} diff --git a/src/main/java/User.java b/src/main/java/User.java index 6bea7de..fe84302 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -10,101 +10,96 @@ public class User { this.password = password; } - public void setUserName(String userName) { + void setUserName(String userName) { this.userName = userName; } - public String getUserName() { + + String getUserName() { return userName; } - public void setUserPassword(String password) { + + void setUserPassword(String password) { this.password = password; } - public String getUserPassword() { + + String getUserPassword() { return password; } - public int accountsArraySize(){ - return accountsArray.size(); - } - - public int addAccount(char accountType) { + int addAccount(String accountType) { Account newAccount = new Account(); newAccount.setType(accountType); newAccount.setBalance(0); newAccount.setAccountNum(); - accountsArray.add(newAccount); return newAccount.getAccountNum(); } - public boolean removeAccount(int accountNum){ + int accountsArraySize() { + return accountsArray.size(); + } + + ArrayList getAccountsArray() { + return accountsArray; + } + + boolean removeAccount(int accountNum) { boolean removedAccount = false; Account removeAccount = EnterAccount(accountNum); - if(removeAccount.getBalance() == 0){ + if (removeAccount.getBalance() == 0) { accountsArray.remove(removeAccount); removedAccount = true; } return removedAccount; } - public boolean AccountExist(int accountNum) { - int index = -1; - boolean accountExist = false; + boolean AccountExist(int accountNum) { Account currentAccount; for (int i = 0; i < accountsArray.size(); i++) { currentAccount = (Account) accountsArray.get(i); if (currentAccount.getAccountNum() == accountNum) { - index = i; + return true; } } - if (index >= 0) { - accountExist = true; - } - return accountExist; + return false; } - public Account EnterAccount(int accountNum) { - int index = -1; + Account EnterAccount(int accountNum) { Account currentAccount; for (int i = 0; i < accountsArray.size(); i++) { currentAccount = (Account) accountsArray.get(i); if (currentAccount.getAccountNum() == accountNum) { - index = i; + return currentAccount; } } - if (index >= 0) { - currentAccount = (Account) accountsArray.get(index); - }else { - currentAccount = null; - } - - return currentAccount; + return null; } - - public boolean withdraw(double amount,Account account){ + boolean withdraw(double amount, Account account) { boolean withdrawMade = false; double currentBalance = account.getBalance(); - if(currentBalance >= amount){ + String newTransaction; + if (currentBalance >= amount) { withdrawMade = true; - account.addToAccountHistory(amount*-1); - account.setBalance(currentBalance-amount); + newTransaction = "Withdraw " + amount; + account.addToAccountHistory(newTransaction); + account.setBalance(currentBalance - amount); } return withdrawMade; } - public boolean deposit(double amount, Account account){ + boolean deposit(double amount, Account account) { double currentBalance = account.getBalance(); - account.setBalance(currentBalance+amount); - account.addToAccountHistory(amount); + account.setBalance(currentBalance + amount); + String newTransaction = "Deposit " + amount; + account.addToAccountHistory(newTransaction); return true; } - public boolean transfer(double amount,Account fromAccount,Account toAccount){ - return withdraw(amount,fromAccount) && deposit(amount,toAccount); + boolean transfer(double amount, Account fromAccount, Account toAccount) { + return withdraw(amount, fromAccount) && deposit(amount, toAccount); } - } diff --git a/src/main/java/UserFactory.java b/src/main/java/UserFactory.java deleted file mode 100644 index e81ab5c..0000000 --- a/src/main/java/UserFactory.java +++ /dev/null @@ -1,3 +0,0 @@ -public class UserFactory { - -} diff --git a/src/test/java/tests.java b/src/test/java/tests.java index 0380ffe..b557132 100644 --- a/src/test/java/tests.java +++ b/src/test/java/tests.java @@ -1,19 +1,27 @@ import org.junit.Assert; import org.junit.Test; +import java.util.ArrayList; + public class tests { ATM atm = ATM.getInstance(); -/* - - @Test + @Test //Test addUsers and returnAllUserSize public void addUserTest(){ int expected = 1; atm.addUser("wes","password"); int actual = atm.returnAllUsersSize(); Assert.assertEquals(expected,actual); + } + + @Test + public void returnNewAccountNumTest(){ + int expected = 1; + + int actual = atm.returnNewAccountNum(); + Assert.assertEquals(expected,actual); } @Test @@ -22,18 +30,58 @@ public void UserExistTest(){ boolean expected1 = true; boolean expected2 = false; - boolean actual1 = atm.UserExist("wes","password"); - boolean actual2 = atm.UserExist("bob","password"); + boolean actual1 = atm.UserExist("wes"); + boolean actual2 = atm.UserExist("bob"); Assert.assertEquals(expected1,actual1); Assert.assertEquals(expected2,actual2); } + @Test + public void UserIndexTest(){ + int expected1 = 0; + int expected2 = 1; + atm.addUser("wes","password"); + atm.addUser("bob","password"); + + int actual1 = atm.UserIndex("wes"); + int actual2 = atm.UserIndex("bob"); + + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); + } + + @Test + public void UserNameAndPasswordCorrectTest(){ + atm.addUser("wes","password"); + boolean expected1 = true; + boolean expected2 = false; + + boolean actual1 = atm.UserNameAndPasswordCorrect("wes","password"); + boolean actual2 = atm.UserNameAndPasswordCorrect("bob","password"); + + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); + } @Test - public void UserNameTest(){ + public void EnterUserTest(){ + atm.addUser("wes","password"); + String expected = "wes"; + + User currentUser = atm.EnterUser("wes"); + String actual = currentUser.getUserName(); + + Assert.assertEquals(expected,actual); + + } + + //-------------------------------------------------------------------- + + @Test //Test setUserName and getUserName + public void setUserNameTest(){ atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); + User currentUser = atm.EnterUser("wes"); String expected1 = "wes"; String expected2 = "bob"; @@ -45,10 +93,10 @@ public void UserNameTest(){ Assert.assertEquals(expected2,actual2); } - @Test - public void UserPasswordTest(){ + @Test //Test setUserPassword and getUserPassword + public void setUserPasswordTest(){ atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); + User currentUser = atm.EnterUser("wes"); String expected1 = "password"; String expected2 = "newPassword"; @@ -60,24 +108,55 @@ public void UserPasswordTest(){ Assert.assertEquals(expected2,actual2); } - @Test public void addAccountTest(){ atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); - currentUser.addAccount('c'); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("checking"); int expected = 1; int actual = currentUser.accountsArraySize(); Assert.assertEquals(expected,actual); } + + @Test + public void accountArraySizeTest(){ + atm.addUser("wes","pass"); + User currentUser = atm.EnterUser("wes"); + int expected1 = 0; + int expected2 = 1; + + int actual1 = currentUser.accountsArraySize(); + currentUser.addAccount("checking"); + int actual2 = currentUser.accountsArraySize(); + + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); + } + + @Test + public void getAccountArrayTest(){ + atm.addUser("wes","pass"); + User currentUser = atm.EnterUser("wes"); + int expected = 1; + + currentUser.addAccount("Checking"); + + ArrayList accounts = currentUser.getAccountsArray(); + Account account = (Account)accounts.get(0); + int actual = account.getAccountNum(); + + Assert.assertEquals(expected,actual); + + } + @Test public void removeAccountTest(){ atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); - currentUser.addAccount('c'); - currentUser.addAccount('s'); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("checking"); + currentUser.addAccount("savings"); boolean expected1 = true; int expected2 = 1; @@ -97,10 +176,10 @@ public void removeAccountTest(){ } @Test - public void accountExistTest(){ + public void AccountExistTest(){ atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); - currentUser.addAccount('c'); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("checking"); boolean expected1 = true; boolean expected2 = false; @@ -114,27 +193,26 @@ public void accountExistTest(){ @Test public void EnterAccountTest(){ atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); - currentUser.addAccount('c'); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("checking"); Account currentAccount = currentUser.EnterAccount(1); - char expected = 'c'; + String expected = "checking"; - char actual = currentAccount.getType(); + String actual = currentAccount.getType(); Assert.assertEquals(expected,actual); } - @Test - public void AccountBalanceTest(){ + public void withdrawTest(){ atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); - currentUser.addAccount('c'); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("savings"); Account currentAccount = currentUser.EnterAccount(1); + currentAccount.setBalance(100); - double expected = 500; - - currentAccount.setBalance(500); + double expected = 50; + currentUser.withdraw(50,currentAccount); double actual = currentAccount.getBalance(); @@ -145,8 +223,8 @@ public void AccountBalanceTest(){ @Test public void depositTest(){ atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); - currentUser.addAccount('s'); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("savings"); Account currentAccount = currentUser.EnterAccount(1); double expected = 100; @@ -158,29 +236,12 @@ public void depositTest(){ Assert.assertEquals(expected,actual,0); } - @Test - public void withdrawTest(){ - atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); - currentUser.addAccount('s'); - Account currentAccount = currentUser.EnterAccount(1); - currentAccount.setBalance(100); - - double expected = 50; - currentUser.withdraw(50,currentAccount); - - double actual = currentAccount.getBalance(); - - Assert.assertEquals(expected,actual,0); - - } - @Test public void transferTest(){ atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); - currentUser.addAccount('s'); - currentUser.addAccount('c'); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("savings"); + currentUser.addAccount("checking"); Account firstAccount = currentUser.EnterAccount(1); Account secondAccount = currentUser.EnterAccount(2); firstAccount.setBalance(100); @@ -198,23 +259,65 @@ public void transferTest(){ } - @Test - public void accountHistoryTest(){ + //----------------------------------------------------------------- + + @Test // test getAccountBalance and setAccountBalance + public void AccountBalanceTest(){ atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes","password"); - currentUser.addAccount('s'); - Account account = currentUser.EnterAccount(1); - currentUser.deposit(50,account); - double expected = 50; - double firstPlace = account.getAccountHistory()[0]; - double actual = firstPlace; + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("checking"); + Account currentAccount = currentUser.EnterAccount(1); + + double expected = 500; + + currentAccount.setBalance(500); + + double actual = currentAccount.getBalance(); Assert.assertEquals(expected,actual,0); + } + @Test // test getAccountType and setAccountType + public void AccountTypeTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes"); + + String expected = "checking"; + + currentUser.addAccount(expected); + Account currentAccount = currentUser.EnterAccount(1); + String actual = currentAccount.getType(); + + Assert.assertEquals(expected,actual); + } + @Test // test getAccountNum and setAccountNum + public void AccountNumberTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("savings"); + Account currentAccount = currentUser.EnterAccount(1); + int expected = 1; + int actual = currentAccount.getAccountNum(); + + Assert.assertEquals(expected,actual); } - */ + @Test // test getAccountHistory and addToAccountHistory + public void accountHistoryTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("savings"); + Account account = currentUser.EnterAccount(1); + currentUser.deposit(50,account); + String expected = "Deposit 50.0"; + + ArrayList history = account.getAccountHistory(); + String firstPlace = (String)history.get(0); + String actual = firstPlace; + + Assert.assertEquals(expected,actual); + } } From 5edde03d5a8fb21a7683a1608fd06ee2620f94c6 Mon Sep 17 00:00:00 2001 From: wesley Date: Wed, 25 Oct 2017 18:31:24 -0400 Subject: [PATCH 5/8] saving 6:30 10/25 --- src/main/java/Account.java | 35 ++++++++++++---------------- src/main/java/CheckingAccount.java | 5 +++- src/main/java/Console.java | 34 ++++++++++++++------------- src/main/java/InvestmentAccount.java | 5 +++- src/main/java/SavingAccount.java | 6 ++--- src/main/java/User.java | 3 +-- src/test/java/tests.java | 10 ++++---- 7 files changed, 50 insertions(+), 48 deletions(-) diff --git a/src/main/java/Account.java b/src/main/java/Account.java index 43f37e7..12fc184 100644 --- a/src/main/java/Account.java +++ b/src/main/java/Account.java @@ -1,6 +1,6 @@ import java.util.ArrayList; -public /*abstract*/ class Account { +public class Account { private int accountNum; private double accountBalance; private String accountType; @@ -8,40 +8,35 @@ ATM atm = ATM.getInstance(); - Account(){} + Account(String accountType){ + this.accountType = accountType; + } - void setBalance(double balanceGiven){ + void setBalance(double balanceGiven) { accountBalance = balanceGiven; } - double getBalance(){ + double getBalance() { return accountBalance; } - void setType(String type){ - accountType = type; - } - String getType(){ - return accountType; - } - - - - void setAccountNum(){ + void setAccountNum() { this.accountNum = atm.returnNewAccountNum(); } - int getAccountNum(){ + int getAccountNum() { return accountNum; } - ArrayList getAccountHistory(){ + String getAccountType(){ + return accountType; + } + + ArrayList getAccountHistory() { return accountHistory; } - void addToAccountHistory(String newTransaction){ + void addToAccountHistory(String newTransaction) { accountHistory.add(newTransaction); } - -} - +} \ No newline at end of file diff --git a/src/main/java/CheckingAccount.java b/src/main/java/CheckingAccount.java index d4ca04e..6545218 100644 --- a/src/main/java/CheckingAccount.java +++ b/src/main/java/CheckingAccount.java @@ -1,2 +1,5 @@ -public class CheckingAccount { +public class CheckingAccount extends Account { + public CheckingAccount(){ + super("Checking"); + } } diff --git a/src/main/java/Console.java b/src/main/java/Console.java index 6fe1801..888d285 100644 --- a/src/main/java/Console.java +++ b/src/main/java/Console.java @@ -7,9 +7,7 @@ public class Console { void frontPage() { System.out.print("\nWelcome\n 1) New User\n 2) Login\n 0) Exit\n"); - - int inputNum = catchErrorInput(); - switch (inputNum) { + switch (scan.nextInt()) { case 1: addUser(); break; @@ -20,17 +18,23 @@ void frontPage() { return; default: System.out.println("Not a valid input"); - //frontPage(); + frontPage(); } } - private int catchErrorInput() { - int output; - while (! scan.hasNextInt()) - output = scan.nextInt(); - output = scan.nextInt(); - return output; - } +// private int catchErrorInput() { +// int output = -1; +// while(output<0) { +// if (scan.hasNextInt()) { +// +// output = scan.nextInt(); +// } else { +// output = -1; +// } +// +// } +// return output; +// } private void userPage(User user) { System.out.print( @@ -110,9 +114,7 @@ private void transferPrint(User user) { private void addAccount(User user) { System.out.print("What type of account?\n 1) Checking\n 2) Savings\n 3) Investment\n"); String accountType; - int input = Integer.parseInt(scan.next()); - ; - switch (input) { + switch (scan.nextInt()) { case 1: accountType = "Checking "; break; @@ -130,7 +132,7 @@ private void addAccount(User user) { } if (!"x".equals(accountType)) { int accountNum = user.addAccount(accountType); - System.out.print("Account added\nNew account number : " + accountNum + "\n"); + System.out.print("\nAccount added\n\nNew account number : " + accountNum + "\n"); } userPage(user); } @@ -144,7 +146,7 @@ public void printAccounts(User user) { } public void printAccountInfo(Account account) { - String accountType = account.getType(); + String accountType = account.getAccountType(); int accountNum = account.getAccountNum(); double accountBalance = account.getBalance(); System.out.println("Account type : " + accountType + "\tAccount number : " + accountNum + "\t\tAccount balance\t: " + accountBalance); diff --git a/src/main/java/InvestmentAccount.java b/src/main/java/InvestmentAccount.java index 147762e..09e6e9a 100644 --- a/src/main/java/InvestmentAccount.java +++ b/src/main/java/InvestmentAccount.java @@ -1,2 +1,5 @@ -public class InvestmentAccount { +public class InvestmentAccount extends Account{ + public InvestmentAccount(){ + super("Investment"); + } } diff --git a/src/main/java/SavingAccount.java b/src/main/java/SavingAccount.java index 4c43316..5624846 100644 --- a/src/main/java/SavingAccount.java +++ b/src/main/java/SavingAccount.java @@ -1,7 +1,5 @@ public class SavingAccount extends Account { - private String accountType = "Savings"; - String getType(){ - return accountType; + public SavingAccount(){ + super("Savings"); } - } diff --git a/src/main/java/User.java b/src/main/java/User.java index fe84302..615e657 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -27,8 +27,7 @@ String getUserPassword() { } int addAccount(String accountType) { - Account newAccount = new Account(); - newAccount.setType(accountType); + Account newAccount = new Account(accountType); newAccount.setBalance(0); newAccount.setAccountNum(); accountsArray.add(newAccount); diff --git a/src/test/java/tests.java b/src/test/java/tests.java index b557132..49efc62 100644 --- a/src/test/java/tests.java +++ b/src/test/java/tests.java @@ -6,12 +6,13 @@ public class tests { ATM atm = ATM.getInstance(); - @Test //Test addUsers and returnAllUserSize public void addUserTest(){ int expected = 1; + atm.addUser("wes","password"); int actual = atm.returnAllUsersSize(); + Assert.assertEquals(expected,actual); } @@ -116,6 +117,7 @@ public void addAccountTest(){ int expected = 1; int actual = currentUser.accountsArraySize(); + Assert.assertEquals(expected,actual); } @@ -142,7 +144,6 @@ public void getAccountArrayTest(){ int expected = 1; currentUser.addAccount("Checking"); - ArrayList accounts = currentUser.getAccountsArray(); Account account = (Account)accounts.get(0); int actual = account.getAccountNum(); @@ -198,7 +199,7 @@ public void EnterAccountTest(){ Account currentAccount = currentUser.EnterAccount(1); String expected = "checking"; - String actual = currentAccount.getType(); + String actual = currentAccount.getAccountType(); Assert.assertEquals(expected,actual); } @@ -276,6 +277,7 @@ public void AccountBalanceTest(){ Assert.assertEquals(expected,actual,0); } + @Test // test getAccountType and setAccountType public void AccountTypeTest(){ atm.addUser("wes","password"); @@ -285,7 +287,7 @@ public void AccountTypeTest(){ currentUser.addAccount(expected); Account currentAccount = currentUser.EnterAccount(1); - String actual = currentAccount.getType(); + String actual = currentAccount.getAccountType(); Assert.assertEquals(expected,actual); } From f5ec2aee20e0f46fd20df0a2a584c056ddf3a4e2 Mon Sep 17 00:00:00 2001 From: wesley Date: Wed, 25 Oct 2017 19:45:35 -0400 Subject: [PATCH 6/8] error catching --- src/main/java/Console.java | 64 ++++++++++++++++++++++---------------- 1 file changed, 38 insertions(+), 26 deletions(-) diff --git a/src/main/java/Console.java b/src/main/java/Console.java index 888d285..deafd6f 100644 --- a/src/main/java/Console.java +++ b/src/main/java/Console.java @@ -7,7 +7,7 @@ public class Console { void frontPage() { System.out.print("\nWelcome\n 1) New User\n 2) Login\n 0) Exit\n"); - switch (scan.nextInt()) { + switch (catchIntErrorInput()) { case 1: addUser(); break; @@ -22,26 +22,12 @@ void frontPage() { } } -// private int catchErrorInput() { -// int output = -1; -// while(output<0) { -// if (scan.hasNextInt()) { -// -// output = scan.nextInt(); -// } else { -// output = -1; -// } -// -// } -// return output; -// } - private void userPage(User user) { System.out.print( "\n 1) Check balance of account\n 2) Withdraw from account\n 3) Deposit to account" + "\n 4) Transfer from one account to another\n 5) Print account transaction history" + "\n 6) Close account\n 7) Add new account\n 8) User settings\n 0) Logout\n"); - switch (scan.nextInt()) { + switch (catchIntErrorInput()) { case 1: balancePrint(user); break; @@ -76,7 +62,7 @@ private void userPage(User user) { private void userSettingPage(User user) { System.out.println("\nUser Settings\n 1) Change user name\n 2) Change password\n 3) Look at all accounts\n 0) Back"); - switch (scan.nextInt()) { + switch (catchIntErrorInput()) { case 1: changeUserNamePage(user); break; @@ -96,7 +82,7 @@ private void userSettingPage(User user) { private void transferPrint(User user) { System.out.println("Transfer funds\n 1) Transfer to own account\n 2) Transfer to other users account\n 0) Back"); - switch (scan.nextInt()) { + switch (catchIntErrorInput()) { case 1: selfTransfer(user); break; @@ -114,7 +100,7 @@ private void transferPrint(User user) { private void addAccount(User user) { System.out.print("What type of account?\n 1) Checking\n 2) Savings\n 3) Investment\n"); String accountType; - switch (scan.nextInt()) { + switch (catchIntErrorInput()) { case 1: accountType = "Checking "; break; @@ -137,7 +123,33 @@ private void addAccount(User user) { userPage(user); } - public void printAccounts(User user) { + private int catchIntErrorInput() { + int output = -1; + while(output<0) { + String input = scan.next(); + try { + output = Integer.parseInt(input); + } catch (Exception e) { + System.out.println("Invalid input"); + } + } + return output; + } + + private double catchDoubleErrorInput() { + double output = -1; + while(output<0) { + String input = scan.next(); + try { + output = Double.parseDouble(input); + } catch (Exception e) { + System.out.println("Invalid input"); + } + } + return output; + } + + private void printAccounts(User user) { ArrayList accounts = user.getAccountsArray(); for (Object account : accounts) { printAccountInfo((Account) account); @@ -145,7 +157,7 @@ public void printAccounts(User user) { userSettingPage(user); } - public void printAccountInfo(Account account) { + private void printAccountInfo(Account account) { String accountType = account.getAccountType(); int accountNum = account.getAccountNum(); double accountBalance = account.getBalance(); @@ -169,7 +181,7 @@ private void otherUserTransfer(User user) { User toUser = enterUser(); Account toAccount = enterAccount(toUser); System.out.print("How mush would you like to transfer >> "); - double amount = scan.nextDouble(); + double amount = catchDoubleErrorInput(); if (user.withdraw(amount, fromAccount) && toUser.deposit(amount, toAccount)) { System.out.println("Transfer made"); } @@ -213,7 +225,7 @@ private void selfTransfer(User user) { System.out.print("To account\n"); Account toAccount = enterAccount(user); System.out.print("How much would you like to transfer >> "); - double amount = scan.nextDouble(); + double amount = catchDoubleErrorInput(); if (user.transfer(amount, fromAccount, toAccount)) { System.out.print("Transfer made\n"); userPage(user); @@ -268,7 +280,7 @@ private void closeAccount(User user) { private void depositPrint(User user) { Account account = enterAccount(user); System.out.print("Deposit amount >> "); - double amount = scan.nextDouble(); + double amount = catchDoubleErrorInput(); if (user.deposit(amount, account)) { System.out.print("Deposit made\n"); userPage(user); @@ -281,7 +293,7 @@ private void depositPrint(User user) { private void withdrawPrint(User user) { Account account = enterAccount(user); System.out.print("Withdraw amount >> "); - double amount = scan.nextDouble(); + double amount = catchDoubleErrorInput(); if (user.withdraw(amount, account)) { System.out.print("Withdraw made\n"); userPage(user); @@ -299,7 +311,7 @@ private void balancePrint(User user) { private Account enterAccount(User user) { System.out.print("Account number >> "); - int input = scan.nextInt(); + int input = catchIntErrorInput(); Account account; if (user.AccountExist(input)) { account = user.EnterAccount(input); From 51df54e7cd8ed49c05ddeaa9881c70703b0df375 Mon Sep 17 00:00:00 2001 From: wesley Date: Sat, 28 Oct 2017 15:16:15 -0400 Subject: [PATCH 7/8] add tests --- src/main/java/ATM.java | 2 +- src/main/java/Main.java | 2 +- src/main/java/User.java | 4 - src/test/java/accountTest.java | 69 +++++++++ src/test/java/atmTest.java | 77 ++++++++++ src/test/java/{tests.java => userTest.java} | 147 +------------------- 6 files changed, 154 insertions(+), 147 deletions(-) create mode 100644 src/test/java/accountTest.java create mode 100644 src/test/java/atmTest.java rename src/test/java/{tests.java => userTest.java} (56%) diff --git a/src/main/java/ATM.java b/src/main/java/ATM.java index e56aa1f..a474fd2 100644 --- a/src/main/java/ATM.java +++ b/src/main/java/ATM.java @@ -13,7 +13,7 @@ public static ATM getInstance() { return theInstance; } - void addUser(String userName, String password) { + public void addUser(String userName, String password) { User newUser = new User(userName, password); allUsers.add(newUser); } diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 538f921..5cca5c3 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -1,4 +1,4 @@ -import java.util.Scanner; + /** * Created by iyasuwatts on 10/17/17. diff --git a/src/main/java/User.java b/src/main/java/User.java index 615e657..c624658 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -34,10 +34,6 @@ int addAccount(String accountType) { return newAccount.getAccountNum(); } - int accountsArraySize() { - return accountsArray.size(); - } - ArrayList getAccountsArray() { return accountsArray; } diff --git a/src/test/java/accountTest.java b/src/test/java/accountTest.java new file mode 100644 index 0000000..164d2d3 --- /dev/null +++ b/src/test/java/accountTest.java @@ -0,0 +1,69 @@ +import org.junit.Assert; +import org.junit.Test; + +import java.util.ArrayList; + +public class accountTest { + ATM atm = ATM.getInstance(); + + @Test // test getAccountBalance and setAccountBalance + public void AccountBalanceTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("checking"); + Account currentAccount = currentUser.EnterAccount(1); + + double expected = 500; + + currentAccount.setBalance(500); + + double actual = currentAccount.getBalance(); + + Assert.assertEquals(expected,actual,0); + } + + @Test // test getAccountType and setAccountType + public void AccountTypeTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes"); + + String expected = "checking"; + + currentUser.addAccount(expected); + Account currentAccount = currentUser.EnterAccount(1); + String actual = currentAccount.getAccountType(); + + Assert.assertEquals(expected,actual); + } + + @Test // test getAccountNum and setAccountNum + public void AccountNumberTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("savings"); + Account currentAccount = currentUser.EnterAccount(1); + + int expected = 1; + + int actual = currentAccount.getAccountNum(); + + Assert.assertEquals(expected,actual); + } + + @Test // test getAccountHistory and addToAccountHistory + public void accountHistoryTest(){ + atm.addUser("wes","password"); + User currentUser = atm.EnterUser("wes"); + currentUser.addAccount("savings"); + Account account = currentUser.EnterAccount(1); + currentUser.deposit(50,account); + String expected = "Deposit 50.0"; + + ArrayList history = account.getAccountHistory(); + String actual = (String)history.get(0); + + + Assert.assertEquals(expected,actual); + } + +} diff --git a/src/test/java/atmTest.java b/src/test/java/atmTest.java new file mode 100644 index 0000000..83335af --- /dev/null +++ b/src/test/java/atmTest.java @@ -0,0 +1,77 @@ +import org.junit.Assert; +import org.junit.Test; + +public class atmTest { + ATM atm = ATM.getInstance(); + + @Test //Test addUsers and returnAllUserSize + public void addUserTest(){ + int expected = 1; + + atm.addUser("wes","password"); + int actual = atm.returnAllUsersSize(); + + Assert.assertEquals(expected,actual); + } + + @Test + public void returnNewAccountNumTest(){ + int expected = 1; + + int actual = atm.returnNewAccountNum(); + + Assert.assertEquals(expected,actual); + } + + @Test + public void UserExistTest(){ + atm.addUser("wes","password"); + boolean expected1 = true; + boolean expected2 = false; + + boolean actual1 = atm.UserExist("wes"); + boolean actual2 = atm.UserExist("bob"); + + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); + } + + @Test + public void UserIndexTest(){ + int expected1 = 0; + int expected2 = 1; + atm.addUser("wes","password"); + atm.addUser("bob","password"); + + int actual1 = atm.UserIndex("wes"); + int actual2 = atm.UserIndex("bob"); + + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); + } + + @Test + public void UserNameAndPasswordCorrectTest(){ + atm.addUser("wes","password"); + boolean expected1 = true; + boolean expected2 = false; + + boolean actual1 = atm.UserNameAndPasswordCorrect("wes","password"); + boolean actual2 = atm.UserNameAndPasswordCorrect("bob","password"); + + Assert.assertEquals(expected1,actual1); + Assert.assertEquals(expected2,actual2); + } + + @Test + public void EnterUserTest(){ + atm.addUser("wes","password"); + String expected = "wes"; + + User currentUser = atm.EnterUser("wes"); + String actual = currentUser.getUserName(); + + Assert.assertEquals(expected,actual); + + } +} diff --git a/src/test/java/tests.java b/src/test/java/userTest.java similarity index 56% rename from src/test/java/tests.java rename to src/test/java/userTest.java index 49efc62..72c2cd4 100644 --- a/src/test/java/tests.java +++ b/src/test/java/userTest.java @@ -3,82 +3,9 @@ import java.util.ArrayList; -public class tests { +public class userTest { ATM atm = ATM.getInstance(); - @Test //Test addUsers and returnAllUserSize - public void addUserTest(){ - int expected = 1; - - atm.addUser("wes","password"); - int actual = atm.returnAllUsersSize(); - - Assert.assertEquals(expected,actual); - } - - @Test - public void returnNewAccountNumTest(){ - int expected = 1; - - int actual = atm.returnNewAccountNum(); - - Assert.assertEquals(expected,actual); - } - - @Test - public void UserExistTest(){ - atm.addUser("wes","password"); - boolean expected1 = true; - boolean expected2 = false; - - boolean actual1 = atm.UserExist("wes"); - boolean actual2 = atm.UserExist("bob"); - - Assert.assertEquals(expected1,actual1); - Assert.assertEquals(expected2,actual2); - } - - @Test - public void UserIndexTest(){ - int expected1 = 0; - int expected2 = 1; - atm.addUser("wes","password"); - atm.addUser("bob","password"); - - int actual1 = atm.UserIndex("wes"); - int actual2 = atm.UserIndex("bob"); - - Assert.assertEquals(expected1,actual1); - Assert.assertEquals(expected2,actual2); - } - - @Test - public void UserNameAndPasswordCorrectTest(){ - atm.addUser("wes","password"); - boolean expected1 = true; - boolean expected2 = false; - - boolean actual1 = atm.UserNameAndPasswordCorrect("wes","password"); - boolean actual2 = atm.UserNameAndPasswordCorrect("bob","password"); - - Assert.assertEquals(expected1,actual1); - Assert.assertEquals(expected2,actual2); - } - - @Test - public void EnterUserTest(){ - atm.addUser("wes","password"); - String expected = "wes"; - - User currentUser = atm.EnterUser("wes"); - String actual = currentUser.getUserName(); - - Assert.assertEquals(expected,actual); - - } - - //-------------------------------------------------------------------- - @Test //Test setUserName and getUserName public void setUserNameTest(){ atm.addUser("wes","password"); @@ -116,7 +43,7 @@ public void addAccountTest(){ currentUser.addAccount("checking"); int expected = 1; - int actual = currentUser.accountsArraySize(); + int actual = currentUser.getAccountsArray().size(); Assert.assertEquals(expected,actual); } @@ -129,9 +56,9 @@ public void accountArraySizeTest(){ int expected1 = 0; int expected2 = 1; - int actual1 = currentUser.accountsArraySize(); + int actual1 = currentUser.getAccountsArray().size(); currentUser.addAccount("checking"); - int actual2 = currentUser.accountsArraySize(); + int actual2 = currentUser.getAccountsArray().size(); Assert.assertEquals(expected1,actual1); Assert.assertEquals(expected2,actual2); @@ -164,7 +91,7 @@ public void removeAccountTest(){ boolean expected3 = false; boolean actual1 = currentUser.removeAccount(1); - int actual2 = currentUser.accountsArraySize(); + int actual2 = currentUser.getAccountsArray().size(); Account currentAccount = currentUser.EnterAccount(2); currentAccount.setBalance(50); boolean actual3 = currentUser.removeAccount(2); @@ -259,67 +186,5 @@ public void transferTest(){ Assert.assertEquals(expected2,actual2,0); } - - //----------------------------------------------------------------- - - @Test // test getAccountBalance and setAccountBalance - public void AccountBalanceTest(){ - atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes"); - currentUser.addAccount("checking"); - Account currentAccount = currentUser.EnterAccount(1); - - double expected = 500; - - currentAccount.setBalance(500); - - double actual = currentAccount.getBalance(); - - Assert.assertEquals(expected,actual,0); - } - - @Test // test getAccountType and setAccountType - public void AccountTypeTest(){ - atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes"); - - String expected = "checking"; - - currentUser.addAccount(expected); - Account currentAccount = currentUser.EnterAccount(1); - String actual = currentAccount.getAccountType(); - - Assert.assertEquals(expected,actual); - } - - @Test // test getAccountNum and setAccountNum - public void AccountNumberTest(){ - atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes"); - currentUser.addAccount("savings"); - Account currentAccount = currentUser.EnterAccount(1); - - int expected = 1; - - int actual = currentAccount.getAccountNum(); - - Assert.assertEquals(expected,actual); - } - - @Test // test getAccountHistory and addToAccountHistory - public void accountHistoryTest(){ - atm.addUser("wes","password"); - User currentUser = atm.EnterUser("wes"); - currentUser.addAccount("savings"); - Account account = currentUser.EnterAccount(1); - currentUser.deposit(50,account); - String expected = "Deposit 50.0"; - - ArrayList history = account.getAccountHistory(); - String firstPlace = (String)history.get(0); - String actual = firstPlace; - - Assert.assertEquals(expected,actual); - } - } + From 5ca6e34a9bffb1b4ed0ee4556c1b7843cec74b2d Mon Sep 17 00:00:00 2001 From: wesley Date: Fri, 3 Nov 2017 13:24:52 -0400 Subject: [PATCH 8/8] changing things --- src/main/java/ATM.java | 18 ++++++++++++++---- src/main/java/Main.java | 12 +++++++++--- src/main/java/User.java | 4 ++++ src/test/java/accountTest.java | 2 +- src/test/java/atmTest.java | 7 +++++++ src/test/java/userTest.java | 11 +++++++++++ 6 files changed, 46 insertions(+), 8 deletions(-) diff --git a/src/main/java/ATM.java b/src/main/java/ATM.java index a474fd2..404622c 100644 --- a/src/main/java/ATM.java +++ b/src/main/java/ATM.java @@ -1,7 +1,8 @@ import java.util.ArrayList; public class ATM { - private ArrayList allUsers = new ArrayList(); + private ArrayList allUsers = new ArrayList(); + private int numOfAccounts = 0; private static ATM theInstance = new ATM(); @@ -9,6 +10,15 @@ public class ATM { private ATM() { } + public ArrayList getAllUsers() { + return allUsers; + } + + public void clearAllUsers(){ + allUsers.clear(); + + } + public static ATM getInstance() { return theInstance; } @@ -29,9 +39,9 @@ int returnNewAccountNum() { boolean UserExist(String userName) { boolean userExist = false; - User currentUser; - for (int i = 0; i < allUsers.size(); i++) { - currentUser = (User) allUsers.get(i); + + for (User currentUser : allUsers) { + if (userName.equalsIgnoreCase(currentUser.getUserName())) { return true; } diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 5cca5c3..61c495c 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -1,8 +1,6 @@ -/** - * Created by iyasuwatts on 10/17/17. - */ + public class Main { public static void main(String[] args){ @@ -10,6 +8,14 @@ public static void main(String[] args){ console.frontPage(); } + public static void clearAll(){ + ATM atm = ATM.getInstance(); + for(User user : atm.getAllUsers()){ + user.clearAccounts(); + } + atm.clearAllUsers(); + } + } diff --git a/src/main/java/User.java b/src/main/java/User.java index c624658..4cd9f5b 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -10,6 +10,10 @@ public class User { this.password = password; } + public void clearAccounts(){ + accountsArray.clear(); + } + void setUserName(String userName) { this.userName = userName; } diff --git a/src/test/java/accountTest.java b/src/test/java/accountTest.java index 164d2d3..35959e4 100644 --- a/src/test/java/accountTest.java +++ b/src/test/java/accountTest.java @@ -27,7 +27,7 @@ public void AccountTypeTest(){ atm.addUser("wes","password"); User currentUser = atm.EnterUser("wes"); - String expected = "checking"; + String expected = "savings"; currentUser.addAccount(expected); Account currentAccount = currentUser.EnterAccount(1); diff --git a/src/test/java/atmTest.java b/src/test/java/atmTest.java index 83335af..52bc34d 100644 --- a/src/test/java/atmTest.java +++ b/src/test/java/atmTest.java @@ -6,6 +6,7 @@ public class atmTest { @Test //Test addUsers and returnAllUserSize public void addUserTest(){ + atm.clearAllUsers(); int expected = 1; atm.addUser("wes","password"); @@ -16,6 +17,7 @@ public void addUserTest(){ @Test public void returnNewAccountNumTest(){ + atm.clearAllUsers(); int expected = 1; int actual = atm.returnNewAccountNum(); @@ -25,6 +27,7 @@ public void returnNewAccountNumTest(){ @Test public void UserExistTest(){ + atm.clearAllUsers(); atm.addUser("wes","password"); boolean expected1 = true; boolean expected2 = false; @@ -34,10 +37,12 @@ public void UserExistTest(){ Assert.assertEquals(expected1,actual1); Assert.assertEquals(expected2,actual2); + } @Test public void UserIndexTest(){ + atm.clearAllUsers(); int expected1 = 0; int expected2 = 1; atm.addUser("wes","password"); @@ -52,6 +57,7 @@ public void UserIndexTest(){ @Test public void UserNameAndPasswordCorrectTest(){ + atm.clearAllUsers(); atm.addUser("wes","password"); boolean expected1 = true; boolean expected2 = false; @@ -65,6 +71,7 @@ public void UserNameAndPasswordCorrectTest(){ @Test public void EnterUserTest(){ + atm.clearAllUsers(); atm.addUser("wes","password"); String expected = "wes"; diff --git a/src/test/java/userTest.java b/src/test/java/userTest.java index 72c2cd4..53d9c3b 100644 --- a/src/test/java/userTest.java +++ b/src/test/java/userTest.java @@ -8,6 +8,7 @@ public class userTest { @Test //Test setUserName and getUserName public void setUserNameTest(){ + Main.clearAll(); atm.addUser("wes","password"); User currentUser = atm.EnterUser("wes"); String expected1 = "wes"; @@ -23,6 +24,7 @@ public void setUserNameTest(){ @Test //Test setUserPassword and getUserPassword public void setUserPasswordTest(){ + Main.clearAll(); atm.addUser("wes","password"); User currentUser = atm.EnterUser("wes"); String expected1 = "password"; @@ -38,6 +40,7 @@ public void setUserPasswordTest(){ @Test public void addAccountTest(){ + Main.clearAll(); atm.addUser("wes","password"); User currentUser = atm.EnterUser("wes"); currentUser.addAccount("checking"); @@ -51,6 +54,7 @@ public void addAccountTest(){ @Test public void accountArraySizeTest(){ + Main.clearAll(); atm.addUser("wes","pass"); User currentUser = atm.EnterUser("wes"); int expected1 = 0; @@ -66,6 +70,7 @@ public void accountArraySizeTest(){ @Test public void getAccountArrayTest(){ + Main.clearAll(); atm.addUser("wes","pass"); User currentUser = atm.EnterUser("wes"); int expected = 1; @@ -81,6 +86,7 @@ public void getAccountArrayTest(){ @Test public void removeAccountTest(){ + Main.clearAll(); atm.addUser("wes","password"); User currentUser = atm.EnterUser("wes"); currentUser.addAccount("checking"); @@ -105,6 +111,7 @@ public void removeAccountTest(){ @Test public void AccountExistTest(){ + Main.clearAll(); atm.addUser("wes","password"); User currentUser = atm.EnterUser("wes"); currentUser.addAccount("checking"); @@ -120,6 +127,7 @@ public void AccountExistTest(){ @Test public void EnterAccountTest(){ + Main.clearAll(); atm.addUser("wes","password"); User currentUser = atm.EnterUser("wes"); currentUser.addAccount("checking"); @@ -133,6 +141,7 @@ public void EnterAccountTest(){ @Test public void withdrawTest(){ + Main.clearAll(); atm.addUser("wes","password"); User currentUser = atm.EnterUser("wes"); currentUser.addAccount("savings"); @@ -150,6 +159,7 @@ public void withdrawTest(){ @Test public void depositTest(){ + Main.clearAll(); atm.addUser("wes","password"); User currentUser = atm.EnterUser("wes"); currentUser.addAccount("savings"); @@ -166,6 +176,7 @@ public void depositTest(){ @Test public void transferTest(){ + Main.clearAll(); atm.addUser("wes","password"); User currentUser = atm.EnterUser("wes"); currentUser.addAccount("savings");