diff --git a/src/main/java/com/booleanuk/core/Basket.java b/src/main/java/com/booleanuk/core/Basket.java new file mode 100644 index 000000000..b9381f0ec --- /dev/null +++ b/src/main/java/com/booleanuk/core/Basket.java @@ -0,0 +1,108 @@ +package com.booleanuk.core; + +import com.booleanuk.core.Items.Bagel; +import com.booleanuk.core.Items.Item; + +import java.util.ArrayList; +import java.util.List; + + +public class Basket { + + public static int capacity = 8; + + private Inventory storeInventory; + + private List itemsInBasket = new ArrayList<>(); + + + public Basket(){ + + } + + public int getCapacity() { + return capacity; + } + + public boolean setCapacity(int capacity) { + if(capacity>0) { + Basket.capacity = capacity; + return true; + } + + return false; + } + + public Inventory getStoreInventory() { + return storeInventory; + } + + public void setStoreInventory(Inventory storeInventory) { + this.storeInventory = storeInventory; + } + + public List getItemsInBasket() { + return itemsInBasket; + } + + public void setItemsInBasket(List itemsInBasket) { + this.itemsInBasket = itemsInBasket; + } + + public double sum(){ + + + + double sum = 0; + for (Item item : itemsInBasket) { + sum+=item.getPrice(); + } + + return sum; + + } + public boolean add(Item i)throws NullPointerException{ + if(i.getID() == null || i.getID().isEmpty() || i.getVariant().isEmpty() || i.getPrice()<=0) + return false; + + return this.itemsInBasket.add(i); + } + + public boolean remove(Item i){ + + return this.itemsInBasket.remove(i); + + } + + public boolean isFull() { + return this.itemsInBasket.size() == capacity; + } + + public Item getItem(Item i){ + return i; + } + + public double costOfBagel(Item i){ + + return i.getPrice(); + } + + public Bagel getBagel(){ + + for (Item i: this.itemsInBasket){ + if (i instanceof Bagel) + return (Bagel)i; + } + + return null; + } + + + + public boolean hasDiscount(){ + + return false; + } + + +} diff --git a/src/main/java/com/booleanuk/core/Domain_ClassDiagram/Class_Diagram.png b/src/main/java/com/booleanuk/core/Domain_ClassDiagram/Class_Diagram.png new file mode 100644 index 000000000..638188755 Binary files /dev/null and b/src/main/java/com/booleanuk/core/Domain_ClassDiagram/Class_Diagram.png differ diff --git a/src/main/java/com/booleanuk/core/Domain_ClassDiagram/Domain_Model.md b/src/main/java/com/booleanuk/core/Domain_ClassDiagram/Domain_Model.md new file mode 100644 index 000000000..37113fc21 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Domain_ClassDiagram/Domain_Model.md @@ -0,0 +1,39 @@ + + +| Classes | Methods | Scenario | Outputs | +| --------- | --------------------------------------- | ------------------------- | ---------------- | +| | | | | +| Member | boolean addToBasket(String ID) | id exists | true | +| | | id dosen't exist | false | +| | | id is null | false | +| Member | boolean removeFromBasket(String ID) | id exists | true | +| | | id dosen't exist | false | +| | | id is null | false | +| Member | boolean isBasketFull() | basket is full | true | +| | | basket is not full | false | +| Customer | double getTotalCost() | items in basket | total cost | +| | | no items in basket | 0 | +| Customer | double getCostOfBagel(String ID) | ID exists | cost of bagel | +| | | ID dosen't exist | 0 | +| | | ID is null | 0 | +| Customer | boolean chooseFilling(String ID) | ID exists | true | +| | | ID dosen't exist | false | +| | | ID is null | null | +| Manager | boolean ChangeCapacity(int newCapacity) | newCapacity is positive | true | +| | | newCapacity is negative | false | +| Manager | boolean addItemToStore(Item i) | item is valid type | true | +| | | item is null | false | +| Basket | double sum() | basket has items | total cost | +| | | basket is empty | 0 | +| Basket | boolean add(Item i) | Item is valid | true | +| | | item is null | false | +| Basket | boolean remove(Item i) | Item exists | true | +| | | item dosen't exist | false | +| Inventory | Item getSpecificItem(String ID) | ID is valid | Item | +| | | ID dosen't exist | null | +| | | ID is null | null | +| Inventory | int getQuantity(Item i) | we have many of that item | integer quantity | +| | | we have 0 | 0 | +| Basket | boolean hasDiscount() | enough items for discount | true | +| | | no items | false | + diff --git a/src/main/java/com/booleanuk/core/Inventory.java b/src/main/java/com/booleanuk/core/Inventory.java new file mode 100644 index 000000000..cc6b5519b --- /dev/null +++ b/src/main/java/com/booleanuk/core/Inventory.java @@ -0,0 +1,86 @@ +package com.booleanuk.core; + +import com.booleanuk.core.Items.Bagel; +import com.booleanuk.core.Items.Coffee; +import com.booleanuk.core.Items.Filling; +import com.booleanuk.core.Items.Item; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Set; + +import static com.booleanuk.core.Items.BagelVariants.ONION; +import static com.booleanuk.core.Items.CoffeeVariants.BLACK; +import static com.booleanuk.core.Items.FillingVariants.CREAM_CHEESE; + +public class Inventory { + + + private HashMap items = new HashMap<>(); + private Set keys; + + public Inventory(){ + Item bagel = new Bagel( ONION); + Item filling = new Filling(CREAM_CHEESE); + Item coffee = new Coffee(BLACK); + items.put(bagel,1); + items.put(coffee,1); + items.put(filling,1); + this.keys = items.keySet(); + } + + public Inventory(HashMap items){ + + this.items = items; + this.keys = items.keySet(); + } + + + public Set getAllItems(){ + + return items.keySet(); + + } + + public Item getSpecificItem(String ID){ + Item specificItem = null; + for(Item item : keys){ + if(item.getID().equals(ID)) { + specificItem = item; + break; + } + } + + return specificItem; + + } + + public int getQuantity(Item i){ + + return items.get(i); + } + public boolean add(Item item, int quantity){ + + if(quantity<0) + return false; + + if(items.containsKey(item)) { + int oldQuantity = items.get(item); + items.put(item,oldQuantity+quantity); + } + else{ + items.put(item,quantity); + } + keys = items.keySet(); + + return true; + + } + + + + + + + +} diff --git a/src/main/java/com/booleanuk/core/Items/Bagel.java b/src/main/java/com/booleanuk/core/Items/Bagel.java new file mode 100644 index 000000000..bfd8b7be1 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Items/Bagel.java @@ -0,0 +1,55 @@ +package com.booleanuk.core.Items; + +import java.util.List; + +import static com.booleanuk.core.Items.BagelVariants.*; + +public class Bagel implements Item{ + + + private double price; + private String ID; + private Enum variant; + private Filling filling; + + public Bagel(){ + + } + + public Bagel(Enum variant){ + this.variant = variant; + this.price = setPrice(variant); + this.ID = setId(variant); + + } + + public Filling getFilling() { + return filling; + } + + public void setFilling(Filling filling) { + this.filling = filling; + } + + public double getPrice() { + return this.price; + } + public double setPrice(Enum variant){ + return variant.equals(PLAIN) ? 0.39 : 0.49; + } + + public String getID() { + return this.ID; + } + + public String getVariant() { + return this.variant.name(); + } + + private String setId(Enum variant){ + + return variant.equals(ONION)? "BGLO" : + variant.equals(PLAIN)? "BGLP": + variant.equals(EVERYTHING) ? "BGLE" : "BGLS"; + } +} diff --git a/src/main/java/com/booleanuk/core/Items/BagelVariants.java b/src/main/java/com/booleanuk/core/Items/BagelVariants.java new file mode 100644 index 000000000..0159b9fb4 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Items/BagelVariants.java @@ -0,0 +1,8 @@ +package com.booleanuk.core.Items; + +public enum BagelVariants { + ONION, + PLAIN, + EVERYTHING, + SESAME, +} diff --git a/src/main/java/com/booleanuk/core/Items/Coffee.java b/src/main/java/com/booleanuk/core/Items/Coffee.java new file mode 100644 index 000000000..c82a32a29 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Items/Coffee.java @@ -0,0 +1,47 @@ +package com.booleanuk.core.Items; + +import static com.booleanuk.core.Items.CoffeeVariants.*; + +public class Coffee implements Item{ + + + private double price; + private String ID; + private Enum variant; + + public Coffee(){ + + } + + public Coffee(Enum variant) { + this.variant = variant; + this.ID = setId(variant); + this.price = setPrice(variant); + } + + @Override + public double getPrice() { + return this.price ; + } + + @Override + public String getID() { + return this.ID; + } + + @Override + public String getVariant() { + return this.variant.name(); + } + public double setPrice(Enumvariant){ + + return variant.equals(BLACK) ? 0.99 + : variant.equals(WHITE) ? 1.19 : 1.29; + } + private String setId(Enum coffeeVariant){ + + return coffeeVariant.equals(BLACK)? "COFB" : + coffeeVariant.equals(WHITE)? "COFW": + coffeeVariant.equals(CAPUCCINO) ? "COFC" : "COFL"; + } +} diff --git a/src/main/java/com/booleanuk/core/Items/CoffeeVariants.java b/src/main/java/com/booleanuk/core/Items/CoffeeVariants.java new file mode 100644 index 000000000..dda850f1e --- /dev/null +++ b/src/main/java/com/booleanuk/core/Items/CoffeeVariants.java @@ -0,0 +1,9 @@ +package com.booleanuk.core.Items; + +public enum CoffeeVariants { + + BLACK, + WHITE, + CAPUCCINO, + LATTE, +} diff --git a/src/main/java/com/booleanuk/core/Items/Filling.java b/src/main/java/com/booleanuk/core/Items/Filling.java new file mode 100644 index 000000000..4c0020983 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Items/Filling.java @@ -0,0 +1,41 @@ +package com.booleanuk.core.Items; + +import static com.booleanuk.core.Items.FillingVariants.*; + +public class Filling implements Item{ + + + private double price = 0.12; + private String ID; + private Enum variant; + + public Filling(Enum variant) { + this.variant = variant; + this.ID = setId(variant); + } + + @Override + public double getPrice() { + return this.price; + } + + @Override + public String getID() { + return this.ID; + } + + @Override + public String getVariant() { + return this.variant.name(); + } + + + private String setId(Enum fillingVariant){ + return + fillingVariant.equals(BACON)? "FILB" + : fillingVariant.equals(EGG)? "FILE" + : fillingVariant.equals(CHEESE)? "FILC" + : fillingVariant.equals(CREAM_CHEESE)? "FILX" + : fillingVariant.equals(SMOKED_SALMON)? "FILS":"FILH"; + } +} diff --git a/src/main/java/com/booleanuk/core/Items/FillingVariants.java b/src/main/java/com/booleanuk/core/Items/FillingVariants.java new file mode 100644 index 000000000..79a7e1619 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Items/FillingVariants.java @@ -0,0 +1,11 @@ +package com.booleanuk.core.Items; + +public enum FillingVariants { + + BACON, + EGG, + CHEESE, + CREAM_CHEESE, + SMOKED_SALMON, + HAM, +} diff --git a/src/main/java/com/booleanuk/core/Items/Item.java b/src/main/java/com/booleanuk/core/Items/Item.java new file mode 100644 index 000000000..38c5f09f7 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Items/Item.java @@ -0,0 +1,16 @@ +package com.booleanuk.core.Items; + +public interface Item { + + + + double getPrice(); + + String getID(); + + String getVariant(); + + + + +} \ No newline at end of file diff --git a/src/main/java/com/booleanuk/core/Person/Customer.java b/src/main/java/com/booleanuk/core/Person/Customer.java new file mode 100644 index 000000000..a8acb5d35 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Person/Customer.java @@ -0,0 +1,51 @@ +package com.booleanuk.core.Person; + +import com.booleanuk.core.Basket; +import com.booleanuk.core.Items.Bagel; +import com.booleanuk.core.Items.Coffee; +import com.booleanuk.core.Items.Filling; +import com.booleanuk.core.Items.Item; + +public class Customer extends Member { + + private Basket basket = new Basket(); + + public Customer(){ + + } + + @Override + public Basket getBasket() { + return basket; + } + + @Override + public void setBasket(Basket basket) { + this.basket = basket; + } + + public double getTotalCost(){ + + return basket.sum(); + } + + + public double getCostOfBagel(Item i){ + + if(i instanceof Coffee || i instanceof Filling) + return 0; + + return basket.getItem(i).getPrice(); + } + + public boolean chooseFilling(Filling filling) { + + if (basket.getBagel() != null){ + basket.getBagel().setFilling(filling); + return true; + } + + return false; + } + +} diff --git a/src/main/java/com/booleanuk/core/Person/Manager.java b/src/main/java/com/booleanuk/core/Person/Manager.java new file mode 100644 index 000000000..2e93efb21 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Person/Manager.java @@ -0,0 +1,30 @@ +package com.booleanuk.core.Person; + +import com.booleanuk.core.Basket; +import com.booleanuk.core.Inventory; +import com.booleanuk.core.Items.Item; + +public class Manager extends Member{ + + + private Basket basket = new Basket(); + private Inventory inventory = new Inventory(); + + + public Manager(){ + + } + + + public boolean changeCapacity(int newCapacity){ + return basket.setCapacity(newCapacity); + } + + public boolean addItemToStore(Inventory inventory,Item item, Integer quantity){ + return inventory.add(item,quantity); + + } + + + +} diff --git a/src/main/java/com/booleanuk/core/Person/Member.java b/src/main/java/com/booleanuk/core/Person/Member.java new file mode 100644 index 000000000..4e6831165 --- /dev/null +++ b/src/main/java/com/booleanuk/core/Person/Member.java @@ -0,0 +1,40 @@ +package com.booleanuk.core.Person; + +import com.booleanuk.core.Basket; +import com.booleanuk.core.Items.Item; + +public class Member { + + + private Basket basket = new Basket(); + + public Member(){ + } + + public Basket getBasket() { + return this.basket; + } + + public void setBasket(Basket basket) { + + this.basket = basket; + } + + public boolean addToBasket(Item i) { + printItemPrice(i); + return this.basket.add(i); + } + + public boolean removeFromBasket(Item i) { + return this.basket.remove(i); + } + + public boolean isBasketFull() { + return this.basket.isFull(); + } + + private void printItemPrice(Item i){ + + System.out.println(i.getPrice()); + } +} diff --git a/src/test/java/com/booleanuk/core/CoreTest.java b/src/test/java/com/booleanuk/core/CoreTest.java new file mode 100644 index 000000000..e9cc54d92 --- /dev/null +++ b/src/test/java/com/booleanuk/core/CoreTest.java @@ -0,0 +1,187 @@ +package com.booleanuk.core; + +import com.booleanuk.core.Items.*; +import com.booleanuk.core.Person.Customer; +import com.booleanuk.core.Person.Manager; +import com.booleanuk.core.Person.Member; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; + +import static com.booleanuk.core.Items.BagelVariants.*; +import static com.booleanuk.core.Items.FillingVariants.*; +import static com.booleanuk.core.Items.CoffeeVariants.*; + +public class CoreTest { + + private Inventory inventory; + private Basket basketWithValidItems; + private Item bagel = new Bagel(ONION); + private Item filling = new Filling(CREAM_CHEESE); + private Item coffee = new Coffee(BLACK); + private Member member; + private Customer customer; + private Manager manager; + + + @BeforeEach + void setup(){ + + member = new Member(); + customer = new Customer(); + manager = new Manager(); + + bagel = new Bagel(ONION); + filling = new Filling(CREAM_CHEESE); + coffee = new Coffee(BLACK); + basketWithValidItems = new Basket(); + basketWithValidItems.add(filling); + basketWithValidItems.add(bagel); + basketWithValidItems.add(coffee); + HashMap standardItems = new HashMap<>(); + standardItems.put(bagel,1); + standardItems.put(filling,1); + standardItems.put(coffee,1); + inventory = new Inventory(standardItems); + } + + + + @Test + void addToBasket(){ + + Member m = new Member(); + m.addToBasket(bagel); + Item i = m.getBasket().getItemsInBasket().getFirst(); + Assertions.assertEquals(bagel,i); + + } + + @Test + void addIllegalItem(){ + + Item illegalBagel = new Bagel(); + Assertions.assertFalse(member.addToBasket(illegalBagel)); + } + + @Test + void removeFromBasket(){ + member.setBasket(basketWithValidItems); + Item everythingBagel = new Bagel(EVERYTHING); + boolean removedLegal = member.removeFromBasket(bagel); + boolean removedIllegal = member.removeFromBasket(everythingBagel); + Assertions.assertTrue(removedLegal); + Assertions.assertFalse(removedIllegal); + + } + + @Test + void removeNonExistingFromBasket(){ + + Item illegalBagel = new Bagel(); + Assertions.assertFalse(member.removeFromBasket(illegalBagel)); + + } + + + @Test + void basketIsFull(){ + Basket b = new Basket(); + + b.setCapacity(1); + member.setBasket(b); + member.addToBasket(bagel); + + Assertions.assertTrue(member.isBasketFull()); + } + + @Test + void basketIsNotFull(){ + Basket b = new Basket(); + + b.setCapacity(2); + member.setBasket(b); + member.addToBasket(bagel); + + Assertions.assertFalse(member.isBasketFull()); + } + + + @Test + void getTotalCostOfBasket(){ + + + customer.setBasket(basketWithValidItems); + Assertions.assertEquals(1.6, customer.getTotalCost()); + } + + @Test + void getCostOfBagel(){ + + + double coffeePrice= customer.getCostOfBagel(coffee); + double bagelPrice= customer.getCostOfBagel(bagel); + Assertions.assertEquals(0,coffeePrice); + Assertions.assertEquals(0.49,bagelPrice); + } + + + + @Test + void chooseFilling(){ + + customer.setBasket(basketWithValidItems); + Assertions.assertTrue(customer.chooseFilling((Filling)filling)); + + } + + + + @Test + void changeCapacity(){ + + manager.changeCapacity(10); + int newCapacity = new Basket().getCapacity(); + + + + Assertions.assertEquals(10,newCapacity); + Assertions.assertFalse(manager.changeCapacity(-1)); + } + + + @Test + void addItemToStore(){ + + Item bagelEverything = new Bagel(EVERYTHING); + + manager.addItemToStore(inventory, bagelEverything,1); + + Assertions.assertEquals(bagelEverything,inventory.getSpecificItem("BGLE")); + } + + + @Test + void getSumOfBasket(){ + Assertions.assertEquals(1.6,basketWithValidItems.sum()); + } + + + @Test + void getSpecificItem(){ + + Assertions.assertTrue(inventory.getSpecificItem("COFB") == coffee); + Assertions.assertNull(inventory.getSpecificItem("FILB")); + } + + @Test + void quantity(){ + + Assertions.assertEquals(1,inventory.getQuantity(bagel)); + Assertions.assertNotEquals(10,inventory.getQuantity(coffee)); + + } + +} diff --git a/src/test/java/com/booleanuk/core/ExtensionTest.java b/src/test/java/com/booleanuk/core/ExtensionTest.java new file mode 100644 index 000000000..d789dc7e5 --- /dev/null +++ b/src/test/java/com/booleanuk/core/ExtensionTest.java @@ -0,0 +1,69 @@ +package com.booleanuk.core; + +import com.booleanuk.core.Items.Bagel; +import com.booleanuk.core.Items.Coffee; +import com.booleanuk.core.Items.Filling; +import com.booleanuk.core.Items.Item; +import com.booleanuk.core.Person.Customer; +import com.booleanuk.core.Person.Manager; +import com.booleanuk.core.Person.Member; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; + +import static com.booleanuk.core.Items.BagelVariants.ONION; +import static com.booleanuk.core.Items.BagelVariants.SESAME; +import static com.booleanuk.core.Items.CoffeeVariants.BLACK; +import static com.booleanuk.core.Items.FillingVariants.CREAM_CHEESE; + +public class ExtensionTest { + + private Basket basketWithSixBagels; + private Basket basketWithTwelveBagels; + + private Item bagel; + private Item filling = new Filling(CREAM_CHEESE); + private Item coffee = new Coffee(BLACK); + + private Member member; + private Customer customer; + private Manager manager; + + @BeforeEach + void setup(){ + + member = new Member(); + customer = new Customer(); + manager = new Manager(); + + basketWithSixBagels = new Basket(); + basketWithTwelveBagels = new Basket(); + } + + + @Test + void basketWithDiscountBagel(){ + + bagel = new Bagel(ONION); + for (int i = 0; i <6 ; i++) { + basketWithSixBagels.add(bagel); + } + bagel = new Bagel(SESAME); + + for (int i = 0; i <12 ; i++) { + basketWithTwelveBagels.add(bagel); + } + double discountedPrice6 = basketWithSixBagels.sum(); + double discountedPrice12 = basketWithSixBagels.sum(); + Assertions.assertEquals(2.49,discountedPrice6); + Assertions.assertEquals(3.99,discountedPrice12); + + } + + @Test + void basketWithDiscountCoffeeAndBagel(){ + + } +}