Merge pull request #264 from CodIN-INU/develop

Develop

Author: gisu1102

README.md

@@ -12,9 +12,6 @@ CodIN 백엔드 Main API 서버 Repository 입니다.
 - [교과목 API 서버](https://github.com/CodIN-INU/codin-lecture-api)
 
 ---
-## 전체 아키텍처
-
-<img width="1411" height="979" alt="image" src="https://github.com/user-attachments/assets/21768a5d-cfa0-46d8-9e16-2502520ad70c" />
 
 ## 주요 화면
 

src/main/java/inu/codin/codin/common/security/util/SecurityUtils.java

@@ -4,13 +4,16 @@
 import inu.codin.codin.common.security.exception.SecurityErrorCode;
 import inu.codin.codin.domain.user.entity.UserRole;
 import inu.codin.codin.domain.user.security.CustomUserDetails;
+import lombok.extern.slf4j.Slf4j;
 import org.bson.types.ObjectId;
+import org.springframework.security.authentication.AnonymousAuthenticationToken;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.context.SecurityContextHolder;
 
 /**
  * SecurityContext와 관련된 유틸리티 클래스.
  */
+@Slf4j
 public class SecurityUtils {
 
     /**
@@ -20,15 +23,33 @@ public class SecurityUtils {
      * @throws JwtException 인증 정보가 없는 경우 예외 발생
      */
     public static ObjectId getCurrentUserId() {
+        log.info("getCurrentUserId.");
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
-
+        log.info("auth={} / principalClass={}", authentication, (authentication!=null ? authentication.getPrincipal().getClass() : null));
         if (authentication == null || !(authentication.getPrincipal() instanceof CustomUserDetails userDetails)) {
             throw new JwtException(SecurityErrorCode.ACCESS_DENIED);
         }
 
         return userDetails.getId();
     }
 
+
+    /**
+     * 현재 인증된 사용자의 ID를 반환 (nullable 안전 버전)
+     * - 인증이 없거나 익명이면 null 반환
+     */
+    public static ObjectId getCurrentUserIdOrNull() {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+
+        if (authentication == null || !authentication.isAuthenticated()
+                || authentication instanceof AnonymousAuthenticationToken
+                || !(authentication.getPrincipal() instanceof CustomUserDetails userDetails)) {
+            return null;
+        }
+
+        return userDetails.getId();
+    }
+
     public static UserRole getCurrentUserRole(){
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
 
@@ -46,4 +67,10 @@ public static void validateUser(ObjectId id){
         }
     }
 
+    public static void validateOwners(ObjectId currentUserId, ObjectId ownerId) {
+    validateUser(currentUserId);
+        if (!ownerId.equals(currentUserId)) {
+            throw new JwtException(SecurityErrorCode.ACCESS_DENIED, "본인 리소스가 아닙니다. ");
+        }
+    }
 }

src/main/java/inu/codin/codin/domain/block/service/BlockService.java

@@ -78,9 +78,15 @@ public void unblockUser(String strBlockedUserId) {
 
     /**
      * 현재 유저의 차단된 유저 목록 반환
+     * 인증이 없거나 익명이면 빈 리스트 반환
      * @return 차단한 유저 목록 (빈 리스트가 제공될 수 있음)
      */
     public List<ObjectId> getBlockedUsers() {
+        ObjectId currentUserId = SecurityUtils.getCurrentUserIdOrNull();
+        if (currentUserId == null) {
+            return List.of();
+        }
+
         return blockRepository.findByUserId(SecurityUtils.getCurrentUserId())
                 .map(BlockEntity::getBlockedUsers)
                 .orElse(List.of());

src/main/java/inu/codin/codin/domain/board/notice/controller/NoticeController.java

@@ -6,7 +6,7 @@
 import inu.codin.codin.domain.board.notice.dto.response.NoticeDetailResponseDto;
 import inu.codin.codin.domain.board.notice.dto.response.NoticePageResponse;
 import inu.codin.codin.domain.board.notice.service.NoticeService;
-import inu.codin.codin.domain.post.service.PostService;
+import inu.codin.codin.domain.post.service.PostCommandService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
@@ -28,7 +28,7 @@
 public class NoticeController {
 
     private final NoticeService noticeService;
-    private final PostService postService;
+    private final PostCommandService postCommandService;
 
     /*
     ===================
@@ -119,7 +119,7 @@ public ResponseEntity<SingleResponse<?>> deleteNoticeImage(
             @PathVariable String postId,
             @RequestParam String imageUrl) {
 
-        postService.deletePostImage(postId, imageUrl);
+        postCommandService.deletePostImage(postId, imageUrl);
         return ResponseEntity.ok()
                 .body(new SingleResponse<>(200, "공지사항 이미지가 삭제되었습니다.", null));
     }
@@ -130,7 +130,7 @@ public ResponseEntity<SingleResponse<?>> deleteNoticeImage(
     @PreAuthorize("hasAnyRole('MANAGER', 'ADMIN')")
     @DeleteMapping("/{postId}")
     public ResponseEntity<SingleResponse<?>> softDeleteNotice(@PathVariable String postId) {
-        postService.softDeletePost(postId);
+        postCommandService.softDeletePost(postId);
         return ResponseEntity.ok()
                 .body(new SingleResponse<>(200, "공지사항이 삭제되었습니다.", null));
     }

src/main/java/inu/codin/codin/domain/like/service/LikeService.java

@@ -8,8 +8,8 @@
 import inu.codin.codin.domain.like.entity.LikeEntity;
 import inu.codin.codin.domain.like.entity.LikeType;
 import inu.codin.codin.domain.like.repository.LikeRepository;
-import inu.codin.codin.domain.post.domain.comment.domain.reply.repository.ReplyCommentRepository;
 import inu.codin.codin.domain.post.domain.comment.repository.CommentRepository;
+import inu.codin.codin.domain.post.domain.comment.reply.repository.ReplyCommentRepository;
 import inu.codin.codin.domain.post.repository.PostRepository;
 import inu.codin.codin.infra.redis.config.RedisHealthChecker;
 import inu.codin.codin.infra.redis.service.RedisBestService;

src/main/java/inu/codin/codin/domain/notification/service/NotificationService.java

@@ -8,8 +8,8 @@
 import inu.codin.codin.domain.notification.repository.NotificationRepository;
 import inu.codin.codin.domain.post.domain.comment.entity.CommentEntity;
 import inu.codin.codin.domain.post.domain.comment.repository.CommentRepository;
-import inu.codin.codin.domain.post.domain.comment.domain.reply.entity.ReplyCommentEntity;
-import inu.codin.codin.domain.post.domain.comment.domain.reply.repository.ReplyCommentRepository;
+import inu.codin.codin.domain.post.domain.comment.reply.entity.ReplyCommentEntity;
+import inu.codin.codin.domain.post.domain.comment.reply.repository.ReplyCommentRepository;
 import inu.codin.codin.domain.post.entity.PostCategory;
 import inu.codin.codin.domain.post.entity.PostEntity;
 import inu.codin.codin.domain.post.repository.PostRepository;

src/main/java/inu/codin/codin/domain/post/controller/PostController.java

@@ -6,15 +6,17 @@
 import inu.codin.codin.domain.post.dto.request.PostContentUpdateRequestDTO;
 import inu.codin.codin.domain.post.dto.request.PostCreateRequestDTO;
 import inu.codin.codin.domain.post.dto.request.PostStatusUpdateRequestDTO;
-import inu.codin.codin.domain.post.dto.response.PostDetailResponseDTO;
 import inu.codin.codin.domain.post.dto.response.PostPageResponse;
+import inu.codin.codin.domain.post.dto.response.PostPageItemResponseDTO;
 import inu.codin.codin.domain.post.entity.PostCategory;
-import inu.codin.codin.domain.post.service.PostService;
+import inu.codin.codin.domain.post.service.PostCommandService;
+import inu.codin.codin.domain.post.service.PostQueryService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Size;
+import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
@@ -27,40 +29,39 @@
 @RestController
 @RequestMapping("/posts")
 @Validated
+@RequiredArgsConstructor
 @Tag(name = "POST API", description = "게시글 API")
 public class PostController {
 
-    private final PostService postService;
-
-    public PostController(PostService postService) {
-        this.postService = postService;
-    }
+    private final PostCommandService postCommandService;
+    private final PostQueryService postQueryService;
 
     @Operation(
             summary = "게시물 작성",
             description = "JSON 형식의 게시물 데이터(postContent)와 이미지 파일(postImages) 업로드"
     )
     @PostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
-    public ResponseEntity<SingleResponse<?>>  createPost(
+    public ResponseEntity<SingleResponse<Void>>  createPost(
             @RequestPart("postContent") @Valid PostCreateRequestDTO postCreateRequestDTO,
             @RequestPart(value = "postImages", required = false) List<MultipartFile> postImages) {
 
         // postImages가 null이면 빈 리스트로 처리
         if (postImages == null) postImages = List.of();
+        postCommandService.createPost(postCreateRequestDTO, postImages);
         return ResponseEntity.status(HttpStatus.CREATED)
-                .body(new SingleResponse<>(201, "게시물이 작성되었습니다.", postService.createPost(postCreateRequestDTO, postImages)));
+                .body(new SingleResponse<>(201, "게시물이 작성되었습니다.", null));
     }
 
     @Operation(
             summary = "게시물 내용 수정 및 이미지 수정&추가"
     )
     @PatchMapping(value = "/{postId}/content", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
-    public ResponseEntity<SingleResponse<?>>  updatePostContent(
+    public ResponseEntity<SingleResponse<Void>>  updatePostContent(
             @PathVariable String postId,
             @RequestPart("postContent") @Valid PostContentUpdateRequestDTO requestDTO,
             @RequestPart(value = "postImages", required = false) List<MultipartFile> postImages) {
 
-        postService.updatePostContent(postId, requestDTO, postImages);
+        postCommandService.updatePostContent(postId, requestDTO, postImages);
         return ResponseEntity.status(HttpStatus.OK)
                 .body(new SingleResponse<>(200, "게시물 내용이 수정되었습니다.", null));
     }
@@ -69,21 +70,21 @@ public ResponseEntity<SingleResponse<?>>  updatePostContent(
             summary = "상태 수정"
     )
     @PatchMapping("/{postId}/status")
-    public ResponseEntity<SingleResponse<?>> updatePostStatus(
+    public ResponseEntity<SingleResponse<Void>> updatePostStatus(
             @PathVariable String postId,
             @RequestBody PostStatusUpdateRequestDTO requestDTO) {
-        postService.updatePostStatus(postId, requestDTO);
+        postCommandService.updatePostStatus(postId, requestDTO);
         return ResponseEntity.status(HttpStatus.OK)
                 .body(new SingleResponse<>(200, "게시물 상태가 수정되었습니다.", null));
     }
 
 
     @Operation(summary = "게시물 익명 설정 수정")
     @PatchMapping("/{postId}/anonymous")
-    public ResponseEntity<SingleResponse<?>> updatePostAnonymous(
+    public ResponseEntity<SingleResponse<Void>> updatePostAnonymous(
             @PathVariable String postId,
             @RequestBody @Valid PostAnonymousUpdateRequestDTO requestDTO) {
-        postService.updatePostAnonymous(postId, requestDTO);
+        postCommandService.updatePostAnonymous(postId, requestDTO);
         return ResponseEntity.status(HttpStatus.OK)
                 .body(new SingleResponse<>(200, "게시물 익명 설정이 수정되었습니다.", null));
     }
@@ -95,36 +96,36 @@ public ResponseEntity<SingleResponse<?>> updatePostAnonymous(
     @GetMapping("/category")
     public ResponseEntity<SingleResponse<PostPageResponse>> getAllPosts(@RequestParam PostCategory postCategory,
                                                                         @RequestParam("page") @NotNull int pageNumber) {
-        PostPageResponse postpages= postService.getAllPosts(postCategory, pageNumber);
+        PostPageResponse postpages= postQueryService.getAllPosts(postCategory, pageNumber);
         return ResponseEntity.ok()
                 .body(new SingleResponse<>(200, "카테고리별 삭제 되지 않은 모든 게시물 조회 성공", postpages));
     }
 
 
     @Operation(summary = "해당 게시물 상세 조회 (댓글 조회는 Comment에서 따로 조회)")
     @GetMapping("/{postId}")
-    public ResponseEntity<SingleResponse<PostDetailResponseDTO>> getPostWithDetail(@PathVariable String postId) {
-        PostDetailResponseDTO post = postService.getPostWithDetail(postId);
+    public ResponseEntity<SingleResponse<PostPageItemResponseDTO>> getPostWithDetail(@PathVariable String postId) {
+        PostPageItemResponseDTO post = postQueryService.getPostWithDetail(postId);
         return ResponseEntity.ok()
                 .body(new SingleResponse<>(200, "게시물 상세 조회 성공", post));
     }
 
 
     @Operation(summary = "게시물 이미지 삭제")
     @DeleteMapping("/{postId}/images")
-    public ResponseEntity<SingleResponse<?>> deletePostImage(
+    public ResponseEntity<SingleResponse<Void>> deletePostImage(
             @PathVariable String postId,
             @RequestParam String imageUrl) {
 
-        postService.deletePostImage(postId, imageUrl);
+        postCommandService.deletePostImage(postId, imageUrl);
         return ResponseEntity.ok()
                 .body(new SingleResponse<>(200, "게시물 이미지가 삭제되었습니다.", null));
     }
 
     @Operation(summary = "게시물 삭제 (Soft Delete)")
     @DeleteMapping("/{postId}")
-    public ResponseEntity<SingleResponse<?>> softDeletePost(@PathVariable String postId) {
-        postService.softDeletePost(postId);
+    public ResponseEntity<SingleResponse<Void>> softDeletePost(@PathVariable String postId) {
+        postCommandService.softDeletePost(postId);
         return ResponseEntity.ok()
                 .body(new SingleResponse<>(200, "게시물이 삭제되었습니다.", null));
     }
@@ -133,23 +134,23 @@ public ResponseEntity<SingleResponse<?>> softDeletePost(@PathVariable String pos
             summary = "검색 엔진"
     )
     @GetMapping("/search")
-    public ResponseEntity<SingleResponse<?>> searchPosts(@RequestParam("keyword") @Size(min = 2) String keyword,
+    public ResponseEntity<SingleResponse<PostPageResponse>> searchPosts(@RequestParam("keyword") @Size(min = 2) String keyword,
                                                          @RequestParam("pageNumber") @NotNull int pageNumber){
         return ResponseEntity.ok()
-                .body(new SingleResponse<>(200, "'"+keyword+"'"+"으로 검색된 게시글 반환 완료", postService.searchPosts(keyword, pageNumber)));
+                .body(new SingleResponse<>(200, "'"+keyword+"'"+"으로 검색된 게시글 반환 완료", postQueryService.searchPosts(keyword, pageNumber)));
     }
 
     @Operation(summary = "Top 3 베스트 게시글 가져오기")
     @GetMapping("/top3")
-    public ResponseEntity<ListResponse<?>> getTop3BestPosts(){
+    public ResponseEntity<ListResponse<PostPageItemResponseDTO>> getTop3BestPosts(){
         return ResponseEntity.ok()
-                .body(new ListResponse<>(200, "Top3 베스트 게시글 반환 완료", postService.getTop3BestPosts()));
+                .body(new ListResponse<>(200, "Top3 베스트 게시글 반환 완료", postQueryService.getTop3BestPosts()));
     }
 
     @Operation(summary = "Top3로 선정된 게시글들 모두 가져오기")
     @GetMapping("/best")
-    public ResponseEntity<SingleResponse<?>> getBestPosts(@RequestParam("pageNumber") int pageNumber){
+    public ResponseEntity<SingleResponse<PostPageResponse>> getBestPosts(@RequestParam("pageNumber") int pageNumber){
         return ResponseEntity.ok()
-                .body(new SingleResponse<>(200, "Top3로 선정된 게시글들 모두 반환 완료", postService.getBestPosts(pageNumber)));
+                .body(new SingleResponse<>(200, "Top3로 선정된 게시글들 모두 반환 완료", postQueryService.getBestPosts(pageNumber)));
     }
 }

src/main/java/inu/codin/codin/domain/post/domain/best/BestService.java

@@ -0,0 +1,50 @@
+package inu.codin.codin.domain.post.domain.best;
+
+import inu.codin.codin.infra.redis.service.RedisBestService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class BestService {
+    private final RedisBestService redisBestService;
+    private final BestRepository bestRepository;
+
+    // [BestService] - Top 3 베스트 postId 목록 반환
+    public List<String> getTop3BestPostIds() {
+        Map<String, Double> bestPosts = redisBestService.getBests();
+        return bestPosts.keySet()
+                .stream()
+                .limit(3)
+                .collect(Collectors.toList());
+    }
+
+    // [BestService] - BestEntity 페이지 반환
+    public Page<BestEntity> getBestEntities(int pageNumber) {
+        PageRequest pageRequest = PageRequest.of(pageNumber, 20, Sort.by("createdAt").descending());
+        return bestRepository.findAll(pageRequest);
+    }
+
+    // Redis에서 특정 베스트 게시물 삭제
+    public void deleteBestPost(String postId) {
+        redisBestService.deleteBest(postId);
+    }
+
+    // [BestService] - 베스트 점수 적용 처리 래핑
+    public void applyBestScore(ObjectId postId) {
+        redisBestService.applyBestScore(1, postId);
+        log.info("베스트 점수 적용. PostId: {}", postId);
+    }
+
+}