Checkbook/Checkbook.iml

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_8">
-    <output url="file://$MODULE_DIR$/target/classes" />
-    <output-test url="file://$MODULE_DIR$/target/test-classes" />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
-      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
-      <excludeFolder url="file://$MODULE_DIR$/target" />
-    </content>
-    <orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="Maven: junit:junit:4.0" level="project" />
-  </component>
-</module>

Checkbook/src/main/java/Checkbook.java

@@ -1,5 +1,149 @@
+import java.lang.reflect.ParameterizedType;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 public class Checkbook {
 
     //blind us with your Java eloquence....
 
+    private List<Transaction> debitTransactions;
+    private List<Transaction> creditTransactions;
+
+    Payee owner;
+    double cashAmount;
+
+    Checkbook(){
+        new Checkbook(0);
+    }
+
+    Checkbook(double cashAmount){
+        new Checkbook(new Payee(),cashAmount);
+    }
+
+    Checkbook(Payee owner, double cashAmount){
+        this.owner = owner;
+        this.cashAmount = cashAmount;
+        debitTransactions = new ArrayList<>();
+        creditTransactions = new ArrayList<>();
+    }
+
+    public boolean add(Transaction element){
+        if (element.getType() == null) return false;
+        if (element.getType().equals(TransactionType.DEBIT))
+            return debitTransactions.add(element);
+        else return creditTransactions.add(element);
+    }
+
+    public int size(){
+        return debitTransactions.size() + creditTransactions.size();
+    }
+
+    public boolean isEmpty(){
+        return debitTransactions.isEmpty() && creditTransactions.isEmpty();
+    }
+
+    public boolean contains(Transaction element){
+        return debitTransactions.contains(element) || creditTransactions.contains(element);
+    }
+
+    public boolean remove(Transaction element){
+        return debitTransactions.remove(element) || creditTransactions.remove(element);
+    }
+
+    public doubleRater iterator(){
+        return new doubleRater();
+    }
+
+    public Transaction[] toArray(){
+        return Stream.concat(debitTransactions.stream(),creditTransactions.stream()).toArray(Transaction[]::new);
+    }
+
+    public Transaction[] toArray(Transaction[] array){
+        List<Transaction> list = Stream.concat(debitTransactions.stream(),creditTransactions.stream())
+                .collect(Collectors.toList());
+        return list.toArray(array);
+    }
+
+    public double checkbookValue(){
+        double sum = debitTransactions.stream().mapToDouble(Transaction::getAmount).sum();
+        sum += creditTransactions.stream().mapToDouble(Transaction::getAmount).sum();
+        return sum;
+    }
+
+    public Transaction[] getTransactionsForDate(LocalDate aDate){
+        return Arrays.stream(toArray()).filter(e -> e.getDate().equals(aDate)).toArray(Transaction[]::new);
+    }
+
+    public Transaction[] getAllDebitTransactions(){
+        return debitTransactions.toArray(new Transaction[0]);
+    }
+
+    public Transaction[] getAllCreditTransactions(){
+        return creditTransactions.toArray(new Transaction[0]);
+    }
+
+    public boolean containsAll(Collection c){
+        return Stream.concat(debitTransactions.stream(),creditTransactions.stream())
+                .collect(Collectors.toList()).containsAll(c);
+    }
+
+    public boolean addAll(Collection c){
+        for (Object o : c){
+            if (!o.getClass().getSimpleName().equals("Transaction"))
+                return false;
+            add((Transaction) o);
+        }
+        return true;
+    }
+
+    public boolean removeAll(Collection c){
+        int size = size();
+        for (Object o : c)
+            remove((Transaction) o);
+        return size != size();
+    }
+
+    public void clear(){
+        debitTransactions.clear();
+        creditTransactions.clear();
+    }
+
+    private class doubleRater implements Iterator<Transaction> {
+        private final List<Iterator<Transaction>> list;
+        private final Iterator<Iterator<Transaction>> it;
+        private Iterator<Transaction> current;
+
+        doubleRater(){
+            list = new ArrayList<>();
+            list.add(debitTransactions.iterator());
+            list.add(creditTransactions.iterator());
+            it = list.iterator();
+            current = it.next();
+        }
+
+
+        @Override
+        public boolean hasNext() {
+            checkIterator();
+            return current.hasNext();
+        }
+
+        @Override
+        public Transaction next() {
+            checkIterator();
+            return current.next();
+        }
+
+        @Override
+        public void remove() {
+            current.remove();
+        }
+
+        private void checkIterator(){
+            if (!current.hasNext() && it.hasNext())
+                current = it.next();
+        }
+    }
 }

Checkbook/src/main/java/GenericAccount.java

@@ -1,3 +1,91 @@
+import java.lang.reflect.Array;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
-public class GenericAccount {
+public class GenericAccount<T extends AccountBook> {
+    private List<T> transactions;
+
+    Payee owner;
+    double cashAmount;
+
+    GenericAccount(){
+        new GenericAccount<>(0);
+    }
+
+    GenericAccount(double cashAmount){
+        new GenericAccount<>(new Payee(),cashAmount);
+    }
+
+    GenericAccount(Payee owner, double cashAmount){
+        this.owner = owner;
+        this.cashAmount = cashAmount;
+        transactions = new ArrayList<>();
+    }
+
+    public boolean add(T element){
+        return transactions.add(element);
+    }
+
+    public int size(){
+        return transactions.size();
+    }
+
+    public boolean isEmpty(){
+        return transactions.isEmpty();
+    }
+
+    public boolean contains(T element){
+        return transactions.contains(element);
+    }
+
+    public boolean remove(T element){
+        return transactions.remove(element);
+    }
+
+    public Iterator<T> iterator(){
+        return transactions.iterator();
+    }
+
+    public T[] toArray(){
+        Class clazz = transactions.get(0).getClass();
+        T[] array = (T[]) Array.newInstance(clazz,size());
+        for (int i=0; i<array.length; i++)
+            array[i] = transactions.get(i);
+        return array;
+    }
+
+    public T[] toArray(T[] array){
+        return transactions.toArray(array);
+    }
+
+    public double checkbookValue(){
+        return transactions.stream().mapToDouble(T::getAmount).sum();
+    }
+
+    public T[] getTransactionsForDate(LocalDate aDate){
+        long sum = transactions.stream().filter(e -> e.getDate().equals(aDate)).count();
+        Class clazz = transactions.get(0).getClass();
+        T[] array = (T[]) Array.newInstance(clazz,(int) sum);
+        for (int i=0; i<array.length; i++)
+            array[i] = transactions.get(i);
+        return array;
+    }
+
+    public boolean containsAll(Collection c){
+        return transactions.containsAll(c);
+    }
+
+    public boolean addAll(Collection c){
+        return transactions.addAll(c);
+    }
+
+    public boolean removeAll(Collection c){
+        return transactions.removeAll(c);
+    }
+
+    public void clear(){
+        transactions.clear();
+    }
 }

Checkbook/src/main/java/Transaction.java

@@ -1,9 +1,10 @@
 import java.time.LocalDate;
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicReference;
 
-public class Transaction {
+public class Transaction implements AccountBook{
     private final AtomicReference<Integer> id = new AtomicReference<Integer>();
-    private final AtomicReference<LocalDate> date = new AtomicReference<LocalDate>();
+    private final AtomicReference<LocalDate> date = new AtomicReference<LocalDate>(LocalDate.now());
     private String memo;
     private Payee payee;
     private TransactionType typee; // Credit (reduces the checkbook), Debit (increases the checkbook)
@@ -50,4 +51,22 @@ public class Transaction {
         }
         return (-1.0 * amount);
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Transaction that = (Transaction) o;
+        return Objects.equals(id.get(), that.id.get()) &&
+                Objects.equals(date.get(), that.date.get()) &&
+                Objects.equals(memo, that.memo) &&
+                Objects.equals(payee, that.payee) &&
+                typee == that.typee &&
+                Objects.equals(amount, that.amount);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, date, memo, payee, typee, amount);
+    }
 }

Checkbook/src/test/java/CheckbookTest.java

@@ -1,12 +1,171 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
 import static org.junit.Assert.*;
 
 public class CheckbookTest {
 
+    Checkbook checkbook;
+    Payee owner;
+    Transaction transaction;
+
     @org.junit.Before
     public void setUp() throws Exception {
+        checkbook = new Checkbook(owner,100);
+        transaction = new Transaction("-",owner,TransactionType.DEBIT,1.0);
     }
 
     @org.junit.After
     public void tearDown() throws Exception {
     }
+
+    @Test
+    public void testIsEmpty(){
+        Assert.assertTrue(checkbook.isEmpty());
+    }
+
+    @Test
+    public void testAdd(){
+        checkbook.add(transaction);
+        Assert.assertEquals(1,checkbook.size());
+    }
+
+    @Test
+    public void testContains(){
+        checkbook.add(transaction);
+        Assert.assertTrue(checkbook.contains(transaction));
+    }
+
+    @Test
+    public void testRemove(){
+        checkbook.add(transaction);
+        Assert.assertTrue(checkbook.remove(transaction));
+    }
+
+    @Test
+    public void testIterator(){
+        Assert.assertNotNull(checkbook.iterator());
+    }
+
+    @Test
+    public void testIteratorIterates(){
+        createTransactions();
+
+        Iterator<Transaction> it = checkbook.iterator();
+
+        double sum = 0;
+        while(it.hasNext())
+            sum += it.next().getAmount();
+
+        Assert.assertEquals(8.0,sum);
+    }
+
+    @Test
+    public void testToArray(){
+        createTransactions();
+
+        Transaction[] transactionsArray = checkbook.toArray();
+        assertEquals(8, transactionsArray.length);
+    }
+
+    @Test
+    public void testToArray2(){
+        Transaction[] t = new Transaction[]{transaction};
+        createTransactions();
+
+        Transaction[] transactionsArray = checkbook.toArray(t);
+        assertEquals(8, transactionsArray.length);
+    }
+
+    @Test
+    public void testCheckbookValue(){
+        createTransactions();
+        Assert.assertEquals(8.0,checkbook.checkbookValue());
+    }
+
+    @Test
+    public void testGetTransactionsForDate(){
+        createTransactions();
+        Assert.assertEquals(8,checkbook.getTransactionsForDate(LocalDate.of(2018,12,8)).length);
+    }
+
+    @Test
+    public void testGetAllDebitTransactions(){
+        createTransactions();
+        Assert.assertEquals(4,checkbook.getAllDebitTransactions().length);
+    }
+
+    @Test
+    public void testGetAllCreditTransactions(){
+        createTransactions();
+        Assert.assertEquals(4,checkbook.getAllCreditTransactions().length);
+    }
+
+    @Test
+    public void testContainsAll(){
+        createTransactions();
+        List<Transaction> list = new ArrayList<>();
+        Transaction t1 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        Transaction t2 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        list.add(t1);
+        list.add(t2);
+
+        Assert.assertTrue("doesn't contain", checkbook.containsAll(list));
+
+    }
+
+    @Test
+    public void testAddAll(){
+        createTransactions();
+        List<Transaction> list = new ArrayList<>();
+        Transaction t1 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        Transaction t2 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        list.add(t1);
+        list.add(t2);
+
+        Assert.assertTrue("doesn't contain", checkbook.addAll(list));
+    }
+
+    @Test
+    public void testRemoveAll(){
+        createTransactions();
+        List<Transaction> list = new ArrayList<>();
+        Transaction t1 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        Transaction t2 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        list.add(t1);
+        list.add(t2);
+
+        Assert.assertTrue(checkbook.removeAll(list));
+    }
+
+    @Test
+    public void testClear(){
+        createTransactions();
+        checkbook.clear();
+        Assert.assertEquals(0,checkbook.size());
+    }
+
+    public void createTransactions(){
+        owner = new Payee();
+        owner.setGivenName("Will");
+        owner.setFamilyName("Smith");
+
+        Payee person = new Payee();
+        person.setFamilyName("Jackson");
+        person.setGivenName("Jet");
+
+        for (int i=0; i<4; i++) {
+            Transaction t1 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+            Transaction t2 = new Transaction("--", person, TransactionType.CREDIT, 2.0);
+
+            checkbook.add(t1);
+            checkbook.add(t2);
+        }
+    }
+
 }

Checkbook/src/test/java/GenericAccountTest.java

@@ -0,0 +1,157 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class GenericAccountTest {
+    GenericAccount<Transaction> genAccount;
+    Payee owner;
+    Transaction transaction;
+
+    @org.junit.Before
+    public void setUp() throws Exception {
+        genAccount = new GenericAccount<>(owner,100);
+        transaction = new Transaction("-",owner,TransactionType.DEBIT,1.0);
+    }
+
+    @org.junit.After
+    public void tearDown() throws Exception {
+    }
+
+    @Test
+    public void testIsEmpty(){
+        Assert.assertTrue(genAccount.isEmpty());
+    }
+
+    @Test
+    public void testAdd(){
+        genAccount.add(transaction);
+        Assert.assertEquals(1,genAccount.size());
+    }
+
+    @Test
+    public void testContains(){
+        genAccount.add(transaction);
+        Assert.assertTrue(genAccount.contains(transaction));
+    }
+
+    @Test
+    public void testRemove(){
+        genAccount.add(transaction);
+        Assert.assertTrue(genAccount.remove(transaction));
+    }
+
+    @Test
+    public void testIterator(){
+        Assert.assertNotNull(genAccount.iterator());
+    }
+
+    @Test
+    public void testIteratorIterates(){
+        createTransactions();
+
+        Iterator<Transaction> it = genAccount.iterator();
+
+        double sum = 0;
+        while(it.hasNext())
+            sum += it.next().getAmount();
+
+        Assert.assertEquals(8.0,sum);
+    }
+
+    @Test
+    public void testToArray(){
+        createTransactions();
+
+        Transaction[] transactionsArray = genAccount.toArray();
+        assertEquals(8, transactionsArray.length);
+    }
+
+    @Test
+    public void testToArray2(){
+        Transaction[] t = new Transaction[]{transaction};
+        createTransactions();
+
+        Transaction[] transactionsArray = genAccount.toArray(t);
+        assertEquals(8, transactionsArray.length);
+    }
+
+    @Test
+    public void testCheckbookValue(){
+        createTransactions();
+        Assert.assertEquals(8.0,genAccount.checkbookValue());
+    }
+
+    @Test
+    public void testGetTransactionsForDate(){
+        createTransactions();
+        Assert.assertEquals(8,genAccount.getTransactionsForDate(LocalDate.of(2018,12,8)).length);
+    }
+
+    @Test
+    public void testContainsAll(){
+        createTransactions();
+        List<Transaction> list = new ArrayList<>();
+        Transaction t1 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        Transaction t2 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        list.add(t1);
+        list.add(t2);
+
+        Assert.assertTrue("doesn't contain", genAccount.containsAll(list));
+
+    }
+
+    @Test
+    public void testAddAll(){
+        createTransactions();
+        List<Transaction> list = new ArrayList<>();
+        Transaction t1 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        Transaction t2 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        list.add(t1);
+        list.add(t2);
+
+        Assert.assertTrue("doesn't contain", genAccount.addAll(list));
+    }
+
+    @Test
+    public void testRemoveAll(){
+        createTransactions();
+        List<Transaction> list = new ArrayList<>();
+        Transaction t1 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        Transaction t2 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+        list.add(t1);
+        list.add(t2);
+
+        Assert.assertTrue(genAccount.removeAll(list));
+    }
+
+    @Test
+    public void testClear(){
+        createTransactions();
+        genAccount.clear();
+        Assert.assertEquals(0,genAccount.size());
+    }
+
+    public void createTransactions(){
+        owner = new Payee();
+        owner.setGivenName("Will");
+        owner.setFamilyName("Smith");
+
+        Payee person = new Payee();
+        person.setFamilyName("Jackson");
+        person.setGivenName("Jet");
+
+        for (int i=0; i<4; i++) {
+            Transaction t1 = new Transaction("--", owner, TransactionType.DEBIT, 4.0);
+            Transaction t2 = new Transaction("--", person, TransactionType.CREDIT, 2.0);
+
+            genAccount.add(t1);
+            genAccount.add(t2);
+        }
+    }
+}