RINGUS v1 Server 배포

.github/workflows/ci.yml

@@ -1,16 +1,10 @@
 name: CI Workflow
 
 on:
-  push:
-    branches:
-      - main         # main 브랜치
-      - develop      # develop 브랜치
-      - feature/*    # 모든 feature/* 브랜치
   pull_request:
     branches:
       - main         # main 브랜치로의 PR
       - develop      # develop 브랜치로의 PR
-      - feature/*    # feature/* 브랜치로의 PR
 
 jobs:
   build-and-test:
@@ -39,14 +33,13 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-gradle-
 
+      - name: Create .env.dev file
+        run: |
+          touch .env.dev
+          echo "${{ secrets.ENV }}" >> .env.dev
+
       # 4. dev.sh 실행 (환경 변수 로드 및 빌드 준비)
       - name: Run dev.sh
         run: |
           chmod +x ./dev.sh    # dev.sh에 실행 권한 부여
           ./dev.sh             # dev.sh 실행
-
-      # 5. Gradle 빌드 및 테스트 실행
-      - name: Build and Test (Gradle)
-        run: |
-          ./gradlew clean build -x test
-          ./gradlew test

.github/workflows/main-cd.yml

@@ -36,9 +36,18 @@ jobs:
               git clone [email protected]:Ring-Us/ring-us-server.git /home/ubuntu/ring-us-server
               cd /home/ubuntu/ring-us-server
             fi
+
+            cd /home/ubuntu/ring-us-server
+
+            echo "${{ secrets.ENV }}" > .env.dev
+
+            # 🛠 Gradle 빌드 권한 설정
+            echo "[GitHub Actions] 🔧 Fixing Gradle permissions"
+            sudo chown -R $USER:$USER ~/.gradle
+            sudo chmod -R 777 ~/.gradle
 
             # 권한 설정 (dev.sh 실행 가능하도록, 추후에 deploy.sh와 분리)
-            chmod +x dev.sh
+            sudo chmod +x dev.sh
 
             # 스크립트 실행 (환경 변수 로드, 빌드, 배포 포함)
-            ./dev.sh
+            sudo ./dev.sh

build.gradle

@@ -33,6 +33,8 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-mail'
     implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
     implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.2.0'
+    implementation 'org.flywaydb:flyway-core'
+    implementation 'org.flywaydb:flyway-mysql'
     compileOnly 'org.projectlombok:lombok'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'
     runtimeOnly 'com.mysql:mysql-connector-j'
@@ -46,6 +48,12 @@ dependencies {
     implementation 'software.amazon.awssdk:sts'
     implementation 'software.amazon.awssdk:core:2.30.20'
     implementation 'software.amazon.awssdk:ec2'
+
+    // QueryDSL
+    implementation "com.querydsl:querydsl-jpa:5.0.0:jakarta"
+    annotationProcessor "com.querydsl:querydsl-apt:5.0.0:jakarta"
+    annotationProcessor "jakarta.annotation:jakarta.annotation-api:3.0.0"
+    annotationProcessor "jakarta.persistence:jakarta.persistence-api:3.1.0"
 }
 
 tasks.named('test') {

src/main/java/es/princip/ringus/application/bookmark/BookmarkService.java

@@ -0,0 +1,62 @@
+package es.princip.ringus.application.bookmark;
+
+import es.princip.ringus.domain.bookmark.Bookmark;
+import es.princip.ringus.domain.bookmark.BookmarkRepository;
+import es.princip.ringus.domain.exception.BookmarkErrorCode;
+import es.princip.ringus.domain.exception.MenteeErrorCode;
+import es.princip.ringus.domain.exception.MentorErrorCode;
+import es.princip.ringus.domain.mentee.Mentee;
+import es.princip.ringus.domain.mentee.MenteeRepository;
+import es.princip.ringus.domain.mentor.Mentor;
+import es.princip.ringus.domain.mentor.MentorRepository;
+import es.princip.ringus.global.exception.CustomRuntimeException;
+import es.princip.ringus.presentation.bookmark.dto.BookmarkRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class BookmarkService {
+    private final BookmarkRepository bookmarkRepository;
+    private final MentorRepository mentorRepository;
+    private final MenteeRepository menteeRepository;
+
+    @Transactional
+    public Long addBookmark(BookmarkRequest request){
+        Mentor mentor = findMentorById(request.mentorId());
+        Mentee mentee = findMenteeById(request.menteeId());
+
+        if(bookmarkRepository.findByMentorAndMentee(mentor, mentee).isPresent()){
+            throw new CustomRuntimeException(BookmarkErrorCode.BOOKMARK_ALREADY_EXIST);
+        }
+
+        Bookmark bookmark = request.toEntity(mentor, mentee);
+        mentee.addBookmark(bookmark);
+
+        return bookmarkRepository.save(bookmark).getId();
+    }
+
+    @Transactional
+    public void deleteBookmark(BookmarkRequest request){
+        Mentor mentor = findMentorById(request.mentorId());
+        Mentee mentee = findMenteeById(request.menteeId());
+
+        Bookmark bookmark = bookmarkRepository.findByMentorAndMentee(mentor, mentee)
+                .orElseThrow(() -> new CustomRuntimeException(BookmarkErrorCode.BOOKMARK_NOT_FOUND));
+
+        bookmarkRepository.delete(bookmark);
+        mentee.deleteBookmark(bookmark);
+    }
+
+    private Mentor findMentorById(Long mentorId) {
+        return mentorRepository.findById(mentorId)
+                .orElseThrow(() -> new CustomRuntimeException(MentorErrorCode.MENTOR_PROFILE_NOT_FOUND));
+    }
+
+    private Mentee findMenteeById(Long menteeId) {
+        return menteeRepository.findById(menteeId)
+                .orElseThrow(() -> new CustomRuntimeException(MenteeErrorCode.MENTEE_PROFILE_NOT_FOUND));
+    }
+}

src/main/java/es/princip/ringus/application/member/service/MemberMentorProfile.java

@@ -0,0 +1,10 @@
+package es.princip.ringus.application.member.service;
+
+import es.princip.ringus.domain.mentor.vo.Organization;
+import es.princip.ringus.infra.storage.domain.ProfileImage;
+
+public record MemberMentorProfile(
+        ProfileImage profileImage,
+        Organization organization
+) {
+}

src/main/java/es/princip/ringus/application/member/service/MemberService.java

@@ -4,24 +4,36 @@
 import es.princip.ringus.domain.exception.SignUpErrorCode;
 import es.princip.ringus.domain.member.Member;
 import es.princip.ringus.domain.member.MemberRepository;
+import es.princip.ringus.domain.mentee.Mentee;
+import es.princip.ringus.domain.mentee.MenteeRepository;
+import es.princip.ringus.domain.mentor.Mentor;
+import es.princip.ringus.domain.mentor.MentorRepository;
+import es.princip.ringus.domain.mentoring.MentoringRepository;
 import es.princip.ringus.domain.serviceTerm.ServiceTermAgreement;
 import es.princip.ringus.global.exception.CustomRuntimeException;
 import es.princip.ringus.global.util.UniversityDomainUtil;
 import es.princip.ringus.presentation.auth.dto.request.SignUpRequest;
 import es.princip.ringus.presentation.member.dto.MemberResponse;
+import es.princip.ringus.presentation.member.dto.MenteeProfileResponse;
+import es.princip.ringus.presentation.member.dto.MentorProfileResponse;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.Set;
 
+@Slf4j
 @Service
 @RequiredArgsConstructor
 @Transactional(readOnly = true)
 public class MemberService {
     private final MemberRepository memberRepository;
+    private final MentorRepository mentorRepository;
+    private  final MenteeRepository menteeRepository;
     private final PasswordEncoder passwordEncoder;
+    private final MentoringRepository mentoringRepository;
 
     /**
      * 회원 저장 (이메일 인증 후 회원가입 진행)
@@ -43,10 +55,29 @@ public Member createMember(SignUpRequest request, Set<ServiceTermAgreement> serv
         return member;
     }
 
-    public MemberResponse getMemberById(Long memberId){
+    public MemberResponse getMember(Long memberId) {
         Member member = memberRepository.findById(memberId)
                 .orElseThrow(() -> new CustomRuntimeException(MemberErrorCode.MEMBER_NOT_FOUND));
 
-        return MemberResponse.from(member);
+        if (member.isProfileRegistered()) {
+            if (member.isMentee()) {
+                Mentee mentee = menteeRepository.findByMemberId(memberId)
+                        .orElseThrow(() -> new CustomRuntimeException(MemberErrorCode.MEMBER_NOT_FOUND));
+                MenteeProfileResponse profile = MenteeProfileResponse.from(mentee);
+                //null check 필요
+                return MemberResponse.of(member, profile);
+            } else if (member.isMentor()) {
+                Mentor mentor = mentorRepository.findByMemberId(memberId)
+                        .orElseThrow(() -> new CustomRuntimeException(MemberErrorCode.MEMBER_NOT_FOUND));
+
+                MentorProfileResponse profile = MentorProfileResponse.from(mentor, mentoringRepository.findMentoringCountBy(mentor.getId()));
+                return MemberResponse.of(member, profile);
+            }
+        }
+        return MemberResponse.of(member);
+    }
+
+    public boolean isUniqueNickname(String nickname) {
+        return !mentorRepository.existsByNickname(nickname) && !menteeRepository.existsByNickname(nickname);
     }
 }

src/main/java/es/princip/ringus/application/mentee/service/MenteeService.java

@@ -1,14 +1,21 @@
 package es.princip.ringus.application.mentee.service;
 
+import es.princip.ringus.application.support.MenteeCursorParser;
+import es.princip.ringus.domain.exception.MenteeErrorCode;
 import es.princip.ringus.domain.exception.SignUpErrorCode;
 import es.princip.ringus.domain.member.Member;
 import es.princip.ringus.domain.member.MemberRepository;
 import es.princip.ringus.domain.mentee.Mentee;
 import es.princip.ringus.domain.mentee.MenteeRepository;
-import es.princip.ringus.domain.mentor.MentorRepository;
+import es.princip.ringus.domain.support.CursorResponse;
 import es.princip.ringus.global.exception.CustomRuntimeException;
+import es.princip.ringus.presentation.mentee.dto.EditMenteeRequest;
+import es.princip.ringus.presentation.mentee.dto.MenteeCardResponse;
+import es.princip.ringus.presentation.mentee.dto.MenteeCursorRequest;
 import es.princip.ringus.presentation.mentee.dto.MenteeRequest;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -21,10 +28,37 @@ public class MenteeService {
     private final MenteeRepository menteeRepository;
 
     @Transactional
-    public Long register(MenteeRequest request) {
-        Member member = memberRepository.findByEmail(request.email())
-                .orElseThrow(() -> new CustomRuntimeException(SignUpErrorCode.WRONG_EMAIL));
-        Mentee mentee = request.toEntity();
+    public Long register(Long memberId, MenteeRequest request) {
+        Member member = memberRepository.findById(memberId)
+                .orElseThrow(() -> new CustomRuntimeException(SignUpErrorCode.NOT_FOUND_MEMBER));
+
+        if (menteeRepository.existsByMemberId(memberId)) {
+            throw new CustomRuntimeException(MenteeErrorCode.ALREADY_REGISTERED_MENTEE);
+        }
+
+        if (member.isNotMentee()) {
+            throw new CustomRuntimeException(MenteeErrorCode.MEMBER_TYPE_NOT_MENTEE);
+        }
+
+        member.registerProfile();
+
+        Mentee mentee = request.toEntity(member.getId());
         return  menteeRepository.save(mentee).getId();
     }
+
+    @Transactional
+    public Long edit(Long memberId, EditMenteeRequest request) {
+        Mentee mentee = menteeRepository.findByMemberId(memberId)
+                .orElseThrow(() -> new CustomRuntimeException(MenteeErrorCode.MENTEE_PROFILE_NOT_FOUND));
+
+        mentee.edit(request);
+        return mentee.getId();
+    }
+
+    public CursorResponse<MenteeCardResponse> getMenteeBy(MenteeCursorRequest request, Pageable pageable, Long memberId){
+        final Slice<MenteeCardResponse> response = menteeRepository.findMenteeBy(request, pageable, memberId);
+        final  Long cursor = MenteeCursorParser.parse(request.cursor(), response);
+
+        return CursorResponse.of(response, cursor);
+    }
 }

src/main/java/es/princip/ringus/application/mentee/service/MyMenteeService.java

@@ -0,0 +1,23 @@
+package es.princip.ringus.application.mentee.service;
+
+import es.princip.ringus.domain.exception.MenteeErrorCode;
+import es.princip.ringus.domain.mentee.Mentee;
+import es.princip.ringus.domain.mentee.MenteeRepository;
+import es.princip.ringus.global.exception.CustomRuntimeException;
+import es.princip.ringus.presentation.mentee.dto.MyMenteeResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class MyMenteeService {
+    private final MenteeRepository menteeRepository;
+
+    public MyMenteeResponse getDetailBy(Long mentorId) {
+        Mentee mentee = menteeRepository.findByMemberId(mentorId)
+                .orElseThrow(() -> new CustomRuntimeException(MenteeErrorCode.MENTEE_NOT_FOUND));
+        return MyMenteeResponse.from(mentee);
+    }
+}

src/main/java/es/princip/ringus/application/mentor/service/AcceptMentoringService.java

@@ -0,0 +1,58 @@
+package es.princip.ringus.application.mentor.service;
+
+import es.princip.ringus.domain.exception.MenteeErrorCode;
+import es.princip.ringus.domain.exception.MentorErrorCode;
+import es.princip.ringus.domain.exception.MentoringErrorCode;
+import es.princip.ringus.domain.mentee.Mentee;
+import es.princip.ringus.domain.mentee.MenteeRepository;
+import es.princip.ringus.domain.mentor.Mentor;
+import es.princip.ringus.domain.mentor.MentorRepository;
+import es.princip.ringus.domain.mentoring.Mentoring;
+import es.princip.ringus.domain.mentoring.MentoringRepository;
+import es.princip.ringus.domain.mentoring.MentoringTime;
+import es.princip.ringus.domain.mentoring.accept.MentoringAccept;
+import es.princip.ringus.domain.mentoring.accept.MentoringAcceptRepository;
+import es.princip.ringus.global.exception.CustomRuntimeException;
+import es.princip.ringus.presentation.mentoring.dto.AcceptMentoringRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class AcceptMentoringService {
+    private final MentorRepository mentorRepository;
+    private final MenteeRepository menteeRepository;
+    private final MentoringRepository mentoringRepository;
+    private final MentoringAcceptRepository mentoringAcceptRepository;
+
+    private boolean isRequestedTimeInMentoringTime(Mentoring mentoring, AcceptMentoringRequest request) {
+        return mentoring.getApplyTimes().stream()
+                .anyMatch(time -> MentoringTime.equals(time, request.mentoringTime()));
+    }
+
+    public Long accept(AcceptMentoringRequest request, Long memberId) {
+        Mentor mentor = mentorRepository.findByMemberId(memberId)
+                .orElseThrow(() -> new CustomRuntimeException(MentorErrorCode.MENTOR_NOT_FOUND));
+        Mentee mentee = menteeRepository.findById(request.menteeId())
+                .orElseThrow(() -> new CustomRuntimeException(MenteeErrorCode.MENTEE_NOT_FOUND));
+
+        Mentoring mentoring = mentoringRepository.findByMenteeIdAndMentorId(mentee.getId(), mentor.getId())
+                .orElseThrow(() -> new CustomRuntimeException(MentoringErrorCode.MENTORING_NOT_FOUND));
+
+        if (mentoring.isNotWaiting()) {
+            throw new CustomRuntimeException(MentoringErrorCode.MENTORING_STATUS_NOT_WAITING);
+        }
+        if (!isRequestedTimeInMentoringTime(mentoring, request)) {
+            throw new CustomRuntimeException(MentoringErrorCode.MENTORING_TIME_NOT_MATCH);
+        }
+
+        MentoringAccept accept = MentoringAccept.builder()
+                .mentee(mentee)
+                .mentor(mentor)
+                .mentoringTime(request.mentoringTime())
+                .build();
+        mentoring.accept();
+
+        return mentoringAcceptRepository.save(accept).getId();
+    }
+}