[크리스마스 프로모션] 코드리뷰용 Pull Request

src/main/java/christmas/Application.java

@@ -1,7 +1,11 @@
 package christmas;
 
+import christmas.view.input.InputView;
+import christmas.view.output.OutputView;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        EventPlanner eventPlanner = new EventPlanner(new InputView(), new OutputView());
+        eventPlanner.execute();
     }
-}
+}

src/main/java/christmas/EventPlanner.java

@@ -0,0 +1,82 @@
+package christmas;
+
+import camp.nextstep.edu.missionutils.Console;
+import christmas.controller.OrdersController;
+import christmas.controller.ReservationDayController;
+import christmas.domain.EventManager;
+import christmas.domain.Orders;
+import christmas.domain.ReservationDay;
+import christmas.service.EventManagerService;
+import christmas.view.input.InputView;
+import christmas.view.output.OutputView;
+
+public class EventPlanner {
+    private final OutputView outputView;
+    private final ReservationDayController reservationDayController;
+    private final OrdersController ordersController;
+    private final EventManagerService eventManagerService;
+
+    public EventPlanner(InputView inputView, OutputView outputView) {
+        this.outputView = outputView;
+        reservationDayController = new ReservationDayController(inputView, outputView);
+        ordersController = new OrdersController(inputView, outputView);
+        eventManagerService = new EventManagerService();
+        outputView.printGreetingMessage();
+    }
+
+    public void execute() {
+        ReservationDay reservationDay = reservationDayController.insertReservationDay();
+        Orders orders = ordersController.insertOrders();
+        EventManager eventManager = EventManager.of(reservationDay, orders);
+        printResult(reservationDay, orders, eventManager);
+        terminatePlanner();
+    }
+
+    private void printResult(ReservationDay reservationDay, Orders orders, EventManager eventManager) {
+        printIntroMessage(reservationDay);
+        printOrderedMenus(orders);
+        printTotalAmountWithNoDiscount(orders);
+        printGiftMenu(orders);
+        printBenefitsDetails(eventManager);
+        printTotalBenefitedAmount(eventManager);
+        printEstimatedAmountWithDiscount(eventManager);
+        printEventBadge(eventManager);
+    }
+
+    private void printIntroMessage(ReservationDay reservationDay) {
+        outputView.printIntroMessage(reservationDayController.createEventBenefitsPreviousDto(reservationDay));
+    }
+
+    private void printOrderedMenus(Orders orders) {
+        outputView.printOrderedMenus(ordersController.createOrderedMenusDto(orders));
+    }
+
+    private void printTotalAmountWithNoDiscount(Orders orders) {
+        outputView.printTotalAmountWithNoDiscount(ordersController.createTotalAmountWithNoDiscountDto(orders));
+    }
+
+    private void printGiftMenu(Orders orders) {
+        outputView.printGiftMenu(eventManagerService.createGiftDto(orders));
+    }
+
+    private void printBenefitsDetails(EventManager eventManager) {
+        outputView.printBenefitsDetails(eventManagerService.createBenefitsDetailsDto(eventManager));
+    }
+
+    private void printTotalBenefitedAmount(EventManager eventManager) {
+        outputView.printTotalBenefitedAmount(eventManagerService.createTotalBenefitedAmountDto(eventManager));
+    }
+
+    private void printEstimatedAmountWithDiscount(EventManager eventManager) {
+        outputView.printEstimatedAmountWithDiscount(
+                eventManagerService.createEstimatedAmountWithDiscountDto(eventManager));
+    }
+
+    private void printEventBadge(EventManager eventManager) {
+        outputView.printEventBadge(eventManagerService.createEventBadgeDto(eventManager));
+    }
+
+    private void terminatePlanner() {
+        Console.close();
+    }
+}

src/main/java/christmas/controller/OrdersController.java

@@ -0,0 +1,47 @@
+package christmas.controller;
+
+import christmas.domain.Orders;
+import christmas.domain.exception.InvalidOrdersException;
+import christmas.dto.OrderedMenusDto;
+import christmas.dto.TotalAmountWithNoDiscountDto;
+import christmas.service.OrdersService;
+import christmas.view.input.InputView;
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.OrdersInputException;
+import christmas.view.output.OutputView;
+import java.util.Map;
+
+public class OrdersController {
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final OrdersService ordersService;
+
+    public OrdersController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+        ordersService = new OrdersService();
+    }
+
+    public Orders insertOrders() {
+        try {
+            Map<String, Integer> orders = askToInsertOrders();
+            return ordersService.createOrders(orders);
+        } catch (BasicInputException | OrdersInputException | InvalidOrdersException e) {
+            outputView.printErrorMessage(e.getMessage());
+            return insertOrders();
+        }
+    }
+
+    private Map<String, Integer> askToInsertOrders() throws BasicInputException, OrdersInputException {
+        outputView.askToInsertOrders();
+        return inputView.getOrders();
+    }
+
+    public OrderedMenusDto createOrderedMenusDto(Orders orders) {
+        return ordersService.createOrdersHistoryDto(orders);
+    }
+
+    public TotalAmountWithNoDiscountDto createTotalAmountWithNoDiscountDto(Orders orders) {
+        return ordersService.createTotalAmountWithNoDiscountDto(orders);
+    }
+}

src/main/java/christmas/controller/ReservationDayController.java

@@ -0,0 +1,41 @@
+package christmas.controller;
+
+import christmas.domain.ReservationDay;
+import christmas.domain.exception.InvalidReservationDayException;
+import christmas.dto.EventBenefitsPreviewDto;
+import christmas.service.ReservationDayService;
+import christmas.view.input.InputView;
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.DayInputException;
+import christmas.view.output.OutputView;
+
+public class ReservationDayController {
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final ReservationDayService reservationDayService;
+
+    public ReservationDayController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+        reservationDayService = new ReservationDayService();
+    }
+
+    public ReservationDay insertReservationDay() {
+        try {
+            int reservationDay = askToInsertReservationDay();
+            return reservationDayService.createReservationDay(reservationDay);
+        } catch (BasicInputException | DayInputException | InvalidReservationDayException e) {
+            outputView.printErrorMessage(e.getMessage());
+            return insertReservationDay();
+        }
+    }
+
+    private int askToInsertReservationDay() throws BasicInputException, DayInputException {
+        outputView.askToInsertReservationDay();
+        return inputView.getReservationDay();
+    }
+
+    public EventBenefitsPreviewDto createEventBenefitsPreviousDto(ReservationDay reservationDay) {
+        return reservationDayService.createEventBenefitsPreviewDto(reservationDay);
+    }
+}

src/main/java/christmas/domain/DayPerMonth.java

@@ -0,0 +1,22 @@
+package christmas.domain;
+
+import static christmas.domain.constant.reservationday.ReservationDayConstant.DECEMBER_LAST_DAY;
+import static christmas.domain.constant.reservationday.ReservationDayConstant.DEFAULT_FIRST_DAY;
+import static christmas.domain.exception.message.InvalidReservationDayExceptionMessage.NOT_IN_APPROPRIATE_RANGE;
+
+import christmas.domain.exception.InvalidReservationDayException;
+
+public abstract class DayPerMonth {
+    public DayPerMonth() {
+    }
+
+    protected void validate(final int day) {
+        if (!isInAppropriateRange(day)) {
+            throw InvalidReservationDayException.of(NOT_IN_APPROPRIATE_RANGE.getMessage());
+        }
+    }
+
+    protected boolean isInAppropriateRange(final int day) {
+        return day >= DEFAULT_FIRST_DAY.getValue() && day <= DECEMBER_LAST_DAY.getValue();
+    }
+}

src/main/java/christmas/domain/EventManager.java

@@ -0,0 +1,138 @@
+package christmas.domain;
+
+import static christmas.domain.constant.event.ChristmasPromotion.CHRISTMAS_D_DAY_PROMOTION;
+import static christmas.domain.constant.event.EventNumberConstant.NONE_PROMOTION_APPLIED_AMOUNT;
+import static christmas.domain.constant.event.Promotion.GIFT_PROMOTION;
+import static christmas.domain.constant.event.Promotion.SPECIAL_PROMOTION;
+import static christmas.domain.constant.event.Promotion.WEEKDAY_PROMOTION;
+import static christmas.domain.constant.event.Promotion.WEEKEND_PROMOTION;
+
+import christmas.domain.constant.event.EventBadge;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class EventManager {
+    private final ReservationDay reservationDay;
+    private final Orders orders;
+
+    private EventManager(ReservationDay reservationDay, Orders orders) {
+        this.reservationDay = reservationDay;
+        this.orders = orders;
+    }
+
+    public static EventManager of(ReservationDay reservationDay, Orders orders) {
+        return new EventManager(reservationDay, orders);
+    }
+
+    public Map<String, Integer> createBenefitsDetails() {
+        Map<String, Integer> benefitsDetails = new LinkedHashMap<>();
+        if (orders.isEventApplicable()) {
+            return makeBenefitsDetails(benefitsDetails);
+        }
+        return Collections.unmodifiableMap(benefitsDetails);
+    }
+
+    private Map<String, Integer> makeBenefitsDetails(Map<String, Integer> benefitsDetails) {
+        addChristmasPromotionDetails(benefitsDetails);
+        addWeekdayPromotionDetails(benefitsDetails);
+        addWeekendPromotionDetails(benefitsDetails);
+        addSpecialPromotionDetails(benefitsDetails);
+        addGiftPromotionDetails(benefitsDetails);
+        return Collections.unmodifiableMap(benefitsDetails);
+    }
+
+    private void addChristmasPromotionDetails(Map<String, Integer> benefitsDetails) {
+        if (reservationDay.isChristmasPromotionApplicable()) {
+            benefitsDetails.put(CHRISTMAS_D_DAY_PROMOTION.getName(),
+                    calculateChristmasPromotionBenefitAmount());
+        }
+    }
+
+    private int calculateChristmasPromotionBenefitAmount() {
+        return CHRISTMAS_D_DAY_PROMOTION.getBenefitAmount(reservationDay.getDay());
+    }
+
+    private void addWeekdayPromotionDetails(Map<String, Integer> benefitsDetails) {
+        if (canAddWeekdayPromotion()) {
+            benefitsDetails.put(WEEKDAY_PROMOTION.getName(),
+                    calculateWeekdayPromotionBenefitAmount());
+        }
+    }
+
+    private boolean canAddWeekdayPromotion() {
+        return reservationDay.isWeekdayPromotionApplicable()
+                && calculateWeekdayPromotionBenefitAmount()
+                > NONE_PROMOTION_APPLIED_AMOUNT.getValue();
+    }
+
+    private int calculateWeekdayPromotionBenefitAmount() {
+        int count = orders.getOrders().stream()
+                .filter(Order::isWeekdayPromotionApplicable)
+                .mapToInt(Order::getMenuCount)
+                .sum();
+        return WEEKDAY_PROMOTION.getBenefitAmount() * count;
+    }
+
+    private void addWeekendPromotionDetails(Map<String, Integer> benefitsDetails) {
+        if (canAddWeekendPromotion()) {
+            benefitsDetails.put(WEEKEND_PROMOTION.getName(),
+                    calculateWeekendPromotionBenefitAmount());
+        }
+    }
+
+    private boolean canAddWeekendPromotion() {
+        return reservationDay.isWeekendPromotionApplicable()
+                && calculateWeekendPromotionBenefitAmount()
+                > NONE_PROMOTION_APPLIED_AMOUNT.getValue();
+    }
+
+    private int calculateWeekendPromotionBenefitAmount() {
+        int count = orders.getOrders().stream()
+                .filter(Order::isWeekendPromotionApplicable)
+                .mapToInt(Order::getMenuCount)
+                .sum();
+        return WEEKEND_PROMOTION.getBenefitAmount() * count;
+    }
+
+    private void addSpecialPromotionDetails(Map<String, Integer> benefitsDetails) {
+        if (reservationDay.isSpecialPromotionApplicable()) {
+            benefitsDetails.put(SPECIAL_PROMOTION.getName(), calculateSpecialPromotionBenefitAmount());
+        }
+    }
+
+    private int calculateSpecialPromotionBenefitAmount() {
+        return SPECIAL_PROMOTION.getBenefitAmount();
+    }
+
+    private void addGiftPromotionDetails(Map<String, Integer> benefitsDetails) {
+        if (orders.isGiftEventApplicable()) {
+            benefitsDetails.put(GIFT_PROMOTION.getName(), calculateGiftPromotionBenefitAmount());
+        }
+    }
+
+    private int calculateGiftPromotionBenefitAmount() {
+        return GIFT_PROMOTION.getBenefitAmount();
+    }
+
+    public int calculateTotalBenefitedAmount() {
+        return createBenefitsDetails().values().stream()
+                .mapToInt(Integer::intValue)
+                .sum();
+    }
+
+    public int calculateEstimatedOrdersAmountWithDiscount() {
+        return orders.calculateTotalAmountWithNoDiscount() - calculateTotalDiscountedAmount();
+    }
+
+    private int calculateTotalDiscountedAmount() {
+        if (orders.isGiftEventApplicable()) {
+            return calculateTotalBenefitedAmount() - calculateGiftPromotionBenefitAmount();
+        }
+        return calculateTotalBenefitedAmount();
+    }
+
+    public String issueEventBadge() {
+        return EventBadge.getBadgeNameByBenefitedPrice(calculateTotalBenefitedAmount());
+    }
+}

src/main/java/christmas/domain/Order.java

@@ -0,0 +1,43 @@
+package christmas.domain;
+
+import christmas.domain.constant.orders.FoodType;
+import christmas.domain.constant.orders.Menu;
+import christmas.domain.exception.InvalidOrdersException;
+
+public class Order {
+    private final Menu menu;
+    private final int count;
+
+    private Order(Menu menu, final int count) {
+        this.menu = menu;
+        this.count = count;
+    }
+
+    public static Order of(final String menuName, final int count) throws InvalidOrdersException {
+        return new Order(Menu.searchByName(menuName), count);
+    }
+
+    public String getMenuName() {
+        return menu.getName();
+    }
+
+    public int getMenuCount() {
+        return count;
+    }
+
+    public FoodType getFoodType() {
+        return menu.getFoodType();
+    }
+
+    public boolean isWeekdayPromotionApplicable() {
+        return menu.isWeekDayPromotionApplicable();
+    }
+
+    public boolean isWeekendPromotionApplicable() {
+        return menu.isWeekendPromotionApplicable();
+    }
+
+    public int getTotalPrice() {
+        return menu.getPrice() * count;
+    }
+}