Kai

README.md

@@ -14,7 +14,7 @@ Tests should demonstrate proper behavior, and proper handling of misuse (eg. att
   - Checking
   - Savings
   - Investment
-- Account Actions
+- AccountsAndTransactions.Account Actions
   - Withdraw from acct
   - Deposit to acct
   - Transfer across accounts (self)

pom.xml

@@ -7,6 +7,32 @@
     <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>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>RELEASE</version>
+            <scope>compile</scope>
+        </dependency>
+        <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>compile</scope>
+        </dependency>
+    </dependencies>
 
 
 </project>

src/main/java/AccountsAndTransactions/Account.java

@@ -0,0 +1,123 @@
+package AccountsAndTransactions;
+
+import java.util.ArrayList;
+
+public class Account {
+    private static double chkAcctBal;
+
+
+    /*
+        Things we need here:
+        1. checking accounts
+        2. savings accounts
+        3. investment accounts
+        ***bins would probably be a good way to store this information - have a bin for each user with a slot for each account
+
+        Things we may also need here?
+        1. account balance - there's already a balance value in the User.java tab, but it might work better here because we need separate balances in each type of account
+        2. account number
+        3. BONUS - Persistence
+            - create a way to store user information, account balances, etc
+            - probably the best way if we get to this would be to save a current state of all account balances to a spreadsheet when we close the ATM app
+            - alternately, access the spreadsheet every time any transaction is completed, so that if the program crashes before closing all information is still saved
+         */
+
+    //establish all the data stored in the AccountsAndTransactions.Account object:
+    //instances of Accounts should have name [firstLast]
+    private String firstName;
+    private String lastName;
+    private int pin;
+    private int chkAcctNum;
+    private int savAcctNum;
+    private int invAcctNum;
+
+    private double savAcctBal;
+    private double invAcctBal;
+    public ArrayList<String> transactionHistory = new ArrayList<String>();
+
+    //actions that can be called to create a new account bin:
+    public Account(String firstName, String lastName, int pin){
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.pin = pin;
+    }
+
+
+    //create getters for all the data stored in the AccountsAndTransactions.Account object:
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public int getPin() {
+        return pin;
+    }
+
+    public int getChkAcctNum() {
+        return chkAcctNum;
+    }
+
+    public int getSavAcctNum() {
+        return savAcctNum;
+    }
+
+    public int getInvAcctNum() {
+        return invAcctNum;
+    }
+
+    public static double getChkAcctBal() {
+        return chkAcctBal;
+    }
+
+    public double getSavAcctBal() {
+        return savAcctBal;
+    }
+
+    public double getInvAcctBal() {
+        return invAcctBal;
+    }
+
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public void setPin(int pin) {
+        this.pin = pin;
+    }
+
+    public void setChkAcctNum(int chkAcctNum) {
+        this.chkAcctNum = chkAcctNum;
+    }
+
+    public void setSavAcctNum(int savAcctNum) {
+        this.savAcctNum = savAcctNum;
+    }
+
+    public void setInvAcctNum(int invAcctNum) {
+        this.invAcctNum = invAcctNum;
+    }
+
+    public void setChkAcctBal(double chkAcctBal) {
+        this.chkAcctBal = chkAcctBal;
+    }
+
+    public void setSavAcctBal(double savAcctBal) {
+        this.savAcctBal = savAcctBal;
+    }
+
+    public void setInvAcctBal(double invAcctBal) {
+        this.invAcctBal = invAcctBal;
+    }
+
+    public void setTransactionHistory(ArrayList<String> transactionHistory) {
+        this.transactionHistory = transactionHistory;
+    }
+}

src/main/java/AccountsAndTransactions/AccountTest.java

@@ -0,0 +1,18 @@
+package AccountsAndTransactions;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class AccountTest {
+
+    @Test
+    public void AccountTest(){
+        Account jeff = new Account("Jeff", "Smith",1234);
+        Assert.assertEquals("Jeff", jeff.getFirstName());
+        Assert.assertEquals("Smith", jeff.getLastName());
+        Assert.assertEquals(1234, jeff.getPin());
+    }
+
+}

src/main/java/AccountsAndTransactions/Transactions.java

@@ -0,0 +1,115 @@
+package AccountsAndTransactions;
+
+public class Transactions {
+    /*
+      needed:
+      1. Deposit to acct
+      2. Withdraw from acct
+      3. Transfer across accounts (self)
+      4. Open new account
+      5. Close account (must be empty)
+      6. Print transaction history
+      7. Check balance
+      *. Challenge: Transfer to another user's account (but not from)
+     */
+
+    //establish variables:
+    private double increment;  //the amount to be changed
+    private Account acctName;  //the primary account (used for most transactions
+    private Account acctName2; //used when a second account type is required, such as a transfer)
+    private String acctType;   //the type of account being changed
+    private String acctType2;  //used when a second account type is required, such as a transfer
+
+
+    public Transactions(Account acctName) {
+        this.acctName = acctName;
+    }
+
+    public void deposit(double increment, String acctType){
+        this.increment = increment;        //pull the amount being changed
+        this.acctType = acctType;          //determine which account
+        //determine appropriate account, then perform balance += increment;
+        if(acctType == "checking"){
+            acctName.setChkAcctBal(acctName.getChkAcctBal() + increment);
+        }
+        else if (acctType == "savings"){
+            acctName.setSavAcctBal(acctName.getSavAcctBal() + increment);
+        }
+        else if (acctType == "investment"){
+            acctName.setInvAcctBal(acctName.getInvAcctBal() + increment);
+        }
+        else {
+            System.out.println("not a valid account type");
+            //then return them to the transaction screen
+        }
+        acctName.transactionHistory.add(String.format("Deposited $%.2f to " + acctType + ".", increment)); //append this transaction to the user's transaction history ArrayList
+    }
+
+    public void withdraw(double increment, String acctType){
+        this.increment = increment;                                                   //pull the amount being changed
+        this.acctType = acctType;                                                     //determine which account
+        if(acctType == "checking" && acctName.getChkAcctBal() >= increment) {          //if checking && sufficient funds in acct
+            acctName.setChkAcctBal(acctName.getChkAcctBal() - increment);             //decrement checking account
+        }
+        else if (acctType == "savings" && acctName.getSavAcctBal() >= increment){      //if savings && sufficient funds in acct
+            acctName.setSavAcctBal(acctName.getSavAcctBal() - increment);             //decrement savings account
+        }
+        else if (acctType == "investment" && acctName.getInvAcctBal() >= increment){   //if investment && sufficient funds in acct
+            acctName.setInvAcctBal(acctName.getInvAcctBal() - increment);             //decrement investment acct
+        }
+        else {                                                                        //error or insufficient funds
+            System.out.println("not a valid account type or insufficient funds in " + acctType + " acct");
+        }
+        acctName.transactionHistory.add(String.format("Withdrew $%.2f from " + acctType + ".", increment)); //append this transaction to the user's transaction history ArrayList
+    }
+
+    public void transfer(double increment, String acctType, Account acctName2, String acctType2){
+        this.increment = increment;       //pull the amount being changed
+        this.acctType = acctType;         //determine the origin account
+        this.acctName2 = acctName2;       //Account being deposited into
+        this.acctType2 = acctType2;       //determine the destination account
+        withdraw(increment, acctType);    //withdraw from first user
+        acctName = acctName2;             //switch the account to the second user
+        deposit(increment, acctType2);    //deposit to the second user
+    }
+
+    //close account will close an empty account, but will not run if the member has money remaining in any account
+    public void closeAccount(){
+        if (acctName.getChkAcctBal() == 0 && acctName.getSavAcctBal() == 0 && acctName.getInvAcctBal() == 0){
+            acctName.setFirstName(null);            //java cannot delete objects, so instead we will set all bins to null
+            acctName.setLastName(null);
+            acctName.setPin(1000);
+            acctName.transactionHistory.add("Closed all accounts");
+        }
+    }
+
+    //force close account will close all accounts regardless of balance, and dispenses the sum balance in cash before logging out
+    //think of it like force choking your bank
+    public void forceCloseAccount(){
+        withdraw(acctName.getChkAcctBal(), "checking");
+        withdraw(acctName.getSavAcctBal(), "savings");
+        withdraw(acctName.getInvAcctBal(), "investment");
+        acctName.setFirstName(null);            //java cannot delete objects, so instead we will set all bins to null
+        acctName.setLastName(null);
+        acctName.setPin(1000);
+        acctName.transactionHistory.add("Closed all accounts");
+    }
+
+    public String[] transactionHistory(){
+        String[] history = new String[acctName.transactionHistory.size()];
+        for (int i = 0; i < acctName.transactionHistory.size(); i++){
+            history[i] = acctName.transactionHistory.get(i);
+        }
+        return history;
+        //get a copy of the transaction history
+        //convert the copy to a string array
+        //print it
+    }
+
+    /* --------------------CHALLENGE------------------------
+    public void transferOtherUser(double increment, String acctType, String acctType2, user2){
+    UPDATE - I forgot this was the challenge and I programmed the transfer this way originally because I thought we had to.......
+   }
+    -----------------------CHALLENGE---------------------*/
+
+}