feat: refactor bank account structure and add MoneyOrder and BusinessCheckingAccount classes

Author: bryanasb251

lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/AuditLog.java

@@ -1,23 +1,23 @@
 package com.codedifferently.lesson17.bank;
 
 import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.List;
 
-/**
- * Creates a new saving account.
- *
- * @param accountNumber The account number as log transaction key.
- * @param value The actual debit/credit transaction.
- * @param accountNumberByValueLog The audit log object.
- */
 public class AuditLog {
+    private List<String> logEntries;
 
-  // Method to add a value to an existing ArrayList or create a new one if accountNumber doesn't
-  // exist
-  public void addToMap(
-      HashMap<String, ArrayList<Double>> accountNumberByValueLog,
-      String accountNumber,
-      Double value) {
-    accountNumberByValueLog.computeIfAbsent(accountNumber, k -> new ArrayList<>()).add(value);
-  }
-}
+    public AuditLog() {
+        logEntries = new ArrayList<>();
+    }
+
+    public void logTransaction(BankAccount account, double amount, String transactionType) {
+        String entry = String.format("%s transaction: %s | Amount: %.2f | Balance: %.2f",
+            transactionType, account.getAccountNumber(), amount, account.getBalance());
+        logEntries.add(entry);
+        System.out.println(entry);  // You can remove this line if you prefer logging to a file or database
+    }
+
+    public List<String> getLogEntries() {
+        return logEntries;
+    }
+}

lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/BankAccount.java

@@ -1,47 +1,133 @@
 package com.codedifferently.lesson17.bank;
 
-import java.util.HashSet;
 import java.util.Set;
 
-public abstract class BankAccount {
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+
+public class BankAccount {
   protected String accountNumber;
   protected Set<Customer> owners;
   protected double balance;
-  protected boolean closed;
+  protected boolean isActive;
+  private static final double LARGE_TRANSACTION_THRESHOLD = 5000.0;
 
-  public BankAccount(String accountNumber, Customer owner) {
+ public BankAccount(String accountNumber, Set<Customer> owners, double initialBalance) {
     this.accountNumber = accountNumber;
-    this.owners = new HashSet<>(Set.of(owner));
-    this.balance = 0.0;
-    this.closed = false;
-    owner.addAccount(this);
+    this.owners = owners;
+    this.balance = initialBalance;
+    isActive = true;
   }
 
+  /**
+   * Gets the account number.
+   *
+   * @return The account number.
+   */
   public String getAccountNumber() {
     return accountNumber;
   }
 
+  /**
+   * Gets the owners of the account.
+   *
+   * @return The owners of the account.
+   */
   public Set<Customer> getOwners() {
     return owners;
   }
 
+  /**
+   * Deposits funds into the account.
+   *
+   * @param amount The amount to deposit.
+   */
+  public void deposit(double amount) throws IllegalStateException {
+    if (isClosed()) {
+      throw new IllegalStateException("Cannot deposit to a closed account");
+    }
+    if (amount <= 0) {
+      throw new IllegalArgumentException("Deposit amount must be positive");
+    }
+    if (amount > LARGE_TRANSACTION_THRESHOLD) {
+      System.out.println("Warning: Large transaction detected for deposit.");
+    }
+    balance += amount;
+  }
+
+  
+    // Withdraws funds from the account.
+   
+  public void withdraw(double amount) throws InsufficientFundsException {
+    if (isClosed()) {
+      throw new IllegalStateException("Cannot withdraw from a closed account");
+    }
+    if (amount <= 0) {
+      throw new IllegalStateException("Withdrawal amount must be positive");
+    }
+    if (amount > LARGE_TRANSACTION_THRESHOLD) {
+      System.out.println("Warning: Large transaction detected for withdrawal.");
+    }
+    if (balance < amount) {
+      throw new InsufficientFundsException("Account does not have enough funds for withdrawal");
+    }
+    balance -= amount;
+  }
+  /**
+   * Checks if the account is active.
+   *
+   * @return True if the account is active, otherwise false.
+   */
+
+  /**
+   * Gets the balance of the account.
+   *
+   * @return The balance of the account.
+   */
   public double getBalance() {
     return balance;
   }
 
+  /** Closes the account. */
+  public void closeAccount() throws IllegalStateException {
+    if (balance > 0) {
+      throw new IllegalStateException("Cannot close account with a positive balance");
+    }
+    isActive = false;
+  }
+
+  /**
+   * Checks if the account is closed.
+   *
+   * @return True if the account is closed, otherwise false.
+   */
   public boolean isClosed() {
-    return closed;
+    return !isActive;
   }
 
-  public void deposit(double amount) {
-    balance += amount;
+  @Override
+  public int hashCode() {
+    return accountNumber.hashCode();
   }
 
-  public void withdraw(double amount) {
-    balance -= amount;
+  @Override
+  public boolean equals(Object obj) {
+    if (obj instanceof BankAccount other) {
+      return accountNumber.equals(other.accountNumber);
+    }
+    return false;
   }
 
-  public void closeAccount() {
-    closed = true;
+  @Override
+  public String toString() {
+    return "BnnkAccount{"
+        + "accountNumber='"
+        + accountNumber
+        + '\''
+        + ", balance="
+        + balance
+        + ", isActive="
+        + isActive
+        + '}';
   }
 }
+

lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/BankAtm.java

@@ -1,6 +1,12 @@
 package com.codedifferently.lesson17.bank;
 
 import com.codedifferently.lesson17.bank.exceptions.AccountNotFoundException;
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+
+import main.java.com.codedifferently.lesson17.bank.AuditLog;
+import main.java.com.codedifferently.lesson17.bank.BankAccount;
+import main.java.com.codedifferently.lesson17.bank.MoneyOrder;
+
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
@@ -70,7 +76,15 @@ public void withdrawFunds(String accountNumber, double amount) {
     account.withdraw(amount);
     auditLog.record("Withdrew $" + amount + " from account " + accountNumber);
   }
-
+   /**
+    * Handles a money order transaction.
+    * @param moneyOrder The money order to process.
+    */
+  public void handleMoneyOrder(MoneyOrder moneyOrder) throws InsufficientFundsException {
+    BankAccount account = getAccountOrThrow(moneyOrder.getSourceAccount().getAccountNumber());
+    moneyOrder.process();
+    auditLog.record("Processed money order of $" + moneyOrder.getAmount() + " from account " + account.getAccountNumber());
+  }
   /**
    * Gets an account by its number or throws an exception if not found.
    *

lesson_17/bank/bank_app/src/main/java/com/codedifferently/lesson17/bank/BusinessCheckingAccount.java

@@ -0,0 +1,30 @@
+package com.codedifferently.lesson17.bank;
+
+import java.util.Set;
+
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+
+public class BusinessCheckingAccount extends BankAccount {
+    private boolean isBusiness;
+
+    public BusinessCheckingAccount(String accountNumber, Set<Customer> owners, double initialBalance, boolean isBusiness) {
+        super(accountNumber, owners, initialBalance);
+        this.isBusiness = isBusiness;
+    }
+
+    /**
+     * Business accounts may have special conditions for checks, etc.
+     */
+    @Override
+    public void withdraw(double amount) throws InsufficientFundsException {
+        // Business checking accounts can withdraw with more flexibility
+        if (amount > balance) {
+            throw new InsufficientFundsException("Insufficient funds in business checking account.");
+        }
+        balance -= amount;
+    }
+
+    public boolean isBusiness() {
+        return isBusiness;
+    }
+}