[volume-4] 쿠폰 도메인 추가, 동시성 제어 적용 - 이주옥

apps/commerce-api/src/main/java/com/loopers/application/address/AddressFacade.java

@@ -37,10 +37,10 @@ public List<AddressInfo> getAddresses(String loginId) {
             .toList();
     }
 
-    public void update(String loginId, Long addressId, String label, String recipientName, String recipientPhone,
-                       String zipCode, String address1, String address2) {
+    public void updateInfo(String loginId, Long addressId, String label, String recipientName, String recipientPhone,
+                           String zipCode, String address1, String address2) {
         Long memberId = getMemberId(loginId);
-        addressService.update(addressId, memberId, label, recipientName, recipientPhone,
+        addressService.updateInfo(addressId, memberId, label, recipientName, recipientPhone,
             zipCode, address1, address2);
     }
 

apps/commerce-api/src/main/java/com/loopers/application/brand/BrandFacade.java

@@ -37,8 +37,8 @@ public PagedInfo<BrandInfo> getBrands(String keyword, int page, int size) {
         );
     }
 
-    public void update(Long id, String name, String description) {
-        brandService.update(id, name, description);
+    public void updateInfo(Long id, String name, String description) {
+        brandService.updateInfo(id, name, description);
     }
 
     @Transactional

apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponFacade.java

@@ -0,0 +1,99 @@
+package com.loopers.application.coupon;
+
+import com.loopers.application.PagedInfo;
+import com.loopers.domain.PageResult;
+import com.loopers.domain.coupon.Coupon;
+import com.loopers.domain.coupon.CouponService;
+import com.loopers.domain.coupon.CouponType;
+import com.loopers.domain.coupon.MemberCoupon;
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberService;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@RequiredArgsConstructor
+@Component
+public class CouponFacade {
+
+    private final MemberService memberService;
+    private final CouponService couponService;
+
+    // ── Admin ──
+
+    public CouponInfo createCoupon(String name, String type, Long value, Long minOrderAmount,
+                                    LocalDateTime expiredAt, Integer validDays, Integer totalQuantity) {
+        CouponType couponType;
+        try {
+            couponType = CouponType.valueOf(type);
+        } catch (IllegalArgumentException e) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "유효하지 않은 쿠폰 타입입니다: " + type);
+        }
+        Coupon coupon = couponService.createCoupon(name, couponType, value, minOrderAmount, expiredAt, validDays, totalQuantity);
+        return CouponInfo.of(coupon);
+    }
+
+    public CouponInfo getCoupon(Long couponId) {
+        Coupon coupon = couponService.getCoupon(couponId);
+        return CouponInfo.of(coupon);
+    }
+
+    public PagedInfo<CouponInfo> getCoupons(int page, int size) {
+        PageResult<Coupon> result = couponService.getCoupons(page, size);
+        List<CouponInfo> infos = result.content().stream().map(CouponInfo::of).toList();
+        return new PagedInfo<>(infos, result.totalElements(), result.totalPages(), result.page(), result.size());
+    }
+
+    public void updateCoupon(Long couponId, String name, Long value, Long minOrderAmount, LocalDateTime expiredAt, Integer validDays) {
+        couponService.updateCoupon(couponId, name, value, minOrderAmount, expiredAt, validDays);
+    }
+
+    public void deleteCoupon(Long couponId) {
+        couponService.deleteCoupon(couponId);
+    }
+
+    public PagedInfo<MemberCouponInfo> getIssuedCoupons(Long couponId, int page, int size) {
+        Coupon coupon = couponService.getCoupon(couponId);
+        CouponInfo couponInfo = CouponInfo.of(coupon);
+        PageResult<MemberCoupon> result = couponService.getIssuedCoupons(couponId, page, size);
+        List<MemberCouponInfo> infos = result.content().stream()
+            .map(mc -> MemberCouponInfo.of(mc, couponInfo))
+            .toList();
+        return new PagedInfo<>(infos, result.totalElements(), result.totalPages(), result.page(), result.size());
+    }
+
+    // ── 대고객 ──
+
+    public MemberCouponInfo issueCoupon(String loginId, Long couponId) {
+        Long memberId = getMemberId(loginId);
+        MemberCoupon memberCoupon = couponService.issueCoupon(couponId, memberId);
+        Coupon coupon = couponService.getCoupon(couponId);
+        return MemberCouponInfo.of(memberCoupon, CouponInfo.of(coupon));
+    }
+
+    public PagedInfo<MemberCouponInfo> getMyCoupons(String loginId, int page, int size) {
+        Long memberId = getMemberId(loginId);
+        PageResult<MemberCoupon> result = couponService.getMemberCoupons(memberId, page, size);
+
+        List<Long> couponIds = result.content().stream().map(MemberCoupon::getCouponId).distinct().toList();
+        Map<Long, Coupon> couponMap = couponService.getCoupons(couponIds).stream()
+            .collect(Collectors.toMap(Coupon::getId, Function.identity()));
+
+        List<MemberCouponInfo> infos = result.content().stream()
+            .map(mc -> MemberCouponInfo.of(mc, CouponInfo.of(couponMap.get(mc.getCouponId()))))
+            .toList();
+        return new PagedInfo<>(infos, result.totalElements(), result.totalPages(), result.page(), result.size());
+    }
+
+    private Long getMemberId(String loginId) {
+        Member member = memberService.getMemberByLoginId(loginId);
+        return member.getId();
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponInfo.java

@@ -0,0 +1,31 @@
+package com.loopers.application.coupon;
+
+import com.loopers.domain.coupon.Coupon;
+
+import java.time.LocalDateTime;
+
+public record CouponInfo(
+    Long id,
+    String name,
+    String type,
+    Long value,
+    Long minOrderAmount,
+    LocalDateTime expiredAt,
+    Integer validDays,
+    Integer totalQuantity,
+    int issuedQuantity
+) {
+    public static CouponInfo of(Coupon coupon) {
+        return new CouponInfo(
+            coupon.getId(),
+            coupon.getName(),
+            coupon.getType().name(),
+            coupon.getValue(),
+            coupon.getMinOrderAmount(),
+            coupon.getExpiredAt(),
+            coupon.getValidDays(),
+            coupon.getTotalQuantity(),
+            coupon.getIssuedQuantity()
+        );
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/coupon/MemberCouponInfo.java

@@ -0,0 +1,27 @@
+package com.loopers.application.coupon;
+
+import com.loopers.domain.coupon.MemberCoupon;
+
+import java.time.LocalDateTime;
+
+public record MemberCouponInfo(
+    Long id,
+    Long memberId,
+    Long couponId,
+    String status,
+    LocalDateTime usedAt,
+    LocalDateTime expiredAt,
+    CouponInfo coupon
+) {
+    public static MemberCouponInfo of(MemberCoupon memberCoupon, CouponInfo couponInfo) {
+        return new MemberCouponInfo(
+            memberCoupon.getId(),
+            memberCoupon.getMemberId(),
+            memberCoupon.getCouponId(),
+            memberCoupon.getStatus().name(),
+            memberCoupon.getUsedAt(),
+            memberCoupon.getExpiredAt(),
+            couponInfo
+        );
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/like/LikeFacade.java

@@ -36,11 +36,14 @@ public LikeToggleInfo toggleProductLike(String loginId, Long productId) {
 
         boolean liked = likeService.toggleLike(memberId, LikeTargetType.PRODUCT, productId);
 
-        int likeCount = liked
-            ? productService.increaseLikeCount(productId)
-            : productService.decreaseLikeCount(productId);
-
-        return new LikeToggleInfo(liked, likeCount);
+        if (liked) {
+            productService.increaseLikeCount(productId);
+        } else {
+            productService.decreaseLikeCount(productId);
+        }
+
+        Product product = productService.getProduct(productId);
+        return new LikeToggleInfo(liked, product.getLikeCount());
     }
 
     @Transactional
@@ -50,11 +53,14 @@ public LikeToggleInfo toggleBrandLike(String loginId, Long brandId) {
 
         boolean liked = likeService.toggleLike(memberId, LikeTargetType.BRAND, brandId);
 
-        int likeCount = liked
-            ? brandService.increaseLikeCount(brandId)
-            : brandService.decreaseLikeCount(brandId);
+        if (liked) {
+            brandService.increaseLikeCount(brandId);
+        } else {
+            brandService.decreaseLikeCount(brandId);
+        }
 
-        return new LikeToggleInfo(liked, likeCount);
+        Brand brand = brandService.getBrand(brandId);
+        return new LikeToggleInfo(liked, brand.getLikeCount());
     }
 
     @Transactional(readOnly = true)

apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java

@@ -5,6 +5,8 @@
 import com.loopers.domain.member.Gender;
 import com.loopers.domain.member.Member;
 import com.loopers.domain.member.MemberService;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 
@@ -22,7 +24,12 @@ public boolean authenticate(String loginId, String rawPassword) {
 
     public MemberInfo register(String loginId, String rawPassword, String name,
                                LocalDate birthDate, String gender, String email, String phone) {
-        Gender genderEnum = Gender.valueOf(gender);
+        Gender genderEnum;
+        try {
+            genderEnum = Gender.valueOf(gender);
+        } catch (IllegalArgumentException e) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "유효하지 않은 성별입니다: " + gender);
+        }
         Member member = memberService.register(loginId, rawPassword, name, birthDate, genderEnum, email, phone);
         return MemberInfo.from(member);
     }

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

@@ -4,6 +4,7 @@
 import com.loopers.domain.PageResult;
 import com.loopers.domain.address.Address;
 import com.loopers.domain.address.AddressService;
+import com.loopers.domain.coupon.CouponService;
 import com.loopers.domain.member.Member;
 import com.loopers.domain.member.MemberService;
 import com.loopers.domain.order.Order;
@@ -16,6 +17,7 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDate;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -28,9 +30,11 @@ public class OrderFacade {
     private final ProductService productService;
     private final OrderService orderService;
     private final AddressService addressService;
+    private final CouponService couponService;
 
     @Transactional
-    public OrderInfo createOrder(String loginId, Long addressId, List<OrderItemRequest> itemRequests) {
+    public OrderInfo createOrder(String loginId, Long addressId, Long memberCouponId,
+                                 List<OrderItemRequest> itemRequests) {
         Long memberId = getMemberId(loginId);
 
         // 1. 배송지 검증 + 스냅샷
@@ -42,29 +46,45 @@ public OrderInfo createOrder(String loginId, Long addressId, List<OrderItemReque
             .toList();
         Map<Long, Integer> mergedItems = orderService.mergeOrderItems(serviceRequests);
 
-        // 3. 상품 검증 + 재고 차감 + totalAmount 계산
-        long totalAmount = 0L;
+        // 3. 상품 검증 + 재고 차감 + originalAmount 계산
+        long originalAmount = 0L;
         List<OrderService.OrderItemCommand> commands = new java.util.ArrayList<>();
 
-        for (Map.Entry<Long, Integer> entry : mergedItems.entrySet()) {
+        List<Map.Entry<Long, Integer>> sortedEntries = mergedItems.entrySet().stream()
+            .sorted(Comparator.comparingLong(Map.Entry::getKey))
+            .toList();
+
+        for (Map.Entry<Long, Integer> entry : sortedEntries) {
             Long productId = entry.getKey();
             int quantity = entry.getValue();
 
-            Product product = productService.getProduct(productId);
+            Product product = productService.getProductForUpdate(productId);
             product.validateOrderQuantity(quantity);
             product.decreaseStock(quantity);
 
-            totalAmount += product.getPrice() * quantity;
+            originalAmount += product.getPrice() * quantity;
             commands.add(new OrderService.OrderItemCommand(
                 productId, product.getName(), product.getPrice(), quantity
             ));
         }
 
-        // 4. 주문 생성
-        Order order = orderService.createOrder(
-            memberId, address.getRecipientName(), address.getRecipientPhone(),
-            address.getZipCode(), address.getAddress1(), address.getAddress2(), totalAmount
-        );
+        // 4. 쿠폰 적용
+        Order order;
+        if (memberCouponId != null) {
+            CouponService.CouponApplyResult couponResult = couponService.useCoupon(memberCouponId, memberId, originalAmount);
+            long totalAmount = originalAmount - couponResult.discountAmount();
+
+            order = orderService.createOrder(
+                memberId, address.getRecipientName(), address.getRecipientPhone(),
+                address.getZipCode(), address.getAddress1(), address.getAddress2(),
+                totalAmount, couponResult.memberCouponId(), originalAmount, couponResult.discountAmount()
+            );
+        } else {
+            order = orderService.createOrder(
+                memberId, address.getRecipientName(), address.getRecipientPhone(),
+                address.getZipCode(), address.getAddress1(), address.getAddress2(), originalAmount
+            );
+        }
 
         // 5. 주문 항목 생성
         List<OrderItem> items = orderService.createOrderItems(order.getId(), commands);
@@ -77,52 +97,55 @@ public void cancelOrder(String loginId, Long orderId) {
         Long memberId = getMemberId(loginId);
 
         // 소유권 검증 + 취소 상태 체크 + 상태 전이 (도메인 규칙)
-        List<OrderItem> items = orderService.cancelOrder(orderId, memberId);
+        OrderService.CancelOrderResult result = orderService.cancelOrder(orderId, memberId);
+
+        // 재고 복원 (cross-domain orchestration) — productId 순 정렬로 데드락 방지
+        List<OrderItem> sortedItems = result.items().stream()
+            .sorted(Comparator.comparingLong(OrderItem::getProductId))
+            .toList();
 
-        // 재고 복원 (cross-domain orchestration)
-        for (OrderItem item : items) {
-            Product product = productService.getProduct(item.getProductId());
+        for (OrderItem item : sortedItems) {
+            Product product = productService.getProductForUpdate(item.getProductId());
             product.increaseStock(item.getQuantity());
         }
+
+        // 쿠폰 복원
+        if (result.order().getMemberCouponId() != null) {
+            couponService.restoreCoupon(result.order().getMemberCouponId());
+        }
     }
 
-    @Transactional
     public OrderInfo updateShippingAddress(String loginId, Long orderId,
                                            String recipientName, String recipientPhone,
                                            String zipCode, String address1, String address2) {
         Long memberId = getMemberId(loginId);
-        Order order = orderService.getOrderForMember(orderId, memberId);
-
-        order.updateShippingAddress(recipientName, recipientPhone, zipCode, address1, address2);
+        Order order = orderService.updateShippingAddress(orderId, memberId,
+            recipientName, recipientPhone, zipCode, address1, address2);
 
         List<OrderItem> items = orderService.getOrderItems(orderId);
         return OrderInfo.of(order, items);
     }
 
-    @Transactional(readOnly = true)
     public OrderInfo getOrder(String loginId, Long orderId) {
         Long memberId = getMemberId(loginId);
         Order order = orderService.getOrderForMember(orderId, memberId);
         List<OrderItem> items = orderService.getOrderItems(orderId);
         return OrderInfo.of(order, items);
     }
 
-    @Transactional(readOnly = true)
     public PagedInfo<OrderSummaryInfo> getMyOrders(String loginId, LocalDate startAt, LocalDate endAt,
                                                     int page, int size) {
         Long memberId = getMemberId(loginId);
         PageResult<Order> result = orderService.getMyOrders(memberId, startAt, endAt, page, size);
         return toPagedSummary(result);
     }
 
-    @Transactional(readOnly = true)
     public OrderInfo getOrderForAdmin(Long orderId) {
         Order order = orderService.getOrder(orderId);
         List<OrderItem> items = orderService.getOrderItems(orderId);
         return OrderInfo.of(order, items);
     }
 
-    @Transactional(readOnly = true)
     public PagedInfo<OrderSummaryInfo> getOrdersForAdmin(Long memberId, int page, int size) {
         PageResult<Order> result = orderService.getOrders(memberId, page, size);
         return toPagedSummary(result);