🔧 목표 금액 유즈 케이스 리팩토링

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/ledger/service/TargetAmountDeleteService.java

@@ -0,0 +1,28 @@
+package kr.co.pennyway.api.apis.ledger.service;
+
+import kr.co.pennyway.domain.domains.target.domain.TargetAmount;
+import kr.co.pennyway.domain.domains.target.exception.TargetAmountErrorCode;
+import kr.co.pennyway.domain.domains.target.exception.TargetAmountErrorException;
+import kr.co.pennyway.domain.domains.target.service.TargetAmountService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+public class TargetAmountDeleteService {
+    private final TargetAmountService targetAmountService;
+
+    @Transactional
+    public void execute(Long targetAmountId) {
+        TargetAmount targetAmount = targetAmountService.readTargetAmount(targetAmountId)
+                .filter(TargetAmount::isAllocatedAmount)
+                .orElseThrow(() -> new TargetAmountErrorException(TargetAmountErrorCode.NOT_FOUND_TARGET_AMOUNT));
+
+        if (!targetAmount.isThatMonth()) {
+            throw new TargetAmountErrorException(TargetAmountErrorCode.INVALID_TARGET_AMOUNT_DATE);
+        }
+
+        targetAmountService.deleteTargetAmount(targetAmount);
+    }
+}

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/ledger/service/TargetAmountSaveService.java

@@ -6,25 +6,46 @@
 import kr.co.pennyway.domain.domains.target.exception.TargetAmountErrorException;
 import kr.co.pennyway.domain.domains.target.service.TargetAmountService;
 import kr.co.pennyway.domain.domains.user.domain.User;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorCode;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorException;
+import kr.co.pennyway.domain.domains.user.service.UserService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDate;
 
 @Slf4j
 @Service
 @RequiredArgsConstructor
 public class TargetAmountSaveService {
+    private final UserService userService;
     private final TargetAmountService targetAmountService;
 
-    @DistributedLock(key = "#key.concat(#user.getId()).concat('_').concat(#date.getYear()).concat('-').concat(#date.getMonthValue())")
-    public TargetAmount createTargetAmount(String key, User user, LocalDate date) {
+    @DistributedLock(key = "#key.concat(#userId).concat('_').concat(#date.getYear()).concat('-').concat(#date.getMonthValue())")
+    public TargetAmount createTargetAmount(String key, Long userId, LocalDate date) {
+        User user = userService.readUser(userId).orElseThrow(() -> new UserErrorException(UserErrorCode.NOT_FOUND));
+
         if (targetAmountService.isExistsTargetAmountThatMonth(user.getId(), date)) {
             log.info("{}에 대한 날짜의 목표 금액이 이미 존재합니다.", date);
             throw new TargetAmountErrorException(TargetAmountErrorCode.ALREADY_EXIST_TARGET_AMOUNT);
         }
 
         return targetAmountService.createTargetAmount(TargetAmount.of(-1, user));
     }
+
+    @Transactional
+    public TargetAmount updateTargetAmount(Long targetAmountId, Integer amount) {
+        TargetAmount targetAmount = targetAmountService.readTargetAmount(targetAmountId)
+                .orElseThrow(() -> new TargetAmountErrorException(TargetAmountErrorCode.NOT_FOUND_TARGET_AMOUNT));
+
+        if (!targetAmount.isThatMonth()) {
+            throw new TargetAmountErrorException(TargetAmountErrorCode.INVALID_TARGET_AMOUNT_DATE);
+        }
+
+        targetAmount.updateAmount(amount);
+
+        return targetAmount;
+    }
 }

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/ledger/service/TargetAmountSearchService.java

@@ -0,0 +1,54 @@
+package kr.co.pennyway.api.apis.ledger.service;
+
+import kr.co.pennyway.api.apis.ledger.dto.TargetAmountDto;
+import kr.co.pennyway.api.apis.ledger.mapper.TargetAmountMapper;
+import kr.co.pennyway.domain.domains.spending.dto.TotalSpendingAmount;
+import kr.co.pennyway.domain.domains.spending.service.SpendingService;
+import kr.co.pennyway.domain.domains.target.domain.TargetAmount;
+import kr.co.pennyway.domain.domains.target.exception.TargetAmountErrorCode;
+import kr.co.pennyway.domain.domains.target.exception.TargetAmountErrorException;
+import kr.co.pennyway.domain.domains.target.service.TargetAmountService;
+import kr.co.pennyway.domain.domains.user.domain.User;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorCode;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorException;
+import kr.co.pennyway.domain.domains.user.service.UserService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class TargetAmountSearchService {
+    private final UserService userService;
+    private final SpendingService spendingService;
+    private final TargetAmountService targetAmountService;
+
+    @Transactional(readOnly = true)
+    public TargetAmountDto.WithTotalSpendingRes readTargetAmountAndTotalSpending(Long userId, LocalDate date) {
+        TargetAmount targetAmount = targetAmountService.readTargetAmountThatMonth(userId, date).orElseThrow(() -> new TargetAmountErrorException(TargetAmountErrorCode.NOT_FOUND_TARGET_AMOUNT));
+        Optional<TotalSpendingAmount> totalSpending = spendingService.readTotalSpendingAmountByUserId(userId, date);
+
+        return TargetAmountMapper.toWithTotalSpendingResponse(targetAmount, totalSpending.orElse(null), date);
+    }
+
+    @Transactional(readOnly = true)
+    public List<TargetAmountDto.WithTotalSpendingRes> readTargetAmountsAndTotalSpendings(Long userId, LocalDate date) {
+        User user = userService.readUser(userId).orElseThrow(() -> new UserErrorException(UserErrorCode.NOT_FOUND));
+
+        List<TargetAmount> targetAmounts = targetAmountService.readTargetAmountsByUserId(userId);
+        List<TotalSpendingAmount> totalSpendings = spendingService.readTotalSpendingsAmountByUserId(userId);
+
+        return TargetAmountMapper.toWithTotalSpendingResponses(targetAmounts, totalSpendings, user.getCreatedAt().toLocalDate(), date);
+    }
+
+    @Transactional(readOnly = true)
+    public Integer readRecentTargetAmount(Long userId) {
+        return targetAmountService.readRecentTargetAmount(userId)
+                .map(TargetAmount::getAmount)
+                .orElse(-1);
+    }
+}

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/ledger/usecase/TargetAmountUseCase.java

@@ -2,95 +2,54 @@
 
 import kr.co.pennyway.api.apis.ledger.dto.TargetAmountDto;
 import kr.co.pennyway.api.apis.ledger.mapper.TargetAmountMapper;
-import kr.co.pennyway.api.apis.ledger.service.RecentTargetAmountSearchService;
+import kr.co.pennyway.api.apis.ledger.service.TargetAmountDeleteService;
 import kr.co.pennyway.api.apis.ledger.service.TargetAmountSaveService;
+import kr.co.pennyway.api.apis.ledger.service.TargetAmountSearchService;
 import kr.co.pennyway.common.annotation.UseCase;
 import kr.co.pennyway.domain.common.redisson.DistributedLockPrefix;
-import kr.co.pennyway.domain.domains.spending.dto.TotalSpendingAmount;
-import kr.co.pennyway.domain.domains.spending.service.SpendingService;
 import kr.co.pennyway.domain.domains.target.domain.TargetAmount;
-import kr.co.pennyway.domain.domains.target.exception.TargetAmountErrorCode;
-import kr.co.pennyway.domain.domains.target.exception.TargetAmountErrorException;
-import kr.co.pennyway.domain.domains.target.service.TargetAmountService;
-import kr.co.pennyway.domain.domains.user.domain.User;
-import kr.co.pennyway.domain.domains.user.exception.UserErrorCode;
-import kr.co.pennyway.domain.domains.user.exception.UserErrorException;
-import kr.co.pennyway.domain.domains.user.service.UserService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDate;
 import java.util.List;
-import java.util.Optional;
 
 @Slf4j
 @UseCase
 @RequiredArgsConstructor
 public class TargetAmountUseCase {
-    private final UserService userService;
-    private final TargetAmountService targetAmountService;
-    private final SpendingService spendingService;
-
     private final TargetAmountSaveService targetAmountSaveService;
-    private final RecentTargetAmountSearchService recentTargetAmountSearchService;
+    private final TargetAmountSearchService targetAmountSearchService;
+    private final TargetAmountDeleteService targetAmountDeleteService;
 
     @Transactional
     public TargetAmountDto.TargetAmountInfo createTargetAmount(Long userId, int year, int month) {
-        User user = userService.readUser(userId).orElseThrow(() -> new UserErrorException(UserErrorCode.NOT_FOUND));
-
-        TargetAmount targetAmount = targetAmountSaveService.createTargetAmount(DistributedLockPrefix.TARGET_AMOUNT_USER, user, LocalDate.of(year, month, 1));
+        TargetAmount targetAmount = targetAmountSaveService.createTargetAmount(DistributedLockPrefix.TARGET_AMOUNT_USER, userId, LocalDate.of(year, month, 1));
 
         return TargetAmountDto.TargetAmountInfo.from(targetAmount);
     }
 
-    @Transactional(readOnly = true)
     public TargetAmountDto.WithTotalSpendingRes getTargetAmountAndTotalSpending(Long userId, LocalDate date) {
-        TargetAmount targetAmount = targetAmountService.readTargetAmountThatMonth(userId, date).orElseThrow(() -> new TargetAmountErrorException(TargetAmountErrorCode.NOT_FOUND_TARGET_AMOUNT));
-        Optional<TotalSpendingAmount> totalSpending = spendingService.readTotalSpendingAmountByUserId(userId, date);
-
-        return TargetAmountMapper.toWithTotalSpendingResponse(targetAmount, totalSpending.orElse(null), date);
+        return targetAmountSearchService.readTargetAmountAndTotalSpending(userId, date);
     }
 
-    @Transactional(readOnly = true)
     public List<TargetAmountDto.WithTotalSpendingRes> getTargetAmountsAndTotalSpendings(Long userId, LocalDate date) {
-        User user = userService.readUser(userId).orElseThrow(() -> new UserErrorException(UserErrorCode.NOT_FOUND));
-
-        List<TargetAmount> targetAmounts = targetAmountService.readTargetAmountsByUserId(userId);
-        List<TotalSpendingAmount> totalSpendings = spendingService.readTotalSpendingsAmountByUserId(userId);
-
-        return TargetAmountMapper.toWithTotalSpendingResponses(targetAmounts, totalSpendings, user.getCreatedAt().toLocalDate(), date);
+        return targetAmountSearchService.readTargetAmountsAndTotalSpendings(userId, date);
     }
 
-    @Transactional(readOnly = true)
     public TargetAmountDto.RecentTargetAmountRes getRecentTargetAmount(Long userId) {
-        return TargetAmountMapper.toRecentTargetAmountResponse(recentTargetAmountSearchService.readRecentTargetAmount(userId));
+        return TargetAmountMapper.toRecentTargetAmountResponse(targetAmountSearchService.readRecentTargetAmount(userId));
     }
 
     @Transactional
     public TargetAmountDto.TargetAmountInfo updateTargetAmount(Long targetAmountId, Integer amount) {
-        TargetAmount targetAmount = targetAmountService.readTargetAmount(targetAmountId)
-                .orElseThrow(() -> new TargetAmountErrorException(TargetAmountErrorCode.NOT_FOUND_TARGET_AMOUNT));
-
-        if (!targetAmount.isThatMonth()) {
-            throw new TargetAmountErrorException(TargetAmountErrorCode.INVALID_TARGET_AMOUNT_DATE);
-        }
-
-        targetAmount.updateAmount(amount);
+        TargetAmount targetAmount = targetAmountSaveService.updateTargetAmount(targetAmountId, amount);
 
         return TargetAmountDto.TargetAmountInfo.from(targetAmount);
     }
 
-    @Transactional
     public void deleteTargetAmount(Long targetAmountId) {
-        TargetAmount targetAmount = targetAmountService.readTargetAmount(targetAmountId)
-                .filter(TargetAmount::isAllocatedAmount)
-                .orElseThrow(() -> new TargetAmountErrorException(TargetAmountErrorCode.NOT_FOUND_TARGET_AMOUNT));
-
-        if (!targetAmount.isThatMonth()) {
-            throw new TargetAmountErrorException(TargetAmountErrorCode.INVALID_TARGET_AMOUNT_DATE);
-        }
-
-        targetAmountService.deleteTargetAmount(targetAmount);
+        targetAmountDeleteService.execute(targetAmountId);
     }
 }