Merge pull request #65 from WE-ARE-RACCOONS/RAC-187

RAC-187 fix: 유효성 검사

build.gradle

@@ -28,6 +28,7 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-security'
 	implementation 'org.springframework.boot:spring-boot-starter-web'
 	implementation 'org.springframework.boot:spring-boot-starter-webflux'
+	implementation 'org.springframework.boot:spring-boot-starter-validation'
 	compileOnly 'org.projectlombok:lombok'
 	runtimeOnly 'com.mysql:mysql-connector-j'
 	annotationProcessor 'org.projectlombok:lombok'

src/main/java/com/postgraduate/domain/account/application/mapper/AccountMapper.java

@@ -10,8 +10,8 @@ public static Account mapToAccount(Senior senior, SeniorAccountRequest accountRe
         return Account.builder()
                 .senior(senior)
                 .accountNumber(accountNumber)
-                .accountHolder(accountRequest.getAccountHolder())
-                .bank(accountRequest.getBank())
+                .accountHolder(accountRequest.accountHolder())
+                .bank(accountRequest.bank())
                 .build();
     }
 

src/main/java/com/postgraduate/domain/admin/application/dto/req/SeniorStatusRequest.java

@@ -2,14 +2,8 @@
 
 import com.postgraduate.domain.senior.domain.entity.constant.Status;
 import jakarta.validation.constraints.NotNull;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
 
-@Getter
-@AllArgsConstructor
-@NoArgsConstructor
-public class SeniorStatusRequest {
-    @NotNull
-    private Status status;
-}
+public record SeniorStatusRequest(
+        @NotNull
+        Status certificationStatus
+) { }

src/main/java/com/postgraduate/domain/admin/application/usecase/SeniorManageByAdminUseCase.java

@@ -44,7 +44,7 @@ public CertificationDetailsResponse getCertificationDetails(Long seniorId) {
 
     public void updateSeniorStatus(Long seniorId, SeniorStatusRequest request) {
         Senior senior = seniorGetService.bySeniorId(seniorId);
-        seniorUpdateService.updateCertificationStatus(senior, request.getStatus());
+        seniorUpdateService.updateCertificationStatus(senior, request.certificationStatus());
     }
 
     public SeniorManageResponse getSeniors() {

src/main/java/com/postgraduate/domain/admin/presentation/AdminController.java

@@ -7,31 +7,19 @@
 import com.postgraduate.global.dto.ResponseDto;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
 
-import static com.postgraduate.domain.mentoring.presentation.constant.MentoringResponseCode.MENTORING_FIND;
-import static com.postgraduate.domain.mentoring.presentation.constant.MentoringResponseMessage.GET_MENTORING_DETAIL_INFO;
-import static com.postgraduate.domain.mentoring.presentation.constant.MentoringResponseMessage.GET_MENTORING_LIST_INFO;
-import static com.postgraduate.domain.payment.presentation.constant.PaymentResponseCode.PAYMENT_FIND;
-import static com.postgraduate.domain.payment.presentation.constant.PaymentResponseMessage.GET_PAYMENT_LIST_INFO;
-import static com.postgraduate.domain.salary.presentation.constant.SalaryResponseCode.SALARY_FIND;
-import static com.postgraduate.domain.salary.presentation.constant.SalaryResponseCode.SALARY_UPDATE;
-import static com.postgraduate.domain.salary.presentation.constant.SalaryResponseMessage.GET_SALARY_INFO;
-import static com.postgraduate.domain.salary.presentation.constant.SalaryResponseMessage.UPDATE_SALARY_STATUS;
-import static com.postgraduate.domain.senior.presentation.constant.SeniorResponseCode.SENIOR_FIND;
-import static com.postgraduate.domain.senior.presentation.constant.SeniorResponseCode.SENIOR_UPDATE;
-import static com.postgraduate.domain.senior.presentation.constant.SeniorResponseMessage.*;
-import static com.postgraduate.domain.user.presentation.constant.UserResponseCode.USER_FIND;
-import static com.postgraduate.domain.user.presentation.constant.UserResponseMessage.GET_USER_LIST_INFO;
-import static com.postgraduate.domain.wish.presentation.constant.WishResponseCode.WISH_FIND;
-import static com.postgraduate.domain.wish.presentation.constant.WishResponseMessage.GET_WISH_INFO;
+import static com.postgraduate.domain.admin.presentation.constant.AdminResponseCode.ADMIN_FIND;
+import static com.postgraduate.domain.admin.presentation.constant.AdminResponseCode.ADMIN_UPDATE;
+import static com.postgraduate.domain.admin.presentation.constant.AdminResponseMessage.*;
 
 
 @RestController
 @RequiredArgsConstructor
 @RequestMapping("/admin")
-@Tag(name = "ADMIN Controller")
+@Tag(name = "ADMIN Controller", description = "관리자의 모든 API는 토큰이 필요합니다.")
 public class AdminController {
     private final SeniorManageByAdminUseCase seniorManageUseCase;
     private final UserManageByAdminUseCase userManageUseCase;
@@ -43,7 +31,7 @@ public class AdminController {
     @Operation(summary = "[관리자] 선배 프로필 승인 요청 조회", description = "선배 신청 시 작성한 사전 작성정보 및 첨부사진을 조회합니다.")
     public ResponseDto<CertificationDetailsResponse> getCertificationDetails(@PathVariable Long seniorId) {
         CertificationDetailsResponse certification = seniorManageUseCase.getCertificationDetails(seniorId);
-        return ResponseDto.create(SENIOR_FIND.getCode(), GET_SENIOR_PROFILE.getMessage(), certification);
+        return ResponseDto.create(ADMIN_FIND.getCode(), GET_DETAILS.getMessage(), certification);
     }
 
 //    @GetMapping("/certification")
@@ -55,78 +43,79 @@ public ResponseDto<CertificationDetailsResponse> getCertificationDetails(@PathVa
 
     @PatchMapping("/certification/{seniorId}")
     @Operation(summary = "[관리자] 선배 프로필 승인 요청 응답", description = "선배 승인 신청한 유저를 승인 또는 거부합니다.")
-    public ResponseDto updateSeniorStatus(@PathVariable Long seniorId, @RequestBody SeniorStatusRequest request) {
+    public ResponseDto updateSeniorStatus(@PathVariable Long seniorId,
+                                          @RequestBody @Valid SeniorStatusRequest request) {
         seniorManageUseCase.updateSeniorStatus(seniorId, request);
-        return ResponseDto.create(SENIOR_UPDATE.getCode(), UPDATE_STATUS.getMessage());
+        return ResponseDto.create(ADMIN_UPDATE.getCode(), UPDATE_SENIOR_STATUS.getMessage());
     }
 
     @GetMapping("/users")
     @Operation(summary = "[관리자] 후배 정보 목록", description = "대학생 후배 정보 목록을 조회합니다.")
     public ResponseDto<UserManageResponse> getUsers() {
         UserManageResponse users = userManageUseCase.getUsers();
-        return ResponseDto.create(USER_FIND.getCode(), GET_USER_LIST_INFO.getMessage(), users);
+        return ResponseDto.create(ADMIN_FIND.getCode(), GET_LIST.getMessage(), users);
     }
 
     @GetMapping("/wish/{wishId}")
     @Operation(summary = "[관리자] 후배 매칭 지원 정보", description = "대학생 후배 매칭 지원 정보를 상세 조회합니다.")
     public ResponseDto<WishResponse> getWish(@PathVariable Long wishId) {
         WishResponse wish = userManageUseCase.getWish(wishId);
-        return ResponseDto.create(WISH_FIND.getCode(), GET_WISH_INFO.getMessage(), wish);
+        return ResponseDto.create(ADMIN_FIND.getCode(), GET_DETAILS.getMessage(), wish);
     }
 
     @GetMapping("/seniors")
     @Operation(summary = "[관리자] 선배 정보 목록", description = "대학원생 선배 정보 목록을 조회합니다.")
     public ResponseDto<SeniorManageResponse> getSeniors() {
         SeniorManageResponse seniors = seniorManageUseCase.getSeniors();
-        return ResponseDto.create(SENIOR_FIND.getCode(), GET_SENIOR_LIST_INFO.getMessage(), seniors);
+        return ResponseDto.create(ADMIN_FIND.getCode(), GET_LIST.getMessage(), seniors);
     }
 
     @GetMapping("/salary")
     @Operation(summary = "[관리자] 정산 목록 조회", description = "한 달 기준으로 정산 목록을 조회합니다. 기준일은 [11일 ~ 내월 10일]입니다.")
     public ResponseDto<SalaryManageResponse> getSalaries() {
         SalaryManageResponse salaries = salaryManageUseCase.getSalaries();
-        return ResponseDto.create(SALARY_FIND.getCode(), GET_SALARY_INFO.getMessage(), salaries);
+        return ResponseDto.create(ADMIN_FIND.getCode(), GET_LIST.getMessage(), salaries);
     }
 
     @GetMapping("/salary/{seniorId}")
     @Operation(summary = "[관리자] 선배 정산 상세 정보", description = "대학원생 선배 정산 상세 정보를 조회합니다.")
     public ResponseDto<SalaryDetailsResponse> getSalary(@PathVariable Long seniorId) {
         SalaryDetailsResponse salary = salaryManageUseCase.getSalary(seniorId);
-        return ResponseDto.create(SALARY_FIND.getCode(), GET_SALARY_INFO.getMessage(), salary);
+        return ResponseDto.create(ADMIN_FIND.getCode(), GET_DETAILS.getMessage(), salary);
     }
 
     @PatchMapping("/salary/{seniorId}")
     @Operation(summary = "[관리자] 정산 상태 변경", description = "대학원생 선배 정산 상태를 변경합니다.")
     public ResponseDto updateSalaryStatus(@PathVariable Long seniorId, @RequestParam Boolean status) {
         salaryManageUseCase.updateSalaryStatus(seniorId, status);
-        return ResponseDto.create(SALARY_UPDATE.getCode(), UPDATE_SALARY_STATUS.getMessage());
+        return ResponseDto.create(ADMIN_UPDATE.getCode(), UPDATE_SALARY_STATUS.getMessage());
     }
 
     @GetMapping("/user/{userId}/mentoring")
     @Operation(summary = "[관리자] 후배 멘토링 조회", description = "후배의 멘토링 목록을 조회합니다.")
     public ResponseDto<MentoringManageResponse> getUserMentorings(@PathVariable Long userId) {
         MentoringManageResponse mentorings = mentoringManageUseCase.getUserMentorings(userId);
-        return ResponseDto.create(MENTORING_FIND.getCode(), GET_MENTORING_LIST_INFO.getMessage(), mentorings);
+        return ResponseDto.create(ADMIN_FIND.getCode(), GET_LIST.getMessage(), mentorings);
     }
 
     @GetMapping("/senior/{seniorId}/mentoring")
     @Operation(summary = "[관리자] 선배 멘토링 조회", description = "선배의 멘토링 목록을 조회합니다.")
     public ResponseDto<MentoringManageResponse> getSeniorMentorings(@PathVariable Long seniorId) {
         MentoringManageResponse mentorings = mentoringManageUseCase.getSeniorMentorings(seniorId);
-        return ResponseDto.create(MENTORING_FIND.getCode(), GET_MENTORING_LIST_INFO.getMessage(), mentorings);
+        return ResponseDto.create(ADMIN_FIND.getCode(), GET_LIST.getMessage(), mentorings);
     }
 
     @GetMapping("/payments")
     @Operation(summary = "[관리자] 결제 정보 목록", description = "결제 정보 목록을 조회합니다.")
     public ResponseDto<PaymentManageResponse> getPayments() {
         PaymentManageResponse payments = paymentManageUseCase.getPayments();
-        return ResponseDto.create(PAYMENT_FIND.getCode(), GET_PAYMENT_LIST_INFO.getMessage(), payments);
+        return ResponseDto.create(ADMIN_FIND.getCode(), GET_LIST.getMessage(), payments);
     }
 
     @GetMapping("/payments/{mentoringId}")
     @Operation(summary = "[관리자] 결제된 멘토링 정보", description = "결제된 멘토링 정보를 조회합니다.")
     public ResponseDto<MentoringWithPaymentResponse> getPayments(@PathVariable Long mentoringId) {
         MentoringWithPaymentResponse mentoringWithPayment = mentoringManageUseCase.getMentoringWithPayment(mentoringId);
-        return ResponseDto.create(MENTORING_FIND.getCode(), GET_MENTORING_DETAIL_INFO.getMessage(), mentoringWithPayment);
+        return ResponseDto.create(ADMIN_FIND.getCode(), GET_DETAILS.getMessage(), mentoringWithPayment);
     }
 }

src/main/java/com/postgraduate/domain/admin/presentation/constant/AdminResponseCode.java

@@ -0,0 +1,15 @@
+package com.postgraduate.domain.admin.presentation.constant;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum AdminResponseCode {
+    ADMIN_FIND("ADM200"),
+    ADMIN_CREATE("ADM201"),
+    ADMIN_UPDATE("ADM202"),
+    ADMIN_DELETE("ADM203");
+
+    private final String code;
+}

src/main/java/com/postgraduate/domain/admin/presentation/constant/AdminResponseMessage.java

@@ -0,0 +1,15 @@
+package com.postgraduate.domain.admin.presentation.constant;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum AdminResponseMessage {
+    GET_DETAILS("상세 조회에 성공하였습니다."),
+    GET_LIST("목록 조회에 성공하였습니다."),
+    UPDATE_SENIOR_STATUS("선배 승인 상태 수정에 성공하였습니다."),
+    UPDATE_SALARY_STATUS("정산 상태 수정에 성공하였습니다.");
+
+    private final String message;
+}

src/main/java/com/postgraduate/domain/auth/application/dto/req/SignUpRequest.java

@@ -1,24 +1,18 @@
 package com.postgraduate.domain.auth.application.dto.req;
 
 import jakarta.validation.constraints.NotNull;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
 
-@Getter
-@AllArgsConstructor
-@NoArgsConstructor
-public class SignUpRequest {
-    @NotNull
-    private Long socialId;
-    @NotNull
-    private String phoneNumber;
-    @NotNull
-    private String nickName;
-    @NotNull
-    private Boolean marketingReceive;
-    private String major;
-    private String field;
-    @NotNull
-    private Boolean matchingReceive;
-}
+public record SignUpRequest(
+        @NotNull
+        Long socialId,
+        @NotNull
+        String phoneNumber,
+        @NotNull
+        String nickName,
+        @NotNull
+        Boolean marketingReceive,
+        String major,
+        String field,
+        @NotNull
+        Boolean matchingReceive
+) { }

src/main/java/com/postgraduate/domain/auth/presentation/AuthController.java

@@ -16,6 +16,7 @@
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.servlet.http.HttpServletRequest;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.*;
@@ -36,7 +37,7 @@ public class AuthController {
 
     @PostMapping("/login/{provider}")
     @Operation(summary = "소셜 로그인", description = "회원인 경우 JWT를, 회원이 아닌 경우 socialId를 반환합니다(회원가입은 진행하지 않습니다).")
-    public ResponseDto<?> authLogin(@RequestBody CodeRequest request, @PathVariable Provider provider) {
+    public ResponseDto<?> authLogin(@RequestBody @Valid CodeRequest request, @PathVariable String provider) {
         SignInUseCase signInUseCase = selectOauth.selectStrategy(provider);
         AuthUserResponse authUser = signInUseCase.getUser(request);
         if (authUser.getUser().isEmpty())
@@ -54,32 +55,32 @@ public ResponseDto logout(@AuthenticationPrincipal User user) {
 
     @PostMapping("/user/signup")
     @Operation(summary = "대학생 회원가입", description = "로그인 API에서 반환한 socialId, 닉네임, 번호, 마케팅 수신여부, 희망 학과, 희망 분야, 매칭 희망 여부")
-    public ResponseDto<JwtTokenResponse> signUpUser(@RequestBody SignUpRequest request) {
+    public ResponseDto<JwtTokenResponse> signUpUser(@RequestBody @Valid SignUpRequest request) {
         User user = signUpUseCase.userSignUp(request);
         JwtTokenResponse jwtToken = jwtUseCase.signIn(user);
         return ResponseDto.create(AUTH_CREATE.getCode(), SUCCESS_AUTH.getMessage(), jwtToken);
     }
 
     @PostMapping("/senior/signup")
     @Operation(summary = "대학원생 가입 - 필수 과정만", description = "대학원생 회원가입 - 필수 과정만")
-    public ResponseDto<JwtTokenResponse> singUpSenior(@RequestBody SeniorSignUpRequest request) {
+    public ResponseDto<JwtTokenResponse> singUpSenior(@RequestBody @Valid SeniorSignUpRequest request) {
         User user = signUpUseCase.seniorSignUp(request);
         JwtTokenResponse jwtToken = jwtUseCase.signIn(user);
         return ResponseDto.create(SENIOR_CREATE.getCode(), CREATE_SENIOR.getMessage(), jwtToken);
     }
 
     @PostMapping("/senior/change")
-    @Operation(summary = "선배로 업데이트", description = "대학생 대학원생으로 변경")
+    @Operation(summary = "선배로 업데이트 | 토큰 필요", description = "대학생 대학원생으로 변경")
     public ResponseDto<JwtTokenResponse> changeSenior(@AuthenticationPrincipal User user,
-                                    @RequestBody SeniorChangeRequest changeRequest) {
+                                                      @RequestBody @Valid SeniorChangeRequest changeRequest) {
         User changeUser = signUpUseCase.changeSenior(user, changeRequest);
         JwtTokenResponse jwtToken = jwtUseCase.signIn(changeUser);
         return ResponseDto.create(SENIOR_CREATE.getCode(), CREATE_SENIOR.getMessage(), jwtToken);
     }
 
 
     @PostMapping("/refresh")
-    @Operation(summary = "토큰 재발급 - 토큰 필요", description = "refreshToken 으로 토큰 재발급")
+    @Operation(summary = "토큰 재발급 | 토큰 필요", description = "refreshToken 으로 토큰 재발급")
     public ResponseDto<JwtTokenResponse> refresh(@AuthenticationPrincipal User user, HttpServletRequest request) {
         JwtTokenResponse jwtToken = jwtUseCase.regenerateToken(user, request);
         return ResponseDto.create(AUTH_UPDATE.getCode(), SUCCESS_REGENERATE_TOKEN.getMessage(), jwtToken);

src/main/java/com/postgraduate/domain/mentoring/application/dto/req/MentoringApplyRequest.java

@@ -1,20 +1,14 @@
 package com.postgraduate.domain.mentoring.application.dto.req;
 
 import jakarta.validation.constraints.NotNull;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
 
-@Getter
-@AllArgsConstructor
-@NoArgsConstructor
-public class MentoringApplyRequest {
-    @NotNull
-    private Long seniorId;
-    @NotNull
-    private String topic;
-    @NotNull
-    private String question;
-    @NotNull
-    private String date;
-}
+public record MentoringApplyRequest(
+        @NotNull
+        Long seniorId,
+        @NotNull
+        String topic,
+        @NotNull
+        String question,
+        @NotNull
+        String date
+) { }

src/main/java/com/postgraduate/domain/mentoring/application/mapper/MentoringMapper.java

@@ -81,9 +81,9 @@ public static Mentoring mapToMentoring(User user, Senior senior, MentoringApplyR
         return Mentoring.builder()
                 .user(user)
                 .senior(senior)
-                .topic(request.getTopic())
-                .question(request.getQuestion())
-                .date(request.getDate())
+                .topic(request.topic())
+                .question(request.question())
+                .date(request.date())
                 .build();
     }
 

src/main/java/com/postgraduate/domain/mentoring/application/usecase/MentoringApplyUseCase.java

@@ -19,7 +19,7 @@ public class MentoringApplyUseCase {
     private final SeniorGetService seniorGetService;
 
     public void applyMentoring(User user, MentoringApplyRequest request) {
-        Senior senior = seniorGetService.bySeniorId(request.getSeniorId());
+        Senior senior = seniorGetService.bySeniorId(request.seniorId());
         Mentoring mentoring = MentoringMapper.mapToMentoring(user, senior, request);
         mentoringSaveService.save(mentoring);
     }