Updated system test

.gitignore

@@ -1,4 +1,6 @@
 target/
+.idea/
+SoftwareEngineeringPractice.iml
 
 # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
 # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839

README.md

@@ -1,10 +1,14 @@
 # SoftwareEngineeringPractice
-## grading
-
-To Do | correct
----|---
-at least 8 commits|
-isEmailValid|
-withdraw|
-isamountValid|
-constructor & withdraw fix|
+
+Use Case Diagram: https://www.lucidchart.com/invitations/accept/4307fa3a-0405-408d-ba36-95b8793790b6
+
+Class Diagram: https://www.draw.io/#G14lOqCFtOO7uEm51Zpj4FGR7ti2bjM54R
+
+Sequence Diagram (Saul): Teller, User, Account https://drive.google.com/file/d/1OXqnUsb1rqihpPv-qyBwDjLqungH4SJd/view?usp=sharing
+
+Sequence Diagram (Josh): Admin, Account, CentralBank https://drive.google.com/file/d/1hWu4E4gvjYxcYmPHV18QAMbwkdUuo9Hd/view?usp=sharing
+
+Sequence Diagram (Erich): https://drive.google.com/file/d/1tcE_ITNZHlpZ7IzYDILuwuuKqsxNMex5/view?usp=sharing
+
+Code Review Notes: Need to update class diagram to no longer have user. Update use case diagram to be more readable.
+Generally we want to update tests, Josh will update Admin system test to test for more than two accounts. Saul will make sure method names match the diagram. Eric will update some other tests.

src/main/java/edu/ithaca/dragon/bank/ATM.java

@@ -0,0 +1,45 @@
+package edu.ithaca.dragon.bank;
+
+public class ATM implements BasicAPI {
+
+    protected CentralBank centralBank;
+
+    public ATM(CentralBank bank) {
+        centralBank = bank;
+    }
+
+    @Override
+    public boolean confirmCredentials(String acctId, String password) {
+        return false;
+    }
+
+    @Override
+    public double checkBalance(String acctId) {
+
+        return centralBank.checkBalance(acctId);
+    }
+
+    @Override
+    public void withdraw(String acctId, double amount) throws AccountFrozenException, InsufficientFundsException {
+        centralBank.withdraw(acctId, amount);
+    }
+
+    @Override
+    public void deposit(String acctId, double amount) throws AccountFrozenException {
+        centralBank.deposit(acctId, amount);
+    }
+
+    @Override
+    public void transfer(String acctIdToWithdrawFrom, String acctIdToDepositTo, double amount) throws InsufficientFundsException, AccountFrozenException {
+        centralBank.transfer(acctIdToWithdrawFrom, acctIdToDepositTo, amount);
+    }
+
+    @Override
+    public String transactionHistory(String acctId) {
+        return null;
+    }
+
+    public CentralBank getCentralBank() {
+        return centralBank;
+    }
+}

src/main/java/edu/ithaca/dragon/bank/Account.java

@@ -0,0 +1,117 @@
+package edu.ithaca.dragon.bank;
+
+import java.util.Collection;
+import java.util.regex.Pattern;
+
+public abstract class Account {
+    protected double balance;
+    protected boolean isFrozen;
+    protected Collection<User> users;
+    protected String id;
+
+
+    public Account(double startingBalance, String id) {
+        if (!isAmountValid(startingBalance)) {
+            throw new IllegalArgumentException("Starting balance: " + startingBalance + " is invalid, cannot create account");
+        }
+        else if (id.equals("")){
+            throw new IllegalArgumentException("ID cannot be an empty string");
+        }
+        else {
+            this.balance = startingBalance;
+            this.isFrozen = false;
+            this.id = id;
+        }
+    }
+
+    /**
+     * reduces the balance by amount if amount is non-negative, has 2 or fewer decimals and is smaller or equal to balance
+     * @param amount quantity to reduce balance by
+     * @throws IllegalArgumentException if amount is negative or has more than 2 decimals
+     * @throws InsufficientFundsException if amount is larger than balance
+     */
+    public void withdraw(double amount) throws InsufficientFundsException, AccountFrozenException{
+        if (isFrozen){
+            throw new AccountFrozenException("Account is frozen");
+        }
+        else if (!isAmountValid(amount)) {
+            throw new IllegalArgumentException("Amount: " + amount + " is invalid, cannot withdraw");
+        } else if (amount > balance) {
+            throw new InsufficientFundsException("Not enough money");
+        } else {
+            balance -= amount;
+        }
+    }
+
+    /**
+     * increases the balance by amount if non-negative and has 2 or fewer decimals
+     * @param amount quantity to increase balance by
+     * @throws IllegalArgumentException if amount is negative or has more than 2 decimal places
+     */
+    public void deposit(double amount) throws AccountFrozenException{
+        if (isFrozen){
+            throw new AccountFrozenException("Account is frozen");
+        }
+        else if (!isAmountValid(amount)) {
+            throw new IllegalArgumentException("Amount: " + amount + " is invalid, cannot deposit");
+        } else {
+            balance += amount;
+        }
+    }
+
+    /**
+     * withdraws amount from balance and deposits it into to's balance
+     * @param toAccount BankAccount who's balance will be deposited into
+     * @param amount quantity to withdraw from balance and deposit into to's balance
+     * @throws IllegalArgumentException if amount is negative or has more than 2 decimals
+     * @throws InsufficientFundsException if amount is larger than balance
+     */
+    public void transfer(Account toAccount, double amount) throws InsufficientFundsException, AccountFrozenException {
+        if (this.isFrozen || toAccount.isFrozen){
+            throw new AccountFrozenException("Account is frozen");
+        }
+        else if (!isAmountValid(amount)) {
+            throw new IllegalArgumentException("Amount: " + amount + " is invalid, cannot transfer");
+        } else if (amount > balance) {
+            throw new InsufficientFundsException("Not enough money");
+        } else {
+            withdraw(amount);
+            toAccount.deposit(amount);
+        }
+    }
+
+    public String getCredentials() {
+        return "";
+    }
+
+    public double getBalance() {
+        return balance;
+    }
+
+    public String getHistory() {
+        return "";
+    }
+
+    public boolean getFrozenStatus(){
+        return isFrozen;
+    }
+
+    public  void setFrozen(boolean frozenStatus){
+        isFrozen = frozenStatus;
+    }
+
+    public String getID(){
+        return id;
+    }
+
+    /**
+     * returns true if the amount is non-negative and has two decimal points or less, and false otherwise
+     * @param amount quantity to check
+     * @return true if the amount is non-negative and has two decimal points or less, and false otherwise
+     */
+    public static boolean isAmountValid(double amount) {
+        String amountStr = String.valueOf(amount);
+        int charsAfterDec = amountStr.length() - amountStr.indexOf('.') - 1;
+        return amount >= 0 && charsAfterDec <= 2;
+    }
+}

src/main/java/edu/ithaca/dragon/bank/AccountFrozenException.java

@@ -0,0 +1,9 @@
+package edu.ithaca.dragon.bank;
+
+public class AccountFrozenException extends Exception{
+
+    public AccountFrozenException(String s){
+        super(s);
+    }
+
+}

src/main/java/edu/ithaca/dragon/bank/Admin.java

@@ -0,0 +1,63 @@
+package edu.ithaca.dragon.bank;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+
+
+
+public class Admin implements AdminAPI {
+    private static DecimalFormat twoDecimals = new DecimalFormat("0.00");
+    CentralBank bank;
+
+
+    /**
+     * creates an Admin account that knows what accounts it controls
+     * @param bank the CentralBank that Admin must act on
+     */
+    public Admin(CentralBank bank){
+        this.bank = bank;
+    }
+
+    @Override
+    public double calcTotalAssets() {
+        double total = 0;
+        Iterator<Account> itr = this.bank.getAccounts().values().iterator();
+        while (itr.hasNext()){
+            Account current = itr.next();
+            total += current.getBalance();
+        }
+        total = Double.valueOf(twoDecimals.format(total));
+
+        return total;
+    }
+
+    @Override
+    public Collection<String> findAcctIdsWithSuspiciousActivity() {
+        return null;
+    }
+
+    @Override
+    public void freezeAccount(String acctId) throws IllegalArgumentException {
+        setAcctFreezeStatus(acctId,true);
+    }
+
+    @Override
+    public void unfreezeAcct(String acctId) throws IllegalArgumentException {
+        setAcctFreezeStatus(acctId,false);
+    }
+
+    public void setAcctFreezeStatus(String acctId, boolean isFrozen) {
+        boolean accountFound = (bank.getAccounts().containsKey(acctId));
+        if(accountFound) {
+            bank.getAccounts().get(acctId).setFrozen(isFrozen);
+        } else {
+            throw new IllegalArgumentException("String not in collection");
+        }
+    }
+
+    public CentralBank getBank(){
+        return this.bank;
+    }
+}

src/main/java/edu/ithaca/dragon/bank/AdminAPI.java

@@ -0,0 +1,15 @@
+package edu.ithaca.dragon.bank;
+
+import java.util.Collection;
+
+public interface AdminAPI {
+
+    public double calcTotalAssets();
+
+    public Collection<String> findAcctIdsWithSuspiciousActivity();
+
+    public void freezeAccount(String acctId);
+
+    public void unfreezeAcct(String acctId);
+
+}

src/main/java/edu/ithaca/dragon/bank/AdvancedAPI.java

@@ -0,0 +1,9 @@
+package edu.ithaca.dragon.bank;
+
+//API to be used by Teller systems
+public interface AdvancedAPI extends BasicAPI {
+
+    public void createAccount(String acctId, double startingBalance);
+
+    public void closeAccount(String acctId);
+}