Merge pull request #131 from prgrms-web-devcourse-final-project/feature/EA3-122-study-crud

endorsement0912 · web-flow · commit d10cc9976f08 · 2025-07-18T09:40:18.000+09:00
[EA3-122]  feature: 스터디 내 정보 조회, 메인 화면 조회 기능
diff --git a/src/main/java/grep/neogul_coder/domain/main/controller/MainController.java b/src/main/java/grep/neogul_coder/domain/main/controller/MainController.java
@@ -0,0 +1,40 @@
+package grep.neogul_coder.domain.main.controller;
+
+import grep.neogul_coder.domain.main.controller.dto.response.MainResponse;
+import grep.neogul_coder.domain.recruitment.post.controller.dto.response.RecruitmentPostPagingInfo;
+import grep.neogul_coder.domain.recruitment.post.service.RecruitmentPostService;
+import grep.neogul_coder.domain.study.controller.StudySpecification;
+import grep.neogul_coder.domain.study.controller.dto.response.StudyItemResponse;
+import grep.neogul_coder.domain.study.service.StudyService;
+import grep.neogul_coder.global.auth.Principal;
+import grep.neogul_coder.global.response.ApiResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RequestMapping("/api/main")
+@RequiredArgsConstructor
+@RestController
+public class MainController implements MainSpecification {
+
+    private final StudyService studyService;
+    private final RecruitmentPostService recruitmentPostService;
+
+    @GetMapping
+    public ApiResponse<MainResponse> getMain(@PageableDefault(size = 10) Pageable pageable,
+                               @AuthenticationPrincipal Principal userDetails) {
+        Long userId = userDetails.getUserId();
+
+        List<StudyItemResponse> myStudies = studyService.getMyStudies(userId);
+        RecruitmentPostPagingInfo recruitingStudies = recruitmentPostService.getPagingInfo(pageable);
+        MainResponse response = MainResponse.from(myStudies, recruitingStudies);
+
+        return ApiResponse.success(response);
+    }
+}
diff --git a/src/main/java/grep/neogul_coder/domain/main/controller/MainSpecification.java b/src/main/java/grep/neogul_coder/domain/main/controller/MainSpecification.java
@@ -0,0 +1,15 @@
+package grep.neogul_coder.domain.main.controller;
+
+import grep.neogul_coder.domain.main.controller.dto.response.MainResponse;
+import grep.neogul_coder.global.auth.Principal;
+import grep.neogul_coder.global.response.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.data.domain.Pageable;
+
+@Tag(name = "Main", description = "메인화면 API")
+public interface MainSpecification {
+
+    @Operation(summary = "메인 화면 조회", description = "메인 화면을 조회합니다.")
+    ApiResponse<MainResponse> getMain(Pageable pageable, Principal userDetails);
+}
diff --git a/src/main/java/grep/neogul_coder/domain/main/controller/dto/response/MainResponse.java b/src/main/java/grep/neogul_coder/domain/main/controller/dto/response/MainResponse.java
@@ -0,0 +1,32 @@
+package grep.neogul_coder.domain.main.controller.dto.response;
+
+import grep.neogul_coder.domain.recruitment.post.controller.dto.response.RecruitmentPostPagingInfo;
+import grep.neogul_coder.domain.study.controller.dto.response.StudyItemResponse;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class MainResponse {
+
+    @Schema(description = "참여중인 스터디 목록")
+    private List<StudyItemResponse> myStudies;
+
+    @Schema(description = "모집중인 스터디 목록")
+    private RecruitmentPostPagingInfo recruitingStudies;
+
+    @Builder
+    private MainResponse(List<StudyItemResponse> myStudies, RecruitmentPostPagingInfo recruitingStudies) {
+        this.myStudies = myStudies;
+        this.recruitingStudies = recruitingStudies;
+    }
+
+    public static MainResponse from(List<StudyItemResponse> myStudies, RecruitmentPostPagingInfo recruitingStudies) {
+        return MainResponse.builder()
+            .myStudies(myStudies)
+            .recruitingStudies(recruitingStudies)
+            .build();
+    }
+}
diff --git a/src/main/java/grep/neogul_coder/domain/study/controller/StudyController.java b/src/main/java/grep/neogul_coder/domain/study/controller/StudyController.java
@@ -26,7 +26,7 @@ public class StudyController implements StudySpecification {
     public ApiResponse<StudyItemPagingResponse> getStudies(@PageableDefault(size = 12) Pageable pageable,
                                                            @AuthenticationPrincipal Principal userDetails) {
         Long userId = userDetails.getUserId();
-        StudyItemPagingResponse studies = studyService.getMyStudies(pageable, userId);
+        StudyItemPagingResponse studies = studyService.getMyStudiesPaging(pageable, userId);
         return ApiResponse.success(studies);
     }
 
@@ -50,12 +50,19 @@ public ApiResponse<List<StudyImageResponse>> getStudyImages(@AuthenticationPrinc
     public ApiResponse<StudyInfoResponse> getStudyInfo(@PathVariable("studyId") Long studyId,
                                                        @AuthenticationPrincipal Principal userDetails) {
         Long userId = userDetails.getUserId();
-        return ApiResponse.success(studyService.getStudyInfo(studyId, userId));
+        return ApiResponse.success(studyService.getMyStudyContent(studyId, userId));
+    }
+
+    @GetMapping("/{studyId}/content")
+    public ApiResponse<StudyMyContentResponse> getMyStudyContent(@PathVariable("studyId") Long studyId) {
+        return ApiResponse.success(new StudyMyContentResponse());
     }
 
     @GetMapping("/{studyId}/me")
-    public ApiResponse<StudyMyInfoResponse> getStudyMyInfo(@PathVariable("studyId") Long studyId) {
-        return ApiResponse.success(new StudyMyInfoResponse());
+    public ApiResponse<StudyMemberInfoResponse> getMyStudyMemberInfo(@PathVariable("studyId") Long studyId,
+                                                                     @AuthenticationPrincipal Principal userDetails) {
+        Long userId = userDetails.getUserId();
+        return ApiResponse.success(studyService.getMyStudyMemberInfo(studyId, userId));
     }
 
     @PostMapping
diff --git a/src/main/java/grep/neogul_coder/domain/study/controller/StudySpecification.java b/src/main/java/grep/neogul_coder/domain/study/controller/StudySpecification.java
@@ -29,8 +29,11 @@ public interface StudySpecification {
     @Operation(summary = "스터디 정보 조회", description = "스터디장이 스터디 정보를 조회합니다.")
     ApiResponse<StudyInfoResponse> getStudyInfo(Long studyId, Principal userDetails);
 
-    @Operation(summary = "스터디 내 정보 조회", description = "스터디의 내 정보를 조회합니다.")
-    ApiResponse<StudyMyInfoResponse> getStudyMyInfo(Long studyId);
+    @Operation(summary = "스터디 내가 쓴 게시글 조회", description = "스터디에서 내가 쓴 게시글을 조회합니다.")
+    ApiResponse<StudyMyContentResponse> getMyStudyContent(Long studyId);
+
+    @Operation(summary = "스터디 내 정보 조회", description = "스터디에서 사용자의 정보를 조회합니다.")
+    ApiResponse<StudyMemberInfoResponse> getMyStudyMemberInfo(Long studyId, Principal userDetails);
 
     @Operation(summary = "스터디 생성", description = "새로운 스터디를 생성합니다.")
     ApiResponse<Long> createStudy(StudyCreateRequest request, Principal userDetails);
diff --git a/src/main/java/grep/neogul_coder/domain/study/controller/dto/response/StudyMemberInfoResponse.java b/src/main/java/grep/neogul_coder/domain/study/controller/dto/response/StudyMemberInfoResponse.java
@@ -0,0 +1,41 @@
+package grep.neogul_coder.domain.study.controller.dto.response;
+
+import grep.neogul_coder.domain.study.StudyMember;
+import grep.neogul_coder.domain.study.enums.StudyMemberRole;
+import grep.neogul_coder.domain.users.entity.User;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+public class StudyMemberInfoResponse {
+
+    @Schema(description = "유저 Id", example = "1")
+    private Long userId;
+
+    @Schema(description = "스터디 Id", example = "1")
+    private Long studyId;
+
+    @Schema(description = "스터디 멤버 역할", example = "LEADER")
+    private StudyMemberRole role;
+
+    @Schema(description = "닉네임", example = "너굴")
+    private String nickname;
+
+    @Builder
+    private StudyMemberInfoResponse(Long userId, Long studyId, StudyMemberRole role, String nickname) {
+        this.userId = userId;
+        this.studyId = studyId;
+        this.role = role;
+        this.nickname = nickname;
+    }
+
+    public static StudyMemberInfoResponse from(StudyMember studyMember, User user) {
+        return StudyMemberInfoResponse.builder()
+            .userId(user.getId())
+            .studyId(studyMember.getStudy().getId())
+            .role(studyMember.getRole())
+            .nickname(user.getNickname())
+            .build();
+    }
+}
diff --git a/src/main/java/grep/neogul_coder/domain/study/controller/dto/response/StudyMemberResponse.java b/src/main/java/grep/neogul_coder/domain/study/controller/dto/response/StudyMemberResponse.java
@@ -1,6 +1,7 @@
 package grep.neogul_coder.domain.study.controller.dto.response;
 
 import grep.neogul_coder.domain.study.StudyMember;
+import grep.neogul_coder.domain.study.enums.StudyMemberRole;
 import grep.neogul_coder.domain.users.entity.User;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Builder;
@@ -18,18 +19,23 @@ public class StudyMemberResponse {
     @Schema(description = "스터디원 프로필 사진", example = "http://localhost:8083/image.jpg")
     private String profileImageUrl;
 
+    @Schema(description = "스터디 멤버 역할", example = "LEADER")
+    private StudyMemberRole role;
+
     @Builder
-    public StudyMemberResponse(Long userId, String nickname, String profileImageUrl) {
+    public StudyMemberResponse(Long userId, String nickname, String profileImageUrl, StudyMemberRole role) {
         this.userId = userId;
         this.nickname = nickname;
         this.profileImageUrl = profileImageUrl;
+        this.role = role;
     }
 
     public static StudyMemberResponse from(StudyMember studyMember, User user) {
         return StudyMemberResponse.builder()
             .userId(user.getId())
             .nickname(user.getNickname())
             .profileImageUrl(user.getProfileImageUrl())
+            .role(studyMember.getRole())
             .build();
     }
 }
diff --git a/src/main/java/grep/neogul_coder/domain/study/controller/dto/response/StudyMyContentResponse.java b/src/main/java/grep/neogul_coder/domain/study/controller/dto/response/StudyMyContentResponse.java
@@ -7,7 +7,7 @@
 import java.util.List;
 
 @Getter
-public class StudyMyInfoResponse {
+public class StudyMyContentResponse {
 
     @Schema(description = "게시글 리스트")
     private List<StudyPostListResponse> studyPosts;
diff --git a/src/main/java/grep/neogul_coder/domain/study/repository/StudyMemberRepository.java b/src/main/java/grep/neogul_coder/domain/study/repository/StudyMemberRepository.java
@@ -13,7 +13,7 @@ public interface StudyMemberRepository extends JpaRepository<StudyMember, Long>
     List<StudyMember> findByStudyId(long studyId);
 
     @Query("select m.study from StudyMember m where m.userId = :userId and m.study.activated = true")
-    List<Study> findStudiesByUserId(long userId);
+    List<Study> findStudiesByUserId(@Param("userId") long userId);
 
     @Query("select sm from StudyMember sm join fetch sm.study where sm.study.id = :studyId")
     List<StudyMember> findByStudyIdFetchStudy(@Param("studyId") long studyId);
diff --git a/src/main/java/grep/neogul_coder/domain/study/repository/StudyQueryRepository.java b/src/main/java/grep/neogul_coder/domain/study/repository/StudyQueryRepository.java
@@ -26,7 +26,7 @@ public StudyQueryRepository(EntityManager em) {
         this.queryFactory = new JPAQueryFactory(em);
     }
 
-    public Page<StudyItemResponse> findMyStudies(Pageable pageable, Long userId) {
+    public Page<StudyItemResponse> findMyStudiesPaging(Pageable pageable, Long userId) {
         List<StudyItemResponse> studies = queryFactory
             .select(Projections.constructor(
                 StudyItemResponse.class,
@@ -47,27 +47,48 @@ public Page<StudyItemResponse> findMyStudies(Pageable pageable, Long userId) {
             .join(study).on(study.id.eq(studyMember.study.id))
             .where(
                 studyMember.userId.eq(userId),
-                studyMember.activated.isTrue(),
-                study.activated.isTrue()
+                studyMember.activated.isTrue()
             )
             .fetch();
 
         Long total = queryFactory
             .select(study.count())
             .from(studyMember)
-            .join(study).on(study.id.eq(studyMember.study.id))
             .where(
                 studyMember.userId.eq(userId),
-                studyMember.activated.eq(true),
-                study.activated.eq(true)
+                studyMember.activated.eq(true)
             )
-            .offset(pageable.getOffset())
-            .limit(pageable.getPageSize())
             .fetchOne();
 
         return new PageImpl<>(studies, pageable, total);
     }
 
+    public List<StudyItemResponse> findMyStudies(Long userId) {
+        return queryFactory
+            .select(Projections.constructor(
+                StudyItemResponse.class,
+                study.id,
+                study.name,
+                user.nickname,
+                study.capacity,
+                study.currentCount,
+                study.startDate,
+                study.imageUrl,
+                study.introduction,
+                study.category,
+                study.studyType,
+                study.isFinished
+            ))
+            .from(studyMember)
+            .join(user).on(user.id.eq(studyMember.userId))
+            .join(study).on(study.id.eq(studyMember.study.id))
+            .where(
+                studyMember.userId.eq(userId),
+                studyMember.activated.isTrue()
+            )
+            .fetch();
+    }
+
     public StudyMemberRole findMyRole(Long studyId, Long userId) {
         return queryFactory
             .select(studyMember.role)
diff --git a/src/main/java/grep/neogul_coder/domain/study/service/StudyService.java b/src/main/java/grep/neogul_coder/domain/study/service/StudyService.java
@@ -1,17 +1,19 @@
 package grep.neogul_coder.domain.study.service;
 
 import grep.neogul_coder.domain.recruitment.post.repository.RecruitmentPostRepository;
-import grep.neogul_coder.domain.study.controller.dto.response.StudyItemPagingResponse;
 import grep.neogul_coder.domain.study.Study;
 import grep.neogul_coder.domain.study.StudyMember;
 import grep.neogul_coder.domain.study.controller.dto.request.StudyCreateRequest;
 import grep.neogul_coder.domain.study.controller.dto.request.StudyUpdateRequest;
 import grep.neogul_coder.domain.study.controller.dto.response.*;
 import grep.neogul_coder.domain.study.enums.StudyMemberRole;
 import grep.neogul_coder.domain.study.enums.StudyType;
+import grep.neogul_coder.domain.study.repository.StudyMemberQueryRepository;
 import grep.neogul_coder.domain.study.repository.StudyMemberRepository;
 import grep.neogul_coder.domain.study.repository.StudyQueryRepository;
 import grep.neogul_coder.domain.study.repository.StudyRepository;
+import grep.neogul_coder.domain.users.entity.User;
+import grep.neogul_coder.domain.users.repository.UserRepository;
 import grep.neogul_coder.global.exception.business.BusinessException;
 import grep.neogul_coder.global.exception.business.NotFoundException;
 import lombok.RequiredArgsConstructor;
@@ -21,9 +23,11 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
+import java.util.Optional;
 
 import static grep.neogul_coder.domain.study.enums.StudyMemberRole.LEADER;
 import static grep.neogul_coder.domain.study.exception.code.StudyErrorCode.*;
+import static grep.neogul_coder.domain.users.exception.code.UserErrorCode.USER_NOT_FOUND;
 
 @Transactional(readOnly = true)
 @RequiredArgsConstructor
@@ -34,12 +38,18 @@ public class StudyService {
     private final StudyMemberRepository studyMemberRepository;
     private final StudyQueryRepository studyQueryRepository;
     private final RecruitmentPostRepository recruitmentPostRepository;
+    private final StudyMemberQueryRepository studyMemberQueryRepository;
+    private final UserRepository userRepository;
 
-    public StudyItemPagingResponse getMyStudies(Pageable pageable, Long userId) {
-        Page<StudyItemResponse> page = studyQueryRepository.findMyStudies(pageable, userId);
+    public StudyItemPagingResponse getMyStudiesPaging(Pageable pageable, Long userId) {
+        Page<StudyItemResponse> page = studyQueryRepository.findMyStudiesPaging(pageable, userId);
         return StudyItemPagingResponse.of(page);
     }
 
+    public List<StudyItemResponse> getMyStudies(Long userId) {
+        return studyQueryRepository.findMyStudies(userId);
+    }
+
     public StudyHeaderResponse getStudyHeader(Long studyId) {
         Study study = studyRepository.findByIdAndActivatedTrue(studyId)
             .orElseThrow(() -> new NotFoundException(STUDY_NOT_FOUND));
@@ -48,14 +58,14 @@ public StudyHeaderResponse getStudyHeader(Long studyId) {
     }
 
     public List<StudyImageResponse> getStudyImages(Long userId) {
-        List<Study> myStudies = studyMemberRepository.findStudiesByUserId(userId);
+        List<Study> myStudiesImage = studyMemberRepository.findStudiesByUserId(userId);
 
-        return myStudies.stream()
+        return myStudiesImage.stream()
             .map(StudyImageResponse::from)
             .toList();
     }
 
-    public StudyInfoResponse getStudyInfo(Long studyId, Long userId) {
+    public StudyInfoResponse getMyStudyContent(Long studyId, Long userId) {
         Study study = studyRepository.findByIdAndActivatedTrue(studyId)
             .orElseThrow(() -> new NotFoundException(STUDY_NOT_FOUND));
 
@@ -67,12 +77,22 @@ public StudyInfoResponse getStudyInfo(Long studyId, Long userId) {
         return StudyInfoResponse.from(study, members);
     }
 
+    public StudyMemberInfoResponse getMyStudyMemberInfo(Long studyId, Long userId) {
+        StudyMember studyMember = Optional.ofNullable(studyMemberQueryRepository.findByStudyIdAndUserId(studyId, userId))
+            .orElseThrow(() -> new NotFoundException(STUDY_NOT_MEMBER));
+
+        User user = userRepository.findById(userId)
+            .orElseThrow(() -> new NotFoundException(USER_NOT_FOUND));
+
+        return StudyMemberInfoResponse.from(studyMember, user);
+    }
+
     @Transactional
     public Long createStudy(StudyCreateRequest request, Long userId) {
-        Study study = studyRepository.save(request.toEntity());
-
         validateLocation(request.getStudyType(), request.getLocation());
 
+        Study study = studyRepository.save(request.toEntity());
+
         StudyMember leader = StudyMember.builder()
             .study(study)
             .userId(userId)
diff --git a/src/test/java/grep/neogul_coder/domain/study/service/StudyServiceTest.java b/src/test/java/grep/neogul_coder/domain/study/service/StudyServiceTest.java
@@ -92,7 +92,7 @@ void getStudies() {
         studyMemberRepository.save(studyMember);
 
         // when
-        StudyItemPagingResponse response = studyService.getMyStudies(pageable, userId);
+        StudyItemPagingResponse response = studyService.getMyStudiesPaging(pageable, userId);
 
         // then
         assertThat(response.getStudies().getFirst().getName()).isEqualTo("스터디");
