[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/AsyncConfig.java

@@ -1,10 +1,22 @@
 package com.festago.config;
 
+import java.util.concurrent.Executor;
+import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
 @EnableAsync
 @Configuration
 public class AsyncConfig {
 
+    @Bean
+    public Executor taskExecutor() {
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(8);
+        executor.setWaitForTasksToCompleteOnShutdown(true);
+        executor.setAwaitTerminationSeconds(60);
+        executor.initialize();
+        return executor;
+    }
 }

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,51 @@
+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 lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+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
+@RequiredArgsConstructor
+@Slf4j
+public class EntryAlertEventListener {
+
+    private final EntryAlertService entryAlertService;
+    private final TaskScheduler taskScheduler;
+    private final 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,62 @@
+package com.festago.entryalert.application;
+
+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 lombok.extern.slf4j.Slf4j;
+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
+@Slf4j
+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) {
+        entryAlertRepository.findByIdAndStatusForUpdate(id, AlertStatus.PENDING)
+            .ifPresent(entryAlert -> {
+                List<String> tokens = findFcmTokens(entryAlert);
+                log.info("EntryAlert 전송 시작 / entryAlertId: {} / to {} devices", id, tokens.size());
+                taskExecutor.execute(() -> fcmClient.sendAll(tokens, FCMChannel.ENTRY_ALERT, FcmPayload.entryAlert()));
+                entryAlert.changeRequested();
+            });
+    }
+
+    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;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+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;
+
+    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 changeRequested() {
+        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);
+}