added java files and modified test files

Signed-off-by: calvin <[email protected]>

Author: calvin

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

@@ -0,0 +1,132 @@
+package com.codedifferently.lesson17.bank;
+
+import com.codedifferently.lesson17.bank.exceptions.InsufficientFundsException;
+import java.util.Set;
+
+/** Abstract base class for bank accounts. */
+public abstract class Account {
+
+  protected final Set<Customer> owners;
+  protected final String accountNumber;
+  protected double balance;
+  protected boolean isActive;
+
+  /**
+   * 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;
+    this.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");
+    }
+    balance += amount;
+  }
+
+  /**
+   * Withdraws funds from the account.
+   *
+   * @param amount The amount to withdraw.
+   * @throws InsufficientFundsException If there are insufficient funds.
+   */
+  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;
+  }
+
+  /**
+   * 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 !isActive;
+  }
+
+  @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 this.getClass().getSimpleName()
+        + "{"
+        + "accountNumber='"
+        + accountNumber
+        + '\''
+        + ", balance="
+        + balance
+        + ", isActive="
+        + isActive
+        + '}';
+  }
+}

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

@@ -0,0 +1,51 @@
+package com.codedifferently.lesson17.bank;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Represents an audit log for recording transactions. */
+public class AuditLog {
+
+  private final List<String> logs = new ArrayList<>();
+
+  /**
+   * Logs a deposit transaction.
+   *
+   * @param accountNumber The account number.
+   * @param amount The amount deposited.
+   */
+  public void logDeposit(String accountNumber, double amount) {
+    String logEntry =
+        String.format(
+            "[%s] Deposited $%.2f to account %s", LocalDateTime.now(), amount, accountNumber);
+    logs.add(logEntry);
+  }
+
+  /**
+   * Logs a withdrawal transaction.
+   *
+   * @param accountNumber The account number.
+   * @param amount The amount withdrawn.
+   */
+  public void logWithdrawal(String accountNumber, double amount) {
+    String logEntry =
+        String.format(
+            "[%s] Withdrew $%.2f from account %s", LocalDateTime.now(), amount, accountNumber);
+    logs.add(logEntry);
+  }
+
+  /**
+   * Gets all log entries.
+   *
+   * @return The list of log entries.
+   */
+  public List<String> getLogs() {
+    return new ArrayList<>(logs);
+  }
+
+  @Override
+  public String toString() {
+    return "AuditLog{" + "logs=" + logs + '}';
+  }
+}

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

@@ -10,14 +10,15 @@
 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.
+   * Adds an account to the bank.
    *
    * @param account The account to add.
    */
-  public void addAccount(CheckingAccount account) {
+  public void addAccount(Account account) {
     accountByNumber.put(account.getAccountNumber(), account);
     account
         .getOwners()
@@ -33,7 +34,7 @@ public void addAccount(CheckingAccount account) {
    * @param customerId The ID of the customer.
    * @return The unique set of accounts owned by the customer.
    */
-  public Set<CheckingAccount> findAccountsByCustomerId(UUID customerId) {
+  public Set<Account> findAccountsByCustomerId(UUID customerId) {
     return customerById.containsKey(customerId)
         ? customerById.get(customerId).getAccounts()
         : Set.of();
@@ -46,8 +47,9 @@ 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.logDeposit(accountNumber, amount);
   }
 
   /**
@@ -57,8 +59,9 @@ public void depositFunds(String accountNumber, double amount) {
    * @param check The check to deposit.
    */
   public void depositFunds(String accountNumber, Check check) {
-    CheckingAccount account = getAccountOrThrow(accountNumber);
+    Account account = getAccountOrThrow(accountNumber);
     check.depositFunds(account);
+    auditLog.logDeposit(accountNumber, check.getAmount());
   }
 
   /**
@@ -68,8 +71,9 @@ public void depositFunds(String accountNumber, Check check) {
    * @param amount
    */
   public void withdrawFunds(String accountNumber, double amount) {
-    CheckingAccount account = getAccountOrThrow(accountNumber);
+    Account account = getAccountOrThrow(accountNumber);
     account.withdraw(amount);
+    auditLog.logWithdrawal(accountNumber, amount);
   }
 
   /**
@@ -78,11 +82,20 @@ 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");
     }
     return account;
   }
+
+  /**
+   * Gets the audit log.
+   *
+   * @return The audit log.
+   */
+  public AuditLog getAuditLog() {
+    return auditLog;
+  }
 }

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

@@ -27,12 +27,12 @@ public Check(String checkNumber, double amount, CheckingAccount account) {
   }
 
   /**
-   * Gets the voided status of the check.
+   * Gets the amount of the check.
    *
-   * @return True if the check is voided, and false otherwise.
+   * @return The amount.
    */
-  public boolean getIsVoided() {
-    return isVoided;
+  public double getAmount() {
+    return amount;
   }
 
   /** Voids the check. */
@@ -45,10 +45,13 @@ public void voidCheck() {
    *
    * @param toAccount The account to deposit the check into.
    */
-  public void depositFunds(CheckingAccount toAccount) {
+  public void depositFunds(Account toAccount) {
     if (isVoided) {
       throw new CheckVoidedException("Check is voided");
     }
+    if (!(toAccount instanceof CheckingAccount)) {
+      throw new IllegalArgumentException("Checks can only be deposited into checking accounts");
+    }
     account.withdraw(amount);
     toAccount.deposit(amount);
     voidCheck();