외래키 제거 완료

jenkins/Jenkinsfile

@@ -1,7 +1,13 @@
 pipeline {
     agent any
 
+    triggers {
+        githubPush()
+    }
+
     environment {
+        JENKINS_DOMAIN = credentials('jenkins_domain')
+
         SLACK_WEBHOOK_URL = credentials('slack_webhook_url')
         SLACK_COLOR_SUCCESS = credentials('slack_color_success')
         SLACK_COLOR_FAILURE = credentials('slack_color_failure')
@@ -134,33 +140,96 @@ pipeline {
     post {
         failure {
             script {
-                sendSlackNotification("${env.GIT_CHANGELOG}\n:scream_cat: Deployment failed.", env.SLACK_COLOR_FAILURE)
+                sendSlackBuildNotification(":scream_cat: Deployment failed.", env.SLACK_COLOR_FAILURE)
             }
         }
 
         success {
             script {
-                sendSlackNotification("${env.GIT_CHANGELOG}\n:rocket: Deployment completed successfully.", env.SLACK_COLOR_SUCCESS)
+                sendSlackBuildNotification(":rocket: Deployment completed successfully", env.SLACK_COLOR_SUCCESS)
             }
         }
     }
 }
 
-def sendSlackNotification(message, color) {
-    withEnv([
-        "SLACK_WEBHOOK_URL=${env.SLACK_WEBHOOK_URL}"
-    ]) {
-        def payload = """{
-            "attachments": [
-                {
-                    "color": "${color}",
-                    "text": "${message.replaceAll('"', '\\"').replaceAll('\n', '\\\\n')}"
-                }
+def sendSlackNotification(String message, String color) {
+    def payload = [
+        attachments: [
+            [
+                color: color,
+                text: message.replaceAll('"', '\\"').replaceAll('\n', '\\\\n')
+            ]
+        ]
+    ]
+
+    withEnv(["SLACK_WEBHOOK_URL=${env.SLACK_WEBHOOK_URL}"]) {
+        def payloadJson = groovy.json.JsonOutput.toJson(payload)
+        sh """
+            curl -X POST -H 'Content-type: application/json' --data '${payloadJson}' ${SLACK_WEBHOOK_URL}
+        """
+    }
+}
+
+
+def sendSlackBuildNotification(String message, String color) {
+    def jobUrl = "${env.JENKINS_DOMAIN}/job/${env.JOB_NAME}"
+    def consoleOutputUrl = "${jobUrl}/${env.BUILD_NUMBER}/console"
+
+    def payload = [
+        blocks: [
+            [
+                type: "section",
+                text: [
+                    type: "mrkdwn",
+                    text: message
+                ]
+            ]
+        ],
+        attachments: [
+            [
+                color: color,
+                blocks: [
+                    [
+                        type: "section",
+                        text: [
+                            type: "mrkdwn",
+                            text: "*Change Log:*\n${env.GIT_CHANGELOG}"
+                        ]
+                    ],
+                    [
+                        type: "actions",
+                        elements: [
+                            [
+                                type: "button",
+                                text: [
+                                    type: "plain_text",
+                                    text: "Job",
+                                    emoji: true
+                                ],
+                                url: jobUrl,
+                                value: "click_job"
+                            ],
+                            [
+                                type: "button",
+                                text: [
+                                    type: "plain_text",
+                                    text: "Console Output",
+                                    emoji: true
+                                ],
+                                url: consoleOutputUrl,
+                                value: "click_console_output"
+                            ]
+                        ]
+                    ]
+                ].findAll { it != null }
             ]
-        }"""
+        ]
+    ]
 
+    withEnv(["SLACK_WEBHOOK_URL=${env.SLACK_WEBHOOK_URL}"]) {
+        def payloadJson = groovy.json.JsonOutput.toJson(payload)
         sh """
-            curl -X POST --data-urlencode 'payload=${payload}' ${SLACK_WEBHOOK_URL}
+            curl -X POST -H 'Content-type: application/json' --data '${payloadJson}' ${SLACK_WEBHOOK_URL}
         """
     }
 }
@@ -319,7 +388,7 @@ def performHealthCheck() {
         echo "Public IP address: ${PUBLIC_IP}"
 
         def start_time = System.currentTimeMillis()
-        def timeout = start_time + 240000  // 4 minutes
+        def timeout = start_time + 150000  // 2.5 minutes
 
         while (System.currentTimeMillis() < timeout) {
             def elapsed = (System.currentTimeMillis() - start_time) / 1000

src/main/java/page/clab/api/domain/accuse/application/AccuseEventProcessor.java

@@ -0,0 +1,40 @@
+package page.clab.api.domain.accuse.application;
+
+import jakarta.annotation.PostConstruct;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import page.clab.api.domain.accuse.dao.AccuseRepository;
+import page.clab.api.domain.accuse.domain.Accuse;
+import page.clab.api.domain.member.event.MemberEventProcessor;
+import page.clab.api.domain.member.event.MemberEventProcessorRegistry;
+
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+public class AccuseEventProcessor implements MemberEventProcessor {
+
+    private final AccuseRepository accuseRepository;
+
+    private final MemberEventProcessorRegistry processorRegistry;
+
+    @PostConstruct
+    public void init() {
+        processorRegistry.register(this);
+    }
+
+    @Override
+    @Transactional
+    public void processMemberDeleted(String memberId) {
+        List<Accuse> accuses = accuseRepository.findByMemberId(memberId);
+        accuses.forEach(Accuse::delete);
+        accuseRepository.saveAll(accuses);
+    }
+
+    @Override
+    public void processMemberUpdated(String memberId) {
+        // do nothing
+    }
+
+}

src/main/java/page/clab/api/domain/accuse/application/AccuseService.java

@@ -15,16 +15,15 @@
 import page.clab.api.domain.accuse.domain.AccuseTargetId;
 import page.clab.api.domain.accuse.domain.TargetType;
 import page.clab.api.domain.accuse.dto.request.AccuseRequestDto;
-import page.clab.api.domain.accuse.dto.response.AccuseMemberInfo;
+import page.clab.api.domain.member.dto.shared.MemberBasicInfoDto;
 import page.clab.api.domain.accuse.dto.response.AccuseMyResponseDto;
 import page.clab.api.domain.accuse.dto.response.AccuseResponseDto;
 import page.clab.api.domain.accuse.exception.AccuseTargetTypeIncorrectException;
 import page.clab.api.domain.board.application.BoardService;
 import page.clab.api.domain.board.domain.Board;
 import page.clab.api.domain.comment.application.CommentService;
 import page.clab.api.domain.comment.domain.Comment;
-import page.clab.api.domain.member.application.MemberService;
-import page.clab.api.domain.member.domain.Member;
+import page.clab.api.domain.member.application.MemberLookupService;
 import page.clab.api.domain.notification.application.NotificationService;
 import page.clab.api.domain.review.application.ReviewService;
 import page.clab.api.domain.review.domain.Review;
@@ -33,13 +32,15 @@
 import page.clab.api.global.validation.ValidationService;
 
 import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
 
 @Service
 @RequiredArgsConstructor
 @Slf4j
 public class AccuseService {
 
-    private final MemberService memberService;
+    private final MemberLookupService memberLookupService;
 
     private final BoardService boardService;
 
@@ -59,19 +60,19 @@ public class AccuseService {
     public Long createAccuse(AccuseRequestDto requestDto) {
         TargetType type = requestDto.getTargetType();
         Long targetId = requestDto.getTargetId();
-        Member currentMember = memberService.getCurrentMember();
+        String memberId = memberLookupService.getCurrentMemberId();
 
-        validateAccuseRequest(type, targetId, currentMember);
+        validateAccuseRequest(type, targetId, memberId);
 
         AccuseTarget target = getOrCreateAccuseTarget(requestDto, type, targetId);
         validationService.checkValid(target);
         accuseTargetRepository.save(target);
 
-        Accuse accuse = findOrCreateAccuse(requestDto, currentMember, target);
+        Accuse accuse = findOrCreateAccuse(requestDto, memberId, target);
         validationService.checkValid(accuse);
 
-        notificationService.sendNotificationToMember(currentMember, "신고하신 내용이 접수되었습니다.");
-        notificationService.sendNotificationToSuperAdmins(currentMember.getName() + "님이 신고를 접수하였습니다. 확인해주세요.");
+        notificationService.sendNotificationToMember(memberId, "신고하신 내용이 접수되었습니다.");
+        notificationService.sendNotificationToSuperAdmins(memberId + "님이 신고를 접수하였습니다. 확인해주세요.");
         return accuseRepository.save(accuse).getId();
     }
 
@@ -84,8 +85,8 @@ public PagedResponseDto<AccuseResponseDto> getAccusesByConditions(TargetType typ
 
     @Transactional(readOnly = true)
     public PagedResponseDto<AccuseMyResponseDto> getMyAccuses(Pageable pageable) {
-        Member currentMember = memberService.getCurrentMember();
-        Page<Accuse> accuses = accuseRepository.findByMember(currentMember, pageable);
+        String currentMemberId = memberLookupService.getCurrentMemberId();
+        Page<Accuse> accuses = accuseRepository.findByMemberId(currentMemberId, pageable);
         return new PagedResponseDto<>(accuses.map(AccuseMyResponseDto::toDto));
     }
 
@@ -103,23 +104,23 @@ private AccuseTarget getAccuseTargetByIdOrThrow(TargetType type, Long targetId)
                 .orElseThrow(() -> new NotFoundException("존재하지 않는 신고 대상입니다."));
     }
 
-    private void validateAccuseRequest(TargetType type, Long targetId, Member currentMember) {
+    private void validateAccuseRequest(TargetType type, Long targetId, String currentMemberId) {
         switch (type) {
             case BOARD:
                 Board board = boardService.getBoardByIdOrThrow(targetId);
-                if (board.isOwner(currentMember)) {
+                if (board.isOwner(currentMemberId)) {
                     throw new AccuseTargetTypeIncorrectException("자신의 게시글은 신고할 수 없습니다.");
                 }
                 break;
             case COMMENT:
                 Comment comment = commentService.getCommentByIdOrThrow(targetId);
-                if (comment.isOwner(currentMember)) {
+                if (comment.isOwner(currentMemberId)) {
                     throw new AccuseTargetTypeIncorrectException("자신의 댓글은 신고할 수 없습니다.");
                 }
                 break;
             case REVIEW:
                 Review review = reviewService.getReviewByIdOrThrow(targetId);
-                if (review.isOwner(currentMember)) {
+                if (review.isOwner(currentMemberId)) {
                     throw new AccuseTargetTypeIncorrectException("자신의 리뷰는 신고할 수 없습니다.");
                 }
                 break;
@@ -133,34 +134,40 @@ private AccuseTarget getOrCreateAccuseTarget(AccuseRequestDto requestDto, Target
                 .orElseGet(() -> AccuseRequestDto.toTargetEntity(requestDto));
     }
 
-    private Accuse findOrCreateAccuse(AccuseRequestDto requestDto, Member currentMember, AccuseTarget target) {
-        return accuseRepository.findByMemberAndTarget(currentMember, target)
+    private Accuse findOrCreateAccuse(AccuseRequestDto requestDto, String memberId, AccuseTarget target) {
+        return accuseRepository.findByMemberIdAndTarget(memberId, target.getTargetType(), target.getTargetReferenceId())
                 .map(existingAccuse -> {
                     existingAccuse.updateReason(requestDto.getReason());
                     return existingAccuse;
                 })
                 .orElseGet(() -> {
                     target.increaseAccuseCount();
-                    return AccuseRequestDto.toEntity(requestDto, currentMember, target);
+                    return AccuseRequestDto.toEntity(requestDto, memberId, target);
                 });
     }
 
     @NotNull
     private List<AccuseResponseDto> convertTargetsToResponseDtos(Page<AccuseTarget> accuseTargets) {
         return accuseTargets.stream()
                 .map(accuseTarget -> {
-                    List<Accuse> accuses = accuseRepository.findByTargetOrderByCreatedAtDesc(accuseTarget);
-                    List<AccuseMemberInfo> members = AccuseMemberInfo.create(accuses);
+                    List<Accuse> accuses = accuseRepository.findByTargetOrderByCreatedAtDesc(accuseTarget.getTargetType(), accuseTarget.getTargetReferenceId());
+                    if (accuses.isEmpty()) {
+                        return null;
+                    }
+                    List<MemberBasicInfoDto> members = accuses.stream()
+                            .map(accuse -> memberLookupService.getMemberBasicInfoById(accuse.getMemberId()))
+                            .toList();
                     return AccuseResponseDto.toDto(accuses.getFirst(), members);
                 })
+                .filter(Objects::nonNull)
                 .toList();
     }
 
     private void sendStatusUpdateNotifications(AccuseStatus status, AccuseTarget target) {
-        List<Member> members = accuseRepository.findByTarget(target).stream()
-                .map(Accuse::getMember)
-                .toList();
-        notificationService.sendNotificationToMembers(members, "신고 상태가 " + status.getDescription() + "(으)로 변경되었습니다.");
+        List<String> memberIds = accuseRepository.findByTarget(target.getTargetType(), target.getTargetReferenceId()).stream()
+                .map(Accuse::getMemberId)
+                .collect(Collectors.toList());
+        notificationService.sendNotificationToMembers(memberIds, "신고 상태가 " + status.getDescription() + "(으)로 변경되었습니다.");
     }
 
 }

src/main/java/page/clab/api/domain/accuse/dao/AccuseRepository.java

@@ -3,25 +3,30 @@
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;
 import page.clab.api.domain.accuse.domain.Accuse;
-import page.clab.api.domain.accuse.domain.AccuseTarget;
-import page.clab.api.domain.member.domain.Member;
+import page.clab.api.domain.accuse.domain.TargetType;
 
 import java.util.List;
 import java.util.Optional;
 
 @Repository
 public interface AccuseRepository extends JpaRepository<Accuse, Long> {
 
-    Page<Accuse> findAllByOrderByCreatedAtDesc(Pageable pageable);
+    @Query("SELECT a FROM Accuse a WHERE a.isDeleted = false AND a.memberId = :memberId AND a.target.targetType = :targetType AND a.target.targetReferenceId = :targetReferenceId")
+    Optional<Accuse> findByMemberIdAndTarget(String memberId, TargetType targetType, Long targetReferenceId);
 
-    Optional<Accuse> findByMemberAndTarget(Member member, AccuseTarget target);
+    @Query("SELECT a FROM Accuse a WHERE a.isDeleted = false AND a.target.targetType = :targetType AND a.target.targetReferenceId = :targetReferenceId ORDER BY a.createdAt DESC")
+    List<Accuse> findByTargetOrderByCreatedAtDesc(TargetType targetType, Long targetReferenceId);
 
-    List<Accuse> findByTargetOrderByCreatedAtDesc(AccuseTarget accuseTarget);
+    @Query("SELECT a FROM Accuse a WHERE a.isDeleted = false AND a.memberId = :memberId ORDER BY a.createdAt DESC")
+    Page<Accuse> findByMemberId(String memberId, Pageable pageable);
 
-    Page<Accuse> findByMember(Member currentMember, Pageable pageable);
+    @Query("SELECT a FROM Accuse a WHERE a.isDeleted = false AND a.memberId = :memberId")
+    List<Accuse> findByMemberId(String memberId);
 
-    List<Accuse> findByTarget(AccuseTarget target);
+    @Query("SELECT a FROM Accuse a WHERE a.isDeleted = false AND a.target.targetType = :targetType AND a.target.targetReferenceId = :targetReferenceId")
+    List<Accuse> findByTarget(TargetType targetType, Long targetReferenceId);
 
 }