MOSU-28 feat: 알림톡 기능 구현

build.gradle

@@ -85,6 +85,8 @@ dependencies {
 
     // poi-excel
     implementation 'org.apache.poi:poi-ooxml:5.4.0'
+
+    implementation 'org.springframework.boot:spring-boot-starter-webflux'
 }
 
 tasks.named('test') {

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

@@ -11,6 +11,7 @@
 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.domain.school.SchoolQueryRepositoryImpl;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;
 import life.mosu.mosuserver.global.exception.ErrorCode;
 import life.mosu.mosuserver.global.util.FileRequest;
@@ -31,6 +32,7 @@ public class ApplicationService {
     private final ApplicationJpaRepository applicationJpaRepository;
     private final ApplicationSchoolJpaRepository applicationSchoolJpaRepository;
     private final AdmissionTicketImageJpaRepository admissionTicketImageJpaRepository;
+    private final SchoolQueryRepositoryImpl schoolQueryRepository;
     private final SchoolJpaRepository schoolJpaRepository;
 
     // 신청
@@ -42,32 +44,85 @@ public ApplicationResponse apply(Long userId, ApplicationRequest request) {
         ApplicationJpaEntity application = applicationJpaRepository.save(request.toEntity(userId));
         Long applicationId = application.getId();
 
+        //수험표 저장
         admissionTicketImageJpaRepository.save(
                 createAdmissionTicketImageIfPresent(request.admissionTicket(), applicationId));
 
         for (ApplicationSchoolRequest schoolRequest : schoolRequests) {
+            //해당 학교가 존재하는 학교인지
             Long schoolId = schoolJpaRepository.findBySchoolNameAndAreaAndExamDate(
                             schoolRequest.schoolName(),
                             schoolRequest.validatedArea(schoolRequest.area()),
                             schoolRequest.examDate())
                     .orElseThrow(() -> new CustomRuntimeException(ErrorCode.SCHOOL_NOT_FOUND))
                     .getId();
 
+            //해당 학교를 이미 신청하였는지
             if (applicationSchoolJpaRepository.existsByUserIdAndSchoolId(userId, schoolId)) {
                 throw new CustomRuntimeException(ErrorCode.APPLICATION_SCHOOL_ALREADY_APPLIED);
             }
 
+            //해당 학교를 찾을 수 있는지
             SchoolJpaEntity school = schoolJpaRepository.findById(schoolId)
                     .orElseThrow(() -> new CustomRuntimeException(ErrorCode.SCHOOL_NOT_FOUND));
 
+            //해당 학교를 신청했음을 저장하기
             ApplicationSchoolJpaEntity applicationSchool = schoolRequest.toEntity(userId,
                     applicationId, school);
+
+            //반환용 리스트에 저장하기
             savedEntities.add(applicationSchoolJpaRepository.save(applicationSchool));
         }
 
         return ApplicationResponse.of(applicationId, savedEntities);
     }
 
+    //신청 - 리팩토링
+//    @Transactional
+//    public ApplicationResponse apply(Long userId, ApplicationRequest request) {
+//        Set<ApplicationSchoolRequest> schoolRequests = request.schools();
+////        List<ApplicationSchoolJpaEntity> savedEntities = new ArrayList<>();
+//
+//        ApplicationJpaEntity application = applicationJpaRepository.save(request.toEntity(userId));
+//        Long applicationId = application.getId();
+//
+//        //수험표 저장
+//        admissionTicketImageJpaRepository.save(
+//                createAdmissionTicketImageIfPresent(request.admissionTicket(), applicationId));
+//
+//        List<Triple<String, Area, LocalDate>> conditions = schoolRequests.stream()
+//                .map(school -> Triple.of(
+//                        school.schoolName(),
+//                        school.validatedArea(school.area()),
+//                        school.examDate()
+//                ))
+//                .toList();
+//
+//        //이름, 지역, 날짜 조건에 맞는 학교가 있는지
+//        List<Long> schoolIds = schoolQueryRepository.findSchoolsByConditions(conditions);
+//        if (schoolIds.size() != conditions.size()) {
+//            throw new CustomRuntimeException(ErrorCode.SCHOOL_NOT_FOUND);
+//        }
+//
+//        //해당 학교를 이미 신청하였는지
+//        if (applicationSchoolJpaRepository.existsByUserIdAndSchoolIds(userId, schoolIds)) {
+//            throw new CustomRuntimeException(ErrorCode.APPLICATION_SCHOOL_ALREADY_APPLIED);
+//        }
+//
+
+    /// /            //해당 학교를 찾을 수 있는지 /            SchoolJpaEntity school =
+    /// schoolJpaRepository.findById(schoolId) /                    .orElseThrow(() -> new
+    /// CustomRuntimeException(ErrorCode.SCHOOL_NOT_FOUND));
+//
+//        //해당 학교를 신청했음을 저장하기
+//        ApplicationSchoolJpaEntity applicationSchool = schoolRequest.toEntity(userId,
+//                applicationId, school);
+//
+//        //반환용 리스트에 저장하기
+//        savedEntities.add(applicationSchoolJpaRepository.save(applicationSchool));
+//
+//        return ApplicationResponse.of(applicationId, savedEntities);
+//    }
 
     // 전체 신청 내역 조회
     @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)

src/main/java/life/mosu/mosuserver/application/inquiry/InquiryAnswerService.java

@@ -4,8 +4,10 @@
 import life.mosu.mosuserver.domain.inquiry.InquiryJpaRepository;
 import life.mosu.mosuserver.domain.inquiryAnswer.InquiryAnswerJpaEntity;
 import life.mosu.mosuserver.domain.inquiryAnswer.InquiryAnswerJpaRepository;
+import life.mosu.mosuserver.domain.profile.ProfileJpaRepository;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;
 import life.mosu.mosuserver.global.exception.ErrorCode;
+import life.mosu.mosuserver.infra.notify.NotifyEventPublisher;
 import life.mosu.mosuserver.presentation.inquiry.dto.InquiryAnswerRequest;
 import life.mosu.mosuserver.presentation.inquiry.dto.InquiryAnswerUpdateRequest;
 import life.mosu.mosuserver.presentation.inquiry.dto.InquiryDetailResponse;
@@ -22,6 +24,9 @@ public class InquiryAnswerService {
     private final InquiryAnswerAttachmentService answerAttachmentService;
     private final InquiryAnswerJpaRepository inquiryAnswerJpaRepository;
     private final InquiryJpaRepository inquiryJpaRepository;
+    private final ProfileJpaRepository profileJpaRepository;
+    private final NotifyEventPublisher notifyEventPublisher;
+
 
     @Transactional
     public void createInquiryAnswer(Long postId, InquiryAnswerRequest request) {
@@ -36,6 +41,13 @@ public void createInquiryAnswer(Long postId, InquiryAnswerRequest request) {
 
         answerAttachmentService.createAttachment(request.attachments(), answerEntity);
         inquiryEntity.updateStatusToComplete();
+
+//        ProfileJpaEntity profile = profileJpaRepository.findByUserId(inquiryEntity.getUserId())
+//                .orElseThrow(() -> new RuntimeException(""));
+//        NotifyEvent event = NotifyEvent.create(NotifyStatus.INQUIRY_ANSWER_SUCCESS,
+//                profile.getPhoneNumber(), postId);
+//        notifyEventPublisher.notify(event);
+
     }
 
     @Transactional

src/main/java/life/mosu/mosuserver/application/notify/NotifyService.java

@@ -0,0 +1,41 @@
+package life.mosu.mosuserver.application.notify;
+
+import life.mosu.mosuserver.domain.profile.ProfileJpaEntity;
+import life.mosu.mosuserver.domain.profile.ProfileJpaRepository;
+import life.mosu.mosuserver.global.exception.CustomRuntimeException;
+import life.mosu.mosuserver.global.exception.ErrorCode;
+import life.mosu.mosuserver.infra.notify.NotifyClientAdapter;
+import life.mosu.mosuserver.infra.notify.dto.NotifyEvent;
+import life.mosu.mosuserver.infra.notify.dto.NotifyEventRequest;
+import life.mosu.mosuserver.infra.notify.strategy.NotifyStrategy;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.ApplicationContext;
+import org.springframework.stereotype.Service;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class NotifyService {
+
+    private final NotifyClientAdapter notifier;
+    private final ProfileJpaRepository profileJpaRepository;
+    private final ApplicationContext applicationContext;
+
+    public void notify(NotifyEvent event) {
+        NotifyStrategy strategy = getNotifyStrategy(event.status().getStrategyName());
+
+        ProfileJpaEntity profile = profileJpaRepository.findByUserId(event.targetId())
+                .orElseThrow(() -> new CustomRuntimeException(ErrorCode.PROFILE_NOT_FOUND));
+        String parsedPhoneNumber = profile.getPhoneNumber().replaceAll("-", "");
+
+        NotifyEventRequest request = strategy.apply(parsedPhoneNumber, event);
+
+        notifier.send(request);
+    }
+
+    private NotifyStrategy getNotifyStrategy(String strategyName) {
+        return (NotifyStrategy) applicationContext.getBean(strategyName);
+    }
+
+}

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

@@ -8,14 +8,33 @@
 public interface ApplicationSchoolJpaRepository extends
         JpaRepository<ApplicationSchoolJpaEntity, Long> {
 
+//    boolean existsByUserIdAndSchoolIds(Long userId, List<Long> schoolId);
 
     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);
+
+    @Query("""
+                SELECT p.paymentKey, a.examDate, a.schoolName, a.lunch
+                FROM ApplicationSchoolJpaEntity a
+                LEFT JOIN PaymentJpaEntity p ON a.id = p.applicationSchoolId
+                WHERE a.id = :applicationSchoolId
+            """)
+    ApplicationSchoolNotifyProjection findPaymentByApplicationSchoolId(Long applicationSchoolId);
+
+    @Query("""
+                 SELECT p.paymentKey, a.examDate, a.schoolName
+                 FROM ApplicationSchoolJpaEntity a
+                 JOIN PaymentJpaEntity p ON a.id = p.applicationSchoolId
+                 WHERE a.id = :applicationSchoolId
+            """)
+    OneWeekNotifyProjection findOneWeekNotifyByApplicationSchoolId(Long applicationSchoolId);
+
 }

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

@@ -0,0 +1,13 @@
+package life.mosu.mosuserver.domain.applicationschool;
+
+import java.time.LocalDate;
+import life.mosu.mosuserver.domain.application.Lunch;
+
+public record ApplicationSchoolNotifyProjection(
+        String paymentKey,
+        LocalDate examDate,
+        String schoolName,
+        Lunch lunch
+) {
+
+}

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

@@ -0,0 +1,11 @@
+package life.mosu.mosuserver.domain.applicationschool;
+
+import java.time.LocalDate;
+
+public record OneWeekNotifyProjection(
+        String paymentKey,
+        LocalDate examDate,
+        String schoolName
+) {
+
+}

src/main/java/life/mosu/mosuserver/domain/refund/RefundJpaRepository.java

@@ -1,6 +1,20 @@
 package life.mosu.mosuserver.domain.refund;
 
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
 
 public interface RefundJpaRepository extends JpaRepository<RefundJpaEntity, Long> {
+
+    @Query("""
+                SELECT
+                    p.paymentKey AS paymentKey,
+                    a.examDate AS examDate,
+                    p.paymentMethod AS paymentMethod,
+                    r.reason AS reason
+                FROM RefundJpaEntity r
+                LEFT JOIN PaymentJpaEntity p ON r.applicationSchoolId = p.applicationSchoolId
+                LEFT JOIN ApplicationSchoolJpaEntity a ON r.applicationSchoolId = a.id
+                WHERE r.applicationSchoolId = :applicationSchoolId
+            """)
+    RefundNotifyProjection findRefundByApplicationSchoolId(Long applicationSchoolId);
 }

src/main/java/life/mosu/mosuserver/domain/refund/RefundNotifyProjection.java

@@ -0,0 +1,15 @@
+package life.mosu.mosuserver.domain.refund;
+
+import java.time.LocalDate;
+import life.mosu.mosuserver.domain.payment.PaymentMethod;
+
+public record RefundNotifyProjection(
+        String paymentKey,
+        LocalDate examDate,
+        String schoolName,
+        PaymentMethod paymentMethod,
+        String reason
+        // TODO: 환불 금액 추가
+) {
+
+}

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

@@ -0,0 +1,12 @@
+package life.mosu.mosuserver.domain.school;
+
+import java.time.LocalDate;
+import java.util.List;
+import org.apache.commons.lang3.tuple.Triple;
+
+public interface SchoolQueryRepository {
+
+    List<Long> findSchoolsByConditions(
+            List<Triple<String, Area, LocalDate>> conditions);
+
+}

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

@@ -0,0 +1,38 @@
+package life.mosu.mosuserver.domain.school;
+
+import com.querydsl.core.BooleanBuilder;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import java.time.LocalDate;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.tuple.Triple;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@RequiredArgsConstructor
+public class SchoolQueryRepositoryImpl implements SchoolQueryRepository {
+
+    private final JPAQueryFactory queryFactory;
+
+    @Override
+    public List<Long> findSchoolsByConditions(
+            List<Triple<String, Area, LocalDate>> conditions) {
+        BooleanBuilder builder = new BooleanBuilder();
+
+        for (Triple<String, Area, LocalDate> cond : conditions) {
+            builder.or(
+                    QSchoolJpaEntity.schoolJpaEntity.schoolName.eq(cond.getLeft())
+                            .and(QSchoolJpaEntity.schoolJpaEntity.area.eq(cond.getMiddle()))
+                            .and(QSchoolJpaEntity.schoolJpaEntity.examDate.eq(cond.getRight()))
+            );
+        }
+
+        return queryFactory
+                .select(QSchoolJpaEntity.schoolJpaEntity.id)
+                .from(QSchoolJpaEntity.schoolJpaEntity)
+                .where(builder)
+                .fetch();
+    }
+
+
+}

src/main/java/life/mosu/mosuserver/global/annotation/ReactiveEventListener.java

@@ -0,0 +1,16 @@
+package life.mosu.mosuserver.global.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import org.springframework.context.event.EventListener;
+import org.springframework.scheduling.annotation.Async;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Async
+@EventListener
+public @interface ReactiveEventListener {
+
+}

src/main/java/life/mosu/mosuserver/global/config/MessageSourceConfig.java

@@ -0,0 +1,18 @@
+package life.mosu.mosuserver.global.config;
+
+import org.springframework.context.MessageSource;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.support.ReloadableResourceBundleMessageSource;
+
+@Configuration
+public class MessageSourceConfig {
+
+    @Bean
+    public MessageSource messageSource() {
+        ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
+        messageSource.setBasename("classpath:messages");
+        messageSource.setDefaultEncoding("UTF-8");
+        return messageSource;
+    }
+}

src/main/java/life/mosu/mosuserver/global/config/WebClientConfig.java

@@ -0,0 +1,17 @@
+package life.mosu.mosuserver.global.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.MediaType;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@Configuration
+public class WebClientConfig {
+
+    @Bean
+    public WebClient webClient() {
+        return WebClient.builder()
+                .defaultHeader("Content-Type", MediaType.APPLICATION_JSON_VALUE)
+                .build();
+    }
+}