전반적인 도메인 로직 내에서 validation 체크 및 NPE 안정성 보강

.github/workflows/docker-depoly.yaml

@@ -22,9 +22,16 @@ jobs:
           script: |
             cd /home/ubuntu/mosu
 
-            echo "${{ secrets.ENV_BLUE }}" > .env.blue
-            echo "${{ secrets.ENV_GREEN }}" > .env.green
+            echo "${{ secrets.ENV_BASE }}" > .env
+            echo "${{ secrets.ENV_BASE }}" > .env.blue
+            echo "${{ secrets.ENV_BASE }}" > .env.green
 
+            echo "${{ secrets.ENV }}" >> .env
+            echo "${{ secrets.ENV }}" >> .env.blue
+            echo "${{ secrets.ENV }}" >> .env.green
+
+            echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env
             echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env.blue
             echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env.green
+
             ./deploy.sh

.github/workflows/self-depoly.yaml

@@ -3,20 +3,68 @@ name: Docker CI/CD - Deploy
 on:
   workflow_dispatch:
     branches:
-      - test
+      - develop
 jobs:
   deploy:
     runs-on: self-hosted
 
     steps:
+      - name: Checkout source
+        uses: actions/checkout@v3
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v3
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Cache Gradle files
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: gradle-${{ runner.os }}-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            gradle-${{ runner.os }}-
+
+      - name: Clone external repo with jar into libs/
+        run: |
+          mkdir -p libs
+          git clone https://x-access-token:${{ secrets.GH_PAT }}@github.com/mosu-dev/mosu-kmc-jar.git temp-jar
+          cp temp-jar/*.jar libs/
+
+      - name: Build with Gradle
+        run: ./gradlew build -x test
+
+      - name: Log in to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Build Docker image
+        run: sudo docker build -t kangtaehyun1107/mosu-server:${{ github.sha }} .
+        working-directory:
+      - name: Push Docker image
+        run: sudo docker push kangtaehyun1107/mosu-server:${{ github.sha }}
+
       - name: Deploy via SSH
         run: |
           cd ~/mosu-server
 
-          echo "${{ secrets.TEST_ENV_BLUE }}" > .env.blue
-          echo "${{ secrets.TEST_ENV_GREEN }}" > .env.green
+          echo "${{ secrets.ENV_BASE }}" > .env
+          echo "${{ secrets.ENV_BASE }}" > .env.blue
+          echo "${{ secrets.ENV_BASE }}" > .env.green
+
+          echo "${{ secrets.ENV_TEST }}" >> .env
+          echo "${{ secrets.ENV_TEST }}" >> .env.blue
+          echo "${{ secrets.ENV_TEST }}" >> .env.green
+
+          echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env
           echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env.blue
           echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env.green
+
           sudo docker stop $(sudo docker ps -aq) || true
           sudo docker rm $(sudo docker ps -aq) || true
           echo "Stopping all containers..."

build.gradle

@@ -29,16 +29,17 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'org.springframework.boot:spring-boot-starter-validation'
-    testImplementation 'org.projectlombok:lombok'
-    testImplementation 'org.projectlombok:lombok'
-    testCompileOnly 'org.projectlombok:lombok'
-    testAnnotationProcessor 'org.projectlombok:lombok'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'
-    compileOnly 'org.projectlombok:lombok'
-    annotationProcessor 'org.projectlombok:lombok'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 
+    // Lombok
+    compileOnly 'org.projectlombok:lombok'
+    annotationProcessor 'org.projectlombok:lombok'
+    testCompileOnly 'org.projectlombok:lombok'
+    testImplementation 'org.projectlombok:lombok'
+    testAnnotationProcessor 'org.projectlombok:lombok'
+
     // 인증사 관련 의존성
     implementation 'javax.servlet:jstl:1.2'
     implementation "org.apache.tomcat.embed:tomcat-embed-jasper"
@@ -69,7 +70,6 @@ dependencies {
     testImplementation 'org.testcontainers:junit-jupiter:1.19.3'
     testImplementation 'org.testcontainers:mysql:1.20.0'
 
-
     // security
     implementation 'org.springframework.boot:spring-boot-starter-security'
     implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'
@@ -103,11 +103,6 @@ dependencies {
 
     runtimeOnly 'com.h2database:h2'
 
-    testImplementation 'org.springframework.boot:spring-boot-testcontainers:3.3.5'
-    testImplementation 'org.testcontainers:testcontainers:1.19.3'
-    testImplementation 'org.testcontainers:junit-jupiter:1.19.3'
-    testImplementation 'org.testcoscntainers:mysql:1.20.0'
-
     annotationProcessor "org.springframework.boot:spring-boot-configuration-processor"
 
     implementation 'org.apache.commons:commons-pool2:2.12.1'

src/main/java/life/mosu/mosuserver/application/admin/AdminDashboardService.java

@@ -1,7 +1,8 @@
 package life.mosu.mosuserver.application.admin;
 
 import life.mosu.mosuserver.domain.examapplication.repository.ExamApplicationJpaRepository;
-import life.mosu.mosuserver.domain.refund.repository.RefundJpaRepository;
+import life.mosu.mosuserver.domain.refund.repository.RefundFailureLogJpaRepository;
+import life.mosu.mosuserver.domain.user.entity.UserRole;
 import life.mosu.mosuserver.domain.user.repository.UserJpaRepository;
 import life.mosu.mosuserver.presentation.admin.dto.DashBoardResponse;
 import lombok.RequiredArgsConstructor;
@@ -13,15 +14,19 @@ public class AdminDashboardService {
 
     private final ExamApplicationJpaRepository examApplicationJpaRepository;
     private final UserJpaRepository userJpaRepository;
-    private final RefundJpaRepository refundJpaRepository;
+    private final RefundFailureLogJpaRepository refundFailureLogJpaRepository;
 
     // 대시보드 정보 조회
     public DashBoardResponse getAll() {
-        Long applicationCounts = examApplicationJpaRepository.count();
-        Long refundCounts = refundJpaRepository.count();
-        Long userCounts = userJpaRepository.count();
-        return new DashBoardResponse(applicationCounts, refundCounts, userCounts);
-    }
 
+        Long applicationCounts = examApplicationJpaRepository.countAll();
+        Long refundAbortedCounts = refundFailureLogJpaRepository.count();
+        Long userCounts = userJpaRepository.countByUserRoleNot(UserRole.ROLE_ADMIN);
 
+        return DashBoardResponse.of(
+                applicationCounts,
+                refundAbortedCounts,
+                userCounts
+        );
+    }
 }

src/main/java/life/mosu/mosuserver/application/application/ApplicationService.java

@@ -46,6 +46,9 @@ public CreateApplicationResponse apply(Long userId, ApplicationRequest request)
         List<Long> examIds = request.examApplication().stream()
                 .map(ExamApplicationRequest::examId)
                 .toList();
+
+        validator.agreedToTerms(request);
+        validator.requestNoDuplicateExams(examIds);
         return handleApplication(
                 userId,
                 examIds,
@@ -78,7 +81,6 @@ private CreateApplicationResponse handleApplication(
             List<ExamApplicationRequest> examApplications,
             FileRequest admissionTicket
     ) {
-        validator.requestNoDuplicateExams(examIds);
         List<ExamJpaEntity> exams = examJpaRepository.findAllById(examIds);
         validator.examDateNotPassed(exams);
         validator.examNotFull(exams);

src/main/java/life/mosu/mosuserver/application/application/processor/GetApplicationsStepProcessor.java

@@ -13,10 +13,8 @@
 import life.mosu.mosuserver.presentation.application.dto.ApplicationResponse;
 import life.mosu.mosuserver.presentation.examapplication.dto.ExamApplicationWithStatus;
 import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 
-@Slf4j
 @Component
 @RequiredArgsConstructor
 public class GetApplicationsStepProcessor implements
@@ -33,7 +31,6 @@ public class GetApplicationsStepProcessor implements
     public List<ApplicationResponse> process(Long userId) {
 
         List<ApplicationJpaEntity> applications = applicationJpaRepository.findAllByUserId(userId);
-        log.info("applications info: {}", applications.size());
         if (applications.isEmpty()) {
             return List.of();
         }

src/main/java/life/mosu/mosuserver/application/application/vaildator/ApplicationValidator.java

@@ -6,29 +6,41 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 import life.mosu.mosuserver.application.exam.cache.ExamQuotaCacheManager;
-import life.mosu.mosuserver.domain.application.repository.ApplicationJpaRepository;
 import life.mosu.mosuserver.domain.exam.entity.ExamJpaEntity;
 import life.mosu.mosuserver.domain.exam.entity.ExamJpaRepository;
 import life.mosu.mosuserver.domain.exam.entity.ExamStatus;
+import life.mosu.mosuserver.domain.examapplication.repository.ExamApplicationJpaRepository;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;
 import life.mosu.mosuserver.global.exception.ErrorCode;
+import life.mosu.mosuserver.presentation.application.dto.ApplicationRequest;
 import life.mosu.mosuserver.presentation.application.dto.ExamApplicationRequest;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 
+@Slf4j
 @Component
 @RequiredArgsConstructor
 public class ApplicationValidator {
 
     private final ExamJpaRepository examJpaRepository;
-    private final ApplicationJpaRepository applicationJpaRepository;
+    private final ExamApplicationJpaRepository examApplicationJpaRepository;
     private final ExamQuotaCacheManager examQuotaCacheManager;
 
+    public void agreedToTerms(ApplicationRequest request) {
+        if (!request.agreement().validateAgreement()) {
+            throw new CustomRuntimeException(ErrorCode.NOT_AGREED_TO_TERMS);
+        }
+    }
+
     public void requestNoDuplicateExams(List<Long> examIds) {
         Set<Long> examIdSet = new HashSet<>(examIds);
         if (examIds.size() != examIdSet.size()) {
             throw new CustomRuntimeException(ErrorCode.EXAM_DUPLICATED);
         }
+        if (examIdSet.isEmpty()) {
+            throw new CustomRuntimeException(ErrorCode.EXAM_NOT_APPLIED);
+        }
     }
 
     public void examIdsAndLunchSelection(List<ExamApplicationRequest> requests) {
@@ -39,12 +51,9 @@ public void examIdsAndLunchSelection(List<ExamApplicationRequest> requests) {
         List<Long> requestedExamIds = requests.stream()
                 .map(ExamApplicationRequest::examId)
                 .toList();
+        Set<Long> examIdSet = new HashSet<>(requestedExamIds);
 
-        List<ExamJpaEntity> existingExams = examJpaRepository.findAllById(requestedExamIds);
-
-        if (existingExams.size() != requestedExamIds.size()) {
-            throw new CustomRuntimeException(ErrorCode.EXAM_NOT_FOUND);
-        }
+        List<ExamJpaEntity> existingExams = examJpaRepository.findAllById(examIdSet);
 
         lunchSelection(requests, existingExams);
     }
@@ -56,16 +65,18 @@ private void lunchSelection(List<ExamApplicationRequest> requests,
                 .map(ExamJpaEntity::getId)
                 .collect(Collectors.toSet());
 
-        boolean hasInvalidLunchRequest = requests.stream()
-                .anyMatch(req -> examsWithoutLunch.contains(req.examId()) && req.isLunchChecked());
+        requests.stream()
+                .filter(req -> req.isLunchChecked() && examsWithoutLunch.contains(req.examId()))
+                .findFirst()
+                .ifPresent(req -> {
+                    throw new CustomRuntimeException(ErrorCode.LUNCH_SELECTION_INVALID);
+                });
 
-        if (hasInvalidLunchRequest) {
-            throw new CustomRuntimeException(ErrorCode.LUNCH_SELECTION_INVALID);
-        }
     }
 
     public void noDuplicateApplication(Long userId, List<Long> examIds) {
-        boolean alreadyApplied = applicationJpaRepository.existsByUserIdAndExamIds(userId, examIds);
+        boolean alreadyApplied = examApplicationJpaRepository.existsByUserIdAndExamIds(userId,
+                examIds);
         if (alreadyApplied) {
             throw new CustomRuntimeException(ErrorCode.APPLICATION_SCHOOL_DUPLICATED);
         }

src/main/java/life/mosu/mosuserver/application/auth/processor/SignUpAccountStepProcessor.java

@@ -18,7 +18,9 @@ public class SignUpAccountStepProcessor implements StepProcessor<UserJpaEntity,
     @Transactional
     @Override
     public UserJpaEntity process(UserJpaEntity user) {
-        if (userRepository.existsByLoginId(user.getLoginId())) {
+        if (userRepository.existsByPhoneNumber(user.getPhoneNumber())) {
+            throw new CustomRuntimeException(ErrorCode.USER_ALREADY_EXISTS);
+        } else if (userRepository.existsByLoginId(user.getLoginId())) {
             throw new CustomRuntimeException(ErrorCode.USER_ALREADY_EXISTS);
         }
         return userRepository.save(user);

src/main/java/life/mosu/mosuserver/application/caffeine/LocalCacheConfig.java

@@ -0,0 +1,42 @@
+package life.mosu.mosuserver.application.caffeine;
+
+import com.github.benmanes.caffeine.cache.Caffeine;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import life.mosu.mosuserver.domain.caffeine.CacheGroup;
+import life.mosu.mosuserver.domain.caffeine.CacheType;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.caffeine.CaffeineCache;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+
+@EnableCaching
+@Configuration
+public class LocalCacheConfig {
+
+    @Bean
+    public LocalCacheManager localCacheManager() {
+        List<Cache> caches = Arrays.stream(CacheGroup.values())
+                .filter(g -> g.getCacheType() == CacheType.LOCAL
+                        || g.getCacheType() == CacheType.COMPOSITE)
+                .map(g -> new CaffeineCache(
+                        g.getCacheName(),
+                        Caffeine.newBuilder()
+                                .recordStats()
+                                .expireAfterWrite(g.getExpiredAfterWrite())
+                                .build()
+                )).collect(Collectors.toList());
+
+        return new LocalCacheManager(caches);
+    }
+
+    @Bean
+    @Primary
+    public CacheManager appCacheManager(LocalCacheManager localCacheManager) {
+        return localCacheManager;
+    }
+}