Finished ATM

README.md

@@ -6,7 +6,7 @@ Week 2 project: ATM Simulator
 Every feature must have corresponding unit tests
 Tests should demonstrate proper behavior, and proper handling of misuse (eg. attempts to deposit/transfer/withdraw negative amounts
 
-- User interface: CLI (Command line interface) Only
+- atmproject.User interface: CLI (Command line interface) Only
   - Direct Input
   - Numbered options (instead of on-screen buttons)
   - ASCII art welcome but not required
@@ -17,19 +17,19 @@ Tests should demonstrate proper behavior, and proper handling of misuse (eg. att
 - Account Actions
   - Withdraw from acct
   - Deposit to acct
-  - Transfer across accounts (self)
+  - Transfer across atmproject.accounts (self)
   - Open new account
   - Close account (must be empty)
   - Print transaction history
   - Check balance
   - **Challenge:** Transfer to another user's account (but not from)
 - Support multiple users
-  - Users have associated accounts
+  - Users have associated atmproject.accounts
   - Can create new user
   - Users are authenticated with a password (generated or provided on user creation)
   - Can exit a user and enter another user
 - **BONUS** Persistence
-  - Users and accounts remain persistent
+  - Users and atmproject.accounts remain persistent
   - Opportunity for research
 
 

pom.xml

@@ -7,6 +7,20 @@
     <groupId>io.zipcoder</groupId>
     <artifactId>project-2-atm</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 
 
 </project>

src/main/java/atmproject/ATM.java

@@ -0,0 +1,177 @@
+package atmproject;
+
+
+import atmproject.accounts.Account;
+import atmproject.accounts.InvestmentsAccount;
+import atmproject.accounts.SavingsAccount;
+
+
+public class ATM {
+    private Console console = new Console(System.in, System.out);
+    private UserLogin userLogin = new UserLogin();
+    private User currentUser;
+    private boolean running = true;
+    private AccountMenu accountMenu = new AccountMenu();
+    private Language language = new Language();
+
+    public void turnOnATM(){
+        userLogin.runLoginMenu();
+    }
+
+
+    public void runMainMenu(User currentUser) {
+        setCurrentUser(currentUser);
+        while (running) {
+            console.println(language.getLang(Language.LangKey.MAINMENU));
+            Integer userInput = console.getIntegerInput(":");
+            mainMenuLogic(userInput);
+        }
+    }
+
+    public void mainMenuLogic(Integer userInput){
+        switch (userInput) {
+            case 1:
+                String transaction = callDeposit();
+                console.println(transaction);
+                currentUser.addToHistory(transaction + "\n");
+                break;
+            case 2:
+                transaction = callWithdraw();
+                console.println(transaction);
+                currentUser.addToHistory(transaction + "\n");
+                break;
+            case 3:
+                if (currentUser.getAccountList().size() >= 2) {
+                    transaction = callTransfer();
+                    console.println(transaction);
+                    currentUser.addToHistory(transaction + "\n");
+                } else {
+                    console.println("ERROR: Not enough accounts to transfer money. Please create a new one.");
+                }
+                break;
+            case 4:
+                console.println(checkBalance());
+                break;
+            case 5:
+                console.println(displayHistory(currentUser));
+                break;
+            case 6:
+                callCreateAccount();
+                break;
+            case 7:
+                callRemoveAccount();
+                break;
+            case 8:
+                returnToLoginMenu();
+                break;
+        }
+        giveInterest();
+    }
+
+    public String callDeposit() {
+        Account chosenAccount = accountMenu.selectAccount(currentUser);
+        console.println("How much would you like to deposit?");
+        Double userInput = console.getDoubleInput("$");
+        chosenAccount.deposit(userInput);
+        return String.format("You deposited $%.2f to %s.", userInput, chosenAccount.getAccountName());
+    }
+
+    public String callWithdraw() {
+        Account chosenAccount = accountMenu.selectAccount(currentUser);
+        console.println("How much would you like to withdraw?");
+        Double userInput = console.getDoubleInput("$");
+        if(userInput <= chosenAccount.getBalance()){
+            chosenAccount.withdraw(userInput);
+            return String.format("You withdrew $%.2f from %s.\n", userInput, chosenAccount.getAccountName());
+        }
+        return "ERROR: insufficient funds for withdraw.\n";
+    }
+
+    public String callTransfer(){
+        Account chosenAccount = accountMenu.selectAccount(currentUser);
+        Account destinationAccount = accountMenu.selectAccount(currentUser);
+        if(chosenAccount.equals(destinationAccount)){
+            return "ERROR: Incorrect account entry\n";
+        } else {
+            console.println("How much would you like to transfer?");
+            Double userInput = console.getDoubleInput("$");
+            if(userInput <= chosenAccount.getBalance()){
+                chosenAccount.transfer(destinationAccount, userInput);
+                return String.format("You transferred $%.2f from %s to %s.\n",userInput, chosenAccount.getAccountName(), destinationAccount.getAccountName());
+            }
+            return "ERROR: Insufficient funds for transfer.\n";
+        }
+    }
+
+    public void callCreateAccount(){
+        console.println("What kind of account would you like to create?\n(1) - Checkings\n(2) - Savings\n(3) - Investments");
+        Integer typeOfAccount = console.getIntegerInput(":");
+        switch(typeOfAccount) {
+            case 1:
+                Account account = new Account(currentUser, 0.0, "Checkings Account#" + (currentUser.getAccountList().size() + 1));
+                currentUser.addAccount(account);
+                break;
+            case 2:
+                SavingsAccount savingsAccount = new SavingsAccount(currentUser, 0.0, "Savings Account#" + (currentUser.getAccountList().size() + 1));
+                currentUser.addAccount(savingsAccount);
+                break;
+            case 3:
+                createInvestmentAccount();
+                break;
+
+        }
+    }
+
+    public void callRemoveAccount() {
+        Account chosenAccount = accountMenu.selectAccount(currentUser);
+        if(currentUser.getAccountList().containsValue(chosenAccount)){
+            currentUser.removeAccount(chosenAccount);
+        } else {
+            console.println("ERROR: Chosen account not found.");
+        }
+    }
+
+    private void createInvestmentAccount() {
+        console.println("At this bank, you'll need an initial deposit of $15,000 to open an investment account.\nHow " +
+                "much would you like to deposit?");
+        Integer input = console.getIntegerInput(":");
+        if(input > 14999) {
+            InvestmentsAccount investmentsAccount = new InvestmentsAccount(currentUser, (double)input, "Investment Account#" + (currentUser.getAccountList().size() + 1));
+            currentUser.addAccount(investmentsAccount);
+        } else {
+            console.println("That is not enough of an initial deposit");
+        }
+    }
+
+    public String checkBalance() {
+        Account chosenAccount = accountMenu.selectAccount(currentUser);
+        return String.format("The balance in %s is $%.2f\n", chosenAccount.getAccountName(), chosenAccount.getBalance());
+    }
+
+    public String displayHistory(User currentUser) {
+        if(currentUser.getTransactionHistory().isEmpty()){
+            return "You currently have no history.";
+        }
+        return currentUser.displayHistory();
+    }
+
+    public void returnToLoginMenu() {
+        running = false;
+    }
+
+    public void giveInterest(){
+        for(String name : currentUser.getAccountList().keySet()){
+            if(currentUser.getAccountList().get(name) instanceof SavingsAccount){
+                ((SavingsAccount) currentUser.getAccountList().get(name)).addInterest();
+            }
+        }
+    }
+
+    public void setCurrentUser(User currentUser) {
+        this.currentUser = currentUser;
+    }
+
+    public boolean isRunning() {
+        return running;
+    }
+}

src/main/java/atmproject/AccountMenu.java

@@ -0,0 +1,54 @@
+package atmproject;
+
+import atmproject.accounts.Account;
+import atmproject.accounts.InvestmentsAccount;
+import atmproject.accounts.SavingsAccount;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class AccountMenu {
+    Account returnedAccount;
+    Console console = new Console(System.in, System.out);
+
+    public Account selectAccount(User user) {
+        Map<Integer, Account> returnedMap = new LinkedHashMap<>();
+        returnedAccount = null;
+        Integer counter = 1;
+        printAndStoreAccounts(user, returnedMap, counter);
+        returnedAccount = getUserSelectedAccount(returnedMap, returnedAccount);
+
+
+        return returnedAccount;
+    }
+
+    public Account getUserSelectedAccount(Map<Integer, Account> returnedMap, Account returnedAccount) {
+        while (returnedAccount == null) {
+            console.println("\nPlease select an account.");
+            Integer input = console.getIntegerInput(":");
+
+            returnedAccount = getUsersInput(returnedMap, returnedAccount, input);
+
+        }
+        return returnedAccount;
+    }
+
+    public Account getUsersInput(Map<Integer, Account> returnedMap, Account returnedAccount, Integer input) {
+        if (returnedMap.containsKey(input)) {
+            returnedAccount = returnedMap.get(input);
+        } else {
+            console.println("\nAccount does not exist. Try again: ");
+        }
+        return returnedAccount;
+    }
+
+    public void printAndStoreAccounts(User user, Map<Integer, Account> returnedMap, Integer counter) {
+        console.println("\n");
+        for (String s : user.accountList.keySet()) {
+            console.println("(" + counter + ")" + " - " + s);
+            returnedMap.put(counter, user.accountList.get(s));
+            counter++;
+
+        }
+    }
+}

src/main/java/atmproject/Console.java

@@ -0,0 +1,62 @@
+package atmproject;
+
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.util.Scanner;
+
+public class Console {
+
+    private final Scanner input;
+    private final PrintStream output;
+
+    public Console(InputStream in, PrintStream out) {
+        this.input = new Scanner(in);
+        this.output = out;
+    }
+
+    public void print(String val, Object... args) {
+        output.format(val, args);
+    }
+
+    public void newln() {
+        print("\n");
+    }
+
+    public void println(String val, Object... vals) {
+        print(val + "\n", vals);
+    }
+
+    public String getStringInput(String prompt, Object... args) {
+        print(prompt, args);
+        return input.nextLine();
+    }
+
+    public Double getDoubleInput(String prompt, Object... args) {
+        String stringInput = getStringInput(prompt, args);
+        try {
+            Double doubleInput = Double.parseDouble(stringInput);
+            return doubleInput;
+        } catch (NumberFormatException nfe) { // TODO - Eliminate recursive nature
+            println("[ %s ] is an invalid user input!", stringInput);
+            println("Try inputting a numeric value!");
+            return getDoubleInput(prompt, args);
+        }
+    }
+
+    public Long getLongInput(String prompt, Object... args) {
+        String stringInput = getStringInput(prompt, args);
+        try {
+            Long longInput = Long.parseLong(stringInput);
+            return longInput;
+        } catch (NumberFormatException nfe) { // TODO - Eliminate recursive nature
+            println("[ %s ] is an invalid user input!", stringInput);
+            println("Try inputting an integer value!");
+            return getLongInput(prompt, args);
+        }
+    }
+
+    public Integer getIntegerInput(String prompt, Object... args) {
+        return getLongInput(prompt, args).intValue();
+    }
+
+}

src/main/java/atmproject/Language.java

@@ -0,0 +1,26 @@
+package atmproject;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Language {
+
+    private Map<LangKey, String> langMap;
+    public enum LangKey { EXAMPLE1, EXAMPLE2,MAINMENU }
+
+    public Language() {
+
+        langMap = new HashMap<LangKey, String>();
+        langMap.put(LangKey.EXAMPLE1, "This is an example");
+        langMap.put(LangKey.EXAMPLE2, "This is another Example");
+        langMap.put(LangKey.MAINMENU, "Please select your option:\n" + "(1) - Deposit\n" + "(2) - Withdraw\n" +
+                "(3) - Transfer\n" + "(4) - Balance\n" + "(5) - View History\n" + "(6) - Create New Account\n" + "(7) - Remove Account\n" +
+                "(8) - Exit ATM");
+
+    }
+
+    public String getLang(LangKey key) {
+        return langMap.get(key);
+    }
+
+}

src/main/java/Main.java → src/main/java/atmproject/Main.java

@@ -1,9 +1,12 @@
+package atmproject;
+
 /**
  * Created by iyasuwatts on 10/17/17.
  */
 public class Main {
 
     public static void main(String[] args){
-
+        ATM atm = new ATM();
+        atm.turnOnATM();
     }
 }