Robin Kaga

src/main/java/com/booleanuk/core/Account.java

@@ -0,0 +1,69 @@
+package com.booleanuk.core;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public abstract class Account {
+
+    private float balance;
+    private ArrayList<Transaction> transactions = new ArrayList<>();
+    private long accountNumber;
+
+    public void setAccountNumber(int branchID, int accountID){
+        String s = String.valueOf(branchID) + String.valueOf(accountID);
+        this.accountNumber = Long.parseLong(s);
+    }
+
+    public long getAccountNumber(){
+        return accountNumber;
+    }
+
+    public float getBalance(){
+        return balance;
+    }
+
+    public float calculateBalance(){
+        balance = 0.00f;
+        for (Transaction t : transactions){
+            if (t.getIsWithdrawal()){
+                balance -= t.getAmount();
+            }else {
+                balance += t.getAmount();
+            }
+        }
+        return  balance;
+    }
+
+    public ArrayList<Transaction> getTransactions() {
+        return transactions;
+    }
+
+    public void withdraw(float amount){
+        if (calculateBalance() < amount){
+            System.out.println("Not enough funds in account!");
+            return;
+        }
+        balance -= amount;
+        Transaction transaction = new Transaction(true, balance, amount);
+        transactions.add(transaction);
+    }
+
+    public void deposit(float amount){
+        balance += amount;
+        Transaction transaction = new Transaction(false, balance, amount);
+        transactions.add(transaction);
+
+    }
+
+    public String generateStatement(){
+        ArrayList<Transaction> reversed = new ArrayList<>(transactions);
+        Collections.reverse(reversed);
+        StringBuilder statement = new StringBuilder();
+        statement = new StringBuilder(String.format("%-20s|| %-10s|| %-10s|| %-10s\n", "date", "credit", "debit", "balance"));
+        for (Transaction t : reversed){
+            statement.append(t.toString()).append("\n");
+        }
+        return statement.toString();
+    }
+
+}

src/main/java/com/booleanuk/core/Bank.java

@@ -0,0 +1,28 @@
+package com.booleanuk.core;
+
+import java.util.ArrayList;
+
+public class Bank {
+
+    private ArrayList<Branch> branches = new ArrayList<>();
+
+    public void createBranch(){
+        Branch branch = new Branch();
+        branches.add(branch);
+    }
+
+    public Branch getBranchByID(int id){
+        for (Branch b : branches){
+            if (b.getBranchID() == id){
+                return b;
+            }
+        }
+        System.out.println("Non-existing or not valid branch ID!");
+        return null;
+    }
+
+    public ArrayList<Branch> getBranches(){
+        return this.branches;
+    }
+
+}

src/main/java/com/booleanuk/core/Branch.java

@@ -0,0 +1,39 @@
+package com.booleanuk.core;
+
+import java.util.HashMap;
+
+public class Branch {
+
+    private final int branchID;
+    private static int counter = 1000;
+    private HashMap<Integer, Account> accounts = new HashMap<>();
+    private int accountID = 100000;
+
+    public Branch(){
+        this.branchID = counter;
+        counter += 1;
+    }
+
+    public int getBranchID(){
+        return this.branchID;
+    }
+
+    public HashMap<Integer, Account> getAccounts(){
+        return this.accounts;
+    }
+
+    public void createCurrentAccount( ){
+        CurrentAccount currentAccount = new CurrentAccount();
+        currentAccount.setAccountNumber(branchID, accountID);
+        accounts.put(accountID, currentAccount);
+        accountID+=1;
+    }
+
+    public void createSavingsAccount( ){
+        SavingsAccount savingsAccount = new SavingsAccount();
+        savingsAccount.setAccountNumber(branchID, accountID);
+        accounts.put(accountID, savingsAccount);
+        accountID+=1;
+    }
+
+}

src/main/java/com/booleanuk/core/CurrentAccount.java

@@ -0,0 +1,8 @@
+package com.booleanuk.core;
+
+public class CurrentAccount extends Account{
+
+    public CurrentAccount() {
+
+    }
+}

src/main/java/com/booleanuk/core/SavingsAccount.java

@@ -0,0 +1,23 @@
+package com.booleanuk.core;
+
+public class SavingsAccount extends Account{
+
+    // Was going to add different functionality to savings account,
+    // But Dave said we didnt have to.
+
+//    private int maxWithdraws = 12;
+//    private int totWithdraws;
+
+    public SavingsAccount() {
+
+    }
+
+//    public int getWithdraws(){
+//        return this.totWithdraws;
+//    }
+//
+//    @Override
+//    public void withdraw(float amount){
+//
+//    }
+}

src/main/java/com/booleanuk/core/Transaction.java

@@ -0,0 +1,47 @@
+package com.booleanuk.core;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+public class Transaction {
+
+    private String time;
+    private float balance;
+    private float amount;
+    private boolean isWithdrawal;
+
+    public Transaction(boolean isWithdrawal, float balance, float amount){
+        this.isWithdrawal = isWithdrawal;
+        this.balance = balance;
+        this.amount = amount;
+
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
+        this.time = LocalDateTime.now().format(formatter);
+    }
+
+    public boolean getIsWithdrawal(){
+        return this.isWithdrawal;
+    }
+
+    public float getBalance(){
+        return this.balance;
+    }
+
+    public float getAmount(){
+        return this.amount;
+    }
+
+    public String getTime(){
+        return this.time;
+    }
+
+    @Override
+    public String toString() {
+        if (this.isWithdrawal){
+            return String.format("%-20s|| %-10s|| %-10s|| %-10s", time, "", String.valueOf(this.amount), balance);
+        }
+        return String.format("%-20s|| %-10s|| %-10s|| %-10s", time, String.valueOf(this.amount), "", balance);
+
+    }
+
+}

src/test/java/com/booleanuk/core/TestBank.java

@@ -0,0 +1,36 @@
+package com.booleanuk.core;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class TestBank {
+
+    @Test
+    public void testBankSystem(){
+        Bank bank = new Bank();
+        bank.createBranch();
+        bank.createBranch();
+
+        bank.getBranchByID(1000).createCurrentAccount();
+        bank.getBranchByID(1000).createCurrentAccount();
+        bank.getBranchByID(1001).createCurrentAccount();
+        bank.getBranchByID(1001).createCurrentAccount();
+
+        bank.getBranchByID(1000).getAccounts().get(100000).deposit(1000.00f);
+        bank.getBranchByID(1000).getAccounts().get(100000).withdraw(500.00f);
+        bank.getBranchByID(1000).getAccounts().get(100001).deposit(500.00f);
+        bank.getBranchByID(1000).getAccounts().get(100001).withdraw(250.00f);
+        bank.getBranchByID(1001).getAccounts().get(100000).deposit(2000.00f);
+        bank.getBranchByID(1001).getAccounts().get(100000).withdraw(1000.00f);
+        bank.getBranchByID(1001).getAccounts().get(100001).deposit(3000.00f);
+        bank.getBranchByID(1001).getAccounts().get(100001).withdraw(5000.00f);
+
+
+        Assertions.assertEquals(500.00f, bank.getBranchByID(1000).getAccounts().get(100000).calculateBalance());
+        Assertions.assertEquals(250.00f, bank.getBranchByID(1000).getAccounts().get(100001).calculateBalance());
+        Assertions.assertEquals(1000.00f, bank.getBranchByID(1001).getAccounts().get(100000).calculateBalance());
+        Assertions.assertEquals(3000.00f, bank.getBranchByID(1001).getAccounts().get(100001).calculateBalance());
+
+
+    }
+}

src/test/java/com/booleanuk/core/TestBranch.java

@@ -0,0 +1,43 @@
+package com.booleanuk.core;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+
+public class TestBranch {
+
+    @BeforeEach
+    public void resetCounter() throws NoSuchFieldException, IllegalAccessException {
+        Field counterField = Branch.class.getDeclaredField("counter");
+        counterField.setAccessible(true);
+        counterField.set(null, 1000);
+    }
+
+    @Test
+    public void testGetBranchID(){
+        Branch branch1 = new Branch();
+        Assertions.assertEquals(1000, branch1.getBranchID());
+        Branch branch2 = new Branch();
+        Assertions.assertEquals(1001, branch2.getBranchID());
+        Branch branch3 = new Branch();
+        Assertions.assertEquals(1002, branch3.getBranchID());
+    }
+
+    //Same for savings account
+    @Test
+    public void testCreateCurrentAccount(){
+        Branch branch = new Branch();
+        branch.createCurrentAccount();
+        branch.createCurrentAccount();
+        Assertions.assertEquals(1000100000, branch.getAccounts().get(100000).getAccountNumber());
+        Assertions.assertEquals(1000100001, branch.getAccounts().get(100001).getAccountNumber());
+
+        Branch branch1 = new Branch();
+        branch1.createCurrentAccount();
+        branch1.createCurrentAccount();
+        Assertions.assertEquals(1001100000, branch1.getAccounts().get(100000).getAccountNumber());
+        Assertions.assertEquals(1001100001, branch1.getAccounts().get(100001).getAccountNumber());
+    }
+}

src/test/java/com/booleanuk/core/TestCurrentAccount.java

@@ -0,0 +1,65 @@
+package com.booleanuk.core;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+public class TestCurrentAccount {
+
+    @Test
+    public void testDeposit(){
+        CurrentAccount currentAccount = new CurrentAccount();
+        currentAccount.deposit(100.00f);
+        Assertions.assertEquals(100.00f, currentAccount.getBalance());
+        currentAccount.deposit(74.00f);
+        Assertions.assertEquals(174.00f, currentAccount.getBalance());
+    }
+
+    @Test
+    public void testInsufficientFunds(){
+        CurrentAccount currentAccount = new CurrentAccount();
+        currentAccount.deposit(100.00f);
+        currentAccount.withdraw(500.00f);
+        Assertions.assertEquals(100.00f, currentAccount.getBalance());
+    }
+
+    @Test
+    public void testWithdraw(){
+        CurrentAccount currentAccount = new CurrentAccount();
+        currentAccount.deposit(100.00f);
+        Assertions.assertEquals(100.00f, currentAccount.getBalance());
+        currentAccount.withdraw(20.00f);
+        Assertions.assertEquals(80.00f, currentAccount.getBalance());
+        currentAccount.withdraw(74.00f);
+        Assertions.assertEquals(6.00f, currentAccount.getBalance());
+    }
+
+    @Test
+    public void testCalculateBalance(){
+        CurrentAccount currentAccount = new CurrentAccount();
+        currentAccount.deposit(3000.00f);
+        currentAccount.deposit(3000.00f);
+        Assertions.assertEquals(6000.00f, currentAccount.calculateBalance());
+        currentAccount.withdraw(500.00f);
+        currentAccount.withdraw(50.00f);
+        Assertions.assertEquals(5450.00f, currentAccount.calculateBalance());
+        currentAccount.withdraw(50.00f);
+        Assertions.assertEquals(5400.00f, currentAccount.calculateBalance());
+
+    }
+
+    @Test
+    public void testStatement(){
+        DateTimeFormatter testFormatter = DateTimeFormatter.ofPattern("yyyy-MM-ddHH:mm");
+        CurrentAccount currentAccount = new CurrentAccount();
+        currentAccount.deposit(1000.00f);
+        currentAccount.deposit(2000.00f);
+        currentAccount.withdraw(500.00f);
+        String expected = "date||credit||debit||balance\n" + LocalDateTime.now().format(testFormatter) +
+                "||||500.0||2500.0\n" + LocalDateTime.now().format(testFormatter) + "||2000.0||||3000.0\n" +
+                LocalDateTime.now().format(testFormatter) + "||1000.0||||1000.0";
+        Assertions.assertEquals(expected, currentAccount.generateStatement().replaceAll("[ ]+", "").strip());
+    }
+}