diff --git a/src/main/java/com/booleanuk/core/Account.java b/src/main/java/com/booleanuk/core/Account.java new file mode 100644 index 000000000..d129c0c2b --- /dev/null +++ b/src/main/java/com/booleanuk/core/Account.java @@ -0,0 +1,15 @@ +package com.booleanuk.core; + +public interface Account { + + + BankStatement getBankstatement(); + boolean deposit(double amount); + boolean withdraw(double amount); + double getBalance(); + Enum getBranch(); + void setBranch(Enum newBranch); + boolean requestOverdraft(double amount); + + +} diff --git a/src/main/java/com/booleanuk/core/AccountOperation.java b/src/main/java/com/booleanuk/core/AccountOperation.java new file mode 100644 index 000000000..7a2e481ef --- /dev/null +++ b/src/main/java/com/booleanuk/core/AccountOperation.java @@ -0,0 +1,6 @@ +package com.booleanuk.core; + +public enum AccountOperation { + DEPOSIT, + WITHDRAW, +} diff --git a/src/main/java/com/booleanuk/core/BankStatement.java b/src/main/java/com/booleanuk/core/BankStatement.java new file mode 100644 index 000000000..6f1ebebb9 --- /dev/null +++ b/src/main/java/com/booleanuk/core/BankStatement.java @@ -0,0 +1,38 @@ +package com.booleanuk.core; + + +import java.util.ArrayList; +import java.util.List; +import static com.booleanuk.core.AccountOperation.*; + +public class BankStatement { + + private List transactions = new ArrayList<>(); + + public BankStatement(){ + + } + + public void printStatement(){ + + String x = String.format("%-15s || %-15s || %-15s || %s" , "date", "credit", "debit", "balance" ); + System.out.println(x); + + for (Transaction t : transactions){ + if(t.getType()==DEPOSIT) + System.out.printf("%-15s || %-15s || %-15s || %s%n", t.getDate(), 0 , t.getAmount(), t.getBalance() ); + else + System.out.printf("%-15s || %-15s || %-15s || %s%n", t.getDate(), t.getAmount() ,0 , t.getBalance() ); + + } + } + + + public boolean add(Transaction t){ + return transactions.add(t); + } + + public List getTransactions() { + return transactions; + } +} diff --git a/src/main/java/com/booleanuk/core/Branches.java b/src/main/java/com/booleanuk/core/Branches.java new file mode 100644 index 000000000..51120407f --- /dev/null +++ b/src/main/java/com/booleanuk/core/Branches.java @@ -0,0 +1,10 @@ +package com.booleanuk.core; + +public enum Branches { + + OSLO, + TRONDHEIM, + BERGEN, + + +} diff --git a/src/main/java/com/booleanuk/core/CurrentAccount.java b/src/main/java/com/booleanuk/core/CurrentAccount.java new file mode 100644 index 000000000..dbad6c3e7 --- /dev/null +++ b/src/main/java/com/booleanuk/core/CurrentAccount.java @@ -0,0 +1,73 @@ +package com.booleanuk.core; +import static com.booleanuk.core.AccountOperation.*; +import static com.booleanuk.core.Branches.*; + +public class CurrentAccount implements Account{ + + private double balance; + private Enum branch; + private final BankStatement bankStatement = new BankStatement(); + private final double OVERDRAFTLIMIT = -3000; + + public CurrentAccount(){ + balance = calculateBalance(); + this.branch = OSLO; + + } + + @Override + public BankStatement getBankstatement() { + return this.bankStatement; + } + + @Override + public boolean deposit(double amount) { + if(amount < 0 ) return false; + Transaction t = new Transaction(amount,this.balance+amount,DEPOSIT); + this.bankStatement.add(t); + this.balance+=amount; + return true; + } + + @Override + public boolean withdraw(double amount) { + if(amount < 0 || this.balance-amount < 0 ) return false; + Transaction t = new Transaction(amount,this.balance - amount, WITHDRAW); + bankStatement.add(t); + this.balance-=amount; + + return true; + } + + @Override + public double getBalance() { + return this.balance; + } + + @Override + public Enum getBranch() { + return this.branch; + } + + @Override + public void setBranch(Enum newBranch) { + this.branch = newBranch; + } + + private double calculateBalance(){ + + if(bankStatement.getTransactions().isEmpty()) + return 0; + + double sum = 0; + for (Transaction t : bankStatement.getTransactions()) + sum += t.getAmount(); + + return sum; + + } + + public boolean requestOverdraft(double amount){ + return this.balance-amount < OVERDRAFTLIMIT; + } +} diff --git a/src/main/java/com/booleanuk/core/Customer.java b/src/main/java/com/booleanuk/core/Customer.java new file mode 100644 index 000000000..6d8427a71 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Customer.java @@ -0,0 +1,76 @@ +package com.booleanuk.core; + + +public class Customer { + + private Account currentAccount; + private Account savingsAccount; + + public Customer(){ + + } + + public Account getCurrentAccount() { + return currentAccount; + } + + public Account getSavingsAccount() { + return savingsAccount; + } + + public boolean createCurrentAccount(){ + if(currentAccount != null) return false; + + currentAccount = new CurrentAccount(); + return true; + + } + + public boolean createSavingsAccount(){ + + if(savingsAccount != null) return false; + + savingsAccount = new SavingsAccount(); + + return true; + } + + public boolean deposit(Account ac, double amount){ + if(ac == null || amount < 0) + return false; + + ac.deposit(amount); + return true; + + } + + public boolean withdraw(Account ac, double amount){ + if(ac == null || amount < 0) + return false; + + ac.deposit(amount); + return true; + } + + public BankStatement getBankStatement(Account ac) { + return ac.getBankstatement(); + } + + public boolean changeAccountBranch(Account ac, Enum branch){ + if(ac==null) + return false; + + ac.setBranch(branch); + return true; + } + + + public boolean requestOverdraft(double amount){ + + return !currentAccount.requestOverdraft(amount); + + } + + + +} diff --git a/src/main/java/com/booleanuk/core/Models/Class_Diagram.png b/src/main/java/com/booleanuk/core/Models/Class_Diagram.png new file mode 100644 index 000000000..7bb8c7b6a Binary files /dev/null and b/src/main/java/com/booleanuk/core/Models/Class_Diagram.png differ diff --git a/src/main/java/com/booleanuk/core/Models/domain_model.md b/src/main/java/com/booleanuk/core/Models/domain_model.md new file mode 100644 index 000000000..6449b28a3 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Models/domain_model.md @@ -0,0 +1,25 @@ + + +| Classes | Methods | Scenario | Outputs | +| ------------- | ------------------------------------------ | ----------------------------------------------------- | ----------------------------------- | +| | | | | +| Account | boolean deposit(double amount) | amount is positive | true | +| | | amount is negative | false | +| Account | boolean withdraw(double amount) | amount is less than current balance | true | +| | | amount is greater than current balance | false | +| Account | createCurrentAccount() | customer already has current account | false | +| | | customer dosen't have current account | true | +| Account | createSavingsAccount() | customer already has savings account | false | +| | | customer dosen't have savings account | true | +| Account | BankStatement getBankStatement(Account ac) | account is created and there exists an bank statement | bankstatement with all transactions | +| | | account dosen't exist | null | +| | | bank statement dosen't exist | null | +| BankStatement | List\getTransactoins() | if there exists transactions | List of all transactions | +| | | no transactions exists | null | +| Account | boolean requestOverdarft(double amount) | amount does not go past limit | true | +| | | amount exceeds limit | false | +| | | | | +| | | | | +| | | | | +| | | | | + diff --git a/src/main/java/com/booleanuk/core/SavingsAccount.java b/src/main/java/com/booleanuk/core/SavingsAccount.java new file mode 100644 index 000000000..5ecb8f76e --- /dev/null +++ b/src/main/java/com/booleanuk/core/SavingsAccount.java @@ -0,0 +1,76 @@ +package com.booleanuk.core; + +import static com.booleanuk.core.AccountOperation.DEPOSIT; +import static com.booleanuk.core.AccountOperation.WITHDRAW; + +public class SavingsAccount implements Account{ + + + private double balance; + private Enum branch; + private final BankStatement bankStatement = new BankStatement(); + + public SavingsAccount(){ + balance = calculateBalance(); + + } + + @Override + public BankStatement getBankstatement() { + return this.bankStatement; + } + + @Override + public boolean deposit(double amount) { + if(amount < 0 ) return false; + Transaction t = new Transaction(amount,this.balance+amount,DEPOSIT); + this.bankStatement.add(t); + this.balance+=amount; + return true; + } + + @Override + public boolean withdraw(double amount) { + double negative = amount * -1; + if(amount < 0 || this.balance-amount < 0 ) return false; + Transaction t = new Transaction(negative,this.balance + negative, WITHDRAW); + bankStatement.add(t); + this.balance-=amount; + + return true; + } + + @Override + public double getBalance() { + return this.balance; + } + + @Override + public Enum getBranch() { + return this.branch; + } + + @Override + public void setBranch(Enum newBranch) { + this.branch = newBranch; + } + + @Override + public boolean requestOverdraft(double amount) { + return false; + } + + private double calculateBalance(){ + + if(bankStatement.getTransactions().isEmpty()) + return 0; + + double sum = 0; + for (Transaction t : bankStatement.getTransactions()) + sum += t.getAmount(); + + return sum; + + } + +} diff --git a/src/main/java/com/booleanuk/core/Transaction.java b/src/main/java/com/booleanuk/core/Transaction.java new file mode 100644 index 000000000..bfc09cb39 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Transaction.java @@ -0,0 +1,41 @@ +package com.booleanuk.core; + +import java.time.LocalDate; + +public class Transaction { + + + private LocalDate date = LocalDate.now(); + private double amount; + private double balance; + private Enum type; + + public Transaction(double amount, double balance, Enumtype) { + this.amount = amount; + this.balance = balance; + this.type = type; + } + + public double getBalance() { + return balance; + } + + + public double getAmount() { + return amount; + } + + + public LocalDate getDate() { + return date; + } + + + public Enum getType() { + return type; + } + + public void setType(Enum type) { + this.type = type; + } +} diff --git a/src/test/java/com/booleanuk/core/BankTest.java b/src/test/java/com/booleanuk/core/BankTest.java new file mode 100644 index 000000000..a63fa8961 --- /dev/null +++ b/src/test/java/com/booleanuk/core/BankTest.java @@ -0,0 +1,136 @@ +package com.booleanuk.core; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static com.booleanuk.core.AccountOperation.*; + +public class BankTest { + + private Account currentAccount = new CurrentAccount(); + + @Test + void deposit(){ + + currentAccount.deposit(25); + Assertions.assertEquals(25,currentAccount.getBalance()); + } + + @Test + void withdraw(){ + + currentAccount.deposit(50); + currentAccount.withdraw(25); + Assertions.assertEquals(25,currentAccount.getBalance()); + } + + @Test + void depositNegative(){ + boolean answer = currentAccount.deposit(-50); + Assertions.assertFalse(answer); + } + + @Test + void withdrawNegative(){ + + currentAccount.deposit(50); + boolean answer = currentAccount.withdraw(100); + Assertions.assertFalse(answer); + } + + @Test + void createAccount(){ + + Customer c1 = new Customer(); + Assertions.assertTrue(c1.createCurrentAccount()); + Assertions.assertTrue(c1.createSavingsAccount()); + } + + @Test + void createAccountTwice(){ + + Customer c1 = new Customer(); + c1.createCurrentAccount(); + c1.createSavingsAccount(); + Assertions.assertFalse(c1.createCurrentAccount()); + Assertions.assertFalse(c1.createSavingsAccount()); + } + + + @Test + void createTransaction(){ + + Customer customer = new Customer(); + customer.createCurrentAccount(); + customer.deposit(customer.getCurrentAccount(), 50); + + BankStatement b = customer.getBankStatement(customer.getCurrentAccount()); + Assertions.assertTrue(b.getTransactions().size()>0); + } + + @Test + void getBalance(){ + + Account ac = new CurrentAccount(); + ac.deposit(1000); + Assertions.assertEquals(1000,ac.getBalance()); + } + + + @Test + void checkTransactions(){ + + + Account account = new CurrentAccount(); + + account.deposit(1000); + account.deposit(2000); + account.withdraw(500); + BankStatement b = account.getBankstatement(); + List tList = b.getTransactions(); + Transaction depositTransaction1 = tList.get(0); + Transaction depositTransaction2 = tList.get(1); + Transaction withdrawTransaction = tList.get(2); + + Assertions.assertEquals(1_000,depositTransaction1.getBalance()); + Assertions.assertEquals(1_000,depositTransaction1.getAmount()); + Assertions.assertEquals(2_000,depositTransaction2.getAmount()); + Assertions.assertEquals(3_000,depositTransaction2.getBalance()); + Assertions.assertEquals(2_500,withdrawTransaction.getBalance()); + Assertions.assertEquals(500,withdrawTransaction.getAmount()); + + + } + + + @Test + void print(){ + + Transaction t1 = new Transaction(1000,1500,DEPOSIT); + Transaction t2 = new Transaction(500,1000,WITHDRAW); + + BankStatement bankStatement = new BankStatement(); + bankStatement.add(t1); + bankStatement.add(t2); + + bankStatement.printStatement(); + Assertions.assertTrue(true); + + } + + @Test + void overdraft(){ + + Customer c1 = new Customer(); + c1.createCurrentAccount(); + c1.deposit(c1.getCurrentAccount(),100); + + Assertions.assertTrue(c1.requestOverdraft(400)); + Assertions.assertFalse(c1.requestOverdraft(3200)); + + } + + +}