Jonas Finborud Nyman

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

@@ -0,0 +1,61 @@
+package com.booleanuk.core;
+
+import java.util.ArrayList;
+import java.util.UUID;
+
+public class Account {
+
+    private UUID id;
+    private AccountType accountType;
+    private ArrayList<Transaction> transactions;
+    private float overdraft;
+
+    public Account(AccountType accountType) {
+        this.id = UUID.randomUUID();
+        this.accountType = accountType;
+        transactions = new ArrayList<>();
+        overdraft = 0F;
+    }
+
+    public boolean deposit(float amount) {
+        if(amount <= 0F) {
+            System.out.println("Deposit amount must be above £0.");
+            return false;
+        }
+        transactions.add(new Transaction(this.getID(), amount));
+        return true;
+    }
+
+    public boolean withdraw(float amount) {
+        if(getBalance() < amount) {
+            System.out.println("Insufficient funds. Withdrawal denied.");
+            return false;
+        }
+        transactions.add(new Transaction(this.getID(), amount * -1));
+        return true;
+    }
+
+    public UUID getID() {
+        return id;
+    }
+
+    public float getBalance() {
+        float balance = 0F;
+        for (Transaction t : this.transactions) {
+            balance += t.getAmount();
+        }
+        return balance;
+    }
+
+    public AccountType getAccountType() {
+        return accountType;
+    }
+
+    public float getOverdraft() {
+        return this.overdraft;
+    }
+
+    public void setOverdraft(float overdraft) {
+        this.overdraft = overdraft;
+    }
+}

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

@@ -0,0 +1,6 @@
+package com.booleanuk.core;
+
+public enum AccountType {
+    CURRENT,
+    SAVING
+}

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

@@ -0,0 +1,113 @@
+package com.booleanuk.core;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.UUID;
+
+public class BankSystem {
+
+    private HashMap<UUID, ArrayList<Transaction>> transactionMap;
+    private HashMap<UUID, Account> accountMap;
+    private HashMap<UUID, Float> overdraftRequests;
+
+    public BankSystem() {
+        transactionMap = new HashMap<>();
+        accountMap = new HashMap<>();
+        overdraftRequests = new HashMap<>();
+    }
+
+    public Account createBankAccount(AccountType accountType) {
+        Account account = new Account(accountType);
+        transactionMap.put(account.getID(), new ArrayList<>());
+        accountMap.put(account.getID(), account);
+        return account;
+    }
+
+    public Transaction makeDeposit(UUID accountID, float amount) {
+        if(!accountMap.containsKey(accountID)) {
+            System.out.println("Account ID doesn't exist. Deposit cancelled.");
+            return null;
+        }
+
+        Transaction transaction = new Transaction(accountID, amount);
+        accountMap.get(accountID).deposit(amount);
+        transactionMap.get(accountID).add(transaction);
+        return transaction;
+    }
+
+    public Transaction makeWithdrawal(UUID accountID, float amount) {
+        if(!accountMap.containsKey(accountID)) {
+            System.out.println("Account ID doesn't exist. Withdrawal cancelled.");
+            return null;
+        }
+
+        Transaction transaction = new Transaction(accountID, amount*-1);
+        if(!accountMap.get(accountID).withdraw(amount)) {
+            System.out.println("Insufficient funds. Withdrawal cancelled.");
+            return null;
+        }
+        transactionMap.get(accountID).add(transaction);
+        return transaction;
+    }
+
+    public boolean requestOverdraft(UUID accountID, float amount) {
+        if(amount <= 0) {
+            System.out.println("Overdraft amount must be above £0");
+            return false;
+        }
+        if(overdraftRequests.containsKey(accountID)) {
+            System.out.println("Your previous overdraft request has been updated.");
+        }
+        overdraftRequests.put(accountID, amount);
+        return true;
+    }
+
+    public void reviewOverdrafts() {
+
+        Scanner sc = new Scanner(System.in);
+        String input = "";
+        for(UUID k : overdraftRequests.keySet()) {
+            System.out.println("Account " + k + " requests an overdraft of £" + overdraftRequests.get(k) + ".");
+            System.out.println("Would you like to confirm this request? (Y / N)");
+            input = sc.nextLine();
+            if(input.equalsIgnoreCase("y")) {
+                this.accountMap.get(k).setOverdraft(overdraftRequests.get(k));
+                System.out.println("Overdraft request has been granted.");
+            } else {
+                System.out.println("Overdraft request has been declined.");
+            }
+            overdraftRequests.remove(k);
+        }
+    }
+
+    public StringBuilder generateStatement(UUID accountID) {
+        ArrayList<Transaction> transactions = this.transactionMap.get(accountID);
+        StringBuilder statement = new StringBuilder();
+        float balance = 0;
+        statement.append("Date\t\t\tCredit\tDebit\tBalance\n");
+        for(Transaction t : transactions) {
+            balance += t.getAmount();
+            if(t.getAmount() > 0) {
+                statement.append(t.getTransactionDate().toLocalDate() + "\t\t" + t.getAmount() + "\t\t\t" + balance + "\n");
+            }
+            else {
+                statement.append(t.getTransactionDate().toLocalDate() + "\t\t\t\t" + (t.getAmount() * -1) + "\t" + balance + "\n");
+            }
+        }
+        System.out.println(statement);
+        return statement;
+    }
+
+    public HashMap<UUID, ArrayList<Transaction>> getTransactionMap() {
+        return this.transactionMap;
+    }
+
+    public HashMap<UUID, Account> getAccountMap() {
+        return this.accountMap;
+    }
+
+    public HashMap<UUID, Float> getOverdraftRequests() {
+        return this.overdraftRequests;
+    }
+}

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

@@ -0,0 +1,35 @@
+package com.booleanuk.core;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+public class Transaction {
+
+    private float amount;
+    private LocalDateTime transactionDate;
+    private UUID ID;
+    private UUID accountID;
+
+    public Transaction(UUID accountID, float amount) {
+        this.accountID = accountID;
+        this.amount = amount;
+        this.transactionDate = LocalDateTime.now();
+        this.ID = UUID.randomUUID();
+    }
+
+    public float getAmount() {
+        return amount;
+    }
+
+    public LocalDateTime getTransactionDate() {
+        return transactionDate;
+    }
+
+    public UUID getID() {
+        return ID;
+    }
+
+    public UUID getAccountID() {
+        return accountID;
+    }
+}

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

@@ -0,0 +1,53 @@
+package com.booleanuk.core;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class AccountTest {
+
+    @Test
+    public void getRightBalanceTest() {
+        Account acc = new Account(AccountType.CURRENT);
+        Assertions.assertTrue(acc.deposit(500.0F));
+        Assertions.assertEquals(500.0F, acc.getBalance());
+    }
+
+    @Test
+    public void getWrongBalanceTest() {
+        Account acc = new Account(AccountType.CURRENT);
+        acc.deposit(500.0F);
+        Assertions.assertNotEquals(0F, acc.getBalance());
+    }
+
+    @Test
+    public void depositNegativeAmountTest() {
+        Account acc = new Account(AccountType.CURRENT);
+        Assertions.assertFalse(acc.deposit(-500.0F));
+    }
+
+    @Test
+    public void sufficientWithdrawalTest() {
+        Account acc = new Account(AccountType.CURRENT);
+        acc.deposit(500.0F);
+        Assertions.assertTrue(acc.withdraw(200.0F));
+    }
+
+    @Test
+    public void insufficientWithdrawalTest() {
+        Account acc = new Account(AccountType.CURRENT);
+        acc.deposit(500.0F);
+        Assertions.assertFalse(acc.withdraw(1000F));
+    }
+
+    @Test
+    public void getRightAccountTypeTest() {
+        Account acc = new Account(AccountType.CURRENT);
+        Assertions.assertEquals(AccountType.CURRENT, acc.getAccountType());
+    }
+
+    @Test
+    public void getWrongAccountTypeTest() {
+        Account acc = new Account(AccountType.CURRENT);
+        Assertions.assertNotEquals(AccountType.SAVING, acc.getAccountType());
+    }
+}

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

@@ -0,0 +1,84 @@
+package com.booleanuk.core;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class BankSystemTest {
+
+    @Test
+    public void makeDepositTest() {
+        BankSystem bank = new BankSystem();
+        Account acc = bank.createBankAccount(AccountType.CURRENT);
+        Assertions.assertNotEquals(null, bank.makeDeposit(acc.getID(), 200.0F));
+    }
+
+    @Test
+    public void makeDepositAndCheckTransactionAmountTest() {
+        BankSystem bank = new BankSystem();
+        Account acc = bank.createBankAccount(AccountType.CURRENT);
+        Transaction transaction = bank.makeDeposit(acc.getID(), 200.0F);
+        Assertions.assertEquals(200.0F, transaction.getAmount());
+    }
+
+    @Test
+    public void makeDepositAndCheckWrongTransactionAmountTest() {
+        BankSystem bank = new BankSystem();
+        Account acc = bank.createBankAccount(AccountType.CURRENT);
+        Transaction transaction = bank.makeDeposit(acc.getID(), 200.0F);
+        Assertions.assertNotEquals(0F, transaction.getAmount());
+    }
+
+    @Test
+    public void checkDepositIsLoggedCorrectlyTest() {
+        BankSystem bank = new BankSystem();
+        Account acc = bank.createBankAccount(AccountType.CURRENT);
+        Transaction transaction = bank.makeDeposit(acc.getID(), 200.0F);
+        Assertions.assertEquals(transaction.getID(), bank.getTransactionMap().get(acc.getID()).get(0).getID());
+    }
+
+    @Test
+    public void checkDepositIsLoggedCorrectlyTest2() {
+        BankSystem bank = new BankSystem();
+        Account acc = bank.createBankAccount(AccountType.CURRENT);
+        Transaction transaction1 = bank.makeDeposit(acc.getID(), 200.0F);
+        Transaction transaction2 = bank.makeDeposit(acc.getID(), 500.0F);
+        Assertions.assertEquals(transaction2.getAmount(), bank.getTransactionMap().get(acc.getID()).get(1).getAmount());
+    }
+
+    @Test
+    public void makeWithdrawalAndCheckTransactionAmountTest() {
+        BankSystem bank = new BankSystem();
+        Account acc = bank.createBankAccount(AccountType.CURRENT);
+        acc.deposit(500F);
+        Transaction transaction = bank.makeWithdrawal(acc.getID(), 400.0F);
+        Assertions.assertEquals(-400.0F, transaction.getAmount());
+    }
+
+    @Test
+    public void generateStatementTest() {
+        BankSystem bank = new BankSystem();
+        Account acc = bank.createBankAccount(AccountType.CURRENT);
+        bank.makeDeposit(acc.getID(), 200.0F);
+        bank.makeDeposit(acc.getID(), 500.0F);
+        bank.makeDeposit(acc.getID(), 500.0F);
+        bank.makeWithdrawal(acc.getID(), 300.0F);
+        System.out.println(bank.generateStatement(acc.getID()));
+    }
+
+    @Test
+    public void createOverdraftTest() {
+        BankSystem bank = new BankSystem();
+        Account acc = bank.createBankAccount(AccountType.CURRENT);
+        Assertions.assertEquals(0, bank.getOverdraftRequests().size());
+        bank.requestOverdraft(acc.getID(), 1000F);
+        Assertions.assertEquals(1, bank.getOverdraftRequests().size());
+    }
+
+    @Test
+    public void createOverdraftTest2() {
+        BankSystem bank = new BankSystem();
+        Account acc = bank.createBankAccount(AccountType.CURRENT);
+        bank.requestOverdraft(acc.getID(), 1000.0F);
+        Assertions.assertEquals(1000.0F, bank.getOverdraftRequests().get(acc.getID()));
+    }
+}

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

@@ -0,0 +1,28 @@
+package com.booleanuk.core;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class TransactionTest {
+
+    @Test
+    public void getRightAmountTest() {
+        Account acc = new Account(AccountType.CURRENT);
+        Transaction transaction = new Transaction(acc.getID(), 200.0F);
+        Assertions.assertEquals(200.0F, transaction.getAmount());
+    }
+
+    @Test
+    public void getWrongAmountTest() {
+        Account acc = new Account(AccountType.CURRENT);
+        Transaction transaction = new Transaction(acc.getID(), 200.0F);
+        Assertions.assertNotEquals(500.0F, transaction.getAmount());
+    }
+
+    @Test
+    public void getRightAccountTest() {
+        Account acc = new Account(AccountType.CURRENT);
+        Transaction transaction = new Transaction(acc.getID(), 200.0F);
+        Assertions.assertEquals(acc.getID(), transaction.getAccountID());
+    }
+}