Merge branch 'dev' into refactor/delivery-schedule-individual-transaction(WR9-142)

Kojinyoung7220 · Kojinyoung7220 · commit e26c94fb5505 · 2025-03-12T00:46:38.000+09:00
# Conflicts:
#	src/main/java/io/crops/warmletter/global/config/AsyncConfig.java
diff --git a/src/main/java/io/crops/warmletter/domain/badword/controller/BadWordController.java b/src/main/java/io/crops/warmletter/domain/badword/controller/BadWordController.java
@@ -4,6 +4,7 @@
 import io.crops.warmletter.domain.badword.dto.request.CreateBadWordRequest;
 import io.crops.warmletter.domain.badword.dto.request.UpdateBadWordRequest;
 import io.crops.warmletter.domain.badword.dto.request.UpdateBadWordStatusRequest;
+import io.crops.warmletter.domain.badword.dto.response.BadWordResponse;
 import io.crops.warmletter.domain.badword.dto.response.UpdateBadWordResponse;
 import io.crops.warmletter.domain.badword.service.BadWordService;
 import io.crops.warmletter.global.response.BaseResponse;
@@ -28,19 +29,18 @@ public class BadWordController {
 
     @PostMapping
     @Operation(summary = "금칙어 등록", description = "금칙어 등록하는 API입니다.")
-    public ResponseEntity<BaseResponse<Void>> createBadWord(@RequestBody @Valid CreateBadWordRequest request) {
-        badWordService.createBadWord(request);
-        return ResponseEntity.ok(BaseResponse.of(null, "금칙어 등록완료"));
+    public ResponseEntity<BaseResponse<BadWordResponse>> createBadWord(@RequestBody @Valid CreateBadWordRequest request) {
+        BadWordResponse response = badWordService.createBadWord(request);
+        return ResponseEntity.ok(BaseResponse.of(response, "금칙어 등록완료"));
     }
 
     @PatchMapping("/{badWordId}/status")
     @Operation(summary = "금칙어 상태변경", description = "금칙어 상태변경 활성여부 API입니다.")
-    public ResponseEntity<BaseResponse<Void>> updateBadWordStatus(
+    public ResponseEntity<BaseResponse<BadWordResponse>> updateBadWordStatus(
             @PathVariable Long badWordId,
             @RequestBody @Valid UpdateBadWordStatusRequest request) {
-
-        badWordService.updateBadWordStatus(badWordId, request);
-        return ResponseEntity.ok(BaseResponse.of(null, "금칙어 상태 변경 완료"));
+        BadWordResponse response = badWordService.updateBadWordStatus(badWordId, request);
+        return ResponseEntity.ok(BaseResponse.of(response, "금칙어 상태 변경 완료"));
     }
 
     @GetMapping
diff --git a/src/main/java/io/crops/warmletter/domain/badword/dto/response/BadWordResponse.java b/src/main/java/io/crops/warmletter/domain/badword/dto/response/BadWordResponse.java
@@ -1,5 +1,6 @@
 package io.crops.warmletter.domain.badword.dto.response;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
@@ -11,4 +12,11 @@ public class BadWordResponse {
     private Long id;
     @Schema(description = "금지어 단어", example = "비속어")
     private String word;
+
+    private boolean isUsed;
+
+    @JsonProperty("isUsed")
+    public boolean isUsed() {
+        return isUsed;
+    }
 }
diff --git a/src/main/java/io/crops/warmletter/domain/badword/repository/BadWordRepository.java b/src/main/java/io/crops/warmletter/domain/badword/repository/BadWordRepository.java
@@ -12,7 +12,7 @@
 public interface BadWordRepository extends JpaRepository<BadWord, Long> {
     boolean existsByWord(String word);
 
-    @Query("SELECT new io.crops.warmletter.domain.badword.dto.response.BadWordResponse(b.id, b.word) FROM BadWord b WHERE b.isUsed = true")
+    @Query("SELECT new io.crops.warmletter.domain.badword.dto.response.BadWordResponse(b.id, b.word, b.isUsed) FROM BadWord b ")
     List<BadWordResponse> findAllBadWords();
 
 }
diff --git a/src/main/java/io/crops/warmletter/domain/badword/service/BadWordService.java b/src/main/java/io/crops/warmletter/domain/badword/service/BadWordService.java
@@ -4,6 +4,7 @@
 import io.crops.warmletter.domain.badword.dto.request.CreateBadWordRequest;
 import io.crops.warmletter.domain.badword.dto.request.UpdateBadWordRequest;
 import io.crops.warmletter.domain.badword.dto.request.UpdateBadWordStatusRequest;
+import io.crops.warmletter.domain.badword.dto.response.BadWordResponse;
 import io.crops.warmletter.domain.badword.dto.response.UpdateBadWordResponse;
 import io.crops.warmletter.domain.badword.entity.BadWord;
 import io.crops.warmletter.domain.badword.exception.BadWordContainsException;
@@ -33,7 +34,8 @@ public class BadWordService {
     private static final String BAD_WORD_PATTERN = "[^가-힣ㄱ-ㅎㅏ-ㅣa-zA-Z0-9\\s]";
 
 
-    public void createBadWord(CreateBadWordRequest request) {
+    @Transactional
+    public BadWordResponse createBadWord(CreateBadWordRequest request) {
         String word = request.getWord();
 
         boolean exists = badWordRepository.existsByWord(word);
@@ -46,38 +48,43 @@ public void createBadWord(CreateBadWordRequest request) {
                 .isUsed(true)
                 .build();
 
-
-        badWordRepository.save(badWord);
+        BadWord savedBadWord = badWordRepository.save(badWord);
 
         redisTemplate.opsForHash().put(BAD_WORD_KEY, badWord.getId().toString(), word);
+        return new BadWordResponse(savedBadWord.getId(), savedBadWord.getWord(), savedBadWord.isUsed());
     }
 
 
     @Transactional
-    public void updateBadWordStatus(Long badWordId, UpdateBadWordStatusRequest request) {
+    public BadWordResponse updateBadWordStatus(Long badWordId, UpdateBadWordStatusRequest request) {
         BadWord badWord = badWordRepository.findById(badWordId)
                 .orElseThrow(BadWordNotFoundException::new);
         badWord.updateStatus(request.isUsed());
+        BadWord savedBadWord = badWordRepository.save(badWord);
+        redisTemplate.opsForHash().delete(BAD_WORD_KEY,badWordId.toString(), badWord.getWord());
+        redisTemplate.opsForHash().put(BAD_WORD_KEY,badWordId.toString(), badWord.getWord());
+        return new BadWordResponse(savedBadWord.getId(), savedBadWord.getWord(), savedBadWord.isUsed());
 
-        if (request.isUsed()) {
-            redisTemplate.opsForHash().put(BAD_WORD_KEY,badWordId.toString(), badWord.getWord());
-        } else {
-            redisTemplate.opsForHash().delete(BAD_WORD_KEY,badWordId.toString(), badWord.getWord());
-        }
     }
 
     public List<Map<String, String>> getBadWords() {
         Map<Object, Object> entries = redisTemplate.opsForHash().entries(BAD_WORD_KEY);
         return entries.entrySet().stream()
                 .map(e -> {
                     Map<String, String> map = new HashMap<>();
-                    map.put("id", e.getKey().toString());
+                    // 여기서 id 변수를 선언합니다.
+                    String id = e.getKey().toString();
+                    map.put("id", id);
                     map.put("word", e.getValue().toString());
+                    // DB에서 조회한 isUsed 값을 포함 (없으면 기본값 false)
+                    Optional<BadWord> optional = badWordRepository.findById(Long.valueOf(id));
+                    map.put("isUsed", optional.map(bw -> Boolean.toString(bw.isUsed())).orElse("false"));
                     return map;
                 })
-                .toList();
+                .collect(Collectors.toList());
     }
 
+
     @Transactional
     public UpdateBadWordResponse updateBadWord(Long id, UpdateBadWordRequest request) {
         BadWord badWord = badWordRepository.findById(id)
diff --git a/src/main/java/io/crops/warmletter/domain/report/service/ReportService.java b/src/main/java/io/crops/warmletter/domain/report/service/ReportService.java
@@ -17,6 +17,7 @@
 import io.crops.warmletter.domain.report.dto.response.ReportsResponse;
 import io.crops.warmletter.domain.report.dto.response.UpdateReportResponse;
 import io.crops.warmletter.domain.report.entity.Report;
+import io.crops.warmletter.domain.report.enums.ReasonType;
 import io.crops.warmletter.domain.report.enums.ReportStatus;
 import io.crops.warmletter.domain.report.enums.ReportType;
 import io.crops.warmletter.domain.report.exception.DuplicateReportException;
@@ -30,20 +31,19 @@
 import io.crops.warmletter.domain.share.repository.ShareProposalRepository;
 import io.crops.warmletter.domain.timeline.dto.request.NotificationRequest;
 import io.crops.warmletter.domain.timeline.enums.AlarmType;
-import io.crops.warmletter.domain.timeline.facade.NotificationFacade;
 import jakarta.transaction.Transactional;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
+import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
 
 import java.time.LocalDateTime;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.concurrent.CompletableFuture;
 
 @Service
 @RequiredArgsConstructor
@@ -101,6 +101,7 @@ public Page<ReportsResponse> getAllReports(String reportType, String status, Pag
     @Transactional
     public ReportResponse createReport(CreateReportRequest request) {
         Long memberId = authFacde.getCurrentUserId();
+        //Long memberId = 1L;
         Map<String, String> reportedContentMap = new HashMap<>();
         validateRequest(request, memberId, reportedContentMap);
         String reportedContent = reportedContentMap.get("content");
@@ -124,13 +125,19 @@ public ReportResponse createReport(CreateReportRequest request) {
         }
         Report report = builder.build();
         Report savedReport = reportRepository.save(report);
-        CompletableFuture.runAsync(() -> {
-            Map<String, String> moderationResult = reportModerationService.moderateText(reportedContent, request.getReasonType(), request.getReason());
-            updateReportWithAIResult(savedReport.getId(), moderationResult);
-        });
+
+        processReportInBackground(savedReport.getId(), reportedContent, request.getReasonType(), request.getReason());
+
         return new ReportResponse(savedReport);
     }
 
+    // 신고 AI 판별 비동기 처리
+    @Async
+    public void processReportInBackground(Long reportId, String reportedContent, ReasonType reasonType, String reason) {
+        Map<String, String> moderationResult = reportModerationService.moderateText(reportedContent, reasonType, reason);
+        updateReportWithAIResult(reportId, moderationResult);
+    }
+
     @Transactional
     public void updateReportWithAIResult(Long reportId, Map<String, String> moderationResult) {
         Report report = reportRepository.findById(reportId)
diff --git a/src/main/java/io/crops/warmletter/domain/share/repository/ShareProposalRepository.java b/src/main/java/io/crops/warmletter/domain/share/repository/ShareProposalRepository.java
@@ -9,12 +9,14 @@ public interface ShareProposalRepository extends JpaRepository<ShareProposal,Lon
     @Query("SELECT m.zipCode " +
             "FROM ShareProposal proposal " +
             "JOIN Member m ON proposal.requesterId = m.id " +
-            "WHERE proposal.requesterId = :requesterId")
-    String findZipCodeByRequesterId(Long requesterId);
+            "WHERE proposal.id = :id " +
+            "AND proposal.requesterId = :requesterId ")
+    String findZipCodeByRequesterId(Long id, Long requesterId);
 
     @Query("SELECT m.zipCode " +
             "FROM ShareProposal proposal " +
             "JOIN Member m ON proposal.recipientId = m.id " +
-            "WHERE proposal.recipientId = :recipientId")
-    String findZipCodeByRecipientId(Long recipientId);
+            "WHERE proposal.id = :id " +
+            "AND proposal.recipientId = :recipientId ")
+    String findZipCodeByRecipientId(Long id, Long recipientId);
 }
diff --git a/src/main/java/io/crops/warmletter/domain/share/service/SharePostLikeService.java b/src/main/java/io/crops/warmletter/domain/share/service/SharePostLikeService.java
@@ -27,6 +27,14 @@ public SharePostLikeResponse getLikeCountAndStatus(Long sharePostId) {
         if (sharePostId == null)
             throw new ShareInvalidInputValue();
 
-        return sharePostLikeRepository.getLikeCountAndStatus(sharePostId,memberId);
+        boolean isLikedInRedis = postLikeRedisManager.isLiked(sharePostId,memberId);
+
+        SharePostLikeResponse response = sharePostLikeRepository.getLikeCountAndStatus(sharePostId,memberId);
+
+        if (isLikedInRedis != response.isLiked()) {
+            return new SharePostLikeResponse(response.getLikeCount(), isLikedInRedis);
+        }
+
+        return response;
     }
 }
diff --git a/src/main/java/io/crops/warmletter/domain/share/service/ShareProposalService.java b/src/main/java/io/crops/warmletter/domain/share/service/ShareProposalService.java
@@ -14,7 +14,6 @@
 import io.crops.warmletter.domain.share.repository.*;
 import io.crops.warmletter.domain.timeline.dto.request.NotificationRequest;
 import io.crops.warmletter.domain.timeline.enums.AlarmType;
-import io.crops.warmletter.domain.timeline.facade.NotificationFacade;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;
@@ -79,8 +78,8 @@ public ShareProposalStatusResponse approveShareProposal(Long shareProposalId) {
                 .build();
         sharePost = sharePostRepository.save(sharePost);
         // 알림 전송(양쪽 다)
-        String requestZipCode = shareProposalRepository.findZipCodeByRequesterId(shareProposal.getRequesterId());
-        String recipientZipCode = shareProposalRepository.findZipCodeByRecipientId(shareProposal.getRecipientId());
+        String requestZipCode = shareProposalRepository.findZipCodeByRequesterId(shareProposalId, shareProposal.getRequesterId());
+        String recipientZipCode = shareProposalRepository.findZipCodeByRecipientId(shareProposalId, shareProposal.getRecipientId());
         notificationPublisher.publishEvent(NotificationRequest.builder()
                 .senderZipCode(recipientZipCode)
                 .receiverId(shareProposal.getRequesterId())
diff --git a/src/main/java/io/crops/warmletter/domain/timeline/facade/NotificationFacade.java b/src/main/java/io/crops/warmletter/domain/timeline/facade/NotificationFacade.java
@@ -1,7 +1,6 @@
 package io.crops.warmletter.domain.timeline.facade;
 
 import io.crops.warmletter.domain.timeline.dto.request.NotificationRequest;
-import io.crops.warmletter.domain.timeline.enums.AlarmType;
 import io.crops.warmletter.domain.timeline.service.NotificationService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.scheduling.annotation.Async;
diff --git a/src/main/java/io/crops/warmletter/domain/timeline/service/NotificationService.java b/src/main/java/io/crops/warmletter/domain/timeline/service/NotificationService.java
@@ -1,6 +1,5 @@
 package io.crops.warmletter.domain.timeline.service;
 
-import io.crops.warmletter.domain.auth.exception.UnauthorizedException;
 import io.crops.warmletter.domain.auth.facade.AuthFacade;
 import io.crops.warmletter.domain.timeline.dto.response.NotificationResponse;
 import io.crops.warmletter.domain.timeline.entity.Timeline;
@@ -9,6 +8,7 @@
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.MediaType;
+import org.springframework.scheduling.annotation.Async;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -57,7 +57,9 @@ protected void handleTimeout(Long memberId, SseEmitter emitter) {
     }
 
     // 편지 수신, 신고 조치, 공유 요청, 공유 게시글 등록 시 호출 필요
-    public void createNotification(String senderZipCode, Long receiverId, AlarmType alarmType, String data){
+    @Transactional
+    public void createNotification(String senderZipCode, Long receiverId, AlarmType alarmType, String data) {
+
         Timeline.TimelineBuilder builder = Timeline.builder()
                 .memberId(receiverId)
                 // data = LETTER: letterId / REPORT: adminMemo, 경고횟수 / SHARE: shareProposalId / POSTED: sharePostId
@@ -111,6 +113,7 @@ protected void sendEventToClient(Long receiverId, NotificationResponse notificat
     }
 
     // 연결을 확인하기 위한 Heartbeat를 30초마다 실행
+    @Async
     @Scheduled(fixedRate = 30000)
     public void sendHeartbeat() {
         NotificationResponse notificationResponse = NotificationResponse.builder()
diff --git a/src/main/java/io/crops/warmletter/global/config/AsyncConfig.java b/src/main/java/io/crops/warmletter/global/config/AsyncConfig.java
@@ -6,8 +6,10 @@
 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
 import java.util.concurrent.ThreadPoolExecutor;
+import org.springframework.scheduling.annotation.EnableAsync;
 
 @Configuration
+@EnableAsync
 public class AsyncConfig {
 
     @Bean
diff --git a/src/test/java/io/crops/warmletter/domain/badword/cache/BadWordCacheInitializerTest.java b/src/test/java/io/crops/warmletter/domain/badword/cache/BadWordCacheInitializerTest.java
@@ -46,8 +46,8 @@ void loadBadWordsRedis_WithWords() {
         Long id2 = 2L;
         // given
         List<BadWordResponse> badWords = List.of(
-                new BadWordResponse(id1, "시발"),
-                new BadWordResponse(id2, "병신")
+                new BadWordResponse(id1, "시발", true),
+                new BadWordResponse(id2, "병신", true)
         );
         when(badWordRepository.findAllBadWords()).thenReturn(badWords);
 
diff --git a/src/test/java/io/crops/warmletter/domain/badword/service/BadWordServiceTest.java b/src/test/java/io/crops/warmletter/domain/badword/service/BadWordServiceTest.java
@@ -131,39 +131,52 @@ void updateBadWordStatus_activate_success() {
                 .build();
         UpdateBadWordStatusRequest request = new UpdateBadWordStatusRequest(true);
 
+        // badWordRepository.findById() 호출에 대해 badWord 반환
         when(badWordRepository.findById(1L)).thenReturn(Optional.of(badWord));
+        // badWordRepository.save() 호출 시 입력된 객체에 ID를 설정하여 반환하도록 스텁 설정
+        when(badWordRepository.save(any(BadWord.class))).thenAnswer(invocation -> {
+            BadWord updated = invocation.getArgument(0);
+            // 예시로 ID를 1L로 설정
+            ReflectionTestUtils.setField(updated, "id", 1L);
+            return updated;
+        });
+
         // when
         badWordService.updateBadWordStatus(1L, request);
 
         // then
         assertTrue(badWord.isUsed());
-        // 서비스 코드에서 hashOperations.put 호출하므로 해당 호출 검증
+        // hashOperations.put 호출 검증 (활성화 상태이므로 Redis에 업데이트)
         verify(hashOperations).put("bad_word", "1", "비속어");
     }
 
-
     @Test
     @DisplayName("금칙어 상태 업데이트 - 비활성화 성공")
     void updateBadWordStatus_deactivate_success() {
         // given
         BadWord badWord = BadWord.builder()
-                .id(1L)  // ID를 직접 할당
+                .id(1L)  // ID 직접 할당
                 .word("비속어")
                 .isUsed(true)
                 .build();
 
         UpdateBadWordStatusRequest request = new UpdateBadWordStatusRequest(false);
 
-        // Mock 동작 설정
+        // findById는 기존 badWord를 반환하도록 설정
         when(badWordRepository.findById(1L)).thenReturn(Optional.of(badWord));
-        // when
+        // save() 호출 시 업데이트된 객체를 반환하도록 스텁 설정 (이 경우 ID는 그대로 1L)
+        when(badWordRepository.save(any(BadWord.class))).thenAnswer(invocation -> invocation.getArgument(0));
+
+        // when: 상태 업데이트 메서드 호출 (비활성화)
         badWordService.updateBadWordStatus(1L, request);
 
         // then
-        assertFalse(badWord.isUsed()); // 상태 업데이트 확인
+        // 상태가 false로 변경되었는지 검증
+        assertFalse(badWord.isUsed());
+        // Redis 캐시에서 해당 금칙어 삭제가 호출되었는지 검증
         verify(hashOperations).delete("bad_word", "1", "비속어");
     }
-//
+
     @Test
     @DisplayName("금칙어가 포함되어 있지 않을 때 정상 통과")
     void validateText_noBadWord_success() {
@@ -286,7 +299,6 @@ void deleteBadWord_success() {
         // given
         Long badWordId = 1L;
         BadWord badWord = new BadWord();
-        // 필요한 경우 badWord에 속성을 추가할 수 있습니다.
         when(badWordRepository.findById(badWordId)).thenReturn(Optional.of(badWord));
 
         // when
@@ -311,15 +323,13 @@ void deleteBadWord_notFound() {
     @Test
     @DisplayName("금칙어가 포함된 경우 - 예외 발생")
     void testValidateTextWithBadWord() {
-        // 테스트용 텍스트: 금칙어가 독립된 단어로 존재하도록 공백을 둡니다.
         String targetStr = "이 문장에는 금칙어0 가 포함되어 있습니다.";
         System.out.println("targetStr: " + targetStr);
 
         // 해당 테스트에서 사용할 모의 금칙어 데이터: 오직 "금칙어0"만 포함
         Map<Object, Object> testBadWords = new HashMap<>();
         testBadWords.put("1", "금칙어0");
 
-        // 테스트 케이스 내에서 모의 데이터를 재설정(오버라이드)합니다.
         when(hashOperations.entries(BAD_WORD_KEY)).thenReturn(testBadWords);
         assertThrows(BadWordContainsException.class, () -> {
             badWordService.validateText(targetStr);
diff --git a/src/test/java/io/crops/warmletter/domain/report/service/ReportServiceTest.java b/src/test/java/io/crops/warmletter/domain/report/service/ReportServiceTest.java
diff --git a/src/test/java/io/crops/warmletter/domain/share/service/SharePostLikeServiceTest.java b/src/test/java/io/crops/warmletter/domain/share/service/SharePostLikeServiceTest.java

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`	`public interface BadWordRepository extends JpaRepository<BadWord, Long> {`
`13`	`13`	`boolean existsByWord(String word);`
`14`	`14`
`15`		`- @Query("SELECT new io.crops.warmletter.domain.badword.dto.response.BadWordResponse(b.id, b.word) FROM BadWord b WHERE b.isUsed = true")`
	`15`	`+ @Query("SELECT new io.crops.warmletter.domain.badword.dto.response.BadWordResponse(b.id, b.word, b.isUsed) FROM BadWord b ")`
`16`	`16`	`List<BadWordResponse> findAllBadWords();`
`17`	`17`
`18`	`18`	`}`