feat : 결제 기능

src/main/java/Application.java

@@ -1,5 +1,6 @@
 import domain.Menu;
 //import jdk.internal.util.xml.impl.Input;
+import domain.PayType;
 import repository.MenuRepository;
 import domain.Table;
 import repository.OrderRepository;
@@ -9,6 +10,8 @@
 import view.OutputView;
 
 import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
 
 public class Application {
     // TODO 구현 진행
@@ -28,6 +31,9 @@ public static void main(String[] args) {
             {
                 payOrders(tables, cafeOrderService);
             }
+            else if(func>3 || func<0){
+                throw new NoSuchElementException("해당 기능은 존재하지 않습니다.");
+            }
             OutputView.printMain();
             func = InputView.inputFunction();
         }
@@ -36,27 +42,37 @@ public static void main(String[] args) {
     private static void payOrders(List<Table> tables, CafeOrderService cafeOrderService) {
         OutputView.printTables(tables, cafeOrderService);
         int tableNum = InputView.inputPayTableNumber();
-        OutputView.printOrders(cafeOrderService, tableNum);
+        if(cafeOrderService.checkOrderedTable(tableNum)==false){
+            OutputView.printNoOrder();
+            return;
+        };
+        Map<Menu, Long> bill = cafeOrderService.getBillByTable(tableNum);
+        OutputView.printBill(bill);
+        OutputView.printPayMessage(tableNum);
+        int payTypeNumber = InputView.inputPayType();
+        PayType payType = PayType.findByNumber(payTypeNumber);
+        long amountOfPayment = cafeOrderService.getAmountOfPayment(tableNum, payType);
+        OutputView.printAmountOfPayment(amountOfPayment);
     }
 
     private static void orderMenu(List<Table> tables, CafeOrderService cafeOrderService)
     {
         OutputView.printTables(tables, cafeOrderService);
         int tableNum = InputView.inputTableNumber();
-        boolean isValidTblNum = cafeOrderService.isValidTableNum(tableNum);
+        boolean isValidTblNum = cafeOrderService.isValidTableNumber(tableNum);
         if(isValidTblNum==false){
             orderMenu(tables, cafeOrderService);
         }
         final List<Menu> menus = MenuRepository.menus();
         OutputView.printMenus(menus);
         int menuNum = InputView.inputMenu();
-        boolean isValidMenuNum = cafeOrderService.checkMenuNum(menuNum);
+        boolean isValidMenuNum = cafeOrderService.isValidMenuNumber(menuNum);
         if(isValidMenuNum==false){
             OutputView.printMenuAlert();
             orderMenu(tables, cafeOrderService);
         }
         int menuCount = InputView.inputCount();
-        boolean isValidMenuCount = cafeOrderService.canOrderMenu(tableNum, menuNum, menuCount);
+        boolean isValidMenuCount = cafeOrderService.checkMaximumCount(tableNum, menuNum, menuCount);
         if(isValidMenuCount==false){
             OutputView.printMaxAlert();
             return;

src/main/java/domain/Menu.java

@@ -29,6 +29,12 @@ public int getPrice() {
         return price;
     }
 
+    public boolean isEqualNumber(int number){
+        return this.number == number;
+    }
+
+    public boolean isThisCake(){ return this.category==Category.CAKE;}
+
     @Override
     public String toString() {
         return category + " " + number + " - " + name + " : " + price + "원";

src/main/java/domain/Order.java

@@ -1,23 +1,27 @@
 package domain;
 
 public class Order {
-    private final int menuNum;
-    private final int tableNum;
+    private final int menuNumber;
+    private final int tableNumber;
 
     public Order(int menuNum, int tableNum) {
-        this.menuNum = menuNum;
-        this.tableNum = tableNum;
+        this.menuNumber = menuNum;
+        this.tableNumber = tableNum;
     }
 
-    public int getMenuNum() {
-        return this.menuNum;
+    public int getMenuNumber() {
+        return menuNumber;
     }
 
-    public int getTableNum() {
-        return tableNum;
+    public int getTableNumber() {
+        return tableNumber;
     }
 
-    public boolean isEqualTable(int tableNum){
-        return this.tableNum == tableNum;
+    public boolean isEqualTable(int tableNumber){
+        return this.tableNumber == tableNumber;
+    }
+
+    public boolean isEqualMenuNumber(int menuNumber){
+        return this.menuNumber==menuNumber;
     }
 }

src/main/java/domain/PayType.java

@@ -0,0 +1,32 @@
+package domain;
+
+import java.util.Arrays;
+
+//지불 수단
+public enum PayType {
+    CARD(1, 0), CASH(2,10);
+
+    private final int number;
+    private final int discountRate;
+
+    PayType(int number, int discountRate){
+        this.number = number;
+        this.discountRate = discountRate;
+    }
+
+    public static PayType findByNumber(int number){
+        return Arrays.stream(values())
+                .filter(payType -> isEqualPayType(payType, number))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("결제 수단은 카드(1)와 현금(2)만 존재합니다."));
+    }
+
+    private static boolean isEqualPayType(PayType payType, int number){
+        return payType.number==number;
+    }
+
+    public int getDiscountRate(){
+        return this.discountRate;
+    }
+
+}

src/main/java/domain/Table.java

@@ -11,6 +11,8 @@ public int getNumber() {
         return number;
     }
 
+    public boolean isEqualNumber(int tableNumber){ return this.number==number;}
+
     @Override
     public String toString() {
         return Integer.toString(number);

src/main/java/repository/MenuRepository.java

@@ -24,13 +24,20 @@ public class MenuRepository {
         menus.add(new Menu(24, "그린티 라떼", Category.BEVERAGE, 6000));
     }
 
+    //해당 숫자에 해당하는 메뉴 객체를 return한다.
     public static Menu findByNumber(int number){
         return menus.stream()
-                .filter(menu -> menu.getNumber()==number)
+                .filter(menu -> menu.isEqualNumber(number))
                 .findFirst()
                 .orElseThrow(IllegalAccessError::new);
     }
 
+    //입력된 숫자에 해당하는 메뉴가 있는지 검사한다.
+    public static boolean checkMenuNumber(int number){
+        Menu menu = findByNumber(number);
+        return menu.isEqualNumber(number);
+    }
+
     public Optional<Menu> findByName(String name){
         return menus.stream()
                 .filter(menu -> menu.getName().equals(name))

src/main/java/repository/OrderRepository.java

@@ -2,95 +2,92 @@
 
 import domain.Menu;
 import domain.Order;
+import domain.PayType;
+import service.CafeOrderService;
 
 import java.util.*;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 import static java.util.stream.Collectors.*;
 
-public class OrderRepository {
+//주문 정보들을 저장하고 주문한 것들의 합을 계산한다.
+public class OrderRepository{
     private static final int MAX_NUMBER_PER_MENU = 30;
     private final List<Order> orders = new ArrayList<>();
 
+    //주문을 받는다.
     public void addOrder(final Order order)
     {
         orders.add(order);
     }
 
-    public int countOrders(){
-        return orders.size();
-    }
-
-    public int countMenusPerTable(int tableNum)
-    {
-        return (int)orders.stream()
-                .filter(order-> order.isEqualTable(tableNum))
-                .count();
-    }
-
-    public int countMenusNumber(int tableNum, int menuNum){
+    //해당 테이블에서 주문한 해당 메뉴의 수량을 return한다.
+    public int countMenusNumber(int tableNumber, int menuNumber){
         int count= (int)orders.stream()
-                .filter(order->order.isEqualTable(tableNum))
-                .filter(order->menuNum==order.getMenuNum())
+                .filter(order->order.isEqualTable(tableNumber))
+                .filter(order->order.isEqualMenuNumber(menuNumber))
                 .count();
         return count;
     }
 
-    //가장 수량이 많은 메뉴의 수량을 체크하는 메서드
-    //need to edit
-    public int countNumberPerMenu(int tableNum)
-    {
-        List<Order> orders = findByTableNumber(tableNum);
-        if(orders.isEmpty()){
-            return 0;
-        }
-        Map<Menu, Long> bill = orders.stream()
-                .map(order -> MenuRepository.findByNumber(order.getMenuNum()))
-                .collect(Collectors.groupingBy(order->order,HashMap::new, counting()));
-        List<Map.Entry<Menu, Long>> entryList = new LinkedList(bill.entrySet());
-        entryList.sort(Map.Entry.comparingByValue());
-
-        System.out.println(entryList.get(0).getValue().intValue());
-        return entryList.get(0).getValue().intValue();
-    }
-
-    public boolean canOrder(int tableNum)
-    {
-        if(countNumberPerMenu(tableNum)<=MAX_NUMBER_PER_MENU){
+    //해당 테이블에서 주문할 수 있는 한 메뉴의 최대 수량을 넘는지 아닌지 검사한다.
+    public boolean checkMaximumPerMenu(int tableNumber, int menuNumber, int menuCount){
+        int existedMenusCount = countMenusNumber(tableNumber, menuNumber);
+        if(existedMenusCount+menuCount<=MAX_NUMBER_PER_MENU){
             return true;
-        }else{
-            return false;
         }
+        return false;
     }
-
-    public boolean canOrder(int tableNum, int menuNum, int menuCount){
-        int existedMenusNum = countMenusNumber(tableNum, menuNum);
-        if(existedMenusNum+menuCount<=MAX_NUMBER_PER_MENU){
-            return true;
-        }else{
-            return false;
-        }
-    }
-
-    public List<Order> findByTableNumber(int tableNum)
+    //해당 테이블에서 주문한 것들을 모두 return한다.
+    public List<Order> findByTableNumber(int tableNumber)
     {
         return 
                 orders.stream()
-                        .filter(order-> order.isEqualTable(tableNum))
-                .collect(toList());
+                        .filter(order-> order.isEqualTable(tableNumber))
+                        .collect(toList());
     }
 
-    //해당 테이블에서 해당 메뉴의 수량을 출력하는 메소드
-    public Map<Menu, Long> getBill(int tableNum){
-        List<Order> orders = findByTableNumber(tableNum);
+    //해당 테이블에서 주문한 메뉴와 수량을 return한다.
+    public Map<Menu, Long> getBill(int tableNumber){
+        List<Order> orders = findByTableNumber(tableNumber);
         Map<Menu, Long> bill = orders.stream()
-                .map(order -> MenuRepository.findByNumber(order.getMenuNum()))
+                .map(order -> MenuRepository.findByNumber(order.getMenuNumber()))
                 .collect(Collectors.groupingBy(order->order,HashMap::new, counting()));
 
         return bill;
     }
 
+    //지불이 완료되면 해당 테이블의 주문을 모두 삭제한다.
+    public void finishedPayment(int tableNumber){
+        orders.removeIf(order->order.isEqualTable(tableNumber));
+    }
 
+    //해당 테이블이 주문된 테이블인지 검사한다.
+    public boolean isOrderedTable(int tableNumber){
+        if(getBill(tableNumber).isEmpty()){
+            return false;
+        }
+        return true;
+    }
+
+    //해당 테이블에서 주문한 케익의 갯수를 계산한다.
+    public int getNumberOfCakes(int tableNumber) {
+        int numberOfCakes = 0;
+        Map<Menu, Long> bill = getBill(tableNumber);
+        for (Map.Entry<Menu, Long> entry : bill.entrySet()){
+            numberOfCakes += entry.getKey().isThisCake() ? entry.getValue() : 0;
+        }
+        return numberOfCakes;
+    }
+
+    //해당 테이블에서 주문한 메뉴들 가격의 총 합을 계산한다.
+    public long getSumOfPayment(int tableNumber){
+        long totalSumOfPayment = 0;
+        Map<Menu, Long> bill = getBill(tableNumber);
+        for (Map.Entry<Menu, Long> entry : bill.entrySet()){
+            totalSumOfPayment += entry.getKey().getPrice() * entry.getValue();
+        }
+        return totalSumOfPayment;
+    }
 
 }

src/main/java/repository/TableRepository.java

@@ -1,6 +1,7 @@
 package repository;
 
 import domain.Table;
+import service.CafeOrderService;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -19,8 +20,12 @@ public class TableRepository {
         tables.add(new Table(8));
     }
 
-    public Optional<Table> findByNumber(int number) {
-        return Optional.ofNullable(tables.get(number)); //Optional로 감싸줌으로써, Null이더라도 반환해서 클라이언트 단에서 처리해줄 수 있도록
+    //nubmer에 해당하는 Table을 return한다.
+    public static Optional<Table> findByNumber(int number){
+        return Optional.ofNullable(tables.stream()
+                .filter(table -> table.isEqualNumber(number))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException(number+"번 테이블은 존재하지 않는 테이블입니다.")));//Optional로 감싸줌으로써, Null이더라도 반환해서 클라이언트 단에서 처리해줄 수 있도록
     }
 
     public static List<Table> tables() {