Marie Helene Hansen

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

@@ -0,0 +1,32 @@
+package com.booleanuk.core;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Bagel extends Item {
+
+    private List<Filling> fillingList;
+
+    public Bagel(String SKU, float price, String name, String variant) {
+        super(SKU, price, name, variant);
+        fillingList = new ArrayList<>();
+    }
+
+    public boolean addFilling(Filling f) {
+        // make void? or keep boolean and set max number of fillings?
+        fillingList.add(f);
+        return true;
+    }
+
+    public List<Filling> getFillingList() {
+        return this.fillingList;
+    }
+
+    public float getPriceWithFillings() {
+        float updatedPrice = this.getPrice();
+        for (Filling f : this.getFillingList()) {
+            updatedPrice += f.getPrice();
+        }
+        return updatedPrice;
+    }
+}

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

@@ -0,0 +1,225 @@
+package com.booleanuk.core;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Basket {
+
+    private int capacity;
+    private Map<Item, Integer> items;
+
+    public Basket(int capacity) {
+        this.capacity = capacity;
+        items = new HashMap<>();
+    }
+
+    private boolean hasBGL6Offer() {
+
+        if (this.items.isEmpty()) {
+            return false;
+        }
+
+        int numBagels = 0;
+        for (Map.Entry<Item, Integer> entry : this.items.entrySet()) {
+            if (entry.getKey() instanceof Bagel) {
+                numBagels += entry.getValue();
+            }
+        }
+        return numBagels >= 6;
+    }
+
+    private boolean hasCOFBOffer() {
+        if (items.isEmpty() || items.size() < 2 || getCapacity() < 2) {
+            return false;
+        }
+        return this.items.keySet().stream().anyMatch(Coffee.class::isInstance) && this.items.keySet().stream().anyMatch(Bagel.class::isInstance);
+    }
+
+    private boolean hasBGL12Offer() {
+        if (this.items.isEmpty()) {
+            return false;
+        }
+
+        int numBagels = 0;
+        for (Map.Entry<Item, Integer> entry : this.items.entrySet()) {
+
+            if (entry.getKey() instanceof Bagel) {
+                numBagels += entry.getValue();
+            }
+        }
+        return numBagels >= 12;
+    }
+
+    private int getDozens(Map<Item, Integer> items) {
+
+        int bagelCount = 0;
+        for (Map.Entry<Item, Integer> entry : items.entrySet()) {
+
+            if (entry.getKey() instanceof Bagel) {
+                bagelCount += entry.getValue();
+            }
+        }
+        return bagelCount / 12;
+    }
+
+    private int getSixes(Map<Item, Integer> items) {
+
+        int bagelCount = 0;
+        for (Map.Entry<Item, Integer> entry : items.entrySet()) {
+
+            if (entry.getKey() instanceof Bagel) {
+                bagelCount += entry.getValue();
+            }
+        }
+        return bagelCount / 6;
+    }
+
+    private int getCoffeeBagelCombos(Map<Item, Integer> items) {
+
+        int bagelCount = 0;
+        for (Item it : items.keySet()) {
+            if (it instanceof Bagel) {
+                bagelCount ++;
+            }
+        }
+
+        int coffeeCount = 0;
+        for (Item it : items.keySet()) {
+            if (it instanceof Coffee) {
+                coffeeCount ++;
+            }
+        }
+        return Math.min(bagelCount, coffeeCount);
+    }
+
+    private void removeBagels(Map<Item, Integer> its, int countToRemove) {
+
+        // have to make sure countToRemove and current count is checked!!
+        for (Item it : new ArrayList<>(its.keySet())) {
+
+             if (it instanceof Bagel && countToRemove > 0) {
+
+                 int thisCount = its.get(it);
+                 int remove = Math.min(thisCount, countToRemove);
+                 its.put(it, thisCount - remove);
+
+                 if (its.get(it) == 0) {
+                     its.remove(it);
+                 }
+             }
+        }
+    }
+
+    private void removeCoffeeAndBagels(Map<Item, Integer> its, int combos) {
+
+        removeBagels(its, combos);
+        for (Item it : new ArrayList<>(its.keySet())) {
+
+            if (it instanceof Coffee && combos > 0) {
+
+                int thisCount = its.get(it);
+                int remove = Math.min(thisCount, combos);
+                its.put(it, thisCount - remove);
+
+                if (its.get(it) == 0) {
+                    its.remove(it);
+                }
+            }
+        }
+    }
+
+    public Map<Item, Integer> getItems() {
+        return items;
+    }
+
+    public boolean setCapacity(int newCap) {
+
+        if (newCap < 0 || newCap > 100) {
+            return false;
+        }
+        this.capacity = newCap;
+        return true;
+    }
+
+    public boolean add(Item item) {
+        if (this.isFull()) {
+            return false;
+        }
+        else {
+            if (this.items.containsKey(item)) {
+                int amount = this.items.get(item) + 1;
+                this.items.put(item, amount);
+            }
+            else {
+                this.items.put(item, 1);
+            }
+            return true;
+        }
+    }
+
+    public boolean remove(Item item) {
+        if (!this.items.containsKey(item)) {
+            return false;
+        }
+        this.items.remove(item);
+        return true;
+    }
+
+    public float getTotalCost() {
+        float total = 0f;
+        Map<Item, Integer> remainingItems = new HashMap<>(this.items); // copy of this.items
+
+        // check 12 bagel offer
+        if (this.hasBGL12Offer()) {
+
+            int dozens = getDozens(remainingItems);
+            total += dozens * 3.99f;
+
+            removeBagels(remainingItems, dozens * 12);
+        }
+        // check 6 bagel offer
+        if (this.hasBGL6Offer()) {
+
+            int sixes = getSixes(remainingItems);
+            total += sixes * 2.49f;
+
+            removeBagels(remainingItems, sixes * 6);
+        }
+
+        // check if remaining items can get coffee+bagel offer
+        if (hasCOFBOffer()) {
+
+            int combos = getCoffeeBagelCombos(remainingItems);
+            total += combos * 1.25f;
+
+            removeCoffeeAndBagels(remainingItems, combos);
+        }
+
+        for (Item it : remainingItems.keySet()) {
+
+            if (it instanceof Bagel) {
+                total += ((Bagel) it).getPriceWithFillings();
+            } else {
+                total += it.getPrice();
+            }
+        }
+        return total;
+    }
+
+    public int getCapacity() {
+        return this.capacity - this.items.size();
+    }
+
+    public int getAvailableCapacity() {
+        // available after items are added
+        // getCapacity if items-map is empty
+        // check this first, make sure Manager does not screw it up
+
+        return 0;
+    }
+
+    public boolean isFull() {
+        return getCapacity() < this.items.size();
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.booleanuk.core;
+
+public class Coffee extends Item {
+    public Coffee(String SKU, float price, String name, String variant) {
+        super(SKU, price, name, variant);
+    }
+
+}

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

@@ -0,0 +1,35 @@
+package com.booleanuk.core;
+
+import java.util.List;
+
+public class Customer extends Guest {
+
+    public Customer(String name) {
+        super(name);
+    }
+
+    public float getTotalPriceBasket() {
+        return this.getBasket().getTotalCost();
+    }
+
+    public float getPriceBagel(Bagel b) {
+        return b.getPriceWithFillings();
+    }
+
+    public float getPriceFilling(Filling f) {
+        return f.getPrice();
+    }
+
+    public boolean setFillings(Bagel b, List<Filling> fillingList) {
+        if (this.getBasket().isFull()) {
+            return false;
+        }
+        else if (!this.getBasket().getItems().containsKey(b)) {
+            return false;
+        }
+        for (Filling f : fillingList) {
+            b.addFilling(f);
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.booleanuk.core;
+
+public class Filling extends Item {
+    public Filling(String SKU, float price, String name, String variant) {
+        super(SKU, price, name, variant);
+    }
+
+}

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

@@ -0,0 +1,33 @@
+package com.booleanuk.core;
+
+public class Guest {
+    // "MEMBER OF PUBLIC"
+    private String name;
+    private Basket basket;
+    private int defaultCap = 10;
+
+    public Guest(String name) {
+        this.name = name;
+        this.basket = new Basket(defaultCap);
+    }
+
+    public Basket getBasket() {
+        return this.basket;
+    }
+
+    public boolean addToBasket(Item item) {
+        return this.basket.add(item);
+    }
+
+    public boolean removeFromBasket(Item item) {
+        return this.basket.remove(item);
+    }
+
+    public boolean guestBasketIsFull() {
+        return this.basket.isFull();
+    }
+
+    public boolean hasItemInBasket(Item item) {
+        return this.basket.getItems().containsKey(item);
+    }
+}

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

@@ -0,0 +1,4 @@
+package com.booleanuk.core;
+
+public enum Inventory {
+}

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

@@ -0,0 +1,31 @@
+package com.booleanuk.core;
+
+abstract public class Item {
+    private final String SKU;
+    private final float price; // methods for basketPrice for discounts
+    private final String name;
+    private final String variant;
+
+    public Item(String SKU, float price, String name, String variant) {
+        this.SKU = SKU;
+        this.price = price;
+        this.name = name;
+        this.variant = variant;
+    }
+
+    public String getSKU() {
+        return this.SKU;
+    }
+
+    public float getPrice() {
+        return this.price;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public String getVariant() {
+        return this.variant;
+    }
+}

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

@@ -0,0 +1,13 @@
+package com.booleanuk.core;
+
+public class Manager {
+
+    public boolean setCapacity(Basket b, int cap) {
+        return b.setCapacity(cap);
+    }
+
+    public boolean isInItems(Basket b) {
+        // make a map for inventory, check here
+        return false;
+    }
+}