feat : payment 실패시 status 변경

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

@@ -7,8 +7,8 @@
 import life.mosu.mosuserver.domain.application.AdmissionTicketImageJpaRepository;
 import life.mosu.mosuserver.domain.application.ApplicationJpaEntity;
 import life.mosu.mosuserver.domain.application.ApplicationJpaRepository;
-import life.mosu.mosuserver.domain.application.ApplicationSchoolJpaRepository;
 import life.mosu.mosuserver.domain.applicationschool.ApplicationSchoolJpaEntity;
+import life.mosu.mosuserver.domain.applicationschool.ApplicationSchoolJpaRepository;
 import life.mosu.mosuserver.domain.school.SchoolJpaEntity;
 import life.mosu.mosuserver.domain.school.SchoolJpaRepository;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;

src/main/java/life/mosu/mosuserver/application/applicationschool/ApplicationSchoolService.java

@@ -7,9 +7,9 @@
 import life.mosu.mosuserver.domain.application.AdmissionTicketImageJpaRepository;
 import life.mosu.mosuserver.domain.application.ApplicationJpaEntity;
 import life.mosu.mosuserver.domain.application.ApplicationJpaRepository;
-import life.mosu.mosuserver.domain.application.ApplicationSchoolJpaRepository;
 import life.mosu.mosuserver.domain.application.Subject;
 import life.mosu.mosuserver.domain.applicationschool.ApplicationSchoolJpaEntity;
+import life.mosu.mosuserver.domain.applicationschool.ApplicationSchoolJpaRepository;
 import life.mosu.mosuserver.domain.profile.ProfileJpaEntity;
 import life.mosu.mosuserver.domain.profile.ProfileJpaRepository;
 import life.mosu.mosuserver.domain.refund.RefundJpaRepository;

src/main/java/life/mosu/mosuserver/application/payment/PaymentEvent.java

@@ -4,7 +4,7 @@
 import life.mosu.mosuserver.domain.payment.PaymentStatus;
 
 public record PaymentEvent(
-        List<Long> applicationIds,
+        List<Long> applicationSchoolIds,
         String orderId,
         PaymentStatus status,
         Integer totalAmount

src/main/java/life/mosu/mosuserver/application/payment/PaymentFailureHandler.java

@@ -19,20 +19,20 @@ public class PaymentFailureHandler {
     public void handlePaymentFailure(PaymentEvent event) {
         List<PaymentJpaEntity> existingPayments = paymentRepository.findByOrderId(event.orderId());
         Set<Long> existingAppIds = existingPayments.stream()
-                .map(PaymentJpaEntity::getApplicationId)
+                .map(PaymentJpaEntity::getApplicationSchoolId)
                 .collect(Collectors.toSet());
 
-        List<Long> missingAppIds = event.applicationIds().stream()
-                .filter(appId -> !existingAppIds.contains(appId))
+        List<Long> missingAppSchoolIds = event.applicationSchoolIds().stream()
+                .filter(appSchoolId -> !existingAppIds.contains(appSchoolId))
                 .toList();
 
         // 상태 변경
         existingPayments.forEach(payment -> payment.changeStatus(event.status()));
 
-        // 실패 신규 엔티티 생성
-        List<PaymentJpaEntity> newPayments = missingAppIds.stream()
-                .map(appId -> PaymentJpaEntity.ofFailure(
-                        appId,
+        // 실패 신규 엔티티 생성 ( 배치 후속 처리 필요 )
+        List<PaymentJpaEntity> newPayments = missingAppSchoolIds.stream()
+                .map(appSchoolId -> PaymentJpaEntity.ofFailure(
+                        appSchoolId,
                         event.orderId(),
                         event.status(),
                         event.totalAmount()))

src/main/java/life/mosu/mosuserver/application/payment/PaymentService.java

@@ -3,7 +3,7 @@
 import static life.mosu.mosuserver.domain.discount.DiscountPolicy.FIXED_QUANTITY;
 
 import java.util.List;
-import life.mosu.mosuserver.domain.application.ApplicationJpaRepository;
+import life.mosu.mosuserver.domain.applicationschool.ApplicationSchoolJpaRepository;
 import life.mosu.mosuserver.domain.discount.DiscountPolicy;
 import life.mosu.mosuserver.domain.payment.PaymentJpaEntity;
 import life.mosu.mosuserver.domain.payment.PaymentRepository;
@@ -30,15 +30,13 @@
 @RequiredArgsConstructor
 public class PaymentService {
 
-    private final ApplicationJpaRepository applicationJpaRepository;
-
+    private final ApplicationSchoolJpaRepository applicationSchoolJpaRepository;
     private final TossPaymentClient tossPayment;
     private final OrderIdGenerator orderIdGenerator;
     private final PaymentRepository paymentRepository;
     private final ApplicationEventPublisher publisher;
 
     public PaymentPrepareResponse prepare(PreparePaymentRequest request) {
-        // TODO: 인원 수 체크
         /**
          * 인원 수 redis에 동기화 -> 인원수가 넘어가면, application 까지 rollback
          */
@@ -53,20 +51,20 @@ public PaymentPrepareResponse prepare(PreparePaymentRequest request) {
     @Retryable(retryFor = {HttpStatusCodeException.class})
     public void confirm(PaymentRequest request) {
         String orderId = request.orderId();
-        List<Long> applicationIds = request.applicationIds();
+        List<Long> applicationSchoolIds = request.applicationSchoolIds();
         Integer amount = request.amount();
         try {
-            checkApplicationsExist(request.applicationIds());
+            checkApplicationsExist(applicationSchoolIds);
             verifyAmount(request.applicantSize(), request.amount());
             checkDuplicatePayment(orderId);
             ConfirmTossPaymentResponse response = confirmPaymentWithToss(request);
             List<PaymentJpaEntity> paymentEntities = mapToPaymentEntities(request, response);
             verifyPaymentSuccess(paymentEntities);
             savePayments(paymentEntities);
-            publisher.publishEvent(PaymentEvent.ofSuccess(applicationIds, orderId, amount));
+            publisher.publishEvent(PaymentEvent.ofSuccess(applicationSchoolIds, orderId, amount));
         } catch (Exception ex) {
             log.error("error : {}", ex.getMessage());
-            publisher.publishEvent(PaymentEvent.ofFailed(applicationIds, orderId, amount));
+            publisher.publishEvent(PaymentEvent.ofFailed(applicationSchoolIds, orderId, amount));
             throw ex;
         }
     }
@@ -87,7 +85,7 @@ public void cancel(String paymentId, CancelPaymentRequest request) {
 
 
     private void checkApplicationsExist(List<Long> applicationIds) {
-        boolean existsAll = applicationJpaRepository.existsAllByIds(applicationIds,
+        boolean existsAll = applicationSchoolJpaRepository.existsAllByIds(applicationIds,
                 applicationIds.size());
         if (!existsAll) {
             log.warn("Application IDs not found: {}", applicationIds);
@@ -137,7 +135,7 @@ private ConfirmTossPaymentResponse confirmPaymentWithToss(PaymentRequest request
 
     private List<PaymentJpaEntity> mapToPaymentEntities(PaymentRequest request,
             ConfirmTossPaymentResponse response) {
-        return request.applicationIds().stream()
+        return request.applicationSchoolIds().stream()
                 .map(response::toEntity)
                 .toList();
     }

src/main/java/life/mosu/mosuserver/application/school/SchoolQuotaCacheManager.java

@@ -0,0 +1,64 @@
+package life.mosu.mosuserver.application.school;
+
+import java.util.List;
+import life.mosu.mosuserver.domain.school.SchoolApplicationProjection;
+import life.mosu.mosuserver.domain.school.SchoolJpaEntity;
+import life.mosu.mosuserver.domain.school.SchoolRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class SchoolQuotaCacheManager {
+
+    private static final String REDIS_KEY_SCHOOL_MAX_CAPACITY = "school:max_capacity:";
+    private static final String REDIS_KEY_SCHOOL_CURRENT_APPLICATIONS = "school:current_applications:";
+
+    private final RedisTemplate<String, Long> redisTemplate;
+    private final SchoolRepository schoolRepository;
+
+    public void cacheSchoolMaxCapacities() {
+        List<SchoolJpaEntity> schools = schoolRepository.findAll();
+        for (SchoolJpaEntity school : schools) {
+            String key = REDIS_KEY_SCHOOL_MAX_CAPACITY + school.getSchoolName();
+            redisTemplate.opsForValue().set(key, school.getCapacity());
+        }
+    }
+
+    public void cacheSchoolCurrentApplicationCounts() {
+        List<SchoolApplicationProjection> schoolApplications = schoolRepository.countBySchoolNameGroupBy();
+        for (SchoolApplicationProjection projection : schoolApplications) {
+            String key = REDIS_KEY_SCHOOL_CURRENT_APPLICATIONS + projection.schoolName();
+            redisTemplate.opsForValue().set(key, projection.count());
+        }
+    }
+
+    public Long getSchoolApplicationCounts(String schoolName) {
+        return redisTemplate.opsForValue()
+                .get(REDIS_KEY_SCHOOL_CURRENT_APPLICATIONS + schoolName);
+    }
+
+    public Long getSchoolCapacities(String schoolName) {
+        return redisTemplate.opsForValue()
+                .get(REDIS_KEY_SCHOOL_MAX_CAPACITY + schoolName);
+    }
+
+    public void increaseApplicationCount(String schoolName) {
+        String key = REDIS_KEY_SCHOOL_CURRENT_APPLICATIONS + schoolName;
+        redisTemplate.opsForValue().increment(key);
+    }
+
+    public void decreaseApplicationCount(String schoolName) {
+        String key = REDIS_KEY_SCHOOL_CURRENT_APPLICATIONS + schoolName;
+        Long currentValue = redisTemplate.opsForValue().get(key);
+        if (currentValue != null && currentValue > 0) {
+            redisTemplate.opsForValue().decrement(key);
+        }
+    }
+
+    public void preloadSchoolData() {
+        cacheSchoolMaxCapacities();
+        cacheSchoolCurrentApplicationCounts();
+    }
+}

src/main/java/life/mosu/mosuserver/domain/admin/ApplicationQueryRepositoryImpl.java

@@ -138,7 +138,7 @@ private JPAQuery<Tuple> baseQuery() {
                 )
                 .from(applicationSchool)
                 .leftJoin(application).on(applicationSchool.applicationId.eq(application.id))
-                .leftJoin(payment).on(payment.applicationId.eq(application.id))
+                .leftJoin(payment).on(payment.applicationSchoolId.eq(applicationSchool.id))
                 .leftJoin(user).on(application.userId.eq(user.id))
                 .leftJoin(profile).on(profile.userId.eq(user.id))
                 .leftJoin(admissionTicketImage)
@@ -254,4 +254,4 @@ private String getAdmissionTicketImageUrl(String s3Key) {
                 Duration.ofMinutes(s3Properties.getPresignedUrlExpirationMinutes())
         );
     }
-}
+}

src/main/java/life/mosu/mosuserver/domain/application/ApplicationJpaEntity.java

@@ -55,4 +55,4 @@ public ApplicationJpaEntity(
         this.agreedToRefundPolicy = agreedToRefundPolicy;
     }
 
-}
+}

src/main/java/life/mosu/mosuserver/domain/application/ApplicationJpaRepository.java

@@ -2,14 +2,8 @@
 
 import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
 
 public interface ApplicationJpaRepository extends JpaRepository<ApplicationJpaEntity, Long> {
 
-    @Query("SELECT COUNT(a) = :size FROM ApplicationJpaEntity a WHERE a.id IN :applicationIds")
-    boolean existsAllByIds(@Param("applicationIds") List<Long> applicationIds,
-            @Param("size") long size);
-
     List<ApplicationJpaEntity> findAllByUserId(Long userId);
 }

src/main/java/life/mosu/mosuserver/domain/applicationschool/ApplicationSchoolJpaRepository.java

@@ -1,16 +1,21 @@
 package life.mosu.mosuserver.domain.applicationschool;
 
-import java.util.Collection;
 import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 
 public interface ApplicationSchoolJpaRepository extends
         JpaRepository<ApplicationSchoolJpaEntity, Long> {
 
 
-    boolean existsByUserIdAndSchoolIdIn(Long userId, Collection<Long> schoolIds);
+    boolean existsByUserIdAndSchoolId(Long userId, Long schoolId);
 
     List<ApplicationSchoolJpaEntity> findAllByApplicationId(Long applicationId);
 
     boolean existsByApplicationId(Long applicationId);
+
+    @Query("SELECT COUNT(a) = :size FROM ApplicationSchoolJpaEntity a WHERE a.id IN :applicationSchoolIds")
+    boolean existsAllByIds(@Param("applicationSchoolIds") List<Long> applicationSchoolIds,
+            @Param("size") long size);
 }

src/main/java/life/mosu/mosuserver/domain/payment/PaymentJpaEntity.java

@@ -26,8 +26,8 @@ public class PaymentJpaEntity extends BaseTimeEntity {
     @Column(name = "payment_id")
     private Long id;
 
-    @Column(name = "application_id")
-    private Long applicationId;
+    @Column(name = "application_school_id")
+    private Long applicationSchoolId;
 
     @Column(name = "payment_key")
     private String paymentKey;
@@ -48,14 +48,14 @@ public class PaymentJpaEntity extends BaseTimeEntity {
 
     @Builder(access = AccessLevel.PRIVATE)
     private PaymentJpaEntity(
-            Long applicationId,
+            Long applicationSchoolId,
             String paymentKey,
             String orderId,
             PaymentAmountVO paymentAmount,
             PaymentStatus paymentStatus,
             PaymentMethod paymentMethod
     ) {
-        this.applicationId = applicationId;
+        this.applicationSchoolId = applicationSchoolId;
         this.paymentKey = paymentKey;
         this.orderId = orderId;
         this.paymentAmount = paymentAmount;
@@ -64,15 +64,15 @@ private PaymentJpaEntity(
     }
 
     public static PaymentJpaEntity of(
-            Long applicationId,
+            Long applicationSchoolId,
             String paymentKey,
             String orderId,
             PaymentStatus paymentStatus,
             PaymentAmountVO paymentAmount,
             PaymentMethod paymentMethod
     ) {
         return PaymentJpaEntity.builder()
-                .applicationId(applicationId)
+                .applicationSchoolId(applicationSchoolId)
                 .paymentKey(paymentKey)
                 .orderId(orderId)
                 .paymentStatus(paymentStatus)
@@ -82,14 +82,14 @@ public static PaymentJpaEntity of(
     }
 
     public static PaymentJpaEntity ofFailure(
-            Long applicationId,
+            Long applicationSchoolId,
             String orderId,
             PaymentStatus paymentStatus,
             Integer totalAmount
     ) {
         PaymentAmountVO paymentAmount = PaymentAmountVO.ofFailure(totalAmount);
         return PaymentJpaEntity.builder()
-                .applicationId(applicationId)
+                .applicationSchoolId(applicationSchoolId)
                 .orderId(orderId)
                 .paymentStatus(paymentStatus)
                 .paymentAmount(paymentAmount)

src/main/java/life/mosu/mosuserver/domain/school/SchoolApplicationProjection.java

@@ -0,0 +1,5 @@
+package life.mosu.mosuserver.domain.school;
+
+public record SchoolApplicationProjection(Long schoolId, String schoolName, Long count) {
+
+}

src/main/java/life/mosu/mosuserver/domain/school/SchoolJpaEntity.java

@@ -1,22 +1,29 @@
 package life.mosu.mosuserver.domain.school;
 
 
-import jakarta.persistence.*;
+import jakarta.persistence.Column;
+import jakarta.persistence.Embedded;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import java.time.LocalDate;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
-import java.time.LocalDate;
-
 @Entity
 @Getter
-@Table(name="school")
+@Table(name = "school")
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class SchoolJpaEntity {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name="school_id")
+    @Column(name = "school_id")
     private Long id;
 
     @Column(name = "school_name")
@@ -34,4 +41,12 @@ public class SchoolJpaEntity {
     @Column(name = "capacity")
     private Long capacity;
 
+    public SchoolJpaEntity(String schoolName, Area area, AddressJpaVO address, LocalDate examDate,
+            Long capacity) {
+        this.schoolName = schoolName;
+        this.area = area;
+        this.address = address;
+        this.examDate = examDate;
+        this.capacity = capacity;
+    }
 }