Merge pull request #21 from junoade/week4-feature-order

feat: Order 서비스 개선

Author: junoade

apps/commerce-api/src/main/java/com/loopers/application/order/OrderCommand.java

@@ -0,0 +1,36 @@
+package com.loopers.application.order;
+
+import com.loopers.domain.order.OrderItemModel;
+
+import java.util.List;
+
+public class OrderCommand {
+    /**
+     * 주문 유즈케이스에 대한 입력 DTO 입니다.
+     * 선조회/실행에서 동일한 DTO를 사용합니다.
+     * @param userId
+     * @param orderLineRequests
+     */
+    public record Order (
+        String userId,
+        List<OrderLine> orderLineRequests
+    ) { }
+
+    /**
+     * 주문 유즈케이스에서 주문 항목에 대한 입력 DTO 입니다.
+     * 선조회/실행에서 동일한 DTO를 사용합니다.
+     * @param productId
+     * @param quantity
+     */
+    public record OrderLine(
+            Long productId,
+            int quantity
+    ) {
+        public static OrderLine from(OrderItemModel item) {
+            return new OrderLine(
+                    item.getProduct().getId(),
+                    item.getQuantity()
+            );
+        }
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/order/OrderLineCommand.java

@@ -0,0 +1,44 @@
+package com.loopers.application.order;
+
+import java.util.List;
+
+public class OrderResult {
+    public record PreOrderResult(
+            String userId,
+            int requiringPoints,
+            List<OrderCommand.OrderLine> successLines,
+            List<OrderCommand.OrderLine> failedLines
+    ) {
+        public static PreOrderResult of(String userId,
+                                        int successPoint,
+                                        List<OrderCommand.OrderLine> successLines,
+                                        List<OrderCommand.OrderLine> failedLines) {
+            return new PreOrderResult(userId, successPoint, successLines, failedLines);
+        }
+    }
+
+    public record PlaceOrderResult(
+            String userId,
+            Long orderId,
+            int normalPrice,
+            int errorPrice,
+            List<OrderCommand.OrderLine> successLines,
+            List<OrderCommand.OrderLine> failedLines
+    ) {
+        public static PlaceOrderResult of(String userId,
+                                          Long orderId,
+                                          int normalPrice,
+                                          int errorPrice,
+                                        List<OrderCommand.OrderLine> successLines,
+                                        List<OrderCommand.OrderLine> failedLines) {
+            return new PlaceOrderResult(
+                    userId,
+                    orderId,
+                    normalPrice,
+                    errorPrice,
+                    successLines,
+                    failedLines);
+        }
+    }
+
+}

apps/commerce-api/src/main/java/com/loopers/application/order/OrderResult.java

@@ -0,0 +1,22 @@
+package com.loopers.application.order;
+
+import java.util.List;
+
+public record StockResult(
+            List<OrderCommand.OrderLine> successLines,
+            List<OrderCommand.OrderLine> failedLines,
+            int requiringPrice,
+            int errorPrice
+    ) {
+        public static StockResult of(
+                List<OrderCommand.OrderLine> successLines,
+                List<OrderCommand.OrderLine> failedLines,
+                int requiringPrice,
+                int errorPrice
+        )  {
+            return new StockResult(successLines,
+                    failedLines,
+                    requiringPrice,
+                    errorPrice);
+        }
+}

apps/commerce-api/src/main/java/com/loopers/application/order/StockDecreaseResult.java

@@ -1,10 +1,15 @@
 package com.loopers.application.order;
 
+import com.loopers.domain.order.OrderItemModel;
+import com.loopers.domain.order.OrderItemStatus;
 import com.loopers.domain.order.OrderModel;
 import com.loopers.domain.order.OrderService;
+import com.loopers.domain.product.ProductModel;
 import com.loopers.domain.product.ProductService;
 import com.loopers.domain.user.UserModel;
 import com.loopers.domain.user.UserService;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -20,42 +25,112 @@ public class UserOrderProductFacade {
     private final UserService userService;
 
     @Transactional(readOnly = true)
-    public boolean preOrder(Long userPkId, List<OrderLineCommand> orderLines) {
-        productService.markCurrentStockStatus(orderLines);
-        UserModel userModel = userService.getUser(userPkId);
-        Integer total = productService.getTotalAmountOfAvailStock(orderLines);
-        return userModel.hasEnoughPoint(total);
+    public OrderResult.PreOrderResult preOrder(OrderCommand.Order orderCommand) {
+        UserModel userModel = userService.getUser(orderCommand.userId());
+        StockResult result = readAllStocks(orderCommand.orderLineRequests());
+        if(!userModel.hasEnoughPoint(result.requiringPrice())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "포인트가 부족합니다.");
+        }
+
+        return OrderResult.PreOrderResult.of(
+                userModel.getUserId(),
+                result.requiringPrice(),
+                result.successLines(),
+                result.failedLines()
+        );
     }
 
+    /**
+     *
+     * @param orderCommand
+     */
     @Transactional
-    public void placeOrder(Long userPkId, List<OrderLineCommand> orderLines) {
-        OrderModel order = orderService.putOrder(orderLines);
-        StockDecreaseResult stockResult = decreaseAllStocks(orderLines);
-        // TODO 클린 아키텍처 고려하기
-        orderService.putFailStatus(order, stockResult.failedLines());
-        Integer totalAmountPoint = stockResult.totalAmount();
-
-        // 포인트 부족 시 예외 → 전체 롤백
-        userService.decreaseUserPoint(userPkId, totalAmountPoint);
+    public OrderResult.PlaceOrderResult placeOrder(OrderCommand.Order orderCommand) {
+        UserModel userModel = userService.getUser(orderCommand.userId());
+        List<OrderItemModel> orderItems = toDomainOrderItem(orderCommand.orderLineRequests());
+        OrderModel orderModel = orderService.createPendingOrder(userModel, orderItems);
+
+        StockResult stockResult = decreaseAllStocks(orderItems);
+
+        Integer requiringPoints = stockResult.requiringPrice();
+        // 포인트 부족 시 롤백
+        if(!userModel.hasEnoughPoint(requiringPoints)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "포인트가 부족합니다. 다시 확인해주세요");
+        }
+
+        userService.decreaseUserPoint(userModel.getId(), requiringPoints);
+
+        boolean hasOutOfStockCase = !stockResult.failedLines().isEmpty();
+        if(hasOutOfStockCase) {
+            orderService.updateOrderAsPartialSuccess(orderModel, stockResult.requiringPrice() , stockResult.errorPrice());
+        } else {
+            orderService.updateOrderAsSuccess(orderModel, stockResult.requiringPrice());
+        }
+
+
+        return OrderResult.PlaceOrderResult.of(
+                userModel.getUserId(),
+                orderModel.getId(),
+                stockResult.requiringPrice(),
+                stockResult.errorPrice(),
+                stockResult.successLines(),
+                stockResult.failedLines()
+        );
     }
 
     @Transactional
-    protected StockDecreaseResult decreaseAllStocks(List<OrderLineCommand> lines) {
-        List<OrderLineCommand> success = new ArrayList<>();
-        List<OrderLineCommand> failed = new ArrayList<>();
-        int total = 0;
+    protected StockResult decreaseAllStocks(List<OrderItemModel> items) {
+        List<OrderCommand.OrderLine> success = new ArrayList<>();
+        List<OrderCommand.OrderLine> failed = new ArrayList<>();
+        int total = 0, fail = 0;
 
-        for (OrderLineCommand line : lines) {
+        for (OrderItemModel item : items) {
+            ProductModel p = item.getProduct();
+            boolean ok = productService.decreaseStock(p.getId(), item.getQuantity());
+            OrderCommand.OrderLine line = OrderCommand.OrderLine.from(item);
+            int requiringPoint = productService.getPrice(p.getId(), item.getQuantity());
+            if (ok) {
+                item.setStatus(OrderItemStatus.SUCCESS);
+                total += requiringPoint;
+                success.add(line);
+            } else {
+                item.setStatus(OrderItemStatus.FAILED);
+                fail += requiringPoint;
+                failed.add(line);
+            }
+        }
+
+        return StockResult.of(success, failed, total, fail);
+    }
+
+    protected StockResult readAllStocks(List<OrderCommand.OrderLine> lines) {
+        List<OrderCommand.OrderLine> success = new ArrayList<>();
+        List<OrderCommand.OrderLine> failed = new ArrayList<>();
+        int requiringPrice = 0, errorPrice = 0;
+
+        for (OrderCommand.OrderLine line : lines) {
             // TODO 엔티티 클래스에서 예외 발생시 포인트 계산 제대로 되는지 확인 필요
-            boolean ok = productService.decreaseStock(line.productId(), line.quantity());
+            boolean ok = productService.hasStock(line.productId(), line.quantity());
+            int point = productService.getPrice(line.productId(), line.quantity());
             if (ok) {
                 success.add(line);
-                total += productService.getPrice(line.productId(), line.quantity());
+                requiringPrice += point;
             } else {
                 failed.add(line);
+                errorPrice += point;
             }
         }
+        return StockResult.of(success, failed, requiringPrice, errorPrice);
+    }
+
+
+    public List<OrderItemModel> toDomainOrderItem(List<OrderCommand.OrderLine> lines) {
+        return lines.stream()
+                .map(l -> {
+                    ProductModel p = productService.getProductDetail(l.productId());
+                    return OrderItemModel.of(p, l.quantity());
+                })
+                .toList();
 
-        return StockDecreaseResult.of(success, failed, total);
     }
 }

apps/commerce-api/src/main/java/com/loopers/application/order/StockResult.java

@@ -7,15 +7,19 @@
 @Entity
 @Table(name = "orders_item",
         uniqueConstraints =
-                @UniqueConstraint(name = "uk_order_item",
-                        columnNames = {"orders_id", "product_id"}
-                )
+        @UniqueConstraint(name = "uk_order_item",
+                columnNames = {"orders_id", "product_id"}
+        )
 )
 public class OrderItemModel extends BaseEntity {
 
     @Column(length = 50)
     private String name;
     private Integer price;
+    private Integer quantity;
+
+    @Enumerated(EnumType.STRING)
+    private OrderItemStatus status;
 
     @ManyToOne(fetch = FetchType.LAZY, optional = false)
     @JoinColumn(name = "orders_id", nullable = false)
@@ -24,4 +28,40 @@ public class OrderItemModel extends BaseEntity {
     @ManyToOne(fetch = FetchType.LAZY, optional = false)
     @JoinColumn(name = "product_id", nullable = false)
     private ProductModel product;
+
+    protected OrderItemModel() {}
+
+    public static OrderItemModel of(ProductModel product, int quantity) {
+        OrderItemModel orderItem = new OrderItemModel();
+
+        orderItem.product = product;
+        orderItem.quantity = quantity;
+        orderItem.name = product.getName();
+        orderItem.price = product.getPrice();
+        return orderItem;
+    }
+
+    public void setOrders(OrderModel orders) {
+        this.orders = orders;
+    }
+
+    public void setStatus(OrderItemStatus status) {
+        this.status = status;
+    }
+
+    public Integer getPrice() {
+        return price;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public ProductModel getProduct() {
+        return product;
+    }
+
+    public Integer getQuantity() {
+        return quantity;
+    }
 }

apps/commerce-api/src/main/java/com/loopers/application/order/UserOrderProductFacade.java

@@ -0,0 +1,7 @@
+package com.loopers.domain.order;
+
+public enum OrderItemStatus {
+    WAITING,
+    SUCCESS,
+    FAILED
+}