[오렌지] 치킨집 미션 제출합니다

README.md

@@ -1 +1,29 @@
-# java-chicken-2019
+# java-chicken-2019
+
+## 요구사항
+
++ [x] 메인 화면에서 주문등록, 결제하기, 프로그램 종료 선택 가능
+    + [x] 1,2,3 외의 입력이 들어온 경우 예외처리
++ [x] 주문 등록
+    + [x] 테이블 목록 표시
+        + [x] 1개 이상 주문이 된 테이블은 ₩ 표시
+    + [x] 테이블 선택
+        + [x] 1,2,3,5,6,8 외의 입력 들어온 경우 예외처리
+    + [x] 메뉴 표시
+    + [x] 메뉴 선택
+        + [x] 1,2,3,4,5,6,21,22 외 입력 들어온 경우 예외처리
+    + [x] 메뉴 수량 입력
+        + [x] 0 이하 숫자, 문자 입력시 예외처리
+        + [x] 한 메뉴의 이미 주문한 수량 + 입력한 수량이 100 이상이면 예외처리
++ [x] 결제하기
+    + [x] 테이블 목록 표시 - 주문 등록과 같음
+    + [x] 테이블 선택 - 주문 등록과 같음
+    + [x] 주문 내역 표시 - 메뉴, 수량, 금액
+    + [x] 신용카드와 현금 선택
+        + [x] 1, 2 외 입력시 예외처리
+    + [x] 결제 금액 표시
+        + [x] 치킨종류의 주문수량이 10마리마다 10000원 할인 
+        + [x] 현금결제(2)시 5% 할인 - 치킨할인 후 중복할인 적용
++ [x] 프로그램 종료
+    + [x] 프로그램 종료 전까지는 계속 유지
++ [x] 주문, 계산 실패 시 이유를 보여주고 다시 가능하도록 구현

build.gradle

@@ -11,4 +11,8 @@ repositories {
 dependencies {
     testCompile('org.junit.jupiter:junit-jupiter:5.5.2')
     testCompile('org.assertj:assertj-core:3.14.0')
+}
+
+test {
+    useJUnitPlatform()
 }

src/main/java/Application.java

@@ -1,21 +1,13 @@
-import domain.Menu;
-import domain.MenuRepository;
-import domain.Table;
-import domain.TableRepository;
-import view.InputView;
-import view.OutputView;
-
-import java.util.List;
+import controller.Controller;
 
 public class Application {
-    // TODO 구현 진행
-    public static void main(String[] args) {
-        final List<Table> tables = TableRepository.tables();
-        OutputView.printTables(tables);
-
-        final int tableNumber = InputView.inputTableNumber();
 
-        final List<Menu> menus = MenuRepository.menus();
-        OutputView.printMenus(menus);
+    public static void main(String[] args) throws IllegalAccessException {
+        final Controller controller = new Controller();
+        while (true) {
+            if (!controller.run()) {
+                return;
+            }
+        }
     }
 }

src/main/java/controller/Controller.java

@@ -0,0 +1,109 @@
+package controller;
+
+import domain.*;
+import view.InputView;
+import view.OutputView;
+
+import java.util.List;
+
+public class Controller {
+
+    private final List<Table> tables = TableRepository.tables();
+    private final List<Menu> menus = MenuRepository.menus();
+
+    public boolean run() throws IllegalAccessException {
+        try {
+            MainType mainType = selectMain();
+            return runPos(mainType);
+        } catch (IllegalArgumentException e) {
+            OutputView.printError(e.getMessage());
+            return true;
+        }
+    }
+
+    private Boolean runPos(MainType mainType) throws IllegalAccessException {
+        if (MainType.ORDER.equals(mainType)) {
+            Table table = selectTable();
+            order(table);
+            return true;
+        }
+        if (MainType.PAYMENT.equals(mainType)) {
+            Table table = selectTable();
+            pay(table);
+            return true;
+        }
+        if (MainType.EXIT.equals(mainType)) {
+            OutputView.printExit();
+            return false;
+        }
+        throw new IllegalAccessException("잘못된 포스기 접근입니다.");
+    }
+
+    private MainType selectMain() {
+        OutputView.printMain();
+        return MainType.of(InputView.inputMain());
+    }
+
+    private Table selectTable() {
+        while (true) {
+            try {
+                OutputView.printTables(tables);
+                return TableRepository.findTableByNumber(InputView.inputTableNumber());
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private void order(Table table) {
+        while (true) {
+            try {
+                Menu menu = selectMenu();
+                Count count = inputCount();
+                Order order = new Order(menu, count);
+                table.order(order);
+                return;
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private Count inputCount() {
+        while (true) {
+            try {
+                return new Count(InputView.inputMenuCount());
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private Menu selectMenu() {
+        while (true) {
+            try {
+                OutputView.printMenus(menus);
+                return MenuRepository.findMenuByNumber(InputView.inputMenuNumber());
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private void pay(Table table) {
+        OutputView.printOrderedMenus(table);
+        PaymentType paymentType = selectPayment(table);
+        OutputView.printTotalPrice(paymentType.calculate(table.getOrders()));
+        table.resetOrder();
+    }
+
+    private PaymentType selectPayment(Table table) {
+        while (true) {
+            try {
+                return PaymentType.of(InputView.inputPayment(table));
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+}

src/main/java/domain/Count.java

@@ -0,0 +1,30 @@
+package domain;
+
+public class Count {
+    private static final int MIN_COUNT = 1;
+    private static final int MAX_COUNT = 99;
+    private int count;
+
+    public Count(final int count) {
+        validate(count);
+        this.count = count;
+    }
+
+    private void validate(final int count) {
+        if (count < MIN_COUNT) {
+            throw new IllegalArgumentException("0이하로 주문할 수 없습니다.");
+        }
+        if (count > MAX_COUNT) {
+            throw new IllegalArgumentException("한 메뉴의 최대 주문량은 99입니다.");
+        }
+    }
+
+    public Count addCount(Count count) {
+        final int addResult = this.count + count.getCount();
+        return new Count(addResult);
+    }
+
+    public int getCount() {
+        return count;
+    }
+}

src/main/java/domain/MainType.java

@@ -0,0 +1,23 @@
+package domain;
+
+import java.util.Arrays;
+
+public enum MainType {
+
+    ORDER(1),
+    PAYMENT(2),
+    EXIT(3);
+
+    private final int number;
+
+    MainType(int number) {
+        this.number = number;
+    }
+
+    public static MainType of(int number) {
+        return Arrays.stream(MainType.values())
+                .filter(mainType -> mainType.number == number)
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 메인메뉴입니다."));
+    }
+}

src/main/java/domain/Menu.java

@@ -17,4 +17,20 @@ public Menu(final int number, final String name, final Category category, final
     public String toString() {
         return category + " " + number + " - " + name + " : " + price + "원";
     }
+
+    public boolean isMenuNumber(int number) {
+        return this.number == number;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getPrice() {
+        return price;
+    }
+
+    public boolean isChicken() {
+        return Category.CHICKEN.equals(category);
+    }
 }

src/main/java/domain/MenuRepository.java

@@ -21,4 +21,11 @@ public class MenuRepository {
     public static List<Menu> menus() {
         return Collections.unmodifiableList(menus);
     }
+
+    public static Menu findMenuByNumber(int number) {
+        return menus().stream()
+                .filter(menu -> menu.isMenuNumber(number))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("해당 메뉴 번호가 존재하지 않습니다."));
+    }
 }

src/main/java/domain/Order.java

@@ -0,0 +1,49 @@
+package domain;
+
+import java.util.Objects;
+
+public class Order {
+
+    private final Menu menu;
+    private Count count;
+
+    public Order(Menu menu, Count count) {
+        validate(menu, count);
+        this.menu = menu;
+        this.count = count;
+    }
+
+    private void validate(Menu menu, Count count) {
+        Objects.requireNonNull(menu, "null 불가");
+        Objects.requireNonNull(count, "null 불가");
+    }
+
+    public boolean isMenuSame(Order order) {
+        return order.getMenu().equals(this.menu);
+    }
+
+    public void orderMore(Order order) {
+        this.count = count.addCount(order.getCount());
+    }
+
+    public boolean isChicken() {
+        return menu.isChicken();
+    }
+
+    public Menu getMenu() {
+        return menu;
+    }
+
+    private Count getCount() {
+        return count;
+    }
+
+    public int getCountNumber() {
+        return count.getCount();
+    }
+
+    public int getTotalPrice() {
+        return menu.getPrice() * count.getCount();
+    }
+
+}

src/main/java/domain/Orders.java

@@ -0,0 +1,56 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Orders {
+    public static final int CHICKEN_SET_UNIT = 10;
+    private final List<Order> orders = new ArrayList<>();
+
+    public Orders() {
+    }
+
+    public void orderMenu(Order order) {
+        if (isNotOrderedMenu(order)) {
+            orders.add(order);
+            return;
+        }
+        orders.stream()
+                .filter(menu -> menu.isMenuSame(order))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("잘못된 주문입니다."))
+                .orderMore(order);
+    }
+
+    private boolean isNotOrderedMenu(Order order) {
+        return orders.stream()
+                .noneMatch(menu -> menu.isMenuSame(order));
+    }
+
+    public void resetOrder() {
+        orders.clear();
+    }
+
+    public int calculateChickenSet() {
+        int chickenCount = orders.stream()
+                .filter(Order::isChicken)
+                .mapToInt(Order::getCountNumber)
+                .sum();
+        return chickenCount / CHICKEN_SET_UNIT;
+    }
+
+    public boolean isOrderEmpty() {
+        return orders.isEmpty();
+    }
+
+    //Todo 이름마음에안듬
+
+    public int getOrderedMenuSize() {
+        return orders.size();
+    }
+
+    public List<Order> getOrders() {
+        return Collections.unmodifiableList(orders);
+    }
+}