[BE] 입장 10분 전 푸시 알림 전송 기능 구현 (#483)

backend/src/main/java/com/festago/common/exception/ConflictException.java

@@ -0,0 +1,8 @@
+package com.festago.common.exception;
+
+public class ConflictException extends FestaGoException {
+
+    public ConflictException(ErrorCode errorCode) {
+        super(errorCode);
+    }
+}

backend/src/main/java/com/festago/common/exception/ErrorCode.java

@@ -25,6 +25,7 @@ public enum ErrorCode {
     DUPLICATE_STUDENT_EMAIL("이미 인증된 이메일입니다."),
     TICKET_CANNOT_RESERVE_STAGE_START("공연의 시작 시간 이후로 예매할 수 없습니다."),
     INVALID_STUDENT_VERIFICATION_CODE("올바르지 않은 학생 인증 코드입니다."),
+    INVALID_ENTRY_ALERT_TIME("올바르지 않은 입장 알림 시간입니다"),
 
     // 401
     EXPIRED_AUTH_TOKEN("만료된 로그인 토큰입니다."),
@@ -46,6 +47,9 @@ public enum ErrorCode {
     TICKET_NOT_FOUND("존재하지 않는 티켓입니다."),
     SCHOOL_NOT_FOUND("존재하지 않는 학교입니다."),
 
+    // 409
+    ALREADY_ALERT("이미 입장 알림이 전송되었습니다."),
+
     // 500
     INTERNAL_SERVER_ERROR("서버 내부에 문제가 발생했습니다."),
     INVALID_ENTRY_CODE_PERIOD("올바르지 않은 입장코드 유효기간입니다."),

backend/src/main/java/com/festago/config/SchedulingConfig.java

@@ -0,0 +1,10 @@
+package com.festago.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+@Configuration
+@EnableScheduling
+public class SchedulingConfig {
+
+}

backend/src/main/java/com/festago/entry_alert/application/EntryAlertEventListener.java

@@ -0,0 +1,56 @@
+package com.festago.entry_alert.application;
+
+import com.festago.entry_alert.dto.EntryAlertResponse;
+import com.festago.ticket.dto.event.TicketCreateEvent;
+import java.time.Clock;
+import java.time.LocalDateTime;
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.scheduling.TaskScheduler;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+@Component
+public class EntryAlertEventListener {
+
+    private static final Logger log = LoggerFactory.getLogger(EntryAlertEventListener.class);
+
+    private final EntryAlertService entryAlertService;
+    private final TaskScheduler taskScheduler;
+    private final Clock clock;
+
+    public EntryAlertEventListener(EntryAlertService entryAlertService, TaskScheduler taskScheduler, Clock clock) {
+        this.entryAlertService = entryAlertService;
+        this.taskScheduler = taskScheduler;
+        this.clock = clock;
+    }
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    @Async
+    public void addEntryAlertSchedule(TicketCreateEvent event) {
+        EntryAlertResponse entryAlert = entryAlertService.create(event.stageId(), event.entryTime());
+        addSchedule(entryAlert);
+    }
+
+    private void addSchedule(EntryAlertResponse entryAlert) {
+        log.info("add entryAlert schedule: {}", entryAlert.id());
+        Runnable task = createEntryAlertTask(entryAlert.id());
+        LocalDateTime alertTime = entryAlert.alertTime();
+        taskScheduler.schedule(task, alertTime.atZone(clock.getZone()).toInstant());
+    }
+
+    private Runnable createEntryAlertTask(Long id) {
+        return () -> entryAlertService.sendEntryAlert(id);
+    }
+
+    @EventListener(ApplicationReadyEvent.class)
+    public void initEntryAlertSchedule() {
+        List<EntryAlertResponse> entryAlerts = entryAlertService.findAll();
+        entryAlerts.forEach(this::addSchedule);
+    }
+}

backend/src/main/java/com/festago/entry_alert/application/EntryAlertService.java

@@ -0,0 +1,71 @@
+package com.festago.entry_alert.application;
+
+import com.festago.common.exception.ConflictException;
+import com.festago.common.exception.ErrorCode;
+import com.festago.entry_alert.domain.EntryAlert;
+import com.festago.entry_alert.dto.EntryAlertResponse;
+import com.festago.entry_alert.repository.EntryAlertRepository;
+import com.festago.fcm.application.FcmClient;
+import com.festago.fcm.domain.FCMChannel;
+import com.festago.fcm.domain.MemberFCM;
+import com.festago.fcm.dto.FcmPayload;
+import com.festago.fcm.repository.MemberFCMRepository;
+import com.festago.ticketing.repository.MemberTicketRepository;
+import java.time.LocalDateTime;
+import java.util.List;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional
+public class EntryAlertService {
+
+    private static final int BATCH_ALERT_SIZE = 500;
+
+    private final EntryAlertRepository entryAlertRepository;
+    private final MemberTicketRepository memberTicketRepository;
+    private final MemberFCMRepository memberFCMRepository;
+    private final FcmClient fcmClient;
+
+    public EntryAlertService(EntryAlertRepository entryAlertRepository, MemberTicketRepository memberTicketRepository,
+                             MemberFCMRepository memberFCMRepository, FcmClient fcmClient) {
+        this.entryAlertRepository = entryAlertRepository;
+        this.memberTicketRepository = memberTicketRepository;
+        this.memberFCMRepository = memberFCMRepository;
+        this.fcmClient = fcmClient;
+    }
+
+    @Transactional(readOnly = true)
+    public List<EntryAlertResponse> findAll() {
+        return entryAlertRepository.findAll().stream()
+            .map(alert -> new EntryAlertResponse(alert.getId(), alert.findAlertTime()))
+            .toList();
+    }
+
+    public EntryAlertResponse create(Long stageId, LocalDateTime entryTime) {
+        EntryAlert entryAlert = entryAlertRepository.save(new EntryAlert(stageId, entryTime));
+        return new EntryAlertResponse(entryAlert.getId(), entryAlert.findAlertTime());
+    }
+
+    @Async
+    public void sendEntryAlert(Long id) {
+        EntryAlert entryAlert = entryAlertRepository.findByIdForUpdate(id)
+            .orElseThrow(() -> new ConflictException(ErrorCode.ALREADY_ALERT));
+        List<Long> memberIds = memberTicketRepository.findAllOwnerIdByStageIdAndEntryTime(entryAlert.getStageId(),
+            entryAlert.getEntryTime());
+        List<String> tokens = memberFCMRepository.findAllByMemberIdIn(memberIds)
+            .stream()
+            .map(MemberFCM::getFcmToken)
+            .toList();
+        sendMessages(tokens);
+        entryAlertRepository.delete(entryAlert);
+    }
+
+    private void sendMessages(List<String> tokens) {
+        for (int i = 0; i < tokens.size(); i += BATCH_ALERT_SIZE) {
+            List<String> subTokens = tokens.subList(i, Math.min(i + BATCH_ALERT_SIZE, tokens.size()));
+            fcmClient.sendAllAsync(subTokens, FCMChannel.ENTRY_ALERT, FcmPayload.entryAlert());
+        }
+    }
+}

backend/src/main/java/com/festago/entry_alert/domain/EntryAlert.java

@@ -0,0 +1,62 @@
+package com.festago.entry_alert.domain;
+
+import com.festago.common.exception.BadRequestException;
+import com.festago.common.exception.ErrorCode;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.validation.constraints.NotNull;
+import java.time.LocalDateTime;
+
+@Entity
+public class EntryAlert {
+
+    private static final int ENTRY_ALERT_MINUTES_BEFORE = 10;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @NotNull
+    private Long stageId;
+
+    @NotNull
+    private LocalDateTime entryTime;
+
+    protected EntryAlert() {
+    }
+
+    public EntryAlert(Long stageId, LocalDateTime entryTime) {
+        this(null, stageId, entryTime);
+    }
+
+    public EntryAlert(Long id, Long stageId, LocalDateTime entryTime) {
+        this.id = id;
+        this.stageId = stageId;
+        this.entryTime = entryTime;
+    }
+
+    public static EntryAlert create(Long stageId, LocalDateTime entryTime, LocalDateTime currentTime) {
+        if (currentTime.isAfter(entryTime.minusMinutes(ENTRY_ALERT_MINUTES_BEFORE))) {
+            throw new BadRequestException(ErrorCode.INVALID_ENTRY_ALERT_TIME);
+        }
+        return new EntryAlert(stageId, entryTime);
+    }
+
+    public LocalDateTime findAlertTime() {
+        return entryTime.minusMinutes(ENTRY_ALERT_MINUTES_BEFORE);
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public Long getStageId() {
+        return stageId;
+    }
+
+    public LocalDateTime getEntryTime() {
+        return entryTime;
+    }
+}

backend/src/main/java/com/festago/entry_alert/dto/EntryAlertResponse.java

@@ -0,0 +1,10 @@
+package com.festago.entry_alert.dto;
+
+import java.time.LocalDateTime;
+
+public record EntryAlertResponse(
+    Long id,
+    LocalDateTime alertTime
+) {
+
+}

backend/src/main/java/com/festago/entry_alert/repository/EntryAlertRepository.java

@@ -0,0 +1,16 @@
+package com.festago.entry_alert.repository;
+
+import com.festago.entry_alert.domain.EntryAlert;
+import jakarta.persistence.LockModeType;
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+public interface EntryAlertRepository extends JpaRepository<EntryAlert, Long> {
+
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT ea FROM EntryAlert ea WHERE ea.id = :id")
+    Optional<EntryAlert> findByIdForUpdate(@Param("id") Long id);
+}

backend/src/main/java/com/festago/fcm/application/FCMNotificationEventListener.java

@@ -1,90 +1,38 @@
 package com.festago.fcm.application;
 
-import com.festago.common.exception.ErrorCode;
-import com.festago.common.exception.InternalServerException;
 import com.festago.entry.dto.event.EntryProcessEvent;
 import com.festago.fcm.domain.FCMChannel;
+import com.festago.fcm.dto.FcmPayload;
 import com.festago.fcm.dto.MemberFCMResponse;
-import com.google.firebase.messaging.AndroidConfig;
-import com.google.firebase.messaging.AndroidNotification;
-import com.google.firebase.messaging.BatchResponse;
-import com.google.firebase.messaging.FirebaseMessaging;
-import com.google.firebase.messaging.FirebaseMessagingException;
-import com.google.firebase.messaging.Message;
-import com.google.firebase.messaging.SendResponse;
 import java.util.List;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.context.annotation.Profile;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.event.TransactionPhase;
 import org.springframework.transaction.event.TransactionalEventListener;
 
 @Component
-@Profile({"dev", "prod"})
 public class FCMNotificationEventListener {
 
-    private static final Logger log = LoggerFactory.getLogger(FCMNotificationEventListener.class);
-
-    private final FirebaseMessaging firebaseMessaging;
+    private final FcmClient fcmClient;
     private final MemberFCMService memberFCMService;
 
-    public FCMNotificationEventListener(FirebaseMessaging firebaseMessaging, MemberFCMService memberFCMService) {
-        this.firebaseMessaging = firebaseMessaging;
+    public FCMNotificationEventListener(FcmClient fcmClient, MemberFCMService memberFCMService) {
+        this.fcmClient = fcmClient;
         this.memberFCMService = memberFCMService;
     }
 
     @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
     @Async
     public void sendFcmNotification(EntryProcessEvent event) {
-        List<Message> messages = createMessages(getMemberFCMToken(event.memberId()), FCMChannel.NOT_DEFINED.name());
-        try {
-            BatchResponse batchResponse = firebaseMessaging.sendAll(messages);
-            checkAllSuccess(batchResponse, event.memberId());
-        } catch (FirebaseMessagingException e) {
-            log.error("fail send FCM message", e);
-            throw new InternalServerException(ErrorCode.FAIL_SEND_FCM_MESSAGE);
-        }
+        List<String> tokens = getMemberFCMToken(event.memberId());
+        fcmClient.sendAll(tokens, FCMChannel.ENTRY_PROCESS, FcmPayload.entryProcess());
     }
 
     private List<String> getMemberFCMToken(Long memberId) {
-        return memberFCMService.findMemberFCM(memberId).memberFCMs().stream()
+        return memberFCMService.findMemberFCM(memberId)
+            .memberFCMs()
+            .stream()
             .map(MemberFCMResponse::fcmToken)
             .toList();
     }
-
-    private List<Message> createMessages(List<String> tokens, String channelId) {
-        return tokens.stream()
-            .map(token -> createMessage(token, channelId))
-            .toList();
-    }
-
-    private Message createMessage(String token, String channelId) {
-        return Message.builder()
-            .setAndroidConfig(createAndroidConfig(channelId))
-            .setToken(token)
-            .build();
-    }
-
-    private AndroidConfig createAndroidConfig(String channelId) {
-        return AndroidConfig.builder()
-            .setNotification(createAndroidNotification(channelId))
-            .build();
-    }
-
-    private AndroidNotification createAndroidNotification(String channelId) {
-        return AndroidNotification.builder()
-            .setChannelId(channelId)
-            .build();
-    }
-
-    private void checkAllSuccess(BatchResponse batchResponse, Long memberId) {
-        List<SendResponse> failSend = batchResponse.getResponses().stream()
-            .filter(sendResponse -> !sendResponse.isSuccessful())
-            .toList();
-
-        log.warn("member {} 에 대한 다음 요청들이 실패했습니다. {}", memberId, failSend);
-        throw new InternalServerException(ErrorCode.FAIL_SEND_FCM_MESSAGE);
-    }
 }

backend/src/main/java/com/festago/fcm/application/FcmClient.java

@@ -0,0 +1,12 @@
+package com.festago.fcm.application;
+
+import com.festago.fcm.domain.FCMChannel;
+import com.festago.fcm.dto.FcmPayload;
+import java.util.List;
+
+public interface FcmClient {
+
+    void sendAllAsync(List<String> tokens, FCMChannel channel, FcmPayload fcmPayload);
+
+    void sendAll(List<String> tokens, FCMChannel channel, FcmPayload fcmPayload);
+}

backend/src/main/java/com/festago/fcm/application/MockFcmClient.java

@@ -0,0 +1,28 @@
+package com.festago.fcm.application;
+
+import com.festago.fcm.domain.FCMChannel;
+import com.festago.fcm.dto.FcmPayload;
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+
+@Component
+@Profile({"!prod", "!dev"})
+public class MockFcmClient implements FcmClient {
+
+    private static final Logger log = LoggerFactory.getLogger(MockFcmClient.class);
+
+    @Override
+    @Async
+    public void sendAllAsync(List<String> tokens, FCMChannel channel, FcmPayload fcmPayload) {
+        sendAll(tokens, channel, fcmPayload);
+    }
+
+    @Override
+    public void sendAll(List<String> tokens, FCMChannel channel, FcmPayload fcmPayload) {
+        log.info("[FCM] title: {} / body: {} / to {} device", fcmPayload.title(), fcmPayload.body(), tokens.size());
+    }
+}