Implement Seller Coupon Management REST API

src/main/java/com/bulkpurchase/config/GlobalExceptionHandler.java

@@ -0,0 +1,19 @@
+package com.bulkpurchase.config;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.context.request.WebRequest;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.Map;
+import java.util.Objects;
+
+@ControllerAdvice
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(ResponseStatusException.class)
+    public ResponseEntity<Object> handleResponseStatusException(ResponseStatusException ex, WebRequest request) {
+        return ResponseEntity.status(ex.getStatusCode()).body(Map.of("message", Objects.requireNonNull(ex.getReason())));
+    }
+}

src/main/java/com/bulkpurchase/domain/dto/coupon/CouponApplicableProductRequestDTO.java

@@ -0,0 +1,19 @@
+package com.bulkpurchase.domain.dto.coupon;
+
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import java.util.List;
+
+@Getter
+@Setter
+@ToString
+public class CouponApplicableProductRequestDTO {
+
+    @NotEmpty
+    private Long couponID;
+
+    private List<Long> productIDs;
+}

src/main/java/com/bulkpurchase/domain/dto/coupon/CouponResponseDTO.java

@@ -1,35 +1,35 @@
 package com.bulkpurchase.domain.dto.coupon;
 
 import com.bulkpurchase.domain.entity.coupon.Coupon;
-import com.bulkpurchase.domain.enums.CouponType;
 import lombok.Getter;
 import lombok.Setter;
 
-import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 
 @Getter
 @Setter
 public class CouponResponseDTO {
 
     private Long couponID;
     private String code;
-    private CouponType type;
+    private String type;
     private Double discount;
-    private LocalDateTime validFrom;
-    private LocalDateTime validUntil;
+    private String validFrom;
+    private String validUntil;
     private Double minimumOrderAmount;
     private Integer quantity;
     private String name;
     private String description;
     private Double maxDiscountAmount;
 
     public CouponResponseDTO(Coupon coupon) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm");
         this.couponID = coupon.getCouponID();
         this.code = coupon.getCode();
-        this.type = coupon.getType();
+        this.type = coupon.getType().getDescription();
         this.discount = coupon.getDiscount();
-        this.validFrom = coupon.getValidFrom();
-        this.validUntil = coupon.getValidUntil();
+        this.validFrom = coupon.getValidFrom().format(formatter);
+        this.validUntil = coupon.getValidUntil().format(formatter);
         this.minimumOrderAmount = coupon.getMinimumOrderAmount();
         this.quantity = coupon.getQuantity();
         this.name = coupon.getName();

src/main/java/com/bulkpurchase/domain/dto/product/ProductForCouponDTO.java

@@ -20,6 +20,11 @@ public ProductForCouponDTO(Product product) {
     public ProductForCouponDTO() {
     }
 
+    public ProductForCouponDTO(Long productID, String productName) {
+        this.productID = productID;
+        this.productName = productName;
+    }
+
     @Override
     public String toString() {
         return "ProductForCouponDTO{" +

src/main/java/com/bulkpurchase/domain/entity/coupon/Coupon.java

@@ -70,6 +70,11 @@ public class Coupon {
     public Coupon() {
     }
 
+    public Coupon(Long couponID, User createdBy) {
+        this.couponID = couponID;
+        this.createdBy = createdBy;
+    }
+
     public Coupon(CouponCreateRequestDTO couponCreateRequestDTO) {
         this.type = couponCreateRequestDTO.getType();
         this.discount = couponCreateRequestDTO.getDiscount();

src/main/java/com/bulkpurchase/domain/entity/product/Product.java

@@ -75,6 +75,12 @@ public class Product {
     @OneToMany(mappedBy = "product")
     private List<FavoriteProduct> favoritedByUsers;
 
+    public Product(Long productID, String productName, Category category) {
+        this.productID = productID;
+        this.productName = productName;
+        this.category = category;
+    }
+
     public ProductStatus getOppositeStatus() {
         return this.status == ProductStatus.ACTIVE ? ProductStatus.INACTIVE : ProductStatus.ACTIVE;
     }
@@ -92,6 +98,11 @@ public Product(ProductRequestDTO productRequestDTO, User user) {
     public Product() {
     }
 
+    public Product(Long productID, User user) {
+        this.productID = productID;
+        this.user = user;
+    }
+
     public void update(ProductRequestDTO productRequestDTO) {
         this.productName = productRequestDTO.getProductName();
         this.description = productRequestDTO.getDescription();

src/main/java/com/bulkpurchase/domain/repository/coupon/CouponRepository.java

@@ -2,6 +2,8 @@
 
 import com.bulkpurchase.domain.entity.coupon.Coupon;
 import com.bulkpurchase.domain.entity.user.User;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 
 import java.util.List;
@@ -11,6 +13,7 @@ public interface CouponRepository extends JpaRepository<Coupon, Long> {
 
 
     List<Coupon> findByCreatedBy(User user);
+    Page<Coupon> findByCreatedBy(User user, Pageable pageable);
 
     Coupon findByCode(String couponCode);
 

src/main/java/com/bulkpurchase/domain/repository/review/ReviewRepository.java

@@ -40,7 +40,7 @@ public interface ReviewRepository extends JpaRepository<Review, Long> {
             "(SELECT COUNT(f) FROM ReviewFeedback f WHERE f.review = r AND f.feedbackType = com.bulkpurchase.domain.enums.FeedbackType.DISLIKE) AS dislikeCount " +
             "FROM Review r WHERE r.product.user.userID = :userID " +
             "ORDER BY r.creationDate DESC")
-    List<Object[]> findAllReviewDetailsWithFeedbackCountsByUserId(@Param("userID") Long userID);
+    List<Object[]> findAllReviewDetailsWithFeedbackCountsByUserId(@Param("userID") Long userID, Pageable page);
 
     @Query("SELECT r, " +
             "(SELECT COUNT(f) FROM ReviewFeedback f WHERE f.review = r AND f.feedbackType = com.bulkpurchase.domain.enums.FeedbackType.LIKE) AS likeCount, " +

src/main/java/com/bulkpurchase/domain/service/coupon/CouponService.java

@@ -4,6 +4,8 @@
 import com.bulkpurchase.domain.entity.user.User;
 import com.bulkpurchase.domain.repository.coupon.CouponRepository;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 
@@ -23,6 +25,9 @@ public Coupon save(Coupon coupon) {
     public List<Coupon> findByUser(User user) {
         return couponRepository.findByCreatedBy(user);
     }
+    public Page<Coupon> findByCreatedBy(User user, Pageable pageable) {
+        return couponRepository.findByCreatedBy(user, pageable);
+    }
 
     public Optional<Coupon> findById(Long couponID) {
         return couponRepository.findById(couponID);

src/main/java/com/bulkpurchase/domain/service/review/ReviewService.java

@@ -58,13 +58,14 @@ public Double findAverageRatingByProductID(Long productID) {
         return reviewRepository.findAverageRatingByProductID(productID);
     }
 
-    public List<ReviewDetailDTO> findAllReviewDetailsWithFeedbackCountsBySeller(Long userID) {
-        List<Object[]> results = reviewRepository.findAllReviewDetailsWithFeedbackCountsByUserId(userID);
-        return results.stream().map(result -> new ReviewDetailDTO(
+    public Page<ReviewDetailDTO> findAllReviewDetailsWithFeedbackCountsBySeller(Long userID, Pageable page) {
+        List<Object[]> results = reviewRepository.findAllReviewDetailsWithFeedbackCountsByUserId(userID,page);
+        List<ReviewDetailDTO> dtos = results.stream().map(result -> new ReviewDetailDTO(
                 (Review) result[0],
                 (Long) result[1],
                 (Long) result[2]
         )).collect(Collectors.toList());
+        return new PageImpl<>(dtos, page, dtos.size());
     }
 
     public Page<ReviewDetailDTO> findByUser(User user, Pageable page) {

src/main/java/com/bulkpurchase/domain/validator/CouponApplicableProductValidator.java

@@ -0,0 +1,53 @@
+package com.bulkpurchase.domain.validator;
+
+import com.bulkpurchase.domain.entity.coupon.Coupon;
+import com.bulkpurchase.domain.entity.coupon.CouponApplicableProduct;
+import com.bulkpurchase.domain.entity.product.Product;
+import com.bulkpurchase.domain.entity.user.User;
+import com.bulkpurchase.domain.service.coupon.CouponApplicableProductService;
+import com.bulkpurchase.domain.service.product.ProductService;
+import com.bulkpurchase.domain.validator.user.UserAuthValidator;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Component;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.security.Principal;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Component
+@RequiredArgsConstructor
+public class CouponApplicableProductValidator {
+
+    private final UserAuthValidator userAuthValidator;
+    private final CouponApplicableProductService couponApplicableProductService;
+    private final ProductService productService;
+
+    public void validateCouponOwner(Principal principal, Coupon coupon) {
+        User user = userAuthValidator.getCurrentUser(principal);
+        if (!user.equals(coupon.getCreatedBy())) {
+            throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "권한이 없습니다.");
+        }
+    }
+
+    public void validateAndApplyProductsToCoupon(List<Long> productIDs, Coupon coupon, Principal principal) {
+        User user = userAuthValidator.getCurrentUser(principal);
+        List<Product> products = productIDs.stream()
+                .map(this::validateAndGetProduct)
+                .filter(product -> product.getUser().equals(user)) // 상품이 현재 사용자에 의해 게시되었는지 확인
+                .toList();
+
+        if (products.size() != productIDs.size()) {
+            throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "하나 이상의 상품이 사용자에 의해 게시되지 않았습니다.");
+        }
+
+        couponApplicableProductService.deleteByCoupon(coupon);
+        products.forEach(product -> couponApplicableProductService.save(new CouponApplicableProduct(coupon, product.getProductID())));
+    }
+
+    private Product validateAndGetProduct(Long productID) {
+        return productService.findById(productID)
+                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "잘못된 상품 정보입니다."));
+    }
+}

src/main/java/com/bulkpurchase/domain/validator/user/UserAuthValidator.java

@@ -28,6 +28,9 @@ public Optional<User> authenticate(Principal principal) {
     }
 
     public User getCurrentUser(Principal principal) {
+        if (principal == null) {
+            throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "인증된 사용자 정보가 없습니다.");
+        }
         return userService.findByUsername(principal.getName())
                 .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "사용자를 찾을 수 없습니다."));
     }

src/main/java/com/bulkpurchase/web/controller/api/CouponAPIController.java

@@ -1,19 +1,19 @@
 package com.bulkpurchase.web.controller.api;
 
 import com.bulkpurchase.domain.dto.coupon.*;
-import com.bulkpurchase.domain.dto.product.ProductForCouponDTO;
 import com.bulkpurchase.domain.entity.coupon.Coupon;
-import com.bulkpurchase.domain.entity.coupon.CouponApplicableProduct;
 import com.bulkpurchase.domain.entity.coupon.UserCoupon;
 import com.bulkpurchase.domain.entity.user.User;
-import com.bulkpurchase.domain.service.coupon.CouponApplicableProductService;
+import com.bulkpurchase.domain.enums.UserRole;
 import com.bulkpurchase.domain.service.coupon.CouponService;
 import com.bulkpurchase.domain.service.coupon.UserCouponService;
-import com.bulkpurchase.domain.service.product.ProductService;
 import com.bulkpurchase.domain.validator.coupon.CouponValidatorImpl;
 import com.bulkpurchase.domain.validator.user.UserAuthValidator;
 import com.bulkpurchase.web.service.coupon.ApplyCouponService;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
@@ -24,7 +24,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
 @RestController
 @RequiredArgsConstructor
@@ -34,8 +33,6 @@ public class CouponAPIController {
     private final CouponService couponService;
     private final UserAuthValidator userAuthValidator;
     private final UserCouponService userCouponService;
-    private final CouponApplicableProductService couponApplicableProductService;
-    private final ProductService productService;
     private final ApplyCouponService applyCouponService;
     private final CouponValidatorImpl couponValidator;
 
@@ -69,7 +66,11 @@ public ResponseEntity<?> delete(@PathVariable("couponID") Long couponID, Princip
         if (couponOpt.isEmpty()) {
             return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(Map.of("message", "쿠폰이 존재하지 않습니다."));
         }
-        couponService.delete(couponOpt.get());
+        Coupon coupon = couponOpt.get();
+        if (!coupon.getCreatedBy().equals(user)) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(Map.of("message", "쿠폰을 삭제할 권한이 없습니다."));
+        }
+        couponService.delete(coupon);
         return ResponseEntity.ok(Map.of("message", "쿠폰이 정상적으로 삭제되었습니다."));
     }
 
@@ -85,16 +86,30 @@ public ResponseEntity<?> one(@PathVariable("couponID") Long couponID) {
 
     @GetMapping("/list")
     public ResponseEntity<List<CouponResponseDTO>> listPage() {
-        Sort sort = Sort.by(Sort.Direction.DESC, "id");
+        Sort sort = Sort.by(Sort.Direction.DESC, "couponID");
         List<Coupon> couponList = couponService.findAll(sort);
 
         List<CouponResponseDTO> dtoList = couponList.stream()
                 .map(CouponResponseDTO::new)
-                .collect(Collectors.toList());
+                .toList();
 
         return ResponseEntity.ok(dtoList);
     }
 
+    @GetMapping("/seller/{sellerID}")
+    public ResponseEntity<?> findListBySeller(@PathVariable("sellerID") Long sellerID,
+                                              @RequestParam(value = "page",defaultValue = "1") Integer page) {
+        User user = userAuthValidator.getCurrentUserByUserID(sellerID);
+        if (user.getRole() != UserRole.ROLE_판매자) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(Map.of("message", "잘못된 요청입니다."));
+        }
+        Sort sort = Sort.by(Sort.Direction.DESC, "couponID");
+        Pageable pageable = PageRequest.of(page - 1, 10, sort);
+        Page<Coupon> couponPage = couponService.findByCreatedBy(user, pageable);
+        List<CouponResponseDTO> coupons = couponPage.getContent().stream().map(CouponResponseDTO::new).toList();
+        return ResponseEntity.ok(Map.of("coupons", coupons, "totalPages", couponPage.getTotalPages(), "currentPage", page));
+    }
+
 
     @PostMapping("/redeem")
     public Map<String, Object> userCouponRedeem(Principal principal, @RequestParam("code") String code) {
@@ -117,20 +132,6 @@ public Map<String, Object> userCouponRedeem(Principal principal, @RequestParam("
         return response;
     }
 
-    @GetMapping("/{couponID}/products")
-    public ResponseEntity<?> findApplicableProductsForCoupon(@PathVariable("couponID") Long couponID) {
-        List<CouponApplicableProduct> couponApplicableProducts = couponApplicableProductService.findByCouponCouponID(couponID);
-
-        List<ProductForCouponDTO> productForCouponDTOList = couponApplicableProducts.stream()
-                .map(CouponApplicableProduct::getProductId)
-                .map(productService::findById)
-                .filter(Optional::isPresent)
-                .map(Optional::get)
-                .map(ProductForCouponDTO::new)
-                .collect(Collectors.toList());
-
-        return ResponseEntity.ok(productForCouponDTOList);
-    }
 
     @GetMapping("/user")
     public ResponseEntity<?> userCoupons(Principal principal) {