[BE] 기존 api 중 폴링으로 인한 변경 반영, studyId로 참여코드 조회 api 구현

backend/src/main/java/harustudy/backend/config/FilterConfig.java

@@ -12,7 +12,7 @@ public class FilterConfig {
     public FilterRegistrationBean<CachingFilter> contentCachingFilter(){
         FilterRegistrationBean<CachingFilter> registrationBean = new FilterRegistrationBean<>();
         registrationBean.setFilter(new CachingFilter());
-        registrationBean.addUrlPatterns("/api/studies/*", "/api/temp/*", "/api/auth/*", "/api/me/*");
+        registrationBean.addUrlPatterns("/api/participant-codes/*", "/api/studies/*", "/api/temp/*", "/api/auth/*", "/api/me/*");
         registrationBean.setOrder(1);
         registrationBean.setName("CachingFilter");
         return registrationBean;

backend/src/main/java/harustudy/backend/participant/domain/Participant.java

@@ -45,6 +45,8 @@ public class Participant extends BaseTimeEntity {
 
     private String nickname;
 
+    private Boolean isHost;
+
     public Participant(Study study, Member member, String nickname) {
         this.study = study;
         this.member = member;

backend/src/main/java/harustudy/backend/participant/dto/ParticipantResponse.java

@@ -2,9 +2,9 @@
 
 import harustudy.backend.participant.domain.Participant;
 
-public record ParticipantResponse(Long participantId, String nickname) {
+public record ParticipantResponse(Long participantId, String nickname, Boolean isHost) {
 
     public static ParticipantResponse from(Participant participant) {
-        return new ParticipantResponse(participant.getId(), participant.getNickname());
+        return new ParticipantResponse(participant.getId(), participant.getNickname(), participant.getIsHost());
     }
 }

backend/src/main/java/harustudy/backend/participantcode/controller/ParticipantCodeController.java

@@ -0,0 +1,32 @@
+package harustudy.backend.participantcode.controller;
+
+import harustudy.backend.auth.Authenticated;
+import harustudy.backend.auth.dto.AuthMember;
+import harustudy.backend.participantcode.dto.ParticipantCodeResponse;
+import harustudy.backend.participantcode.service.ParticipantCodeService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@Tag(name = "참여 코드 관련 기능")
+@RequiredArgsConstructor
+@RestController
+public class ParticipantCodeController {
+
+    private final ParticipantCodeService participantCodeService;
+
+    @Operation(summary = "스터디 아이디로 참여 코드 조회")
+    @GetMapping("/api/participant-codes")
+    public ResponseEntity<ParticipantCodeResponse> findParticipantCodeByStudyId(
+            @Authenticated AuthMember authMember,
+            @RequestParam Long studyId
+    ) {
+        ParticipantCodeResponse response = participantCodeService.findParticipantCodeByStudyId(
+                studyId);
+        return ResponseEntity.ok(response);
+    }
+}

backend/src/main/java/harustudy/backend/participantcode/dto/ParticipantCodeResponse.java

@@ -0,0 +1,10 @@
+package harustudy.backend.participantcode.dto;
+
+import harustudy.backend.participantcode.domain.ParticipantCode;
+
+public record ParticipantCodeResponse(String participantCode) {
+
+    public static ParticipantCodeResponse from(ParticipantCode participantCode) {
+        return new ParticipantCodeResponse(participantCode.getCode());
+    }
+}

backend/src/main/java/harustudy/backend/participantcode/repository/ParticipantCodeRepository.java

@@ -1,10 +1,13 @@
 package harustudy.backend.participantcode.repository;
 
 import harustudy.backend.participantcode.domain.ParticipantCode;
+import harustudy.backend.study.domain.Study;
 import java.util.Optional;
 import org.springframework.data.jpa.repository.JpaRepository;
 
 public interface ParticipantCodeRepository extends JpaRepository<ParticipantCode, Long> {
 
     Optional<ParticipantCode> findByCode(String code);
+
+    Optional<ParticipantCode> findByStudy(Study study);
 }

backend/src/main/java/harustudy/backend/participantcode/service/ParticipantCodeService.java

@@ -0,0 +1,28 @@
+package harustudy.backend.participantcode.service;
+
+import harustudy.backend.participantcode.domain.ParticipantCode;
+import harustudy.backend.participantcode.dto.ParticipantCodeResponse;
+import harustudy.backend.participantcode.repository.ParticipantCodeRepository;
+import harustudy.backend.study.domain.Study;
+import harustudy.backend.study.exception.ParticipantCodeNotFoundException;
+import harustudy.backend.study.repository.StudyRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@RequiredArgsConstructor
+@Transactional
+@Service
+public class ParticipantCodeService {
+
+    private final StudyRepository studyRepository;
+    private final ParticipantCodeRepository participantCodeRepository;
+
+    @Transactional(readOnly = true)
+    public ParticipantCodeResponse findParticipantCodeByStudyId(Long studyId) {
+        Study study = studyRepository.findByIdIfExists(studyId);
+        ParticipantCode participantCode = participantCodeRepository.findByStudy(study)
+                .orElseThrow(ParticipantCodeNotFoundException::new);
+        return ParticipantCodeResponse.from(participantCode);
+    }
+}

backend/src/main/java/harustudy/backend/study/controller/StudyController.java

@@ -3,17 +3,21 @@
 import harustudy.backend.auth.Authenticated;
 import harustudy.backend.auth.dto.AuthMember;
 import harustudy.backend.study.dto.CreateStudyRequest;
-import harustudy.backend.study.dto.CreateStudyResponse;
-import harustudy.backend.study.dto.StudyResponse;
 import harustudy.backend.study.dto.StudiesResponse;
+import harustudy.backend.study.dto.StudyResponse;
 import harustudy.backend.study.service.StudyService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import java.net.URI;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
 
 @Tag(name = "스터디 관련 기능")
 @RequiredArgsConstructor
@@ -46,16 +50,14 @@ public ResponseEntity<StudiesResponse> findStudiesWithFilter(
     @Operation(summary = "스터디 생성")
     @ApiResponse(responseCode = "201")
     @PostMapping("/api/studies")
-    public ResponseEntity<CreateStudyResponse> createStudy(
+    public ResponseEntity<Void> createStudy(
             @Authenticated AuthMember authMember,
             @RequestBody CreateStudyRequest request
     ) {
-        CreateStudyResponse response = studyService.createStudy(request);
-        return ResponseEntity.created(URI.create("/api/studies/" + response.studyId()))
-                .body(response);
+        Long studyId = studyService.createStudy(request);
+        return ResponseEntity.created(URI.create("/api/studies/" + studyId)).build();
     }
 
-    // TODO: SSE 이벤트하는 로직으로 변경시 SSE 컨트롤러로 이동할지 고려
     @Operation(summary = "다음 스터디 단계로 이동")
     @ApiResponse(responseCode = "204")
     @PostMapping("/api/studies/{studyId}/next-step")

backend/src/main/java/harustudy/backend/study/dto/StudyResponse.java

@@ -6,19 +6,19 @@
 import java.time.LocalDateTime;
 
 public record StudyResponse(Long studyId, String name, Integer totalCycle, Integer timePerCycle, Integer currentCycle,
-                            String studyStep, String progress, LocalDateTime createdDateTime) {
+                            String studyStep, String progressStep, LocalDateTime createdDate, LocalDateTime lastModifiedDate) {
 
     public static final String IN_PROGRESS = "inProgress";
 
     public static StudyResponse from(Study study) {
-        String roomStep = getRoomStep(study);
+        String studyStep = getStudyStep(study);
         String progressStep = getProgressStep(study);
 
         return new StudyResponse(study.getId(), study.getName(), study.getTotalCycle(), study.getTimePerCycle(),
-                study.getCurrentCycle(), roomStep, progressStep, study.getCreatedDate());
+                study.getCurrentCycle(), studyStep, progressStep, study.getCreatedDate(), study.getLastModifiedDate());
     }
 
-    private static String getRoomStep(Study study) {
+    private static String getStudyStep(Study study) {
         String roomStep;
         if (study.isStep(Step.PLANNING) ||  study.isStep(Step.STUDYING) || study.isStep(Step.RETROSPECT)) {
             roomStep = IN_PROGRESS;

backend/src/main/java/harustudy/backend/study/service/StudyService.java

@@ -4,16 +4,15 @@
 import harustudy.backend.member.domain.Member;
 import harustudy.backend.member.exception.MemberNotFoundException;
 import harustudy.backend.member.repository.MemberRepository;
-import harustudy.backend.participantcode.domain.GenerationStrategy;
-import harustudy.backend.participantcode.domain.ParticipantCode;
 import harustudy.backend.participant.domain.Participant;
 import harustudy.backend.participant.repository.ParticipantRepository;
+import harustudy.backend.participantcode.domain.GenerationStrategy;
+import harustudy.backend.participantcode.domain.ParticipantCode;
 import harustudy.backend.participantcode.repository.ParticipantCodeRepository;
 import harustudy.backend.study.domain.Study;
 import harustudy.backend.study.dto.CreateStudyRequest;
-import harustudy.backend.study.dto.CreateStudyResponse;
-import harustudy.backend.study.dto.StudyResponse;
 import harustudy.backend.study.dto.StudiesResponse;
+import harustudy.backend.study.dto.StudyResponse;
 import harustudy.backend.study.exception.ParticipantCodeNotFoundException;
 import harustudy.backend.study.exception.StudyNotFoundException;
 import harustudy.backend.study.repository.StudyRepository;
@@ -65,21 +64,20 @@ private StudiesResponse findStudyByMemberId(Long memberId) {
         return StudiesResponse.from(studies);
     }
 
+    // TODO: N+1
     private List<Study> mapToStudies(List<Participant> participants) {
         return participants.stream()
                 .map(Participant::getStudy)
                 .toList();
     }
 
-    public CreateStudyResponse createStudy(CreateStudyRequest request) {
+    public Long createStudy(CreateStudyRequest request) {
         Study study = new Study(request.name(), request.totalCycle(),
                 request.timePerCycle());
         Study savedStudy = studyRepository.save(study);
+        participantCodeRepository.save(generateUniqueCode(savedStudy));
 
-        ParticipantCode participantCode = generateUniqueCode(study);
-        participantCodeRepository.save(participantCode);
-
-        return CreateStudyResponse.from(savedStudy, participantCode);
+        return savedStudy.getId();
     }
 
     private ParticipantCode generateUniqueCode(Study study) {

backend/src/test/java/harustudy/backend/acceptance/AcceptanceTest.java

@@ -18,16 +18,17 @@
 import harustudy.backend.content.dto.WritePlanRequest;
 import harustudy.backend.content.dto.WriteRetrospectRequest;
 import harustudy.backend.integration.LoginResponse;
-import harustudy.backend.participant.dto.ParticipateStudyRequest;
 import harustudy.backend.participant.dto.ParticipantsResponse;
+import harustudy.backend.participant.dto.ParticipateStudyRequest;
+import harustudy.backend.participantcode.dto.ParticipantCodeResponse;
 import harustudy.backend.study.dto.CreateStudyRequest;
-import harustudy.backend.study.dto.CreateStudyResponse;
-import harustudy.backend.study.dto.StudyResponse;
 import harustudy.backend.study.dto.StudiesResponse;
+import harustudy.backend.study.dto.StudyResponse;
 import jakarta.servlet.http.Cookie;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.Map;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayNameGeneration;
 import org.junit.jupiter.api.DisplayNameGenerator.ReplaceUnderscores;
@@ -80,8 +81,7 @@ void setUp() {
     @Test
     void 회원으로_스터디를_진행한다() throws Exception {
         LoginResponse 로그인_정보 = 구글_로그인을_진행한다();
-        String 참여_코드 = 스터디를_개설한다(로그인_정보);
-        Long 스터디_아이디 = 스터디를_조회한다(로그인_정보, 참여_코드);
+        Long 스터디_아이디 = 스터디를_개설한다(로그인_정보);
         Long 참여자_아이디 = 스터디에_참여한다(로그인_정보, 스터디_아이디);
         스터디_상태를_다음_단계로_넘긴다(로그인_정보, 스터디_아이디);
         스터디_계획을_작성한다(로그인_정보, 스터디_아이디, 참여자_아이디);
@@ -106,8 +106,7 @@ void setUp() {
     @Test
     void 비회원으로_스터디를_진행한다() throws Exception {
         LoginResponse 로그인_정보 = 비회원_로그인을_진행한다();
-        String 참여_코드 = 스터디를_개설한다(로그인_정보);
-        Long 스터디_아이디 = 스터디를_조회한다(로그인_정보, 참여_코드);
+        Long 스터디_아이디 = 스터디를_개설한다(로그인_정보);
         Long 진행도_아이디 = 스터디에_참여한다(로그인_정보, 스터디_아이디);
         스터디_상태를_다음_단계로_넘긴다(로그인_정보, 스터디_아이디);
         스터디_계획을_작성한다(로그인_정보, 스터디_아이디, 진행도_아이디);
@@ -118,6 +117,13 @@ void setUp() {
         스터디_종료_후_결과_조회(로그인_정보, 스터디_아이디);
     }
 
+    @Test
+    void 비회원으로_타인의_스터디에_참여한다() throws Exception {
+        String 참여_코드 = 타인의_스터디_참여_코드를_얻는다();
+        LoginResponse 로그인_정보 = 비회원_로그인을_진행한다();
+        참여_코드로_스터디_아이디를_얻는다(로그인_정보, 참여_코드);
+    }
+
     private List<StudyResponse> 회원으로_진행했던_모든_스터디_목록을_조회한다(LoginResponse 로그인_정보)
             throws Exception {
         long memberId = Long.parseLong(jwtTokenProvider
@@ -170,7 +176,7 @@ void setUp() {
         return new LoginResponse(tokenResponse, refreshToken);
     }
 
-    private String 스터디를_개설한다(LoginResponse 로그인_정보) throws Exception {
+    private Long 스터디를_개설한다(LoginResponse 로그인_정보) throws Exception {
         CreateStudyRequest request = new CreateStudyRequest("studyName", 1, 20);
         String jsonRequest = objectMapper.writeValueAsString(request);
         MvcResult result = mockMvc.perform(
@@ -180,24 +186,11 @@ void setUp() {
                                 .header(HttpHeaders.AUTHORIZATION, 로그인_정보.createAuthorizationHeader()))
                 .andExpect(status().isCreated())
                 .andReturn();
-        String jsonResponse = result.getResponse().getContentAsString(StandardCharsets.UTF_8);
-        CreateStudyResponse response = objectMapper.readValue(jsonResponse,
-                CreateStudyResponse.class);
-        return response.participantCode();
-    }
+        String locationHeader = result.getResponse().getHeader(HttpHeaders.LOCATION);
 
-    private Long 스터디를_조회한다(LoginResponse 로그인_정보, String 참여_코드) throws Exception {
-        MvcResult result = mockMvc.perform(
-                        get("/api/studies")
-                                .param("participantCode", 참여_코드)
-                                .header(HttpHeaders.AUTHORIZATION, 로그인_정보.createAuthorizationHeader()))
-                .andExpect(status().isOk())
-                .andReturn();
-        String jsonResponse = result.getResponse().getContentAsString(StandardCharsets.UTF_8);
-        StudiesResponse responses = objectMapper.readValue(jsonResponse,
-                StudiesResponse.class);
-        StudyResponse response = responses.studies().get(0);
-        return response.studyId();
+        String[] parsed = locationHeader.split("/");
+        System.out.println(locationHeader);
+        return Long.parseLong(parsed[3]);
     }
 
     private Long 스터디에_참여한다(LoginResponse 로그인_정보, Long 스터디_아이디) throws Exception {
@@ -265,4 +258,38 @@ void setUp() {
 
         assertThat(jsonResponse.participants()).hasSize(1);
     }
+
+    private String 타인의_스터디_참여_코드를_얻는다() throws Exception {
+        LoginResponse 로그인_정보 = 비회원_로그인을_진행한다();
+        Long 스터디_아이디 = 스터디를_개설한다(로그인_정보);
+        return 스터디_아이디로_참여_코드를_얻는다(로그인_정보, 스터디_아이디);
+    }
+
+    private String 스터디_아이디로_참여_코드를_얻는다(LoginResponse 로그인_정보, Long 스터디_아이디) throws Exception {
+        MvcResult result = mockMvc.perform(get("/api/participant-codes")
+                        .param("studyId", 스터디_아이디.toString())
+                        .accept(MediaType.APPLICATION_JSON)
+                        .header(HttpHeaders.AUTHORIZATION, 로그인_정보.createAuthorizationHeader()))
+                .andExpect(status().isOk())
+                .andReturn();
+
+        String response = result.getResponse().getContentAsString(StandardCharsets.UTF_8);
+        ParticipantCodeResponse jsonResponse = objectMapper.readValue(response,
+                ParticipantCodeResponse.class);
+
+        assertThat(jsonResponse.participantCode()).hasSize(6);
+        return jsonResponse.participantCode();
+    }
+
+    private void 참여_코드로_스터디_아이디를_얻는다(LoginResponse 로그인_정보, String 참여_코드) throws Exception {
+        MvcResult result = mockMvc.perform(get("/api/studies")
+                        .param("participantCode", 참여_코드)
+                        .accept(MediaType.APPLICATION_JSON)
+                        .header(HttpHeaders.AUTHORIZATION, 로그인_정보.createAuthorizationHeader()))
+                .andExpect(status().isOk())
+                .andReturn();
+        String response = result.getResponse().getContentAsString(StandardCharsets.UTF_8);
+        Assertions.assertDoesNotThrow(() -> objectMapper.readValue(response,
+                StudyResponse.class));
+    }
 }