Merge pull request #7 from Kimjipang/round03

Round03

Author: Kimjipang

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

@@ -0,0 +1,69 @@
+package com.loopers.application.like;
+
+import com.loopers.domain.like.Like;
+import com.loopers.domain.like.LikeRepository;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.user.UserRepository;
+import com.loopers.interfaces.api.like.LikeV1Dto;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+@RequiredArgsConstructor
+public class LikeFacade {
+    private final LikeRepository likeRepository;
+    private final UserRepository userRepository;
+    private final ProductRepository productRepository;
+
+    @Transactional
+    public LikeInfo doLike(LikeV1Dto.LikeRequest request) {
+        /*
+        - [ ] 사용자 검증
+        - [ ] 상품 검증
+        - [ ] 좋아요 등록 (멱등)
+         */
+        Long userId = request.userId();
+        Long productId = request.productId();
+
+        userRepository.findById(userId).orElseThrow(
+                () -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 유저입니다.")
+        );
+
+        productRepository.findById(productId).orElseThrow(
+                () -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 상품입니다.")
+        );
+
+        return likeRepository.findByUserIdAndProductId(userId, productId)
+                .map(LikeInfo::from)
+                .orElseGet(() -> {
+                    Like newLike = request.toEntity();
+                    likeRepository.save(newLike);
+
+                    return LikeInfo.from(newLike);
+                });
+    }
+
+    @Transactional
+    public void doUnlike(Long userId, Long productId) {
+        /*
+        - [ ] 사용자 검증
+        - [ ] 상품 검증
+        - [ ] 좋아요 취소 (멱등)
+         */
+
+        userRepository.findById(userId).orElseThrow(
+                () -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 유저입니다.")
+        );
+
+        productRepository.findById(productId).orElseThrow(
+                () -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 상품입니다.")
+        );
+
+        likeRepository.findByUserIdAndProductId(userId, productId)
+                .ifPresent(likeRepository::delete);
+
+    }
+}

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

@@ -0,0 +1,13 @@
+package com.loopers.application.like;
+
+import com.loopers.domain.like.Like;
+
+public record LikeInfo(Long id, Long userId, Long productId) {
+    public static LikeInfo from(Like like) {
+        return new LikeInfo(
+                like.getId(),
+                like.getUserId(),
+                like.getProductId()
+        );
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java

@@ -0,0 +1,54 @@
+package com.loopers.application.product;
+
+import com.loopers.domain.like.LikeRepository;
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.user.UserRepository;
+import com.loopers.interfaces.api.product.ProductV1Dto;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+public class ProductFacade {
+    private final ProductRepository productRepository;
+    private final LikeRepository likeRepository;
+
+
+    @Transactional
+    public ProductInfo registerProduct(ProductV1Dto.ProductRequest request) {
+        Product product = request.toEntity();
+        productRepository.save(product);
+
+        return ProductInfo.from(product, 0);
+    }
+
+    @Transactional
+    public List<ProductInfo> findAllProducts() {
+        List<Product> products = productRepository.findAll();
+
+        return products.stream()
+                .map(product -> {
+                    int likeCount = likeRepository.countByProductId(product.getId());
+                    return ProductInfo.from(product, likeCount);
+                })
+                .toList();
+    }
+
+    @Transactional(readOnly = true)
+    public ProductInfo findProductById(Long id) {
+        Product product = productRepository.findById(id).orElseThrow(
+                () -> new CoreException(ErrorType.NOT_FOUND, "찾고자 하는 상품이 존재하지 않습니다.")
+        );
+
+        int likeCount = likeRepository.countByProductId(id);
+
+        return ProductInfo.from(product, likeCount);
+    }
+
+}

apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java

@@ -0,0 +1,18 @@
+package com.loopers.application.product;
+
+import com.loopers.domain.product.Product;
+
+import java.math.BigDecimal;
+
+public record ProductInfo(Long id, Long brandId, String name, BigDecimal price, int stock, int likeCount) {
+    public static ProductInfo from(Product product, int likeCount) {
+        return new ProductInfo(
+            product.getId(),
+            product.getBrandId(),
+            product.getName(),
+            product.getPrice(),
+            product.getStock(),
+            likeCount
+        );
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/user/UserFacade.java

@@ -28,14 +28,14 @@ public UserInfo signUp(UserV1Dto.SignUpRequest request) {
     }
 
     @Transactional(readOnly = true)
-    public UserInfo getUserByLoginId(String loginId) {
+    public UserInfo findUserByLoginId(String loginId) {
         boolean isExist = userService.existsByLoginId(loginId);
 
         if (!isExist) {
             throw new CoreException(ErrorType.NOT_FOUND, "해당 유저ID의 사용자가 존재하지 않습니다.");
         }
 
-        UserEntity userEntity = userService.getUserByLoginId(loginId);
+        UserEntity userEntity = userService.findUserByLoginId(loginId);
         return UserInfo.from(userEntity);
     }
 }

apps/commerce-api/src/main/java/com/loopers/domain/like/Like.java

@@ -0,0 +1,35 @@
+package com.loopers.domain.like;
+
+import com.loopers.domain.BaseEntity;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@Table(name = "product_like")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Like extends BaseEntity {
+    @Column(name = "ref_user_id", nullable = false)
+    private Long userId;
+
+    @Column(name = "ref_product_id", nullable = false)
+    private Long productId;
+
+    public Like(Long userId, Long productId) {
+        this.userId = userId;
+        this.productId = productId;
+    }
+
+    public boolean isAlreadyLike(Like like) {
+        if (like != null) {
+            return true;
+        }
+        return false;
+    }
+
+
+}

apps/commerce-api/src/main/java/com/loopers/domain/like/LikeRepository.java

@@ -0,0 +1,13 @@
+package com.loopers.domain.like;
+
+import java.util.Optional;
+
+public interface LikeRepository {
+    Optional<Like> findByUserIdAndProductId(Long userId, Long productId);
+
+    Like save(Like like);
+
+    void delete(Like like);
+
+    int countByProductId(Long productId);
+}

apps/commerce-api/src/main/java/com/loopers/domain/product/Product.java

@@ -0,0 +1,61 @@
+package com.loopers.domain.product;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+
+@Getter
+@Entity
+@Table(name = "product")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Product extends BaseEntity {
+    @Column(name = "ref_brand_id", nullable = false)
+    private Long brandId;
+
+    @Column(name = "name", nullable = false)
+    private String name;
+
+    @Column(name = "price", nullable = false)
+    private BigDecimal price;
+
+    @Column(name = "stock", nullable = false)
+    private int stock;
+
+
+    public Product(Long brandId, String name, BigDecimal price, int stock) {
+        this.brandId = brandId;
+        this.name = name;
+        this.price = price;
+        this.stock = stock;
+    }
+
+    public Product changePrice(BigDecimal newPrice) {
+        this.price = newPrice;
+        return this;
+    }
+
+    public Product decreaseStock(int amount) {
+        if (amount <= 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "재고 감소량은 0보다 커야 합니다.");
+        }
+        if (this.stock < amount) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "재고가 부족합니다.");
+        }
+        this.stock -= amount;
+
+        return this;
+    }
+
+    public boolean isInStock(int quantity) {
+        return this.stock >= quantity;
+    }
+
+}

apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRepository.java

@@ -0,0 +1,16 @@
+package com.loopers.domain.product;
+
+import com.loopers.interfaces.api.product.ProductV1Dto;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface ProductRepository {
+    Optional<Product> findById(Long id);
+
+    Product save(Product product);
+
+    List<Product> findAll();
+
+    List<Product> searchProductsByCondition(ProductV1Dto.SearchProductRequest request);
+}

apps/commerce-api/src/main/java/com/loopers/domain/user/UserEntity.java

@@ -1,23 +1,40 @@
 package com.loopers.domain.user;
 
 import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
 import jakarta.persistence.Table;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
+import java.math.BigDecimal;
+
 @Entity
-@Table(name = "user")
+@Table(name = "users")
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class UserEntity extends BaseEntity {
+    @Column(unique = true, nullable = false)
     private String loginId;
+
+    @Column(unique = true, nullable = false)
     private String email;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
     private Gender gender;
+
     private String birth;
+
     private String password;
 
+    private BigDecimal pointBalance = BigDecimal.ZERO;
+
     public UserEntity(String loginId, String email, Gender gender, String birth, String password) {
         UserValidator.validateLoginId(loginId);
         UserValidator.validateEmail(email);
@@ -31,4 +48,21 @@ public UserEntity(String loginId, String email, Gender gender, String birth, Str
         this.password = password;
     }
 
+    public void addPoints(BigDecimal amount) {
+        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "포인트는 반드시 0보다 커야 합니다.");
+        }
+        this.pointBalance = this.pointBalance.add(amount);
+    }
+
+    public void deductPoints(BigDecimal amount) {
+        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "포인트는 반드시 0보다 커야 합니다.");
+        }
+        if (this.pointBalance.compareTo(amount) < 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "포인트 잔액이 부족합니다.");
+        }
+        this.pointBalance = this.pointBalance.subtract(amount);
+    }
+
 }