Emma Lövgren

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

@@ -0,0 +1,116 @@
+package com.booleanuk.core.accounts;
+
+import com.booleanuk.core.idgenerator.IdGenerator;
+import com.booleanuk.core.idgenerator.IdPrefix;
+import com.booleanuk.core.transactons.Transaction;
+import com.booleanuk.core.transactons.TransactionType;
+
+import java.util.*;
+
+public abstract class Account {
+
+    private IdGenerator idGenerator;
+    private final String accountNumber;
+    private Branch branch;
+    private boolean isPossibleToOverdraft;
+    private Map<String, Transaction> transactions;
+
+    public Account(String accountNumber) {
+        this.idGenerator = new IdGenerator();
+        this.accountNumber = accountNumber;
+        this.transactions = new HashMap<>();
+    }
+
+    public String getAccountNumber() {
+        return this.accountNumber;
+    }
+
+    public Branch getBranch() {
+        return branch;
+    }
+
+    public void setBranch(Branch branch) {
+        this.branch = branch;
+    }
+
+    public boolean isPossibleToOverdraft() {
+        return isPossibleToOverdraft;
+    }
+
+    public void setPossibleToOverdraft(boolean possibleToOverdraft) {
+        isPossibleToOverdraft = possibleToOverdraft;
+    }
+
+    protected void addTransaction(Transaction transaction) {
+        this.transactions.put(transaction.getId(), transaction);
+    }
+
+    public void deposit(Double amount) {
+        Transaction transaction = new Transaction(
+                this.idGenerator.createId(IdPrefix.TR),
+                amount,
+                TransactionType.DEBIT,
+                calculateBalance()
+        );
+        this.addTransaction(transaction);
+    }
+
+    protected void validateOverdraft(Double currentBalance, Double withdrawAmount) throws Exception {
+        boolean isNegativeBalance = (currentBalance - withdrawAmount) < 0;
+        if (!this.isPossibleToOverdraft && isNegativeBalance) {
+
+            // TODO: should make custom exception
+
+            throw new Exception("Not possible to overdraft");
+        }
+    }
+
+    public void withdraw(Double amount) {
+        Double currentBalance = this.calculateBalance();
+        try {
+            this.validateOverdraft(currentBalance, amount);
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+        }
+
+        Transaction transaction = new Transaction(
+                this.idGenerator.createId(IdPrefix.TR),
+                amount,
+                TransactionType.CREDIT,
+                currentBalance
+        );
+        this.addTransaction(transaction);
+    }
+
+    public ArrayList<Transaction> getAllTransactions() {
+        ArrayList<Transaction> list = new ArrayList<>(transactions.values());
+        Collections.reverse(list);
+
+        return list;
+    }
+
+    protected Double calculateBalance() {
+        Double sum = 0.0;
+        for (Transaction transaction : transactions.values()) {
+            if (transaction.getType() == TransactionType.DEBIT) {
+                sum += transaction.getAmount();
+            } else if (transaction.getType() == TransactionType.CREDIT) {
+                sum -= transaction.getAmount();
+            }
+        }
+        return sum;
+    }
+
+    public Double getBalance() {
+        return calculateBalance();
+    }
+
+    // TODO: printTransactionHistory
+    public void printTransactionHistory() {
+        System.out.println();
+        System.out.printf("%s", "date", "||");
+        for (Transaction transaction : transactions.values()) {
+            System.out.println();
+        }
+    }
+}

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

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

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

@@ -0,0 +1,7 @@
+package com.booleanuk.core.accounts;
+
+public enum Branch {
+    BRANCH_1,
+    BRANCH_2,
+    BRANCH_3
+}

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

@@ -0,0 +1,13 @@
+package com.booleanuk.core.accounts;
+
+public class CurrentAccount extends Account{
+
+    // TODO: Could this constructor be protected?
+    //  should not be able to create without a Bank
+
+    public CurrentAccount(String accountNumber) {
+        super(accountNumber);
+        this.setBranch(Branch.BRANCH_1);
+        this.setPossibleToOverdraft(true);
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.booleanuk.core.accounts;
+
+public class SavingsAccount extends Account{
+
+    private Double interestRate;
+
+    // TODO: Could this constructor be protected?
+    //  should not be able to create without a Bank
+
+    public SavingsAccount(String accountNumber) {
+        super(accountNumber);
+        this.setBranch(Branch.BRANCH_1);
+        this.setPossibleToOverdraft(false);
+        this.interestRate = 0.12;
+    }
+}

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

@@ -0,0 +1,68 @@
+package com.booleanuk.core.bank;
+
+import com.booleanuk.core.accounts.Account;
+import com.booleanuk.core.accounts.AccountType;
+import com.booleanuk.core.accounts.CurrentAccount;
+import com.booleanuk.core.accounts.SavingsAccount;
+import com.booleanuk.core.idgenerator.IdGenerator;
+import com.booleanuk.core.idgenerator.IdPrefix;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Bank {
+
+    private IdGenerator idGenerator;
+    private Map<String, User> customers;
+    private Map<String, Request> requests;
+
+    public Bank() {
+        this.customers = new HashMap<>();
+        this.requests = new HashMap<>();
+        this.idGenerator = new IdGenerator();
+    }
+
+    public User createUser(String personalNumber) {
+        User customer = new User(personalNumber);
+        this.customers.put(personalNumber, customer);
+        return customer;
+    }
+
+    public void createUserAccount(User user, AccountType type) {
+
+        String id = idGenerator.createId(IdPrefix.AC);
+
+        if (type == AccountType.CURRENT) {
+            Account currentAccount = new CurrentAccount(id);
+            user.addAccount(currentAccount);
+
+        } else if (type == AccountType.SAVINGS) {
+            Account savingsAccount = new SavingsAccount(id);
+            user.addAccount(savingsAccount);
+        }
+    }
+
+    public ArrayList<Request> getAllRequests() {
+        ArrayList<Request> list = new ArrayList<>(requests.values());
+        Collections.reverse(list);
+
+        return list;
+    }
+
+    private void addRequest(Request request) {
+        this.requests.put(request.getId(), request);
+    }
+
+    public void makeRequest(Account account, Double overdraftSum) {
+        String id = this.idGenerator.createId(IdPrefix.RE);
+
+        Request request = new Request(id, account, overdraftSum);
+        this.addRequest(request);
+    }
+
+    private void removeRequest(String requestId) {
+        this.requests.remove(requestId);
+    }
+}

src/main/java/com/booleanuk/core/bank/Request.java

@@ -0,0 +1,32 @@
+package com.booleanuk.core.bank;
+
+import com.booleanuk.core.accounts.Account;
+
+public class Request {
+
+    private final String id;
+    private final Account account;
+    private Double overdraftSum;
+
+    public Request(String id, Account account, Double overdraftSum) {
+        this.id = id;
+        this.account = account;
+        this.overdraftSum = overdraftSum;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    // TODO: If time, add some function so the user can
+    //  validate if it's an reasonable amount of overdraft
+    //  with the overdraft sum
+
+    public void approve() {
+        this.account.setPossibleToOverdraft(true);
+    }
+
+    public void reject() {
+        this.account.setPossibleToOverdraft(false);
+    }
+}

src/main/java/com/booleanuk/core/bank/User.java

@@ -0,0 +1,33 @@
+package com.booleanuk.core.bank;
+
+import com.booleanuk.core.accounts.Account;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class User {
+
+    // TODO: Not safe to store personal numbers ike this, should be a uniqueId instead?
+    // It's personal number for now for simplicity
+
+    private String personalNumber;
+    private Map<String, Account> accounts;
+
+    public User(String personalNumber) {
+        this.personalNumber = personalNumber;
+        this.accounts = new HashMap<>();
+    }
+
+    protected void addAccount(Account account) {
+        this.accounts.put(account.getAccountNumber(), account);
+    }
+
+    public ArrayList<Account> getAllAccounts() {
+        ArrayList<Account> list = new ArrayList<>(accounts.values());
+//        Collections.reverse(list);
+
+        return list;
+    }
+}