feat: Recruitment 생성 API 구현

src/main/java/com/gdschongik/gdsc/domain/common/model/SemesterType.java

@@ -1,5 +1,9 @@
 package com.gdschongik.gdsc.domain.common.model;
 
+import com.gdschongik.gdsc.global.exception.CustomException;
+import com.gdschongik.gdsc.global.exception.ErrorCode;
+import java.time.LocalDateTime;
+import java.time.Month;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
@@ -10,4 +14,30 @@ public enum SemesterType {
     SECOND("2학기");
 
     private final String value;
+
+    public static SemesterType from(LocalDateTime dateTime) {
+        return getSemesterType(dateTime);
+    }
+
+    private static SemesterType getSemesterType(LocalDateTime dateTime) {
+        int year = dateTime.getYear();
+        LocalDateTime firstSemesterStartDate = LocalDateTime.of(year, 3, 1, 0, 0, 0);
+        LocalDateTime secondSemesterStartDate = LocalDateTime.of(year, 9, 1, 0, 0, 0);
+
+        if (dateTime.isAfter(firstSemesterStartDate.minusWeeks(2)) && dateTime.getMonthValue() < 7) {
+            return FIRST;
+        }
+
+        if (dateTime.isAfter(secondSemesterStartDate.minusWeeks(2))) {
+            return SECOND;
+        }
+        throw new CustomException(ErrorCode.SEMESTER_TYPE_INVALID_FOR_DATE);
+    }
+
+    public static Month getStartMonth(SemesterType semesterType) {
+        if (semesterType == FIRST) {
+            return Month.MARCH;
+        }
+        return Month.SEPTEMBER;
+    }
 }

src/main/java/com/gdschongik/gdsc/domain/recruitment/api/AdminRecruitmentController.java

@@ -0,0 +1,29 @@
+package com.gdschongik.gdsc.domain.recruitment.api;
+
+import com.gdschongik.gdsc.domain.recruitment.application.AdminRecruitmentService;
+import com.gdschongik.gdsc.domain.recruitment.dto.request.RecruitmentCreateRequest;
+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.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@Tag(name = "Admin Recruitment", description = "어드민 리쿠르팅 관리 API입니다.")
+@RestController
+@RequestMapping("/admin/recruitment")
+@RequiredArgsConstructor
+public class AdminRecruitmentController {
+
+    private final AdminRecruitmentService adminRecruitmentService;
+
+    @Operation(summary = "리쿠르팅 생성", description = "새로운 리쿠르팅(모집 기간)를 생성합니다.")
+    @PostMapping
+    public ResponseEntity<Void> createRecruitment(@Valid @RequestBody RecruitmentCreateRequest request) {
+        adminRecruitmentService.createRecruitment(request);
+        return ResponseEntity.ok().build();
+    }
+}

src/main/java/com/gdschongik/gdsc/domain/recruitment/application/AdminRecruitmentService.java

@@ -0,0 +1,79 @@
+package com.gdschongik.gdsc.domain.recruitment.application;
+
+import static com.gdschongik.gdsc.global.exception.ErrorCode.*;
+
+import com.gdschongik.gdsc.domain.common.model.SemesterType;
+import com.gdschongik.gdsc.domain.recruitment.dao.RecruitmentRepository;
+import com.gdschongik.gdsc.domain.recruitment.domain.Recruitment;
+import com.gdschongik.gdsc.domain.recruitment.dto.request.RecruitmentCreateRequest;
+import com.gdschongik.gdsc.global.exception.CustomException;
+import java.time.LocalDateTime;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class AdminRecruitmentService {
+
+    private final RecruitmentRepository recruitmentRepository;
+
+    @Transactional
+    public void createRecruitment(RecruitmentCreateRequest request) {
+        validatePeriodMatchesAcademicYear(request.startDate(), request.endDate(), request.academicYear());
+        validatePeriodMatchesSemesterType(request.startDate(), request.endDate(), request.semesterType());
+        validatePeriodWithinTwoWeeks(
+                request.startDate(), request.endDate(), request.academicYear(), request.semesterType());
+        validatePeriodOverlap(request.academicYear(), request.semesterType(), request.startDate(), request.endDate());
+
+        Recruitment recruitment = Recruitment.createRecruitment(
+                request.name(), request.startDate(), request.endDate(), request.academicYear(), request.semesterType());
+        recruitmentRepository.save(recruitment);
+        // todo: recruitment 모집 시작 직전에 멤버 역할 수정하는 로직 필요.
+    }
+
+    private void validatePeriodMatchesAcademicYear(
+            LocalDateTime startDate, LocalDateTime endDate, Integer academicYear) {
+        if (academicYear.equals(startDate.getYear()) && academicYear.equals(endDate.getYear())) {
+            return;
+        }
+
+        throw new CustomException(RECRUITMENT_PERIOD_MISMATCH_ACADEMIC_YEAR);
+    }
+
+    private void validatePeriodMatchesSemesterType(
+            LocalDateTime startDate, LocalDateTime endDate, SemesterType semesterType) {
+        if (SemesterType.from(startDate).equals(semesterType)
+                && SemesterType.from(endDate).equals(semesterType)) {
+            return;
+        }
+
+        throw new CustomException(RECRUITMENT_PERIOD_MISMATCH_SEMESTER_TYPE);
+    }
+
+    private void validatePeriodWithinTwoWeeks(
+            LocalDateTime startDate, LocalDateTime endDate, Integer academicYear, SemesterType semesterType) {
+        LocalDateTime semesterStartDate =
+                LocalDateTime.of(academicYear, SemesterType.getStartMonth(semesterType), 1, 0, 0);
+
+        if (semesterStartDate.minusWeeks(2).isAfter(startDate)
+                || semesterStartDate.plusWeeks(2).isBefore(startDate)) {
+            throw new CustomException(RECRUITMENT_PERIOD_NOT_WITHIN_TWO_WEEKS);
+        }
+
+        if (semesterStartDate.minusWeeks(2).isAfter(endDate)
+                || semesterStartDate.plusWeeks(2).isBefore(endDate)) {
+            throw new CustomException(RECRUITMENT_PERIOD_NOT_WITHIN_TWO_WEEKS);
+        }
+    }
+
+    private void validatePeriodOverlap(
+            Integer academicYear, SemesterType semesterType, LocalDateTime startDate, LocalDateTime endDate) {
+        List<Recruitment> recruitments =
+                recruitmentRepository.findAllByAcademicYearAndSemesterType(academicYear, semesterType);
+
+        recruitments.forEach(recruitment -> recruitment.validatePeriodOverlap(startDate, endDate));
+    }
+}

src/main/java/com/gdschongik/gdsc/domain/recruitment/dao/RecruitmentRepository.java

@@ -1,6 +1,11 @@
 package com.gdschongik.gdsc.domain.recruitment.dao;
 
+import com.gdschongik.gdsc.domain.common.model.SemesterType;
 import com.gdschongik.gdsc.domain.recruitment.domain.Recruitment;
+import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
 
-public interface RecruitmentRepository extends JpaRepository<Recruitment, Long>, RecruitmentCustomRepository {}
+public interface RecruitmentRepository extends JpaRepository<Recruitment, Long>, RecruitmentCustomRepository {
+
+    List<Recruitment> findAllByAcademicYearAndSemesterType(Integer academicYear, SemesterType semesterType);
+}

src/main/java/com/gdschongik/gdsc/domain/recruitment/domain/Recruitment.java

@@ -50,4 +50,8 @@ public static Recruitment createRecruitment(
     public boolean isOpen() {
         return this.period.isOpen();
     }
+
+    public void validatePeriodOverlap(LocalDateTime startDate, LocalDateTime endDate) {
+        this.period.validatePeriodOverlap(startDate, endDate);
+    }
 }

src/main/java/com/gdschongik/gdsc/domain/recruitment/domain/vo/Period.java

@@ -1,7 +1,8 @@
 package com.gdschongik.gdsc.domain.recruitment.domain.vo;
 
+import static com.gdschongik.gdsc.global.exception.ErrorCode.*;
+
 import com.gdschongik.gdsc.global.exception.CustomException;
-import com.gdschongik.gdsc.global.exception.ErrorCode;
 import jakarta.persistence.Embeddable;
 import java.time.LocalDateTime;
 import java.util.Objects;
@@ -31,7 +32,7 @@ public static Period createPeriod(LocalDateTime startDate, LocalDateTime endDate
 
     private static void validatePeriod(LocalDateTime startDate, LocalDateTime endDate) {
         if (startDate.isAfter(endDate) || startDate.isEqual(endDate)) {
-            throw new CustomException(ErrorCode.DATE_PRECEDENCE_INVALID);
+            throw new CustomException(DATE_PRECEDENCE_INVALID);
         }
     }
 
@@ -41,6 +42,13 @@ public boolean isOpen() {
                 && (now.isBefore(this.endDate) || now.isEqual(startDate));
     }
 
+    public void validatePeriodOverlap(LocalDateTime startDate, LocalDateTime endDate) {
+        if (this.endDate.isBefore(startDate) || this.startDate.isAfter(endDate)) {
+            return;
+        }
+        throw new CustomException(RECRUITMENT_PERIOD_OVERLAP);
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

src/main/java/com/gdschongik/gdsc/domain/recruitment/dto/request/RecruitmentCreateRequest.java

@@ -0,0 +1,18 @@
+package com.gdschongik.gdsc.domain.recruitment.dto.request;
+
+import static com.gdschongik.gdsc.global.common.constant.RegexConstant.*;
+
+import com.gdschongik.gdsc.domain.common.model.SemesterType;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Future;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import java.time.LocalDateTime;
+
+public record RecruitmentCreateRequest(
+        @NotBlank @Schema(description = "이름") String name,
+        @Future @Schema(description = "모집기간 시작일", pattern = DATETIME) LocalDateTime startDate,
+        @Future @Schema(description = "모집기간 종료일", pattern = DATETIME) LocalDateTime endDate,
+        @NotNull(message = "학년도는 null이 될 수 없습니다.") @Schema(description = "학년도", pattern = ACADEMIC_YEAR)
+                Integer academicYear,
+        @NotNull(message = "학기는 null이 될 수 없습니다.") @Schema(description = "학기") SemesterType semesterType) {}

src/main/java/com/gdschongik/gdsc/global/common/constant/RegexConstant.java

@@ -8,6 +8,8 @@ public class RegexConstant {
     public static final String NICKNAME = "[ㄱ-ㅣ가-힣]{1,6}$";
     public static final String DEPARTMENT = "^D[0-9]{3}$";
     public static final String HONGIK_EMAIL = "^[^\\W&=+'-+,<>]+(\\.[^\\W&=+'-+,<>]+)*@g\\.hongik\\.ac\\.kr$";
+    public static final String DATETIME = "yyyy-MM-dd'T'HH:mm:ss";
+    public static final String ACADEMIC_YEAR = "^[0-9]{4}$";
 
     private RegexConstant() {}
 }

src/main/java/com/gdschongik/gdsc/global/exception/ErrorCode.java

@@ -58,6 +58,9 @@ public enum ErrorCode {
     DISCORD_NICKNAME_NOTNULL(HttpStatus.INTERNAL_SERVER_ERROR, "닉네임은 빈 값이 될 수 없습니다."),
     DISCORD_MEMBER_NOT_FOUND(HttpStatus.NOT_FOUND, "디스코드 멤버를 찾을 수 없습니다."),
 
+    // SemesterType
+    SEMESTER_TYPE_INVALID_FOR_DATE(HttpStatus.CONFLICT, "해당 날짜가 포함되는 학기가 없습니다."),
+
     // Membership
     PAYMENT_NOT_VERIFIED(HttpStatus.CONFLICT, "회비 납부가 완료되지 않았습니다."),
     MEMBERSHIP_NOT_APPLICABLE(HttpStatus.CONFLICT, "멤버십 가입을 신청할 수 없는 회원입니다."),
@@ -66,7 +69,11 @@ public enum ErrorCode {
     // Recruitment
     DATE_PRECEDENCE_INVALID(HttpStatus.BAD_REQUEST, "종료일이 시작일과 같거나 앞설 수 없습니다."),
     RECRUITMENT_NOT_OPEN(HttpStatus.CONFLICT, "리크루트먼트 모집기간이 아닙니다."),
-    RECRUITMENT_NOT_FOUND(HttpStatus.NOT_FOUND, "열려있는 리크루트먼트가 없습니다.");
+    RECRUITMENT_NOT_FOUND(HttpStatus.NOT_FOUND, "열려있는 리크루트먼트가 없습니다."),
+    RECRUITMENT_PERIOD_OVERLAP(HttpStatus.BAD_REQUEST, "모집 기간이 중복됩니다."),
+    RECRUITMENT_PERIOD_MISMATCH_ACADEMIC_YEAR(HttpStatus.BAD_REQUEST, "모집 시작일과 종료일의 연도가 학년도와 일치하지 않습니다."),
+    RECRUITMENT_PERIOD_MISMATCH_SEMESTER_TYPE(HttpStatus.BAD_REQUEST, "모집 시작일과 종료일의 입력된 학기가 일치하지 않습니다."),
+    RECRUITMENT_PERIOD_NOT_WITHIN_TWO_WEEKS(HttpStatus.BAD_REQUEST, "모집 시작일과 종료일이 학기 시작일로부터 2주 이내에 있지 않습니다.");
 
     private final HttpStatus status;
     private final String message;

src/test/java/com/gdschongik/gdsc/domain/recruitment/application/AdminRecruitmentServiceTest.java

@@ -0,0 +1,83 @@
+package com.gdschongik.gdsc.domain.recruitment.application;
+
+import static com.gdschongik.gdsc.global.common.constant.RecruitmentConstant.*;
+import static com.gdschongik.gdsc.global.exception.ErrorCode.*;
+import static org.assertj.core.api.Assertions.*;
+
+import com.gdschongik.gdsc.domain.common.model.SemesterType;
+import com.gdschongik.gdsc.domain.recruitment.dao.RecruitmentRepository;
+import com.gdschongik.gdsc.domain.recruitment.domain.Recruitment;
+import com.gdschongik.gdsc.domain.recruitment.dto.request.RecruitmentCreateRequest;
+import com.gdschongik.gdsc.global.exception.CustomException;
+import com.gdschongik.gdsc.integration.IntegrationTest;
+import java.time.LocalDateTime;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+class AdminRecruitmentServiceTest extends IntegrationTest {
+
+    @Autowired
+    private AdminRecruitmentService adminRecruitmentService;
+
+    @Autowired
+    private RecruitmentRepository recruitmentRepository;
+
+    private void createRecruitment() {
+        Recruitment recruitment =
+                Recruitment.createRecruitment(RECRUITMENT_NAME, START_DATE, END_DATE, ACADEMIC_YEAR, SEMESTER_TYPE);
+        recruitmentRepository.save(recruitment);
+    }
+
+    @Nested
+    class 모집기간_생성시 {
+        @Test
+        void 기간이_중복되는_Recruitment가_있다면_실패한다() {
+            // given
+            createRecruitment();
+            RecruitmentCreateRequest request =
+                    new RecruitmentCreateRequest(RECRUITMENT_NAME, START_DATE, END_DATE, ACADEMIC_YEAR, SEMESTER_TYPE);
+
+            // when & then
+            assertThatThrownBy(() -> adminRecruitmentService.createRecruitment(request))
+                    .isInstanceOf(CustomException.class)
+                    .hasMessage(RECRUITMENT_PERIOD_OVERLAP.getMessage());
+        }
+
+        @Test
+        void 모집_시작일과_종료일의_연도가_입력된_학년도와_다르다면_실패한다() {
+            // given
+            RecruitmentCreateRequest request =
+                    new RecruitmentCreateRequest(RECRUITMENT_NAME, START_DATE, END_DATE, 2025, SEMESTER_TYPE);
+
+            // when & then
+            assertThatThrownBy(() -> adminRecruitmentService.createRecruitment(request))
+                    .isInstanceOf(CustomException.class)
+                    .hasMessage(RECRUITMENT_PERIOD_MISMATCH_ACADEMIC_YEAR.getMessage());
+        }
+
+        @Test
+        void 모집_시작일과_종료일의_학기가_입력된_학기와_다르다면_실패한다() {
+            // given
+            RecruitmentCreateRequest request = new RecruitmentCreateRequest(
+                    RECRUITMENT_NAME, START_DATE, END_DATE, ACADEMIC_YEAR, SemesterType.SECOND);
+
+            // when & then
+            assertThatThrownBy(() -> adminRecruitmentService.createRecruitment(request))
+                    .isInstanceOf(CustomException.class)
+                    .hasMessage(RECRUITMENT_PERIOD_MISMATCH_SEMESTER_TYPE.getMessage());
+        }
+
+        @Test
+        void 모집_시작일과_종료일이_학기_시작일로부터_2주_이내에_있지_않다면_실패한다() {
+            // given
+            RecruitmentCreateRequest request = new RecruitmentCreateRequest(
+                    RECRUITMENT_NAME, START_DATE, LocalDateTime.of(2024, 4, 10, 00, 00), ACADEMIC_YEAR, SEMESTER_TYPE);
+
+            // when & then
+            assertThatThrownBy(() -> adminRecruitmentService.createRecruitment(request))
+                    .isInstanceOf(CustomException.class)
+                    .hasMessage(RECRUITMENT_PERIOD_NOT_WITHIN_TWO_WEEKS.getMessage());
+        }
+    }
+}