@@ -0,0 +1,101 @@
+package store.model.order;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import store.dto.request.OrderItemInputDto;
+import store.exception.ExceptionMessage;
+import store.exception.ExceptionUtils;
+import store.model.product.Product;
+import store.model.product.ProductManager;
+import store.model.product.Stock;
+
+public class Order {
+    private final ProductManager productManager;
+    private final List<OrderItem> orderItems = new ArrayList<>();
+    private final LocalDate orderDate;
+
+    public Order(ProductManager productManager, List<OrderItemInputDto> orderItemInputsDto,
+                 LocalDate orderDate) {
+        this.productManager = productManager;
+        this.orderDate = orderDate;
+        List<OrderItemInputDto> mergeOrderItemsInput = mergeDuplicateProducts(orderItemInputsDto);
+        for (OrderItemInputDto orderItemInputDto : mergeOrderItemsInput) {
+            createOrderItem(orderItemInputDto.productName(), orderItemInputDto.orderQuantity());
+        }
+    }
+
+    public List<OrderItem> getOrderItems() {
+        return List.copyOf(orderItems);
+    }
+
+    public List<OrderItem> findOrderItemByProductName(String productName) {
+        return orderItems.stream()
+                .filter(orderItem -> orderItem.getProductName().equals(productName))
+                .toList();
+    }
+
+    public void removeOrderItem(OrderItem orderItem) {
+        orderItems.remove(orderItem);
+    }
+
+    private List<OrderItemInputDto> mergeDuplicateProducts(List<OrderItemInputDto> orderItemInputsDto) {
+        Map<String, Integer> mergedProducts = new HashMap<>();
+        for (OrderItemInputDto item : orderItemInputsDto) {
+            mergedProducts.merge(item.productName(), item.orderQuantity(), Integer::sum);
+        }
+        return mergedProducts.entrySet().stream()
+                .map(entry -> new OrderItemInputDto(entry.getKey(), entry.getValue()))
+                .collect(Collectors.toList());
+    }
+
+    private void createOrderItem(String productName, int orderQuantity) {
+        validateProductExistsInStore(productName);
+        validateOrderQuantity(productName, orderQuantity);
+        List<Stock> productStocks = productManager.findStocksByProductName(productName);
+        int remainingQuantity = orderQuantity;
+        for (Stock stock : productStocks) {
+            if (remainingQuantity == 0) {
+                return;
+            }
+            remainingQuantity = createOrderAndUpdateStock(stock, remainingQuantity);
+        }
+    }
+
+    private int createOrderAndUpdateStock(Stock productStock, int remainingQuantity) {
+        if (productStock.getQuantity() <= 0) {
+            return remainingQuantity;
+        }
+        return calculateQuantityAndcreateOrderItem(productStock, remainingQuantity);
+    }
+
+    private int calculateQuantityAndcreateOrderItem(Stock productStock, int remainingQuantity) {
+        if (remainingQuantity <= productStock.getQuantity()) {
+            orderItems.add(new OrderItem(productStock.getProduct(), remainingQuantity));
+            productStock.reduceQuantity(remainingQuantity);
+            return 0;
+        }
+        orderItems.add(new OrderItem(productStock.getProduct(), productStock.getQuantity()));
+        remainingQuantity -= productStock.getQuantity();
+        productStock.reduceQuantity(productStock.getQuantity());
+        return remainingQuantity;
+    }
+
+    private void validateOrderQuantity(String productName, int orderQuantity) {
+        int productTotalQuantity = productManager.getProductTotalQuantity(productName);
+        if (productTotalQuantity < orderQuantity) {
+            ExceptionUtils.throwIllegalArgumentException(ExceptionMessage.INVALID_ORDER_ITEM_QUANTITY);
+        }
+    }
+
+    private void validateProductExistsInStore(String productName) {
+        List<Product> matchingProductsInStore = productManager.findMatchingProducts(productName);
+        if (matchingProductsInStore == null || matchingProductsInStore.isEmpty()) {
+            ExceptionUtils.throwIllegalArgumentException(ExceptionMessage.INVALID_ORDER_PRODUCT);
+        }
+    }
+}
+

리뷰: 해당 메서드 이름은 사용자가 주문한 내용(상품이름, 수량)를 통해 `OrderItem`이란 entity로 만드는 작업이라고 생각하였으나, 재고를 수정하는 로직이 들어있는 메소드로 보입니다. 메소드 명을 더 직관적으로 하면  이해하기 더 편할 것 같습니다..!👍

그리고, 만약 `productStocks`에 조회한 모든 `Stock`들을 for문으로 순차적으로 접근하여 사용자가 구입하고자 하는 수량만큼 감소시키는 것 같습니다. 이 부분에서 궁금한 부분은 다음과 같습니다.
1. 프로모션 상품의 재고부터 감소시키는가. 
2. 프로모션 상품의 재고를 수정할 때, 프로모션 기간인지 확인하고 재고를 감소시키는가.
3. 모든 `Stock`들에 접근하여 수량을 수정하였으나 for문이 끝났음에도 `remainingQuantity`의 값이 0보다 클 경우가 있는가.