core recruit 기능 이관 및 권한/학기 공통 컴포넌트 적용

src/main/java/inha/gdgoc/domain/admin/recruit/core/controller/RecruitCoreAdminController.java

@@ -0,0 +1,91 @@
+package inha.gdgoc.domain.admin.recruit.core.controller;
+
+import inha.gdgoc.domain.admin.recruit.core.dto.request.RecruitCoreApplicationAcceptRequest;
+import inha.gdgoc.domain.admin.recruit.core.dto.request.RecruitCoreApplicationRejectRequest;
+import inha.gdgoc.domain.admin.recruit.core.dto.response.RecruitCoreApplicantSummaryResponse;
+import inha.gdgoc.domain.admin.recruit.core.dto.response.RecruitCoreApplicationDecisionResponse;
+import inha.gdgoc.domain.admin.recruit.core.dto.response.RecruitCoreApplicationPageResponse;
+import inha.gdgoc.domain.admin.recruit.core.service.RecruitCoreAdminService;
+import inha.gdgoc.domain.recruit.core.entity.RecruitCoreApplication;
+import inha.gdgoc.domain.recruit.core.enums.RecruitCoreResultStatus;
+import inha.gdgoc.domain.user.enums.TeamType;
+import inha.gdgoc.global.config.jwt.TokenProvider.CustomUserDetails;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+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.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/v1/admin/recruit/core/applications")
+@RequiredArgsConstructor
+public class RecruitCoreAdminController {
+
+    private static final String ORGANIZER_OR_HR_LEAD_RULE =
+            "@accessGuard.check(authentication,"
+                    + " T(inha.gdgoc.global.security.AccessGuard$AccessCondition).atLeast("
+                    + "T(inha.gdgoc.domain.user.enums.UserRole).ORGANIZER),"
+                    + " T(inha.gdgoc.global.security.AccessGuard$AccessCondition).of("
+                    + "T(inha.gdgoc.domain.user.enums.UserRole).LEAD,"
+                    + " T(inha.gdgoc.domain.user.enums.TeamType).HR))";
+
+    private final RecruitCoreAdminService adminService;
+
+    @PreAuthorize("hasAnyRole('ADMIN','ORGANIZER')")
+    @GetMapping
+    public RecruitCoreApplicationPageResponse list(
+        @RequestParam String session,
+        @RequestParam(required = false) RecruitCoreResultStatus status,
+        @RequestParam(required = false) TeamType team,
+        @RequestParam(defaultValue = "0") int page,
+        @RequestParam(defaultValue = "20") int size
+    ) {
+        Pageable pageable = PageRequest.of(page, size);
+        Page<RecruitCoreApplication> result = adminService.searchApplications(session, status, team, pageable);
+        java.util.List<RecruitCoreApplicantSummaryResponse> content = result
+            .map(RecruitCoreApplicantSummaryResponse::from)
+            .getContent();
+        return RecruitCoreApplicationPageResponse.from(
+            content,
+            result.getNumber(),
+            result.getSize(),
+            result.getTotalElements(),
+            result.getTotalPages(),
+            result.isLast()
+        );
+    }
+
+    @PreAuthorize(ORGANIZER_OR_HR_LEAD_RULE)
+    @PostMapping("/{applicationId}/accept")
+    public ResponseEntity<RecruitCoreApplicationDecisionResponse> accept(
+        @AuthenticationPrincipal CustomUserDetails reviewer,
+        @PathVariable Long applicationId,
+        @Valid @RequestBody RecruitCoreApplicationAcceptRequest request
+    ) {
+        RecruitCoreApplicationDecisionResponse response =
+            adminService.accept(applicationId, reviewer.getUserId(), request);
+        return ResponseEntity.ok(response);
+    }
+
+    @PreAuthorize(ORGANIZER_OR_HR_LEAD_RULE)
+    @PostMapping("/{applicationId}/reject")
+    public ResponseEntity<RecruitCoreApplicationDecisionResponse> reject(
+        @AuthenticationPrincipal CustomUserDetails reviewer,
+        @PathVariable Long applicationId,
+        @Valid @RequestBody RecruitCoreApplicationRejectRequest request
+    ) {
+        RecruitCoreApplicationDecisionResponse response =
+            adminService.reject(applicationId, reviewer.getUserId(), request);
+        return ResponseEntity.ok(response);
+    }
+}

src/main/java/inha/gdgoc/domain/admin/recruit/core/dto/request/RecruitCoreApplicationAcceptRequest.java

@@ -0,0 +1,10 @@
+package inha.gdgoc.domain.admin.recruit.core.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+public record RecruitCoreApplicationAcceptRequest(
+    @NotBlank String resultNote,
+    @NotNull Boolean overwriteTeamIfExists
+) {
+}

src/main/java/inha/gdgoc/domain/admin/recruit/core/dto/request/RecruitCoreApplicationRejectRequest.java

@@ -0,0 +1,8 @@
+package inha.gdgoc.domain.admin.recruit.core.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record RecruitCoreApplicationRejectRequest(
+    @NotBlank String resultNote
+) {
+}

src/main/java/inha/gdgoc/domain/admin/recruit/core/dto/response/RecruitCoreApplicantSummaryResponse.java

@@ -0,0 +1,30 @@
+package inha.gdgoc.domain.admin.recruit.core.dto.response;
+
+import inha.gdgoc.domain.recruit.core.entity.RecruitCoreApplication;
+import inha.gdgoc.domain.recruit.core.enums.RecruitCoreResultStatus;
+import java.time.Instant;
+
+public record RecruitCoreApplicantSummaryResponse(
+    Long applicationId,
+    String name,
+    String studentId,
+    String major,
+    String team,
+    RecruitCoreResultStatus resultStatus,
+    String session,
+    Instant createdAt
+) {
+
+    public static RecruitCoreApplicantSummaryResponse from(RecruitCoreApplication entity) {
+        return new RecruitCoreApplicantSummaryResponse(
+            entity.getId(),
+            entity.getName(),
+            entity.getStudentId(),
+            entity.getMajor(),
+            entity.getTeam(),
+            entity.getResultStatus(),
+            entity.getSession(),
+            entity.getCreatedAt()
+        );
+    }
+}

src/main/java/inha/gdgoc/domain/admin/recruit/core/dto/response/RecruitCoreApplicationDecisionResponse.java

@@ -0,0 +1,44 @@
+package inha.gdgoc.domain.admin.recruit.core.dto.response;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import inha.gdgoc.domain.recruit.core.entity.RecruitCoreApplication;
+import inha.gdgoc.domain.recruit.core.enums.RecruitCoreResultStatus;
+import inha.gdgoc.domain.user.enums.TeamType;
+import inha.gdgoc.domain.user.enums.UserRole;
+import java.time.Instant;
+
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public record RecruitCoreApplicationDecisionResponse(
+    Long applicationId,
+    RecruitCoreResultStatus resultStatus,
+    Instant reviewedAt,
+    Long reviewedBy,
+    UserUpdated userUpdated
+) {
+
+    public static RecruitCoreApplicationDecisionResponse accepted(
+        RecruitCoreApplication application,
+        UserRole userRole,
+        TeamType team
+    ) {
+        return new RecruitCoreApplicationDecisionResponse(
+            application.getId(),
+            application.getResultStatus(),
+            application.getReviewedAt(),
+            application.getReviewedBy(),
+            new UserUpdated(userRole, team)
+        );
+    }
+
+    public static RecruitCoreApplicationDecisionResponse rejected(RecruitCoreApplication application) {
+        return new RecruitCoreApplicationDecisionResponse(
+            application.getId(),
+            application.getResultStatus(),
+            application.getReviewedAt(),
+            application.getReviewedBy(),
+            null
+        );
+    }
+
+    public record UserUpdated(UserRole userRole, TeamType team) {}
+}

src/main/java/inha/gdgoc/domain/admin/recruit/core/dto/response/RecruitCoreApplicationPageResponse.java

@@ -0,0 +1,31 @@
+package inha.gdgoc.domain.admin.recruit.core.dto.response;
+
+import java.util.List;
+
+public record RecruitCoreApplicationPageResponse(
+    List<RecruitCoreApplicantSummaryResponse> content,
+    Pageable pageable,
+    long totalElements,
+    int totalPages,
+    boolean last
+) {
+
+    public static RecruitCoreApplicationPageResponse from(
+        List<RecruitCoreApplicantSummaryResponse> items,
+        int pageNumber,
+        int pageSize,
+        long totalElements,
+        int totalPages,
+        boolean last
+    ) {
+        return new RecruitCoreApplicationPageResponse(
+            items,
+            new Pageable(pageNumber, pageSize),
+            totalElements,
+            totalPages,
+            last
+        );
+    }
+
+    public record Pageable(int pageNumber, int pageSize) {}
+}

src/main/java/inha/gdgoc/domain/admin/recruit/core/service/RecruitCoreAdminService.java

@@ -0,0 +1,114 @@
+package inha.gdgoc.domain.admin.recruit.core.service;
+
+import inha.gdgoc.domain.admin.recruit.core.dto.request.RecruitCoreApplicationAcceptRequest;
+import inha.gdgoc.domain.admin.recruit.core.dto.request.RecruitCoreApplicationRejectRequest;
+import inha.gdgoc.domain.admin.recruit.core.dto.response.RecruitCoreApplicationDecisionResponse;
+import inha.gdgoc.domain.recruit.core.entity.RecruitCoreApplication;
+import inha.gdgoc.domain.recruit.core.enums.RecruitCoreResultStatus;
+import inha.gdgoc.domain.recruit.core.repository.RecruitCoreApplicationRepository;
+import inha.gdgoc.domain.user.entity.User;
+import inha.gdgoc.domain.user.enums.TeamType;
+import inha.gdgoc.domain.user.enums.UserRole;
+import inha.gdgoc.global.exception.BusinessException;
+import inha.gdgoc.global.exception.GlobalErrorCode;
+import java.time.Instant;
+import java.util.Objects;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+public class RecruitCoreAdminService {
+
+    private final RecruitCoreApplicationRepository repository;
+
+    @Transactional(readOnly = true)
+    public Page<RecruitCoreApplication> searchApplications(
+        String session,
+        RecruitCoreResultStatus status,
+        TeamType team,
+        Pageable pageable
+    ) {
+        Specification<RecruitCoreApplication> spec = Specification.where(bySession(session));
+        if (status != null) {
+            spec = spec.and((root, query, builder) -> builder.equal(root.get("resultStatus"), status));
+        }
+        if (team != null) {
+            spec = spec.and((root, query, builder) -> builder.equal(root.get("team"), team.name()));
+        }
+        return repository.findAll(spec, pageable);
+    }
+
+    @Transactional
+    public RecruitCoreApplicationDecisionResponse accept(
+        Long applicationId,
+        Long reviewerId,
+        RecruitCoreApplicationAcceptRequest request
+    ) {
+        RecruitCoreApplication application = getApplication(applicationId);
+        ensureDecidable(application);
+        Instant now = Instant.now();
+        application.accept(reviewerId, request.resultNote(), now);
+
+        User applicant = application.getUser();
+        if (!UserRole.hasAtLeast(applicant.getUserRole(), UserRole.CORE)) {
+            applicant.changeRole(UserRole.CORE);
+        }
+        TeamType applicantTeam = applicant.getTeam();
+        TeamType applicationTeam = teamTypeOf(application.getTeam());
+        if (applicationTeam != null && (Boolean.TRUE.equals(request.overwriteTeamIfExists()) || applicantTeam == null)) {
+            applicant.changeTeam(applicationTeam);
+            applicantTeam = applicationTeam;
+        }
+
+        return RecruitCoreApplicationDecisionResponse.accepted(
+            application,
+            applicant.getUserRole(),
+            applicantTeam
+        );
+    }
+
+    @Transactional
+    public RecruitCoreApplicationDecisionResponse reject(
+        Long applicationId,
+        Long reviewerId,
+        RecruitCoreApplicationRejectRequest request
+    ) {
+        RecruitCoreApplication application = getApplication(applicationId);
+        ensureDecidable(application);
+        Instant now = Instant.now();
+        application.reject(reviewerId, request.resultNote(), now);
+        return RecruitCoreApplicationDecisionResponse.rejected(application);
+    }
+
+    private Specification<RecruitCoreApplication> bySession(String session) {
+        return (root, query, builder) -> builder.equal(root.get("session"), Objects.requireNonNull(session));
+    }
+
+    private RecruitCoreApplication getApplication(Long id) {
+        return repository.findById(id)
+            .orElseThrow(() -> new BusinessException(GlobalErrorCode.RESOURCE_NOT_FOUND));
+    }
+
+    private void ensureDecidable(RecruitCoreApplication application) {
+        if (application.getResultStatus() == RecruitCoreResultStatus.ACCEPTED
+            || application.getResultStatus() == RecruitCoreResultStatus.REJECTED) {
+            throw new BusinessException(GlobalErrorCode.BAD_REQUEST, "이미 처리된 지원서입니다.");
+        }
+    }
+
+    private TeamType teamTypeOf(String team) {
+        if (team == null) {
+            return null;
+        }
+        try {
+            return TeamType.valueOf(team);
+        } catch (IllegalArgumentException ex) {
+            return null;
+        }
+    }
+}