[refactor] Member의 지원자/계정 역할을 applicant로 이전

src/main/java/org/ject/support/admin/account/dto/AdminAccountCreateRequest.java

@@ -5,9 +5,9 @@
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Size;
+import org.ject.support.domain.applicant.entity.Applicant;
 import org.ject.support.domain.member.MemberType;
 import org.ject.support.domain.member.Role;
-import org.ject.support.domain.member.entity.Member;
 
 @Schema(description = "관리자 계정 생성 요청")
 public record AdminAccountCreateRequest(
@@ -36,8 +36,8 @@ public record AdminAccountCreateRequest(
 
     private static final long DEFAULT_ADMIN_ACCOUNT_SEMESTER_ID = 1L;
 
-    public Member toEntity(final String encodedPassword) {
-        return Member.builder()
+    public Applicant toEntity(final String encodedPassword) {
+        return Applicant.builder()
                 .email(email)
                 .pin(encodedPassword)
                 .name(normalizeName())

src/main/java/org/ject/support/admin/account/dto/AdminAccountResponse.java

@@ -1,8 +1,8 @@
 package org.ject.support.admin.account.dto;
 
+import org.ject.support.domain.applicant.dto.ApplicantAccountProjection;
 import org.ject.support.domain.member.MemberStatus;
 import org.ject.support.domain.member.Role;
-import org.ject.support.domain.member.dto.MemberAccountProjection;
 
 public record AdminAccountResponse(
         Long id,
@@ -12,7 +12,7 @@ public record AdminAccountResponse(
         MemberStatus status
 ) {
 
-    public static AdminAccountResponse from(final MemberAccountProjection projection) {
+    public static AdminAccountResponse from(final ApplicantAccountProjection projection) {
         return new AdminAccountResponse(
                 projection.id(),
                 projection.email(),

src/main/java/org/ject/support/admin/account/service/AdminAccountService.java

@@ -10,11 +10,11 @@
 import org.ject.support.admin.component.AdminMemberComponent;
 import org.ject.support.admin.exception.AdminErrorCode;
 import org.ject.support.admin.exception.AdminException;
+import org.ject.support.domain.applicant.entity.Applicant;
+import org.ject.support.domain.applicant.entity.ApplicantEditor;
+import org.ject.support.domain.applicant.repository.ApplicantRepository;
 import org.ject.support.domain.member.MemberStatus;
 import org.ject.support.domain.member.Role;
-import org.ject.support.domain.member.entity.Member;
-import org.ject.support.domain.member.entity.MemberEditor;
-import org.ject.support.domain.member.repository.MemberRepository;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.security.crypto.password.PasswordEncoder;
@@ -28,14 +28,14 @@
 @Transactional(readOnly = true)
 public class AdminAccountService {
 
-    private final MemberRepository memberRepository;
+    private final ApplicantRepository applicantRepository;
     private final AdminMemberComponent adminMemberComponent;
     private final PasswordEncoder passwordEncoder;
 
     public Page<AdminAccountResponse> findAccounts(final AdminAccountSearchCondition condition,
                                                    final Pageable pageable) {
         validateBackofficeRoles(condition.roles());
-        return memberRepository.findAccounts(condition, pageable)
+        return applicantRepository.findAccounts(condition, pageable)
                 .map(AdminAccountResponse::from);
     }
 
@@ -45,7 +45,7 @@ public void createAccount(final AdminAccountCreateRequest request) {
         validateEmailUniqueness(request);
 
         final String encodedPassword = passwordEncoder.encode(request.password());
-        memberRepository.save(request.toEntity(encodedPassword));
+        applicantRepository.save(request.toEntity(encodedPassword));
     }
 
     @Transactional
@@ -56,29 +56,29 @@ public void updateAccount(final Long requesterId,
         validateNotLockingSelf(requesterId, memberId, request.active());
         validateNotChangingOwnAdminRole(requesterId, memberId, request.role());
 
-        final Member member = adminMemberComponent.getRequiredBackofficeMemberById(memberId);
+        final Applicant applicant = adminMemberComponent.getRequiredBackofficeMemberById(memberId);
 
         final MemberStatus status = request.active() ? MemberStatus.ACTIVE : MemberStatus.LOCKED;
-        final MemberEditor editor = member.toEditor()
+        final ApplicantEditor editor = applicant.toEditor()
                 .name(request.normalizeName())
                 .role(request.role())
                 .status(status)
                 .build();
 
-        member.edit(editor);
+        applicant.edit(editor);
     }
 
     @Transactional
     public void updateRole(final Long memberId, final AdminAccountRoleUpdateRequest request) {
         validateBackofficeRole(request.role());
 
-        final Member member = adminMemberComponent.getRequiredBackofficeMemberById(memberId);
+        final Applicant applicant = adminMemberComponent.getRequiredBackofficeMemberById(memberId);
 
-        final MemberEditor editor = member.toEditor()
+        final ApplicantEditor editor = applicant.toEditor()
                 .role(request.role())
                 .build();
 
-        member.edit(editor);
+        applicant.edit(editor);
     }
 
     @Transactional
@@ -87,10 +87,10 @@ public void updateActive(final Long requesterId,
                              final AdminAccountActiveUpdateRequest request) {
         validateNotLockingSelf(requesterId, memberId, request.active());
 
-        final Member member = adminMemberComponent.getRequiredBackofficeMemberById(memberId);
+        final Applicant applicant = adminMemberComponent.getRequiredBackofficeMemberById(memberId);
         final MemberStatus status = request.active() ? MemberStatus.ACTIVE : MemberStatus.LOCKED;
 
-        adminMemberComponent.changeMemberStatus(member, status);
+        adminMemberComponent.changeMemberStatus(applicant, status);
     }
 
     private void validateNotLockingSelf(final Long requesterId,
@@ -126,7 +126,7 @@ private void validateBackofficeRoles(final List<Role> roles) {
     }
 
     private void validateEmailUniqueness(final AdminAccountCreateRequest request) {
-        if (memberRepository.existsByEmail(request.email())) {
+        if (applicantRepository.existsByEmail(request.email())) {
             throw new AdminException(AdminErrorCode.DUPLICATE_ADMIN_EMAIL);
         }
     }

src/main/java/org/ject/support/admin/apply/dto/AdminApplyDetailResponse.java

@@ -22,19 +22,19 @@ public record AdminApplyDetailResponse(
         List<String> interestedDomains
 ) {
     public static AdminApplyDetailResponse from(Apply apply) {
-        var member = apply.getMember();
+        var applicant = apply.getApplicant();
         return new AdminApplyDetailResponse(
                 apply.getId(),
-                member.getName(),
-                member.getPhoneNumber(),
-                member.getEmail(),
-                member.getJobFamily(),
-                Optional.ofNullable(member.getCareerDetails()).map(CareerDetails::getDescription).orElse(""),
+                applicant.getName(),
+                applicant.getPhoneNumber(),
+                applicant.getEmail(),
+                applicant.getJobFamily(),
+                Optional.ofNullable(applicant.getCareerDetails()).map(CareerDetails::getDescription).orElse(""),
                 apply.getRecruit().getRecruitType().name(),
                 apply.getNote(),
-                Optional.ofNullable(member.getRegion()).map(Region::getDescription).orElse(""),
-                Optional.ofNullable(member.getExperiencePeriod()).map(ExperiencePeriod::getDescription).orElse(""),
-                Optional.ofNullable(member.getInterestedDomains()).orElse(List.of())
+                Optional.ofNullable(applicant.getRegion()).map(Region::getDescription).orElse(""),
+                Optional.ofNullable(applicant.getExperiencePeriod()).map(ExperiencePeriod::getDescription).orElse(""),
+                Optional.ofNullable(applicant.getInterestedDomains()).orElse(List.of())
         );
     }
 }

src/main/java/org/ject/support/admin/apply/dto/AdminApplyResponse.java

@@ -16,13 +16,14 @@ public record AdminApplyResponse(
         String note
 ) {
     public static AdminApplyResponse from(Apply apply) {
+        var applicant = apply.getApplicant();
         return new AdminApplyResponse(
                 apply.getId(),
-                apply.getMember().getName(),
-                apply.getMember().getPhoneNumber(),
-                apply.getMember().getEmail(),
-                apply.getMember().getJobFamily(),
-                Optional.ofNullable(apply.getMember().getCareerDetails()).map(CareerDetails::getDescription).orElse(""),
+                applicant.getName(),
+                applicant.getPhoneNumber(),
+                applicant.getEmail(),
+                applicant.getJobFamily(),
+                Optional.ofNullable(applicant.getCareerDetails()).map(CareerDetails::getDescription).orElse(""),
                 apply.getRecruit().getRecruitType().name(),
                 apply.getNote()
         );

src/main/java/org/ject/support/admin/apply/repository/AdminApplyQueryRepositoryImpl.java

@@ -3,7 +3,7 @@
 import static org.ject.support.domain.apply.domain.QApplicationForm.applicationForm;
 import static org.ject.support.domain.apply.domain.QApply.apply;
 import static org.ject.support.domain.apply.domain.QPortfolio.portfolio;
-import static org.ject.support.domain.member.entity.QMember.member;
+import static org.ject.support.domain.applicant.entity.QApplicant.applicant;
 import static org.ject.support.domain.recruit.domain.QRecruit.recruit;
 
 import com.querydsl.core.types.dsl.BooleanExpression;
@@ -35,12 +35,12 @@ public Page<Apply> findApplies(final AdminApplySearchCondition condition,
         List<Apply> content = queryFactory
                 .selectFrom(apply)
                 .distinct()
-                .join(apply.member, member).fetchJoin()
+                .join(apply.applicant, applicant).fetchJoin()
                 .join(apply.applicationForm, applicationForm).fetchJoin()
                 .join(apply.recruit, recruit).fetchJoin()
                 .leftJoin(apply.applicationForm.portfolios, portfolio).fetchJoin()
                 .where(
-                        apply.member.isDeleted.eq(false),
+                        apply.applicant.isDeleted.eq(false),
                         eqJobFamily(condition.jobFamily()),
                         eqApplyStatus(condition.applyStatus()),
                         eqSemesterId(condition.semesterId()),
@@ -56,10 +56,10 @@ public Page<Apply> findApplies(final AdminApplySearchCondition condition,
         Long total = queryFactory
                 .select(apply.count())
                 .from(apply)
-                .join(apply.member, member)
+                .join(apply.applicant, applicant)
                 .join(apply.recruit, recruit)
                 .where(
-                        apply.member.isDeleted.eq(false),
+                        apply.applicant.isDeleted.eq(false),
                         eqJobFamily(condition.jobFamily()),
                         eqApplyStatus(condition.applyStatus()),
                         eqSemesterId(condition.semesterId()),
@@ -76,13 +76,13 @@ public Optional<Apply> findApplyByIdByStatus(final Long applyId, final ApplyStat
         Apply result = queryFactory
                 .selectFrom(apply)
                 .distinct()
-                .join(apply.member, member).fetchJoin()
+                .join(apply.applicant, applicant).fetchJoin()
                 .join(apply.applicationForm, applicationForm).fetchJoin()
                 .join(apply.recruit, recruit).fetchJoin()
                 .leftJoin(apply.applicationForm.portfolios, portfolio).fetchJoin()
                 .where(
                         apply.id.eq(applyId),
-                        apply.member.isDeleted.eq(false),
+                        apply.applicant.isDeleted.eq(false),
                         eqApplyStatus(status)
                 )
                 .fetchOne();
@@ -92,7 +92,7 @@ public Optional<Apply> findApplyByIdByStatus(final Long applyId, final ApplyStat
 
     private BooleanExpression eqJobFamily(final JobFamily jobFamily) {
         return Optional.ofNullable(jobFamily)
-                .map(apply.member.jobFamily::eq)
+                .map(apply.applicant.jobFamily::eq)
                 .orElse(null);
     }
 

src/main/java/org/ject/support/admin/apply/repository/AdminApplyRepository.java

@@ -11,16 +11,16 @@
 
 public interface AdminApplyRepository extends JpaRepository<Apply, Long>, AdminApplyQueryRepository {
 
-    @Query("SELECT a FROM Apply a JOIN FETCH a.member LEFT JOIN FETCH a.applicationForm WHERE a.id = :id")
-    Optional<Apply> findByIdWithMember(@Param("id") Long id);
+    @Query("SELECT a FROM Apply a JOIN FETCH a.applicant LEFT JOIN FETCH a.applicationForm WHERE a.id = :id")
+    Optional<Apply> findByIdWithApplicant(@Param("id") Long id);
 
-    @Query("SELECT a FROM Apply a JOIN FETCH a.member LEFT JOIN FETCH a.applicationForm WHERE a.id IN :ids")
-    List<Apply> findAllByIdWithMember(@Param("ids") List<Long> ids);
+    @Query("SELECT a FROM Apply a JOIN FETCH a.applicant LEFT JOIN FETCH a.applicationForm WHERE a.id IN :ids")
+    List<Apply> findAllByIdWithApplicant(@Param("ids") List<Long> ids);
 
     @Modifying(clearAutomatically = true)
     @Query("UPDATE Apply a SET a.isDeleted = true WHERE a.id IN :ids")
     void deleteAllByIds(@Param("ids") Iterable<Long> ids);
 
-    @Query("select a from Apply a join fetch a.member m where a.id = :applyId and a.status = :status")
-    Optional<Apply> findByIdAndStatusWithMember(@Param("applyId") Long applyId, @Param("status") ApplyStatus status);
+    @Query("select a from Apply a join fetch a.applicant m where a.id = :applyId and a.status = :status")
+    Optional<Apply> findByIdAndStatusWithApplicant(@Param("applyId") Long applyId, @Param("status") ApplyStatus status);
 }

src/main/java/org/ject/support/admin/apply/service/AdminApplyService.java

@@ -10,15 +10,15 @@
 import org.ject.support.admin.apply.repository.AdminApplyRepository;
 import org.ject.support.common.data.PageResponse;
 import org.ject.support.common.util.Map2JsonSerializer;
+import org.ject.support.domain.applicant.entity.Applicant;
+import org.ject.support.domain.applicant.entity.ApplicantEditor;
 import org.ject.support.domain.apply.domain.Apply;
 import org.ject.support.domain.apply.domain.ApplyStatus;
 import org.ject.support.domain.apply.domain.Portfolio;
 import org.ject.support.domain.apply.dto.ApplyPortfolioDto;
 import org.ject.support.domain.apply.exception.ApplyErrorCode;
 import org.ject.support.domain.apply.exception.ApplyException;
 import org.ject.support.domain.apply.repository.ApplyRepository;
-import org.ject.support.domain.member.entity.Member;
-import org.ject.support.domain.member.entity.MemberEditor;
 import org.ject.support.domain.recruit.domain.Recruit;
 import org.ject.support.domain.recruit.exception.QuestionErrorCode;
 import org.ject.support.domain.recruit.exception.QuestionException;
@@ -58,17 +58,17 @@ public AdminApplyDetailResponse findApply(final Long applyId,
     @Transactional
     public void updateSubmittedApply(final Long applyId,
                                      final SubmittedApplyEditRequest request) {
-        Apply apply = adminApplyRepository.findByIdAndStatusWithMember(applyId, ApplyStatus.SUBMITTED)
+        Apply apply = adminApplyRepository.findByIdAndStatusWithApplicant(applyId, ApplyStatus.SUBMITTED)
                 .orElseThrow(() -> new ApplyException(ApplyErrorCode.NOT_FOUND_APPLY));
 
-        Member member = apply.getMember();
-        MemberEditor memberEditor = member.toEditor()
+        Applicant applicant = apply.getApplicant();
+        ApplicantEditor applicantEditor = applicant.toEditor()
                 .name(request.name())
                 .phoneNumber(request.phoneNumber())
                 .email(request.email())
                 .jobFamily(request.jobFamily())
                 .build();
-        member.edit(memberEditor);
+        applicant.edit(applicantEditor);
 
         Map<String, String> answers = request.answers();
         validateQuestions(answers, apply.getRecruit());
@@ -85,7 +85,7 @@ public void updateSubmittedApply(final Long applyId,
 
     @Transactional
     public void deleteApply(final Long applyId) {
-        Apply apply = adminApplyRepository.findByIdWithMember(applyId)
+        Apply apply = adminApplyRepository.findByIdWithApplicant(applyId)
                 .orElseThrow(() -> new ApplyException(ApplyErrorCode.NOT_FOUND_APPLY));
         adminApplyRepository.delete(apply);
     }

src/main/java/org/ject/support/admin/apply/service/ApplyPassService.java

@@ -1,10 +1,10 @@
 package org.ject.support.admin.apply.service;
 
 import lombok.RequiredArgsConstructor;
+import org.ject.support.domain.applicant.entity.Applicant;
 import org.ject.support.domain.apply.domain.Apply;
 import org.ject.support.domain.apply.exception.ApplyException;
 import org.ject.support.domain.apply.repository.ApplyRepository;
-import org.ject.support.domain.member.entity.Member;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -21,7 +21,7 @@ public class ApplyPassService {
     @Transactional
     public int passApply(List<Long> applyIds) {
         // 지원 정보 조회
-        List<Apply> applies = applyRepository.findAllByIdWithMember(applyIds);
+        List<Apply> applies = applyRepository.findAllByIdWithApplicant(applyIds);
 
         // 지원자 합격 처리
         applies.forEach(apply -> {
@@ -31,9 +31,9 @@ public int passApply(List<Long> applyIds) {
             }
 
             // 지원자 role 승격
-            Member member = apply.getMember();
-            member.promoteToSemester();
-            member.updateMemberType(apply.getRecruit().getRecruitType().toMemberType());
+            Applicant applicant = apply.getApplicant();
+            applicant.promoteToSemester();
+            applicant.updateMemberType(apply.getRecruit().getRecruitType().toMemberType());
         });
 
         // 승인한 구성원 수 반환

src/main/java/org/ject/support/admin/auth/service/AdminAuthService.java

@@ -6,8 +6,8 @@
 import org.ject.support.admin.component.AdminMemberComponent;
 import org.ject.support.admin.exception.AdminErrorCode;
 import org.ject.support.admin.exception.AdminException;
+import org.ject.support.domain.applicant.entity.Applicant;
 import org.ject.support.domain.member.MemberStatus;
-import org.ject.support.domain.member.entity.Member;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.crypto.password.PasswordEncoder;
@@ -36,17 +36,17 @@ public class AdminAuthService {
     public Authentication authenticateAdmin(String email, String password) {
         validateLoginAttemptLimit(email);
 
-        Member member = adminMemberComponent.findBackofficeMemberByEmail(email)
+        Applicant applicant = adminMemberComponent.findBackofficeMemberByEmail(email)
                 .orElseThrow(() -> handleInvalidAdminCredentials(email));
 
-        if (!passwordEncoder.matches(password, member.getPin())) {
+        if (!passwordEncoder.matches(password, applicant.getPin())) {
             throw handleInvalidAdminCredentials(email);
         }
 
-        checkMemberStatus(member);
+        checkMemberStatus(applicant);
         clearLoginFailState(email);
 
-        return jwtTokenProvider.createAuthenticationByMember(member);
+        return jwtTokenProvider.createAuthenticationByApplicant(applicant);
     }
 
     private AdminException handleInvalidAdminCredentials(String email) {
@@ -79,8 +79,8 @@ private void clearLoginFailState(String email) {
         redisTemplate.delete(ADMIN_LOGIN_PASSWORD_BLOCK_KEY_PREFIX + email);
     }
 
-    private void checkMemberStatus(Member member) {
-        if (member.getStatus() == MemberStatus.LOCKED) {
+    private void checkMemberStatus(Applicant applicant) {
+        if (applicant.getStatus() == MemberStatus.LOCKED) {
             throw new AdminException(AdminErrorCode.LOCKED_ADMIN);
         }
     }