All done finally!

pom.xml

@@ -7,6 +7,54 @@
     <groupId>io.zipcoder</groupId>
     <artifactId>project-2-atm</artifactId>
     <version>1.0-SNAPSHOT</version>
-
-
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>7</source>
+                    <target>7</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+    <dependencies>
+    <dependency>
+        <groupId>junit</groupId>
+        <artifactId>junit</artifactId>
+        <version>4.12</version>
+        <scope>test</scope>
+    </dependency>
+    <dependency>
+        <groupId>junit</groupId>
+        <artifactId>junit</artifactId>
+        <version>4.12</version>
+        <scope>test</scope>
+    </dependency>
+    <dependency>
+        <groupId>junit</groupId>
+        <artifactId>junit</artifactId>
+        <version>4.12</version>
+        <scope>test</scope>
+    </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>RELEASE</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>RELEASE</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.2</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
 </project>

src/main/java/Account.java

@@ -0,0 +1,90 @@
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Account {
+
+    Double balance;
+    String accountType= "Checking";
+    //Might use this for something later.
+    //Maybe an added modifier in case of multiple accounts of same type
+    String IDnum;
+    List<Double> transHistory=new ArrayList<>();
+
+
+    //A new instance of account would need starting funds and account type
+    public Account(Double startingBalance, String typeOfAccount){
+        if(startingBalance>=0) balance=startingBalance;
+        else {balance=0.0; System.out.println("Can't open with a negative balance.");}
+        accountType=typeOfAccount;
+    }
+
+    //the version of the constructor the tests use.
+    //The console should probably use the other one.
+    //If this constructor IS used, account defaults to a checking account.
+    public Account(Double startingBalance){
+        if(startingBalance>=0) balance=startingBalance;
+        else {balance=0.0; System.out.println("Can't open with a negative balance.");}
+    }
+
+    public Double getBalance(){
+        BigDecimal bd = new BigDecimal(balance).setScale(2, RoundingMode.HALF_UP);
+        balance = bd.doubleValue();
+        return balance;
+    }
+
+    public String getAccountType(){
+        return accountType;
+    }
+
+
+
+    //Possible area to expand on: perhaps withdrawing works differently pending account type?
+    //prevents overdrawing. uses return statement for either
+    //A balance or to be used in the transfer method.
+    public Double withdraw(Double amount){
+        if(amount>balance){
+            System.out.println("Insufficient funds for withdrawal.");
+            return 0.0;
+        }else if(amount<0.0){
+            System.out.println("Cannot withdraw negative amount.");
+            return 0.0;
+        }else{balance-=amount;
+            transHistory.add(-amount);
+            return amount;}
+    }
+
+    //cannot deposit a negative amount
+    public void deposit(Double amount){
+        if (amount>=0.0) {balance+=amount;
+        transHistory.add(amount);}
+        if (amount<0.0) System.out.println("You can't deposit what you don't have.");
+    }
+
+
+
+    public void transfer(Account gettingMoney, Double amount){
+
+        gettingMoney.deposit(this.withdraw(amount));
+    }
+
+    public void showTransactionHistory(){
+        for(Double i:transHistory){
+            if(i>0.0){
+                System.out.println("Deposit :  "+i);
+            }else if(i<0.0){
+                System.out.println("Withdraw:  "+i);}
+        }
+    }
+
+
+    //Returns true if the account can be closed. False if not.
+    public Boolean closeAccount(){
+        if (balance==0.0){return true;}
+        else return false;
+    }
+
+
+
+}

src/main/java/AsciiArtGenerator.java

@@ -0,0 +1,60 @@
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+
+public class AsciiArtGenerator {
+
+    //:D
+    public void introMessage() throws InterruptedException {
+        int width = 100;
+        int height = 21;
+
+        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+        Graphics g = image.getGraphics();
+        g.setFont(new Font("SansSerif", Font.BOLD,20));
+
+        Graphics2D g2 = (Graphics2D) g;
+        g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+        g2.drawString("$ ATM $", 5, 18);
+
+        for(int y = 0; y< height; y++) {
+            StringBuilder sb = new StringBuilder();
+
+            Thread.sleep(80);
+
+            for(int x = 0; x < width; x++) {
+                sb.append(image.getRGB(x, y) == -16777216 ? "$" : " ");
+            }
+            System.out.println(sb);
+
+        }
+        System.out.println("\n");
+    }
+//
+//    public void intruderMessage() throws InterruptedException {
+//        int width = 111;
+//        int height = 21;
+//
+//        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+//        Graphics g = image.getGraphics();
+//        g.setFont(new Font("SansSerif", Font.BOLD,20));
+//
+//        Graphics2D g2 = (Graphics2D) g;
+//        g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+//        g2.drawString("Intruder", 5, 18);
+//
+//        for(int y = 0; y< height; y++) {
+//            StringBuilder sb = new StringBuilder();
+//
+//            Thread.sleep(80);
+//
+//            for(int x = 0; x < width; x++) {
+//                sb.append(image.getRGB(x, y) == -16777216 ? "$" : " ");
+//            }
+//            System.out.println(sb);
+//
+//        }
+//        Thread.sleep(200);
+//        System.out.println("\n");
+//    }
+}

src/main/java/AtmEngine.java

@@ -0,0 +1,81 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class AtmEngine {
+
+    Map<String, List<Account>> bank=new HashMap<String, List<Account>>();
+
+    //No need for parameters right now, as far as I can tell.
+    public AtmEngine(){}
+
+
+    public void addNewAccount(String passcode, Account newAccount){
+        List<Account> tempList = bank.get(passcode);
+        if(tempList == null) {
+            tempList = new ArrayList<>();
+            bank.put(passcode, tempList);
+        }
+        tempList.add(newAccount);
+    }
+
+    //Method to close an account
+    public void closeAccount(String password, int whichOne){
+        List<Account>currentUserAccounts= bank.get(password);
+        if(currentUserAccounts.get(whichOne).closeAccount()){
+            currentUserAccounts.remove(whichOne);
+        }
+    }
+
+
+    //Method to show list of available accounts under a passcode
+    public void printAllAccounts(String password){
+        List<Account>currentUserAccounts= bank.get(password);
+        for(int i=0; i<currentUserAccounts.size();i++){
+            System.out.println("Account #:"+(i+1)+" Type:"+currentUserAccounts.get(i).getAccountType());
+            System.out.println("Balance-------->"+currentUserAccounts.get(i).getBalance());
+        }
+    }
+
+
+    //Method to transfer funds between existing accounts
+    public void transfer(String password, Integer accountGiving, Integer accountReceiving, Double cash){
+        List<Account>currentUserAccounts= bank.get(password);
+        currentUserAccounts.get(accountGiving).transfer(currentUserAccounts.get(accountReceiving),cash);
+    }
+
+
+    //Method to withdraw from a chosen account
+    public void withdrawCash(String password, Integer accountUsed, Double cash){
+        List<Account>currentUserAccounts= bank.get(password);
+        currentUserAccounts.get(accountUsed).withdraw(cash);
+    }
+
+    //Method to withdraw money from a chosen account.
+    public void depositCash(String password, Integer accountUsed, Double cash){
+        List<Account>currentUserAccounts= bank.get(password);
+        currentUserAccounts.get(accountUsed).deposit(cash);
+    }
+
+    public void showAccountTransactions(String password, Integer accountUsed){
+        List<Account>currentUserAccounts=bank.get(password);
+        System.out.println("Transaction history for account #: "+(accountUsed+1));
+        currentUserAccounts.get(accountUsed).showTransactionHistory();
+    }
+
+    //Method to ensure given password exists in database.
+    public Boolean userExists(String password){
+        for (String i : bank.keySet()) {
+            if(i.equals(password)){return true;}
+        }
+        return false;
+    }
+
+    public Integer sizeOfAccountList(String password){
+        List<Account>currentUserAccounts= bank.get(password);
+        return currentUserAccounts.size();
+    }
+
+
+}

src/main/java/BreakCheck.java

@@ -0,0 +1,93 @@
+import javax.swing.*;
+import java.sql.SQLOutput;
+import java.util.Random;
+import java.util.Scanner;
+
+public class BreakCheck {
+
+    //Ensures user chooses from options provided
+    public String confirmIsNumber(){
+        String newString = "";
+        boolean redo = true;
+        while(redo) {
+            newString = Console.getStringInput("1 - Checking, 2 - Savings, 3 - Investing, 4 - Exit");
+            switch(newString){
+                case "1":
+                    redo = false;
+                    return "Checking";
+                case "2":
+                    redo = false;
+                    return "Savings";
+                case "3":
+                    redo = false;
+                    return "Investing";
+                case "4":
+                    System.out.println("Thank you for choosing a real financial institution");
+                    System.exit(0);
+                default: System.out.println("Please choose from the menu!");
+            }
+        }
+        return null;
+    }
+
+    //Checks that amount entered is a double
+    public Double isDouble(){
+
+        Double result = 0.0;
+        boolean check = true;
+        do {
+            String newString = Console.getStringInput("\r");
+            try {
+                result = Double.parseDouble(newString);
+                check = false;
+            } catch (NumberFormatException e) {
+                System.out.println("Please enter valid amount!");
+            }
+        } while(check);
+        return result;
+    }
+
+    public Integer isInteger(){
+        Integer result = 0;
+        boolean check = true;
+        do {
+            String newString = Console.getStringInput("\r");
+            try {
+                result = Integer.parseInt(newString);
+                check = false;
+            } catch (NumberFormatException e) {
+                System.out.println("Please enter valid amount!");
+            }
+        } while(check);
+        return result;
+    }
+
+    //Generates pin for user
+    public String pinGenerator(){
+        String newPin = "";
+        Random randomInt = new Random();
+        for(int i =8; i > 0; i--) {
+            newPin += String.valueOf(randomInt.nextInt(10));
+        }
+
+        return newPin;
+    }
+
+    public Integer isPIN(){
+
+        Integer result = 0;
+        boolean check = true;
+        do {
+            String newString = Console.getStringInput("\r");
+            try {
+                result = Integer.parseInt(newString);
+                check = false;
+            } catch (NumberFormatException e) {
+                System.out.println("Please enter valid PIN");
+            }
+        } while(check);
+        return result;
+    }
+
+
+}