refactor: Simplify ATM implementation and remove unnecessary components

Author: jrcespedes252-hub

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

@@ -1,20 +1,144 @@
 package com.codedifferently.lesson17.bank;
 
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
 import java.util.Set;
 
-/** Base interface for all account types. */
-public interface Account {
-  String getAccountNumber();
+/** Represents an abstract bank account. */
+public abstract class Account {
 
-  Set<Customer> getOwners();
+  protected final Set<Customer> owners;
+  protected final String accountNumber;
+  protected double balance;
+  protected boolean isActive;
+  private final AuditLog auditLog;
 
-  void deposit(double amount);
+  /**
+   * Creates a new account.
+   *
+   * @param accountNumber The account number.
+   * @param owners The owners of the account.
+   * @param initialBalance The initial balance of the account.
+   */
+  public Account(String accountNumber, Set<Customer> owners, double initialBalance) {
+    this.accountNumber = accountNumber;
+    this.owners = owners;
+    this.balance = initialBalance;
+    isActive = true;
+    this.auditLog = new AuditLog();
+  }
 
-  void withdraw(double amount);
+  /**
+   * Gets the account number.
+   *
+   * @return The account number.
+   */
+  public String getAccountNumber() {
+    return accountNumber;
+  }
 
-  double getBalance();
+  /**
+   * Gets the owners of the account.
+   *
+   * @return The owners of the account.
+   */
+  public Set<Customer> getOwners() {
+    return owners;
+  }
 
-  boolean isClosed();
+  /**
+   * Deposits funds into the account. The account must be active to accept deposits.
+   *
+   * @param amount The amount to deposit (must be greater than 0)
+   * @throws IllegalStateException if the account is closed
+   * @throws IllegalArgumentException if the amount is not positive
+   */
+  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");
+    }
+    balance += amount;
+  }
 
-  void closeAccount();
+  /**
+   * Gets the balance of the account.
+   *
+   * @return The balance of the account.
+   */
+  public double getBalance() {
+    return balance;
+  }
+
+  /**
+   * Closes the account.
+   *
+   * @throws IllegalStateException if the account has a positive balance
+   */
+  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 !isActive;
+  }
+
+  /**
+   * Withdraws funds from the account.
+   *
+   * @param amount The amount to withdraw (must be greater than 0)
+   * @throws InsufficientFundsException if the account balance is less than the withdrawal amount
+   * @throws IllegalStateException if the account is closed or the amount is not positive
+   */
+  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 (balance < amount) {
+      throw new InsufficientFundsException("Account does not have enough funds for withdrawal");
+    }
+    balance -= amount;
+  }
+
+  public AuditLog getAuditLog() {
+    return auditLog;
+  }
+
+  @Override
+  public int hashCode() {
+    return accountNumber.hashCode();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (obj instanceof Account other) {
+      return accountNumber.equals(other.accountNumber);
+    }
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return "Account{"
+        + "accountNumber='"
+        + accountNumber
+        + '\''
+        + ", balance="
+        + balance
+        + ", isActive="
+        + isActive
+        + '}';
+  }
 }

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

@@ -1,113 +1,54 @@
 package com.codedifferently.lesson17.bank;
 
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
 
-/** Keeps track of all financial transactions for auditing purposes. */
+/** Maintains a set of records for each transaction performed on bank accounts. */
 public class AuditLog {
+  private Set<String> audits;
 
-  private final List<TransactionRecord> transactions = new ArrayList<>();
-
-  /**
-   * Records a debit transaction.
-   *
-   * @param accountNumber The account number.
-   * @param amount The amount debited.
-   * @param description The description of the transaction.
-   */
-  public void recordDebit(String accountNumber, double amount, String description) {
-    transactions.add(
-        new TransactionRecord(
-            accountNumber, amount, TransactionType.DEBIT, description, LocalDateTime.now()));
+  /** Constructs a new AuditLog with an empty set of audit records. */
+  public AuditLog() {
+    audits = new HashSet<>();
   }
 
   /**
-   * Records a credit transaction.
+   * Logs a financial transaction for the specified account. Contains the account number, action
+   * performed, transaction amount, and the resulting account balance.
    *
-   * @param accountNumber The account number.
-   * @param amount The amount credited.
-   * @param description The description of the transaction.
+   * @param account The account of the transaction
+   * @param action The type of action performed (e.g., "DEPOSIT", "WITHDRAW")
+   * @param amount The amount used in the transaction
    */
-  public void recordCredit(String accountNumber, double amount, String description) {
-    transactions.add(
-        new TransactionRecord(
-            accountNumber, amount, TransactionType.CREDIT, description, LocalDateTime.now()));
-  }
-
-  public List<TransactionRecord> getAllTransactions() {
-    return new ArrayList<>(transactions);
+  public void log(Account account, String action, double amount) {
+    String audit =
+        "Account: "
+            + account.getAccountNumber()
+            + " | Action: "
+            + action
+            + " | Amount: "
+            + amount
+            + " | New Balance: "
+            + account.getBalance();
+    audits.add(audit);
   }
 
-  public List<TransactionRecord> getTransactionsForAccount(String accountNumber) {
-    return transactions.stream()
-        .filter(record -> record.getAccountNumber().equals(accountNumber))
-        .toList();
+  public Set<String> getAudits() {
+    return audits;
   }
 
-  /** Represents a transaction record. */
-  public static class TransactionRecord {
-    private final String accountNumber;
-    private final double amount;
-    private final TransactionType type;
-    private final String description;
-    private final LocalDateTime timestamp;
-
-    public TransactionRecord(
-        String accountNumber,
-        double amount,
-        TransactionType type,
-        String description,
-        LocalDateTime timestamp) {
-      this.accountNumber = accountNumber;
-      this.amount = amount;
-      this.type = type;
-      this.description = description;
-      this.timestamp = timestamp;
-    }
-
-    public String getAccountNumber() {
-      return accountNumber;
-    }
-
-    public double getAmount() {
-      return amount;
-    }
-
-    public TransactionType getType() {
-      return type;
-    }
-
-    public String getDescription() {
-      return description;
-    }
-
-    public LocalDateTime getTimestamp() {
-      return timestamp;
-    }
-
-    @Override
-    public String toString() {
-      return "TransactionRecord{"
-          + "accountNumber='"
-          + accountNumber
-          + '\''
-          + ", amount="
-          + amount
-          + ", type="
-          + type
-          + ", description='"
-          + description
-          + '\''
-          + ", timestamp="
-          + timestamp
-          + '}';
+  /**
+   * Returns a string representation of all audit records. Each audit entry is separated by a
+   * newline character.
+   *
+   * @return A formatted string containing all audit entries, each on a separate line
+   */
+  @Override
+  public String toString() {
+    String auditString = "";
+    for (String audit : audits) {
+      auditString += audit + "\n";
     }
-  }
-
-  /** Enumeration of transaction types. */
-  public enum TransactionType {
-    DEBIT,
-    CREDIT
+    return auditString;
   }
 }