feat : 결제 기능

src/main/java/Application.java

@@ -59,20 +59,20 @@ private static void orderMenu(List<Table> tables, CafeOrderService cafeOrderServ
     {
         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 this.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

@@ -15,11 +15,15 @@ public enum PayType {
 
     public static PayType findByNumber(int number){
         return Arrays.stream(values())
-                .filter(payType -> payType.number==number)
+                .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

@@ -5,56 +5,59 @@
 
 import java.util.*;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 import static java.util.stream.Collectors.*;
 
+//주문 정보들을 저장하는 클래스
 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 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;
     }
 
-    public boolean canOrder(int tableNum, int menuNum, int menuCount){
-        int existedMenusNum = countMenusNumber(tableNum, menuNum);
-        if(existedMenusNum+menuCount<=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 List<Order> findByTableNumber(int tableNum)
+    //해당 테이블에서 주문한 것들을 모두 return한다.
+    public List<Order> findByTableNumber(int tableNumber)
     {
         return 
                 orders.stream()
-                        .filter(order-> order.isEqualTable(tableNum))
+                        .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 tableNum){
-        orders.removeIf(order->order.isEqualTable(tableNum));
+    //지불이 완료되면 해당 테이블의 주문을 모두 삭제한다.
+    public void finishedPayment(int tableNumber){
+        orders.removeIf(order->order.isEqualTable(tableNumber));
     }
 
 }

src/main/java/repository/TableRepository.java

@@ -19,8 +19,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() {

src/main/java/service/CafeOrderService.java

@@ -3,6 +3,8 @@
 import domain.*;
 import repository.MenuRepository;
 import repository.OrderRepository;
+import repository.TableRepository;
+import view.OutputView;
 
 import java.util.Map;
 
@@ -16,79 +18,82 @@ public CafeOrderService(OrderRepository orderRepository) {
         this.orderRepository = orderRepository;
     }
 
-    public boolean isValidTableNum(int tableNum)
+    //해당 테이블이 존재하는 테이블인지 검사한다.
+    public boolean isValidTableNumber(int tableNumber)
     {
-        if(tableNum<0||tableNum==7||tableNum>9){
-            System.out.println("## 존재하지 않는 테이블입니다. \n테이블을 다시 선택하세요\n");
-            return false;
-        }
-        else{
+        if(TableRepository.findByNumber(tableNumber).isPresent()){
             return true;
         }
+        return false;
     }
 
-    public boolean canOrderMenu(int tableNum, int menuNum, int menuCount)
+    //주문하려는 메뉴의 수량이 누적 30개가 넘는지 확인한다.
+    public boolean checkMaximumCount(int tableNumber, int menuNumber, int menuCount)
     {
-        return orderRepository.canOrder(tableNum, menuNum, menuCount);
+        return orderRepository.checkMaximumPerMenu(tableNumber, menuNumber, menuCount);
     }
 
-    public void orderMenu(int menuNum, int count, int tableNum)
+    //메뉴의 번호, 수량, 테이블 번호를 입력받고 수량만큼의 주문을 추가한다.
+    public void orderMenu(int menuNumber, int count, int tableNumber)
     {
         for(int i=0;i<count;i++){
-            orderRepository.addOrder(new Order(menuNum, tableNum));
+            orderRepository.addOrder(new Order(menuNumber, tableNumber));
         }
     }
 
-    public Map<Menu,Long> getBillByTable(int tableNum) {
-        return orderRepository.getBill(tableNum);
+    //해당 테이블에서 주문한 것들에 대한 영수증을 return한다.
+    public Map<Menu,Long> getBillByTable(int tableNumber) {
+        return orderRepository.getBill(tableNumber);
     }
 
-    public boolean isOrderedTable(int tableNum){
-        if(orderRepository.getBill(tableNum).isEmpty()){
+    //해당 테이블에 주문이 들어간 테이블인지 검사한다.
+    public boolean isOrderedTable(int tableNumber){
+        if(this.getBillByTable(tableNumber).isEmpty()){
             return false;
-        }else{
-            return true;
         }
+        return true;
     }
 
-    public boolean checkMenuNum(int menuNum) {
-        try{
-            return MenuRepository.findByNumber(menuNum) instanceof Menu;
-        }catch (Exception e){
-            return false;
+    //입력된 메뉴가 존재하는 메뉴인지 검사한다.
+    public boolean isValidMenuNumber(int menuNumber) {
+        if(MenuRepository.checkMenuNumber(menuNumber)){
+            return true;
         }
+        return false;
     }
 
-    public long getAmountOfPayment(int tableNum, PayType payType, Map<Menu, Long> bill) {
-        int numberOfCakes = getNumOfCakes(bill);
+    //지불해야하는 총 금액을 return한다.
+    public long getAmountOfPayment(int tableNumber, PayType payType, Map<Menu, Long> bill) {
+        int numberOfCakes = getNumberOfCakes(bill);
         long amountOfPayment = getFinalPayment(bill, numberOfCakes, payType.getDiscountRate());
-        orderRepository.finishedPayment(tableNum);
+        orderRepository.finishedPayment(tableNumber);
 
         return amountOfPayment;
     }
 
-    private int getNumOfCakes(Map<Menu, Long> bill) {
-        int numOfCakes = 0;
+    //해당 테이블에서 주문한 케익의 갯수를 return한다.
+    private int getNumberOfCakes(Map<Menu, Long> bill) {
+        int numberOfCakes = 0;
         for (Map.Entry<Menu, Long> entry : bill.entrySet()){
-            if(entry.getKey().getCategory()==Category.CAKE){
-                numOfCakes += entry.getValue();
-            }
+            numberOfCakes += entry.getKey().isThisCake() ? entry.getValue() : 0;
         }
-        return numOfCakes;
+        return numberOfCakes;
     }
 
-    public long getSumOfPayment(Map<Menu, Long> bill){
+    //해당 테이블에서 주문한 메뉴들 가격의 총 합을 계산한다.
+    private long getSumOfPayment(Map<Menu, Long> bill){
         long totalSumOfPayment = 0;
         for (Map.Entry<Menu, Long> entry : bill.entrySet()){
-            totalSumOfPayment += entry.getKey().getPrice()*entry.getValue();
+            totalSumOfPayment += entry.getKey().getPrice() * entry.getValue();
         }
         return totalSumOfPayment;
     }
 
+    //할인을 적용한 가격을 계산한다.
     private long getFinalPayment(Map<Menu,Long> bill, int numberOfCakes, int discountRate){
         long totalSumOfPayment = getSumOfPayment(bill);
         if(numberOfCakes>=DISCOUNT_FOR_CAKES){
-            totalSumOfPayment -= DISCOUNT_MONEY_PER_NUM_OF_CAKES*(numberOfCakes/3);
+            totalSumOfPayment -= DISCOUNT_MONEY_PER_NUM_OF_CAKES * (numberOfCakes/3);
         }
         totalSumOfPayment = (long)(totalSumOfPayment - totalSumOfPayment*((float)discountRate/100));
         return totalSumOfPayment;

src/main/java/view/OutputView.java

@@ -91,4 +91,8 @@ public static void printAmountOfPayment(long amountOfPayment) {
     public static void printNoOrder(){
         System.out.println("주문 정보가 없는 테이블입니다.\n");
     }
+
+    public static void printNoTableAlert() {
+        System.out.println("## 존재하지 않는 테이블입니다. \n테이블을 다시 선택하세요\n");
+    }
 }