[레거시 코드 리팩토링 - 3단계] 허브(방대의) 미션 제출합니다.

README.md

@@ -76,3 +76,12 @@
 ## 테이블
 
 <img width="1011" alt="image" src="https://github.com/greeng00se/greeng00se.github.io/assets/58586537/1c2a352e-bed7-4c0f-89ed-8d6d31487b9c">
+
+## 생각
+
+ID를 받는 생성자를 제거하는 과정에서 생긴 고민
+
+1. 모든 필드를 지정해줄 수 있는 주생성자를 만드는 건 구현 기술에 침투적인 생성자가 생기는 것인가?
+
+id 생성자를 제거한다면, 결국 도메인을 식별하기 위한 값을 넣으려면 jpa와 같은 기술에 의존적인 생성을 해야하는데, 오히려 제거하는 것이 구현 기술에 침투적인 생성자를 만드는 것이 아닌가?
+결국 해당 도메인을 식별하기 위한 값으로 본다면, jpa를 사용하지 않았을 때 값을 지정해줘야 할텐데, 해당 부분을 위해 남겨둬야하지 않을까?

src/main/java/kitchenpos/application/menu/MenuMapper.java

@@ -0,0 +1,50 @@
+package kitchenpos.application.menu;
+
+import static java.util.function.Function.identity;
+import static java.util.stream.Collectors.toMap;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import kitchenpos.domain.menu.Menu;
+import kitchenpos.domain.menu.MenuProduct;
+import kitchenpos.domain.product.Product;
+import kitchenpos.domain.product.ProductRepository;
+import kitchenpos.dto.menu.MenuProductRequest;
+import kitchenpos.dto.menu.MenuRequest;
+import kitchenpos.support.money.Money;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MenuMapper {
+
+    private final ProductRepository productRepository;
+
+    public MenuMapper(ProductRepository productRepository) {
+        this.productRepository = productRepository;
+    }
+
+    public Menu toMenu(MenuRequest request) {
+        Map<Long, Product> products = getProducts(request);
+        List<MenuProduct> menuProducts = toMenuProducts(request, products);
+        return new Menu(request.getName(), Money.valueOf(request.getPrice()), request.getMenuGroupId(), menuProducts);
+    }
+
+    private Map<Long, Product> getProducts(MenuRequest request) {
+        return productRepository.findAllByIdIn(request.getMenuProductIds()).stream()
+                .collect(toMap(Product::getId, identity()));
+    }
+
+    private List<MenuProduct> toMenuProducts(MenuRequest request, Map<Long, Product> products) {
+        return request.getMenuProducts().stream()
+                .map(menuProduct -> toMenuProduct(menuProduct, products.get(menuProduct.getProductId())))
+                .collect(Collectors.toList());
+    }
+
+    private MenuProduct toMenuProduct(MenuProductRequest menuProduct, Product product) {
+        if (product == null) {
+            throw new IllegalArgumentException("상품이 존재하지 않습니다.");
+        }
+        return new MenuProduct(product.getId(), product.getName(), product.getPrice(), menuProduct.getQuantity());
+    }
+}

src/main/java/kitchenpos/application/menu/MenuService.java

@@ -0,0 +1,39 @@
+package kitchenpos.application.menu;
+
+import static java.util.stream.Collectors.toList;
+
+import java.util.List;
+import kitchenpos.domain.menu.Menu;
+import kitchenpos.domain.menu.MenuRepository;
+import kitchenpos.domain.menu.MenuValidator;
+import kitchenpos.dto.menu.MenuRequest;
+import kitchenpos.dto.menu.MenuResponse;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+@Service
+public class MenuService {
+    private final MenuRepository menuRepository;
+    private final MenuMapper menuMapper;
+    private final MenuValidator menuValidator;
+
+    public MenuService(MenuRepository menuRepository, MenuMapper menuMapper, MenuValidator menuValidator) {
+        this.menuRepository = menuRepository;
+        this.menuMapper = menuMapper;
+        this.menuValidator = menuValidator;
+    }
+
+    public MenuResponse create(MenuRequest request) {
+        Menu menu = menuMapper.toMenu(request);
+        menu.register(menuValidator);
+        return MenuResponse.from(menuRepository.save(menu));
+    }
+
+    @Transactional(readOnly = true)
+    public List<MenuResponse> list() {
+        return menuRepository.findAll().stream()
+                .map(MenuResponse::from)
+                .collect(toList());
+    }
+}

src/main/java/kitchenpos/application/MenuGroupService.java → src/main/java/kitchenpos/application/menugroup/MenuGroupService.java

@@ -1,12 +1,12 @@
-package kitchenpos.application;
+package kitchenpos.application.menugroup;
 
 import static java.util.stream.Collectors.toList;
 
 import java.util.List;
-import kitchenpos.dao.MenuGroupRepository;
-import kitchenpos.domain.MenuGroup;
-import kitchenpos.dto.MenuGroupRequest;
-import kitchenpos.dto.MenuGroupResponse;
+import kitchenpos.domain.menugroup.MenuGroup;
+import kitchenpos.domain.menugroup.MenuGroupRepository;
+import kitchenpos.dto.menugroup.MenuGroupRequest;
+import kitchenpos.dto.menugroup.MenuGroupResponse;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 

src/main/java/kitchenpos/application/order/OrderService.java

@@ -0,0 +1,45 @@
+package kitchenpos.application.order;
+
+import static java.util.stream.Collectors.toList;
+
+import java.util.List;
+import kitchenpos.domain.order.Order;
+import kitchenpos.domain.order.OrderRepository;
+import kitchenpos.domain.order.OrderStatus;
+import kitchenpos.domain.order.OrderValidator;
+import kitchenpos.dto.order.OrderCreateRequest;
+import kitchenpos.dto.order.OrderResponse;
+import kitchenpos.dto.order.OrderStatusUpdateRequest;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+@Service
+public class OrderService {
+    private final OrderRepository orderRepository;
+    private final OrderValidator orderValidator;
+
+    public OrderService(OrderRepository orderRepository, OrderValidator orderValidator) {
+        this.orderRepository = orderRepository;
+        this.orderValidator = orderValidator;
+    }
+
+    public OrderResponse create(OrderCreateRequest request) {
+        Order order = request.toOrder();
+        order.place(orderValidator);
+        return OrderResponse.from(orderRepository.save(order));
+    }
+
+    @Transactional(readOnly = true)
+    public List<OrderResponse> list() {
+        return orderRepository.findAll().stream()
+                .map(OrderResponse::from)
+                .collect(toList());
+    }
+
+    public OrderResponse changeOrderStatus(Long orderId, OrderStatusUpdateRequest request) {
+        Order order = orderRepository.getById(orderId);
+        order.changeOrderStatus(OrderStatus.valueOf(request.getOrderStatus()));
+        return OrderResponse.from(orderRepository.save(order));
+    }
+}

src/main/java/kitchenpos/application/order/OrderTableChangedEventHandler.java

@@ -0,0 +1,25 @@
+package kitchenpos.application.order;
+
+import kitchenpos.domain.order.Order;
+import kitchenpos.domain.order.OrderRepository;
+import kitchenpos.domain.table.OrderTableChangedEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+public class OrderTableChangedEventHandler {
+
+    private final OrderRepository orderRepository;
+
+    public OrderTableChangedEventHandler(OrderRepository orderRepository) {
+        this.orderRepository = orderRepository;
+    }
+
+    @Transactional
+    @EventListener(OrderTableChangedEvent.class)
+    public void handle(OrderTableChangedEvent event) {
+        orderRepository.findByOrderTableId(event.getOrderTableId())
+                .ifPresent(Order::validateChangeTableStatusAllowed);
+    }
+}

src/main/java/kitchenpos/application/order/TableGroupUngroupedEventHandler.java

@@ -0,0 +1,39 @@
+package kitchenpos.application.order;
+
+import static java.util.stream.Collectors.toList;
+
+import java.util.List;
+import kitchenpos.domain.order.Order;
+import kitchenpos.domain.order.OrderRepository;
+import kitchenpos.domain.table.OrderTable;
+import kitchenpos.domain.table.OrderTableRepository;
+import kitchenpos.domain.tablegroup.TableGroupUngroupedEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+public class TableGroupUngroupedEventHandler {
+
+    private final OrderRepository orderRepository;
+    private final OrderTableRepository orderTableRepository;
+
+    public TableGroupUngroupedEventHandler(OrderRepository orderRepository, OrderTableRepository orderTableRepository) {
+        this.orderRepository = orderRepository;
+        this.orderTableRepository = orderTableRepository;
+    }
+
+    @Transactional
+    @EventListener(TableGroupUngroupedEvent.class)
+    public void handle(TableGroupUngroupedEvent event) {
+        List<Long> tableIds = getTableIds(event.getTableGroupId());
+        orderRepository.findAllByOrderTableIds(tableIds)
+                .forEach(Order::validateUngroupTableAllowed);
+    }
+
+    private List<Long> getTableIds(Long tableGroupId) {
+        return orderTableRepository.findAllByTableGroupId(tableGroupId).stream()
+                .map(OrderTable::getId)
+                .collect(toList());
+    }
+}