feat: 멘토 승격 api 구현

src/main/java/com/example/solidconnection/common/exception/ErrorCode.java

@@ -119,6 +119,11 @@ public enum ErrorCode {
     MENTORING_NOT_FOUND(HttpStatus.NOT_FOUND.value(), "해당 멘토링 신청을 찾을 수 없습니다."),
     UNAUTHORIZED_MENTORING(HttpStatus.FORBIDDEN.value(), "멘토링 권한이 없습니다."),
     MENTORING_ALREADY_CONFIRMED(HttpStatus.BAD_REQUEST.value(), "이미 승인 또는 거절된 멘토링입니다."),
+    MENTOR_APPLICATION_ALREADY_EXISTED(HttpStatus.CONFLICT.value(),"멘토 승격 요청이 이미 존재합니다."),
+    INVALID_EXCHANGE_STATUS_FOR_MENTOR(HttpStatus.BAD_REQUEST.value(), "멘토 승격 지원 가능한 교환학생 상태가 아닙니다."),
+    UNIVERSITY_ID_REQUIRED_FOR_CATALOG(HttpStatus.BAD_REQUEST.value(), "목록에서 학교를 선택한 경우 학교 정보가 필요합니다."),
+    UNIVERSITY_ID_MUST_BE_NULL_FOR_OTHER(HttpStatus.BAD_REQUEST.value(), "기타 학교를 선택한 경우 학교 정보를 입력할 수 없습니다."),
+    INVALID_UNIVERSITY_SELECT_TYPE(HttpStatus.BAD_REQUEST.value(), "지원하지 않는 학교 선택 방식입니다."),
 
     // socket
     UNAUTHORIZED_SUBSCRIBE(HttpStatus.FORBIDDEN.value(), "구독 권한이 없습니다."),

src/main/java/com/example/solidconnection/mentor/controller/MentorApplicationController.java

@@ -0,0 +1,32 @@
+package com.example.solidconnection.mentor.controller;
+
+import com.example.solidconnection.common.resolver.AuthorizedUser;
+import com.example.solidconnection.mentor.dto.MentorApplicationRequest;
+import com.example.solidconnection.mentor.service.MentorApplicationService;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RequestPart;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+@RequiredArgsConstructor
+@RequestMapping("/mentees")
+@RestController
+public class MentorApplicationController {
+
+    private final MentorApplicationService mentorApplicationService;
+
+    @PostMapping("/mentor-applications")
+    public ResponseEntity<Void> requestMentorApplication(
+            @AuthorizedUser long siteUserId,
+            @Valid @RequestPart("mentorApplicationRequest") MentorApplicationRequest mentorApplicationRequest,
+            @RequestParam("file") MultipartFile file
+    ) {
+        mentorApplicationService.submitMentorApplication(siteUserId, mentorApplicationRequest, file);
+        return ResponseEntity.ok().build();
+    }
+}

src/main/java/com/example/solidconnection/mentor/domain/MentorApplication.java

@@ -0,0 +1,109 @@
+package com.example.solidconnection.mentor.domain;
+
+import com.example.solidconnection.common.BaseEntity;
+import com.example.solidconnection.common.exception.CustomException;
+import com.example.solidconnection.common.exception.ErrorCode;
+import com.example.solidconnection.siteuser.domain.ExchangeStatus;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Set;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.Check;
+
+@Entity
+@Getter
+@AllArgsConstructor
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Check(
+        name = "chk_ma_university_select_rule",
+        constraints = """ 
+                      (university_select_type = 'CATALOG' AND university_id IS NOT NULL) OR
+                      (university_select_type = 'OTHER' AND university_id IS NULL)
+                      """
+)
+public class MentorApplication extends BaseEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private long siteUserId;
+
+    @Column(nullable = false, name = "country_code")
+    private String countryCode;
+
+    @Column
+    private Long universityId;
+
+    @Column(nullable = false)
+    @Enumerated(EnumType.STRING)
+    private UniversitySelectType universitySelectType;
+
+    @Column(nullable = false, name = "mentor_proof_url", length = 500)
+    private String mentorProofUrl;
+
+    private String rejectedReason;
+
+    @Column(nullable = false)
+    @Enumerated(EnumType.STRING)
+    private ExchangeStatus exchangeStatus;
+
+    @Column(nullable = false)
+    @Enumerated(EnumType.STRING)
+    private MentorApplicationStatus mentorApplicationStatus = MentorApplicationStatus.PENDING;
+
+    private static final Set<ExchangeStatus> ALLOWED =
+            Collections.unmodifiableSet(EnumSet.of(ExchangeStatus.STUDYING_ABROAD, ExchangeStatus.AFTER_EXCHANGE));
+
+    public MentorApplication(
+            long siteUserId,
+            String countryCode,
+            Long universityId,
+            UniversitySelectType universitySelectType,
+            String mentorProofUrl,
+            ExchangeStatus exchangeStatus
+    ) {
+        validateExchangeStatus(exchangeStatus);
+        validateUniversitySelection(universitySelectType, universityId);
+
+        this.siteUserId = siteUserId;
+        this.countryCode = countryCode;
+        this.universityId = universityId;
+        this.universitySelectType = universitySelectType;
+        this.mentorProofUrl = mentorProofUrl;
+        this.exchangeStatus = exchangeStatus;
+    }
+
+    private void validateUniversitySelection(UniversitySelectType universitySelectType, Long universityId) {
+        switch (universitySelectType) {
+            case CATALOG -> {
+                if(universityId == null) {
+                    throw new CustomException(ErrorCode.UNIVERSITY_ID_REQUIRED_FOR_CATALOG);
+                }
+            }
+            case OTHER -> {
+                if(universityId != null) {
+                    throw new CustomException(ErrorCode.UNIVERSITY_ID_MUST_BE_NULL_FOR_OTHER);
+                }
+            }
+            default ->  throw new CustomException(ErrorCode.INVALID_UNIVERSITY_SELECT_TYPE);
+        }
+    }
+
+    private void validateExchangeStatus(ExchangeStatus exchangeStatus) {
+        if(!ALLOWED.contains(exchangeStatus)) {
+            throw new CustomException(ErrorCode.INVALID_EXCHANGE_STATUS_FOR_MENTOR);
+        }
+    }
+}

src/main/java/com/example/solidconnection/mentor/domain/MentorApplicationStatus.java

@@ -0,0 +1,9 @@
+package com.example.solidconnection.mentor.domain;
+
+public enum MentorApplicationStatus {
+
+    PENDING,
+    APPROVED,
+    REJECTED,
+    ;
+}

src/main/java/com/example/solidconnection/mentor/domain/UniversitySelectType.java

@@ -0,0 +1,7 @@
+package com.example.solidconnection.mentor.domain;
+
+public enum UniversitySelectType {
+
+    CATALOG,
+    OTHER
+}

src/main/java/com/example/solidconnection/mentor/dto/MentorApplicationRequest.java

@@ -0,0 +1,14 @@
+package com.example.solidconnection.mentor.dto;
+
+import com.example.solidconnection.mentor.domain.UniversitySelectType;
+import com.example.solidconnection.siteuser.domain.ExchangeStatus;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+public record MentorApplicationRequest(
+        @JsonProperty("preparationStatus")
+        ExchangeStatus exchangeStatus,
+        UniversitySelectType universitySelectType,
+        String country,
+        Long universityId
+) {
+}

src/main/java/com/example/solidconnection/mentor/repository/MentorApplicationRepository.java

@@ -0,0 +1,11 @@
+package com.example.solidconnection.mentor.repository;
+
+import com.example.solidconnection.mentor.domain.MentorApplication;
+import com.example.solidconnection.mentor.domain.MentorApplicationStatus;
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface MentorApplicationRepository extends JpaRepository<MentorApplication, Long> {
+
+    boolean existsBySiteUserIdAndMentorApplicationStatusIn(long siteUserId, List<MentorApplicationStatus> mentorApplicationStatuses);
+}

src/main/java/com/example/solidconnection/mentor/service/MentorApplicationService.java

@@ -0,0 +1,58 @@
+package com.example.solidconnection.mentor.service;
+
+import com.example.solidconnection.common.exception.CustomException;
+import com.example.solidconnection.mentor.domain.MentorApplication;
+import com.example.solidconnection.mentor.domain.MentorApplicationStatus;
+import com.example.solidconnection.mentor.dto.MentorApplicationRequest;
+import com.example.solidconnection.mentor.repository.MentorApplicationRepository;
+import com.example.solidconnection.s3.domain.ImgType;
+import com.example.solidconnection.s3.dto.UploadedFileUrlResponse;
+import com.example.solidconnection.s3.service.S3Service;
+import com.example.solidconnection.siteuser.domain.SiteUser;
+import com.example.solidconnection.siteuser.repository.SiteUserRepository;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.multipart.MultipartFile;
+
+import static com.example.solidconnection.common.exception.ErrorCode.MENTOR_APPLICATION_ALREADY_EXISTED;
+import static com.example.solidconnection.common.exception.ErrorCode.USER_NOT_FOUND;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class MentorApplicationService {
+
+    private final MentorApplicationRepository mentorApplicationRepository;
+    private final SiteUserRepository siteUserRepository;
+    private final S3Service s3Service;
+
+    @Transactional
+    public void submitMentorApplication(
+            long siteUserId,
+            MentorApplicationRequest mentorApplicationRequest,
+            MultipartFile file
+    ) {
+        if (mentorApplicationRepository.existsBySiteUserIdAndMentorApplicationStatusIn(
+                siteUserId,
+                List.of(MentorApplicationStatus.PENDING, MentorApplicationStatus.APPROVED))
+        ) {
+            throw new CustomException(MENTOR_APPLICATION_ALREADY_EXISTED);
+        }
+
+        SiteUser siteUser = siteUserRepository.findById(siteUserId)
+                .orElseThrow(() -> new CustomException(USER_NOT_FOUND));
+        UploadedFileUrlResponse uploadedFile = s3Service.uploadFile(file, ImgType.MENTOR_PROOF);
+        MentorApplication mentorApplication = new MentorApplication(
+                siteUser.getId(),
+                mentorApplicationRequest.country(),
+                mentorApplicationRequest.universityId(),
+                mentorApplicationRequest.universitySelectType(),
+                uploadedFile.fileUrl(),
+                mentorApplicationRequest.exchangeStatus()
+        );
+        mentorApplicationRepository.save(mentorApplication);
+    }
+}

src/main/java/com/example/solidconnection/s3/domain/ImgType.java

@@ -4,7 +4,14 @@
 
 @Getter
 public enum ImgType {
-    PROFILE("profile"), GPA("gpa"), LANGUAGE_TEST("language"), COMMUNITY("community"), NEWS("news"), CHAT("chat");
+    PROFILE("profile"),
+    GPA("gpa"),
+    LANGUAGE_TEST("language"),
+    COMMUNITY("community"),
+    NEWS("news"),
+    CHAT("chat"),
+    MENTOR_PROOF("mentor-proof"),
+    ;
 
     private final String type;
 

src/main/resources/db/migration/V35__add_mentor_application_table.sql

@@ -0,0 +1,20 @@
+CREATE TABLE mentor_application
+(
+    id                        BIGINT       NOT NULL AUTO_INCREMENT,
+    site_user_id              BIGINT,
+    country_code              VARCHAR(255),
+    university_id             BIGINT,
+    university_select_type    enum ('CATALOG','OTHER') not null,
+    mentor_proof_url          VARCHAR(500) NOT NULL,
+    rejected_reason           VARCHAR(255),
+    exchange_status           enum('AFTER_EXCHANGE','STUDYING_ABROAD') NOT NULL,
+    mentor_application_status enum('APPROVED','PENDING','REJECTED') NOT NULL,
+    created_at                DATETIME(6),
+    updated_at                DATETIME(6),
+    PRIMARY KEY (id),
+    CONSTRAINT fk_mentor_application_site_user FOREIGN KEY (site_user_id) REFERENCES site_user (id),
+    CONSTRAINT chk_ma_university_select_rule CHECK (
+        (university_select_type = 'CATALOG' AND university_id IS NOT NULL) OR
+        (university_select_type = 'OTHER'   AND university_id IS NULL)
+    )
+) ENGINE=InnoDB

src/test/java/com/example/solidconnection/mentor/fixture/MentorApplicationFixture.java

@@ -0,0 +1,66 @@
+package com.example.solidconnection.mentor.fixture;
+
+import com.example.solidconnection.mentor.domain.MentorApplication;
+import com.example.solidconnection.mentor.domain.MentorApplicationStatus;
+import com.example.solidconnection.mentor.domain.UniversitySelectType;
+import com.example.solidconnection.siteuser.domain.ExchangeStatus;
+import lombok.RequiredArgsConstructor;
+import org.springframework.boot.test.context.TestComponent;
+
+@TestComponent
+@RequiredArgsConstructor
+public class MentorApplicationFixture {
+
+    private final MentorApplicationFixtureBuilder mentorApplicationFixtureBuilder;
+
+    private static final String DEFAULT_COUNTRY_CODE = "US";
+    private static final String DEFAULT_PROOF_URL   = "/mentor-proof.pdf";
+    private static final ExchangeStatus DEFAULT_EXCHANGE_STATUS = ExchangeStatus.AFTER_EXCHANGE;
+
+    public MentorApplication 대기중_멘토신청(
+            long siteUserId,
+            UniversitySelectType selectType,
+            Long universityId
+    ) {
+        return mentorApplicationFixtureBuilder.mentorApplication()
+                .siteUserId(siteUserId)
+                .countryCode(DEFAULT_COUNTRY_CODE)
+                .universityId(universityId)
+                .universitySelectType(selectType)
+                .mentorProofUrl(DEFAULT_PROOF_URL)
+                .exchangeStatus(DEFAULT_EXCHANGE_STATUS)
+                .create();
+    }
+
+    public MentorApplication 승인된_멘토신청(
+            long siteUserId,
+            UniversitySelectType selectType,
+            Long universityId
+    ){
+        return mentorApplicationFixtureBuilder.mentorApplication()
+                .siteUserId(siteUserId)
+                .countryCode(DEFAULT_COUNTRY_CODE)
+                .universityId(universityId)
+                .universitySelectType(selectType)
+                .mentorProofUrl(DEFAULT_PROOF_URL)
+                .exchangeStatus(DEFAULT_EXCHANGE_STATUS)
+                .mentorApplicationStatus(MentorApplicationStatus.APPROVED)
+                .create();
+    }
+
+    public MentorApplication 거절된_멘토신청(
+            long siteUserId,
+            UniversitySelectType selectType,
+            Long universityId
+    ){
+        return mentorApplicationFixtureBuilder.mentorApplication()
+                .siteUserId(siteUserId)
+                .countryCode(DEFAULT_COUNTRY_CODE)
+                .universityId(universityId)
+                .universitySelectType(selectType)
+                .mentorProofUrl(DEFAULT_PROOF_URL)
+                .exchangeStatus(DEFAULT_EXCHANGE_STATUS)
+                .mentorApplicationStatus(MentorApplicationStatus.REJECTED)
+                .create();
+    }
+}