[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,10 @@ public enum ErrorCode {
     DUPLICATE_STUDENT_EMAIL("이미 인증된 이메일입니다."),
     TICKET_CANNOT_RESERVE_STAGE_START("공연의 시작 시간 이후로 예매할 수 없습니다."),
     INVALID_STUDENT_VERIFICATION_CODE("올바르지 않은 학생 인증 코드입니다."),
+    INVALID_ENTRY_ALERT_TIME("올바르지 않은 입장 알림 시간입니다"),
+    NOT_PENDING_ALERT("전송 대기중인 알림이 아닙니다."),
+    NOT_REQUESTED_ALERT("전송 요청중인 알림이 아닙니다."),
+
 
     // 401
     EXPIRED_AUTH_TOKEN("만료된 로그인 토큰입니다."),
@@ -45,6 +49,10 @@ public enum ErrorCode {
     FESTIVAL_NOT_FOUND("존재하지 않는 축제입니다."),
     TICKET_NOT_FOUND("존재하지 않는 티켓입니다."),
     SCHOOL_NOT_FOUND("존재하지 않는 학교입니다."),
+    ENTRY_ALERT_NOT_FOUND("존재하지 않는 입장 알림입니다."),
+
+    // 409
+    ALREADY_ALERT("이미 입장 알림이 전송되었습니다."),
 
     // 500
     INTERNAL_SERVER_ERROR("서버 내부에 문제가 발생했습니다."),

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/entryalert/application/EntryAlertEventListener.java

@@ -0,0 +1,57 @@
+package com.festago.entryalert.application;
+
+import com.festago.entryalert.dto.EntryAlertResponse;
+import com.festago.ticket.dto.event.TicketCreateEvent;
+import java.time.Clock;
+import java.time.Instant;
+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;
+    }
+
+    @EventListener(ApplicationReadyEvent.class)
+    public void initEntryAlertSchedule() {
+        List<EntryAlertResponse> entryAlerts = entryAlertService.findAllPending();
+        entryAlerts.forEach(this::addSchedule);
+    }
+
+    private void addSchedule(EntryAlertResponse entryAlert) {
+        Long entryAlertId = entryAlert.id();
+        Instant alertTime = toInstant(entryAlert.alertTime());
+        log.info("EntryAlert 스케쥴링 추가. entryAlertId: {}, alertTime: {}", entryAlertId, entryAlert.alertTime());
+        taskScheduler.schedule(() -> entryAlertService.sendEntryAlert(entryAlertId), alertTime);
+    }
+
+    private Instant toInstant(LocalDateTime localDateTime) {
+        return localDateTime.atZone(clock.getZone()).toInstant();
+    }
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    @Async
+    public void addEntryAlertSchedule(TicketCreateEvent event) {
+        EntryAlertResponse entryAlert = entryAlertService.create(event.stageId(), event.entryTime());
+        addSchedule(entryAlert);
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.festago.entryalert.application;
+
+import com.festago.common.exception.ConflictException;
+import com.festago.common.exception.ErrorCode;
+import com.festago.entryalert.domain.AlertStatus;
+import com.festago.entryalert.domain.EntryAlert;
+import com.festago.entryalert.dto.EntryAlertResponse;
+import com.festago.entryalert.repository.EntryAlertRepository;
+import com.festago.fcm.application.FcmClient;
+import com.festago.fcm.domain.FCMChannel;
+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 lombok.RequiredArgsConstructor;
+import org.springframework.core.task.TaskExecutor;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class EntryAlertService {
+
+    private final EntryAlertRepository entryAlertRepository;
+    private final MemberTicketRepository memberTicketRepository;
+    private final MemberFCMRepository memberFCMRepository;
+    private final FcmClient fcmClient;
+    private final TaskExecutor taskExecutor;
+
+    @Transactional(readOnly = true)
+    public List<EntryAlertResponse> findAllPending() {
+        return entryAlertRepository.findAllByStatus(AlertStatus.PENDING)
+            .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.findByIdAndStatusForUpdate(id, AlertStatus.PENDING)
+            .orElseThrow(() -> new ConflictException(ErrorCode.ALREADY_ALERT));
+        List<String> tokens = findFcmTokens(entryAlert);
+        taskExecutor.execute(() -> fcmClient.sendAll(tokens, FCMChannel.ENTRY_ALERT, FcmPayload.entryAlert()));
+        entryAlert.request();
+    }
+
+    private List<String> findFcmTokens(EntryAlert entryAlert) {
+        List<Long> memberIds = memberTicketRepository.findAllOwnerIdByStageIdAndEntryTime(
+            entryAlert.getStageId(), entryAlert.getEntryTime());
+        return memberFCMRepository.findAllTokenByMemberIdIn(memberIds);
+    }
+}

backend/src/main/java/com/festago/entryalert/domain/AlertStatus.java

@@ -0,0 +1,8 @@
+package com.festago.entryalert.domain;
+
+public enum AlertStatus {
+
+    PENDING,
+    REQUESTED,
+    ;
+}

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

@@ -0,0 +1,84 @@
+package com.festago.entryalert.domain;
+
+import com.festago.common.domain.BaseTimeEntity;
+import com.festago.common.exception.BadRequestException;
+import com.festago.common.exception.ErrorCode;
+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.validation.constraints.NotNull;
+import java.time.LocalDateTime;
+
+@Entity
+public class EntryAlert extends BaseTimeEntity {
+
+    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;
+
+    @NotNull
+    @Enumerated(value = EnumType.STRING)
+    private AlertStatus status = AlertStatus.PENDING;
+
+    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 void request() {
+        validateNotPending();
+        this.status = AlertStatus.REQUESTED;
+    }
+
+    private void validateNotPending() {
+        if (status != AlertStatus.PENDING) {
+            throw new BadRequestException(ErrorCode.NOT_PENDING_ALERT);
+        }
+    }
+
+    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;
+    }
+
+    public AlertStatus getStatus() {
+        return status;
+    }
+}

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

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

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

@@ -0,0 +1,21 @@
+package com.festago.entryalert.repository;
+
+import com.festago.entryalert.domain.AlertStatus;
+import com.festago.entryalert.domain.EntryAlert;
+import jakarta.persistence.LockModeType;
+import java.util.List;
+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> {
+
+    @Query("SELECT ea FROM EntryAlert ea WHERE ea.status = :status")
+    List<EntryAlert> findAllByStatus(@Param("status") AlertStatus status);
+
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT ea FROM EntryAlert ea WHERE ea.id = :id and ea.status = :status")
+    Optional<EntryAlert> findByIdAndStatusForUpdate(@Param("id") Long id, @Param("status") AlertStatus status);
+}

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

@@ -1,90 +1,29 @@
 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.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 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;
 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);
-        }
-    }
-
-    private List<String> getMemberFCMToken(Long memberId) {
-        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);
+        List<String> tokens = memberFCMService.findMemberFCMTokens(event.memberId());
+        fcmClient.sendAll(tokens, FCMChannel.ENTRY_PROCESS, FcmPayload.entryProcess());
     }
 }

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

@@ -0,0 +1,10 @@
+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 sendAll(List<String> tokens, FCMChannel channel, FcmPayload fcmPayload);
+}