Merge pull request #19 from CSID-DGU/develop

Test: CI/CD 테스트용

src/main/java/dongguk/osori/TestController.java

@@ -7,6 +7,6 @@
 public class TestController {
     @GetMapping("/")
     public String home() {
-        return "CI/CD 성공!";
+        return "CI/CD test";
     }
 }

src/main/java/dongguk/osori/domain/follow/FollowController.java

@@ -4,14 +4,16 @@
 import dongguk.osori.domain.follow.service.FollowService;
 import dongguk.osori.domain.user.entity.User;
 import dongguk.osori.domain.user.service.UserService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
 
-
 @Slf4j
 @RestController
 @RequiredArgsConstructor
@@ -22,7 +24,11 @@ public class FollowController {
     private final FollowService followService;
     private final UserService userService;
 
-    // 내 팔로잉 목록 및 팔로잉 수 조회
+    @Operation(summary = "내 팔로잉 목록 및 팔로잉 수 조회", description = "로그인한 사용자의 팔로잉 목록과 팔로잉 수를 조회합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "팔로잉 목록 및 수 조회 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자")
+    })
     @GetMapping("/following")
     public ResponseEntity<MyFollowResponse> getMyFollowingList(@SessionAttribute(name = "userId", required = false) Long userId) {
         if (userId == null) {
@@ -35,7 +41,11 @@ public ResponseEntity<MyFollowResponse> getMyFollowingList(@SessionAttribute(nam
         return ResponseEntity.ok(response);
     }
 
-    // 내 팔로워 목록 및 팔로워 수 조회
+    @Operation(summary = "내 팔로워 목록 및 팔로워 수 조회", description = "로그인한 사용자의 팔로워 목록과 팔로워 수를 조회합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "팔로워 목록 및 수 조회 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자")
+    })
     @GetMapping("/followers")
     public ResponseEntity<MyFollowResponse> getMyFollowerList(@SessionAttribute(name = "userId", required = false) Long userId) {
         if (userId == null) {
@@ -48,8 +58,12 @@ public ResponseEntity<MyFollowResponse> getMyFollowerList(@SessionAttribute(name
         return ResponseEntity.ok(response);
     }
 
-
-    // 이메일로 팔로우
+    @Operation(summary = "이메일로 사용자 팔로우", description = "이메일로 사용자를 검색해 팔로우합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "팔로우 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자"),
+            @ApiResponse(responseCode = "404", description = "해당 이메일의 사용자를 찾을 수 없음")
+    })
     @PostMapping()
     public ResponseEntity<Void> followUserByEmail(@SessionAttribute(name = "userId", required = false) Long userId, @RequestBody FollowRequestDto followRequestDto) {
         if (userId == null) {
@@ -65,8 +79,11 @@ public ResponseEntity<Void> followUserByEmail(@SessionAttribute(name = "userId",
         return ResponseEntity.ok().build();
     }
 
-
-    // 언팔로우
+    @Operation(summary = "언팔로우", description = "사용자를 언팔로우합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "언팔로우 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자")
+    })
     @DeleteMapping()
     public ResponseEntity<Void> unfollowUser(@SessionAttribute(name = "userId", required = false) Long userId,
                                              @RequestBody UnfollowRequestDto unfollowRequestDto) {
@@ -77,9 +94,11 @@ public ResponseEntity<Void> unfollowUser(@SessionAttribute(name = "userId", requ
         return ResponseEntity.ok().build();
     }
 
-
-    // 팔로워 끊기
-    // TODO: 팔로워 끊기와 언팔로우 통합 방안 고려
+    @Operation(summary = "팔로워 끊기", description = "팔로워를 끊습니다. (차단 기능)")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "팔로워 끊기 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자")
+    })
     @DeleteMapping("/block")
     public ResponseEntity<Void> blockFollower(@SessionAttribute(name = "userId", required = false) Long userId,
                                               @RequestBody BlockFollowerRequestDto blockFollowerRequestDto) {
@@ -89,5 +108,4 @@ public ResponseEntity<Void> blockFollower(@SessionAttribute(name = "userId", req
         followService.blockFollower(userId, blockFollowerRequestDto.getFollowerId());
         return ResponseEntity.ok().build();
     }
-
 }

src/main/java/dongguk/osori/domain/goal/GoalController.java

@@ -4,6 +4,9 @@
 import dongguk.osori.domain.goal.dto.GoalDto;
 import dongguk.osori.domain.goal.entity.Goal;
 import dongguk.osori.domain.goal.service.GoalService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import jakarta.servlet.http.HttpSession;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -22,7 +25,11 @@ public class GoalController {
 
     private final GoalService goalService;
 
-    // 로그인한 사용자의 목표 조회
+    @Operation(summary = "로그인한 사용자의 목표 조회", description = "세션의 userId를 사용하여 로그인한 사용자의 목표 목록을 조회합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "목표 목록 조회 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자")
+    })
     @GetMapping
     public ResponseEntity<List<Goal>> getUserGoals(HttpSession session) {
         Long userId = (Long) session.getAttribute("userId");
@@ -33,7 +40,11 @@ public ResponseEntity<List<Goal>> getUserGoals(HttpSession session) {
         return ResponseEntity.ok(goals);
     }
 
-    // 로그인한 사용자의 목표 생성
+    @Operation(summary = "로그인한 사용자의 목표 생성", description = "로그인한 사용자의 새로운 목표를 생성합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "목표 생성 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자")
+    })
     @PostMapping
     public ResponseEntity<Goal> createGoal(@RequestBody GoalDto goalDto, HttpSession session) {
         Long userId = (Long) session.getAttribute("userId");
@@ -44,7 +55,12 @@ public ResponseEntity<Goal> createGoal(@RequestBody GoalDto goalDto, HttpSession
         return ResponseEntity.ok(createdGoal);
     }
 
-    // 로그인한 사용자의 목표 수정
+    @Operation(summary = "로그인한 사용자의 목표 수정", description = "로그인한 사용자의 기존 목표를 수정합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "목표 수정 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자"),
+            @ApiResponse(responseCode = "404", description = "목표를 찾을 수 없음")
+    })
     @PatchMapping("/{goalId}")
     public ResponseEntity<Goal> updateGoal(@PathVariable("goalId") Long goalId, @RequestBody GoalDto goalDto, HttpSession session) {
         Long userId = (Long) session.getAttribute("userId");
@@ -56,7 +72,11 @@ public ResponseEntity<Goal> updateGoal(@PathVariable("goalId") Long goalId, @Req
                 .orElseGet(() -> ResponseEntity.notFound().build());
     }
 
-    // 로그인한 사용자의 목표 삭제
+    @Operation(summary = "로그인한 사용자의 목표 삭제", description = "로그인한 사용자의 기존 목표를 삭제합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "204", description = "목표 삭제 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자")
+    })
     @DeleteMapping("/{goalId}")
     public ResponseEntity<Void> deleteGoal(@PathVariable("goalId") Long goalId, HttpSession session) {
         Long userId = (Long) session.getAttribute("userId");
@@ -67,7 +87,12 @@ public ResponseEntity<Void> deleteGoal(@PathVariable("goalId") Long goalId, Http
         return ResponseEntity.noContent().build();
     }
 
-    // 로그인한 사용자의 목표 달성 여부 수정
+    @Operation(summary = "로그인한 사용자의 목표 달성 여부 수정", description = "로그인한 사용자의 목표 달성 상태를 수정합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "목표 달성 상태 수정 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자"),
+            @ApiResponse(responseCode = "404", description = "목표를 찾을 수 없음")
+    })
     @PatchMapping("/{goalId}/completion")
     public ResponseEntity<Goal> updateGoalCompletion(@PathVariable("goalId") Long goalId, @RequestBody GoalCompletionDto goalCompletionDto, HttpSession session) {
         Long userId = (Long) session.getAttribute("userId");

src/main/java/dongguk/osori/domain/user/UserController.java

@@ -3,6 +3,9 @@
 import dongguk.osori.domain.user.dto.*;
 import dongguk.osori.domain.user.service.EmailService;
 import dongguk.osori.domain.user.service.UserService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import jakarta.servlet.http.HttpSession;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -21,39 +24,33 @@ public class UserController {
     private final UserService userService;
     private final EmailService emailService;
 
-
-    // 이메일 인증 코드 전송
+    @Operation(summary = "이메일 인증 코드 전송", description = "회원가입을 위해 이메일로 인증 코드를 전송합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "인증 코드 전송 성공"),
+            @ApiResponse(responseCode = "400", description = "잘못된 이메일 입력")
+    })
     @PostMapping("/signup/send-email")
-    public ResponseEntity<String> sendSignupEmail(@RequestBody Map<String,String> request) {
-        String email = request.get("email"); // 이메일 주소 추출
+    public ResponseEntity<String> sendSignupEmail(@RequestBody Map<String, String> request) {
+        String email = request.get("email");
         if (email == null || email.isEmpty()) {
             return ResponseEntity.status(400).body("이메일이 올바르지 않습니다.");
         }
         emailService.sendEmail(email);
         return ResponseEntity.ok("인증 코드가 이메일로 전송되었습니다.");
     }
 
-//    // 이메일 인증 코드 확인
-//    @PostMapping("/signup/verify-code")
-//    public ResponseEntity<String> verifyEmailCode(@RequestBody EmailVerificationDto verificationDto) {
-//        boolean isVerified = emailService.verifyAuthCode(verificationDto.getEmail(), verificationDto.getCode());
-//
-//        if (isVerified) {
-//            return ResponseEntity.ok("이메일 인증이 완료되었습니다.");
-//        } else {
-//            return ResponseEntity.status(400).body("잘못된 인증 코드입니다.");
-//        }
-//    }
-
-    // 회원가입
+    @Operation(summary = "회원가입", description = "이메일 인증을 완료한 사용자가 회원가입을 진행합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "회원가입 성공"),
+            @ApiResponse(responseCode = "400", description = "이메일 인증 실패 또는 잘못된 요청"),
+            @ApiResponse(responseCode = "500", description = "서버 에러")
+    })
     @PostMapping("/signup")
     public ResponseEntity<String> signup(@RequestBody SignupUserDto signupUserDto) {
         try {
-            // 이메일 인증이 완료된 사용자만 회원가입 가능
             if (!emailService.verifyAuthCode(signupUserDto.getEmail(), signupUserDto.getAuthCode())) {
                 return ResponseEntity.status(400).body("이메일 인증이 완료되지 않았습니다.");
             }
-
             userService.signup(signupUserDto);
             return ResponseEntity.ok("회원가입이 완료되었습니다.");
         } catch (IllegalArgumentException e) {
@@ -63,19 +60,27 @@ public ResponseEntity<String> signup(@RequestBody SignupUserDto signupUserDto) {
         }
     }
 
-    // 유저 프로필 정보 조회
+    @Operation(summary = "유저 프로필 조회", description = "로그인한 사용자의 프로필 정보를 조회합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "프로필 조회 성공"),
+            @ApiResponse(responseCode = "401", description = "인증되지 않은 사용자")
+    })
     @GetMapping("/profile")
     public ResponseEntity<UserProfileDto> getUserProfile(HttpSession session) {
         Long userId = (Long) session.getAttribute("userId");
-
         if (userId == null) {
             return ResponseEntity.status(401).build();
         }
         UserProfileDto userDto = userService.getUserProfile(userId);
         return ResponseEntity.ok(userDto);
     }
 
-    // 로그인
+    @Operation(summary = "로그인", description = "이메일과 비밀번호로 로그인합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "로그인 성공"),
+            @ApiResponse(responseCode = "401", description = "로그인 실패"),
+            @ApiResponse(responseCode = "500", description = "서버 에러")
+    })
     @PostMapping("/login")
     public ResponseEntity<String> login(@RequestBody LoginRequestDto loginRequest, HttpSession session) {
         try {
@@ -92,22 +97,28 @@ public ResponseEntity<String> login(@RequestBody LoginRequestDto loginRequest, H
         }
     }
 
-    // 로그아웃 시 세션 무효화
+    @Operation(summary = "로그아웃", description = "사용자를 로그아웃하고 세션을 무효화합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "로그아웃 성공")
+    })
     @PostMapping("/logout")
     public ResponseEntity<Void> logout(HttpSession session) {
         session.invalidate();
         return ResponseEntity.ok().build();
     }
 
-    // 유저 프로필 수정
+    @Operation(summary = "유저 프로필 수정", description = "로그인한 사용자의 프로필 정보를 수정합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "프로필 수정 성공"),
+            @ApiResponse(responseCode = "400", description = "잘못된 요청"),
+            @ApiResponse(responseCode = "500", description = "서버 에러")
+    })
     @PatchMapping("/profile")
     public ResponseEntity<String> updateUserProfile(@RequestBody UserProfileEditDto userProfileEditDto, HttpSession session) {
         Long userId = (Long) session.getAttribute("userId");
-
         if (userId == null) {
             return ResponseEntity.status(401).body("로그인이 필요합니다.");
         }
-
         try {
             userService.updateUserProfile(userId, userProfileEditDto);
             return ResponseEntity.ok("프로필 수정이 완료되었습니다.");
@@ -119,20 +130,21 @@ public ResponseEntity<String> updateUserProfile(@RequestBody UserProfileEditDto
         }
     }
 
-
-    // 현재 비밀번호 확인
+    @Operation(summary = "현재 비밀번호 확인", description = "비밀번호 확인용 엔드포인트로, 현재 비밀번호가 맞는지 확인합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "비밀번호 확인 성공"),
+            @ApiResponse(responseCode = "400", description = "잘못된 비밀번호"),
+            @ApiResponse(responseCode = "500", description = "서버 에러")
+    })
     @PostMapping("/verify-password")
     public ResponseEntity<String> verifyPassword(@RequestBody PasswordDto passwordDto, HttpSession session) {
         Long userId = (Long) session.getAttribute("userId");
-
         if (userId == null) {
             return ResponseEntity.status(401).body("로그인이 필요합니다.");
         }
-
         if (passwordDto.getPassword() == null || passwordDto.getPassword().isEmpty()) {
             return ResponseEntity.status(400).body("비밀번호가 입력되지 않았습니다.");
         }
-
         try {
             boolean isVerified = userService.verifyPassword(userId, passwordDto);
             if (isVerified) {
@@ -146,36 +158,33 @@ public ResponseEntity<String> verifyPassword(@RequestBody PasswordDto passwordDt
         }
     }
 
-    // 비밀번호 변경
+    @Operation(summary = "비밀번호 변경", description = "현재 비밀번호를 확인 후 새로운 비밀번호로 변경합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "비밀번호 변경 성공"),
+            @ApiResponse(responseCode = "400", description = "잘못된 요청 또는 현재 비밀번호 불일치"),
+            @ApiResponse(responseCode = "500", description = "서버 에러")
+    })
     @PatchMapping("/password")
     public ResponseEntity<String> updatePassword(@RequestBody Map<String, String> request, HttpSession session) {
         Long userId = (Long) session.getAttribute("userId");
-
         if (userId == null) {
             return ResponseEntity.status(401).body("로그인이 필요합니다.");
         }
-
         String currentPassword = request.get("currentPassword");
         String newPassword = request.get("newPassword");
-
         if (currentPassword == null || newPassword == null || currentPassword.isEmpty() || newPassword.isEmpty()) {
             return ResponseEntity.status(400).body("비밀번호가 올바르게 입력되지 않았습니다.");
         }
-
         try {
-            // 현재 비밀번호 확인
             boolean isVerified = userService.verifyPassword(userId, new PasswordDto(currentPassword));
             if (!isVerified) {
                 return ResponseEntity.status(400).body("현재 비밀번호가 일치하지 않습니다.");
             }
-
-            // 비밀번호 변경
             userService.updatePassword(userId, new PasswordDto(newPassword));
             return ResponseEntity.ok("비밀번호가 성공적으로 변경되었습니다.");
         } catch (Exception e) {
             log.error("Unexpected error during password update", e);
             return ResponseEntity.status(500).body("서버 에러 발생. 나중에 다시 시도해주세요.");
         }
     }
-}
-
+}