lesson 17

Author: dxbenson252

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

@@ -0,0 +1,63 @@
+package com.codedifferently.lesson17.bank;
+
+import java.util.Set;
+
+/**
+ * Interface representing a bank account. This interface defines the common operations that all
+ * account types must support.
+ */
+public interface Account {
+
+  /**
+   * Gets the account number.
+   *
+   * @return The account number.
+   */
+  String getAccountNumber();
+
+  /**
+   * Gets the owners of the account.
+   *
+   * @return The owners of the account.
+   */
+  Set<Customer> getOwners();
+
+  /**
+   * Deposits funds into the account.
+   *
+   * @param amount The amount to deposit.
+   * @throws IllegalStateException if the account is closed or amount is invalid.
+   */
+  void deposit(double amount);
+
+  /**
+   * Withdraws funds from the account.
+   *
+   * @param amount The amount to withdraw.
+   * @throws IllegalStateException if the account is closed or amount is invalid.
+   * @throws com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException if insufficient
+   *     funds.
+   */
+  void withdraw(double amount);
+
+  /**
+   * Gets the balance of the account.
+   *
+   * @return The balance of the account.
+   */
+  double getBalance();
+
+  /**
+   * Closes the account.
+   *
+   * @throws IllegalStateException if the account cannot be closed.
+   */
+  void closeAccount();
+
+  /**
+   * Checks if the account is closed.
+   *
+   * @return True if the account is closed, otherwise false.
+   */
+  boolean isClosed();
+}

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

@@ -0,0 +1,149 @@
+package com.codedifferently.lesson17.bank;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Audit log for tracking all banking transactions. Records debits and credits to accounts for
+ * compliance and traceability.
+ */
+public class AuditLog {
+
+  private final List<AuditEntry> entries = new ArrayList<>();
+
+  /**
+   * Records a debit transaction.
+   *
+   * @param accountNumber The account number.
+   * @param amount The amount debited.
+   * @param description Description of the transaction.
+   */
+  public void recordDebit(String accountNumber, double amount, String description) {
+    entries.add(new AuditEntry(accountNumber, TransactionType.DEBIT, amount, description));
+  }
+
+  /**
+   * Records a credit transaction.
+   *
+   * @param accountNumber The account number.
+   * @param amount The amount credited.
+   * @param description Description of the transaction.
+   */
+  public void recordCredit(String accountNumber, double amount, String description) {
+    entries.add(new AuditEntry(accountNumber, TransactionType.CREDIT, amount, description));
+  }
+
+  /**
+   * Gets all audit entries.
+   *
+   * @return List of all audit entries.
+   */
+  public List<AuditEntry> getAllEntries() {
+    return new ArrayList<>(entries);
+  }
+
+  /**
+   * Gets audit entries for a specific account.
+   *
+   * @param accountNumber The account number to filter by.
+   * @return List of audit entries for the specified account.
+   */
+  public List<AuditEntry> getEntriesForAccount(String accountNumber) {
+    return entries.stream()
+        .filter(entry -> entry.getAccountNumber().equals(accountNumber))
+        .toList();
+  }
+
+  /**
+   * Gets the total number of recorded transactions.
+   *
+   * @return The total number of transactions.
+   */
+  public int getTransactionCount() {
+    return entries.size();
+  }
+
+  /** Represents a single audit entry. */
+  public static class AuditEntry {
+    private final String accountNumber;
+    private final TransactionType type;
+    private final double amount;
+    private final String description;
+    private final LocalDateTime timestamp;
+
+    /**
+     * Creates a new audit entry.
+     *
+     * @param accountNumber The account number.
+     * @param type The transaction type.
+     * @param amount The transaction amount.
+     * @param description The transaction description.
+     */
+    public AuditEntry(
+        String accountNumber, TransactionType type, double amount, String description) {
+      this.accountNumber = accountNumber;
+      this.type = type;
+      this.amount = amount;
+      this.description = description;
+      this.timestamp = LocalDateTime.now();
+    }
+
+    /**
+     * Gets the account number.
+     *
+     * @return The account number.
+     */
+    public String getAccountNumber() {
+      return accountNumber;
+    }
+
+    /**
+     * Gets the transaction type.
+     *
+     * @return The transaction type.
+     */
+    public TransactionType getType() {
+      return type;
+    }
+
+    /**
+     * Gets the transaction amount.
+     *
+     * @return The transaction amount.
+     */
+    public double getAmount() {
+      return amount;
+    }
+
+    /**
+     * Gets the transaction description.
+     *
+     * @return The transaction description.
+     */
+    public String getDescription() {
+      return description;
+    }
+
+    /**
+     * Gets the transaction timestamp.
+     *
+     * @return The transaction timestamp.
+     */
+    public LocalDateTime getTimestamp() {
+      return timestamp;
+    }
+
+    @Override
+    public String toString() {
+      return String.format(
+          "[%s] %s %s: %.2f - %s", timestamp, accountNumber, type, amount, description);
+    }
+  }
+
+  /** Enumeration for transaction types. */
+  public enum TransactionType {
+    CREDIT,
+    DEBIT
+  }
+}

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

@@ -1,23 +1,43 @@
 package com.codedifferently.lesson17.bank;
 
-import com.codedifferently.lesson17.bank.exceptions.AccountNotFoundException;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
 
-/** Represents a bank ATM. */
+import com.codedifferently.lesson17.bank.exceptions.AccountNotFoundException;
+
+/** Represents a bank ATM with audit logging capabilities. */
 public class BankAtm {
 
   private final Map<UUID, Customer> customerById = new HashMap<>();
-  private final Map<String, CheckingAccount> accountByNumber = new HashMap<>();
+  private final Map<String, Account> accountByNumber = new HashMap<>();
+  private final AuditLog auditLog = new AuditLog();
 
   /**
    * Adds a checking account to the bank.
    *
    * @param account The account to add.
    */
   public void addAccount(CheckingAccount account) {
+    addAccountInternal(account);
+  }
+
+  /**
+   * Adds a savings account to the bank.
+   *
+   * @param account The savings account to add.
+   */
+  public void addAccount(SavingsAccount account) {
+    addAccountInternal(account);
+  }
+
+  /**
+   * Internal method to add any type of account.
+   *
+   * @param account The account to add.
+   */
+  private void addAccountInternal(Account account) {
     accountByNumber.put(account.getAccountNumber(), account);
     account
         .getOwners()
@@ -46,30 +66,55 @@ public Set<CheckingAccount> findAccountsByCustomerId(UUID customerId) {
    * @param amount The amount to deposit.
    */
   public void depositFunds(String accountNumber, double amount) {
-    CheckingAccount account = getAccountOrThrow(accountNumber);
+    Account account = getAccountOrThrow(accountNumber);
     account.deposit(amount);
+    auditLog.recordCredit(accountNumber, amount, "Cash deposit");
   }
 
   /**
-   * Deposits funds into an account using a check.
+   * Deposits funds into an account using a check. Note: Only checking accounts support check
+   * deposits.
    *
    * @param accountNumber The account number.
    * @param check The check to deposit.
+   * @throws IllegalArgumentException if trying to deposit a check to a savings account.
    */
   public void depositFunds(String accountNumber, Check check) {
-    CheckingAccount account = getAccountOrThrow(accountNumber);
-    check.depositFunds(account);
+    Account account = getAccountOrThrow(accountNumber);
+
+    // Only checking accounts can accept check deposits
+    if (!(account instanceof CheckingAccount)) {
+      throw new IllegalArgumentException("Cannot deposit checks to savings accounts");
+    }
+
+    CheckingAccount checkingAccount = (CheckingAccount) account;
+    check.depositFunds(checkingAccount);
+    auditLog.recordCredit(
+        accountNumber,
+        check.getAmount(),
+        String.format(
+            "Check deposit from account %s", check.getSourceAccount().getAccountNumber()));
   }
 
   /**
    * Withdraws funds from an account.
    *
-   * @param accountNumber
-   * @param amount
+   * @param accountNumber The account number.
+   * @param amount The amount to withdraw.
    */
   public void withdrawFunds(String accountNumber, double amount) {
-    CheckingAccount account = getAccountOrThrow(accountNumber);
+    Account account = getAccountOrThrow(accountNumber);
     account.withdraw(amount);
+    auditLog.recordDebit(accountNumber, amount, "Cash withdrawal");
+  }
+
+  /**
+   * Gets the audit log for transaction tracking.
+   *
+   * @return The audit log instance.
+   */
+  public AuditLog getAuditLog() {
+    return auditLog;
   }
 
   /**
@@ -78,8 +123,8 @@ public void withdrawFunds(String accountNumber, double amount) {
    * @param accountNumber The account number.
    * @return The account.
    */
-  private CheckingAccount getAccountOrThrow(String accountNumber) {
-    CheckingAccount account = accountByNumber.get(accountNumber);
+  private Account getAccountOrThrow(String accountNumber) {
+    Account account = accountByNumber.get(accountNumber);
     if (account == null || account.isClosed()) {
       throw new AccountNotFoundException("Account not found");
     }