일정 알림 기능 개발

src/main/java/im/toduck/domain/notification/domain/data/ScheduleReminderData.java

@@ -1,5 +1,9 @@
 package im.toduck.domain.notification.domain.data;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import im.toduck.domain.schedule.persistence.vo.ScheduleAlram;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
@@ -8,7 +12,19 @@
  */
 @Getter
 @NoArgsConstructor
+@AllArgsConstructor
 public class ScheduleReminderData extends AbstractNotificationData {
-	// TODO: 필요한 필드 추가
-	// 예상 필드: 일정 ID, 일정 제목, 일정 시작 시간, 남은 시간 등
+	private Long scheduleId;
+	private String scheduleTitle;
+	private ScheduleAlram reminderType;
+	@JsonProperty("allDay")
+	private boolean isAllDay;
+
+	public static ScheduleReminderData of(
+			final Long scheduleId,
+			final String scheduleTitle,
+			final ScheduleAlram reminderType,
+			final boolean isAllDay) {
+		return new ScheduleReminderData(scheduleId, scheduleTitle, reminderType, isAllDay);
+	}
 }

src/main/java/im/toduck/domain/notification/domain/event/ScheduleReminderNotificationEvent.java

@@ -0,0 +1,58 @@
+package im.toduck.domain.notification.domain.event;
+
+import im.toduck.domain.notification.domain.data.ScheduleReminderData;
+import im.toduck.domain.notification.persistence.entity.NotificationType;
+import im.toduck.domain.schedule.persistence.vo.ScheduleAlram;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class ScheduleReminderNotificationEvent extends NotificationEvent<ScheduleReminderData> {
+
+    private ScheduleReminderNotificationEvent(final Long userId, final ScheduleReminderData data) {
+        super(userId, NotificationType.SCHEDULE_REMINDER, data);
+    }
+
+    public static ScheduleReminderNotificationEvent of(
+            final Long userId,
+            final Long scheduleId,
+            final String scheduleTitle,
+            final ScheduleAlram reminderType,
+            final boolean isAllDay) {
+        return new ScheduleReminderNotificationEvent(
+                userId,
+                ScheduleReminderData.of(scheduleId, scheduleTitle, reminderType, isAllDay));
+    }
+
+    @Override
+    public String getInAppTitle() {
+        return "";
+    }
+
+    @Override
+    public String getInAppBody() {
+        return "";
+    }
+
+    @Override
+    public String getPushTitle() {
+        return getData().getScheduleTitle();
+    }
+
+    @Override
+    public String getPushBody() {
+        if (getData().isAllDay()) {
+            return "일정 하루 전! 준비된 하루를 시작해볼까요? 📅";
+        }
+
+        ScheduleAlram reminderType = getData().getReminderType();
+        return String.format("일정 %d분 전! 준비된 하루를 시작해볼까요? 📅", reminderType.getMinutes());
+    }
+
+    @Override
+    public String getActionUrl() {
+        return "toduck://todo";
+    }
+}

src/main/java/im/toduck/domain/schedule/domain/event/ScheduleCreatedEvent.java

@@ -0,0 +1,14 @@
+package im.toduck.domain.schedule.domain.event;
+
+import lombok.Getter;
+
+@Getter
+public class ScheduleCreatedEvent {
+    private final Long scheduleId;
+    private final Long userId;
+
+    public ScheduleCreatedEvent(final Long scheduleId, final Long userId) {
+        this.scheduleId = scheduleId;
+        this.userId = userId;
+    }
+}

src/main/java/im/toduck/domain/schedule/domain/event/ScheduleDeletedEvent.java

@@ -0,0 +1,12 @@
+package im.toduck.domain.schedule.domain.event;
+
+import lombok.Getter;
+
+@Getter
+public class ScheduleDeletedEvent {
+    private final Long scheduleId;
+
+    public ScheduleDeletedEvent(final Long scheduleId) {
+        this.scheduleId = scheduleId;
+    }
+}

src/main/java/im/toduck/domain/schedule/domain/event/ScheduleReminderEventListener.java

@@ -0,0 +1,75 @@
+package im.toduck.domain.schedule.domain.event;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+import im.toduck.domain.schedule.domain.service.ScheduleReadService;
+import im.toduck.domain.schedule.domain.service.ScheduleReminderSchedulerService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+@ConditionalOnProperty(name = "spring.quartz.auto-startup", havingValue = "true", matchIfMissing = true)
+public class ScheduleReminderEventListener {
+
+    private final ScheduleReadService scheduleReadService;
+    private final ScheduleReminderSchedulerService scheduleReminderSchedulerService;
+
+    @Async
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void handleScheduleCreated(final ScheduleCreatedEvent event) {
+        log.info("일정 생성 이벤트 처리 시작 - ScheduleId: {}", event.getScheduleId());
+
+        try {
+            scheduleReadService.getScheduleById(event.getScheduleId())
+                    .ifPresent(schedule -> {
+                        LocalDateTime currentDateTime = LocalDateTime.now();
+                        scheduleReminderSchedulerService.scheduleScheduleReminders(schedule, currentDateTime, false);
+                    });
+        } catch (Exception e) {
+            log.error("일정 생성 이벤트 처리 중 오류 발생 - ScheduleId: {}", event.getScheduleId(), e);
+        }
+    }
+
+    @Async
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void handleScheduleUpdated(final ScheduleUpdatedEvent event) {
+        log.info("일정 수정 이벤트 처리 시작 - ScheduleId: {}", event.getScheduleId());
+
+        try {
+            if (event.isReminderRelatedChanged()) {
+                scheduleReminderSchedulerService.cancelFutureScheduleReminders(
+                        event.getScheduleId(), LocalDate.now());
+
+                scheduleReadService.getScheduleById(event.getScheduleId())
+                        .ifPresent(schedule -> {
+                            LocalDateTime currentDateTime = LocalDateTime.now();
+                            scheduleReminderSchedulerService.scheduleScheduleReminders(
+                                    schedule, currentDateTime, false);
+                        });
+            }
+        } catch (Exception e) {
+            log.error("일정 수정 이벤트 처리 중 오류 발생 - ScheduleId: {}", event.getScheduleId(), e);
+        }
+    }
+
+    @Async
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void handleScheduleDeleted(final ScheduleDeletedEvent event) {
+        log.info("일정 삭제 이벤트 처리 시작 - ScheduleId: {}", event.getScheduleId());
+
+        try {
+            scheduleReminderSchedulerService.cancelAllScheduleReminders(event.getScheduleId());
+        } catch (Exception e) {
+            log.error("일정 삭제 이벤트 처리 중 오류 발생 - ScheduleId: {}", event.getScheduleId(), e);
+        }
+    }
+}

src/main/java/im/toduck/domain/schedule/domain/event/ScheduleUpdatedEvent.java

@@ -0,0 +1,39 @@
+package im.toduck.domain.schedule.domain.event;
+
+import lombok.Getter;
+
+@Getter
+public class ScheduleUpdatedEvent {
+    private final Long scheduleId;
+    private final Long userId;
+    private final boolean isAlarmChanged;
+    private final boolean isTimeChanged;
+    private final boolean isAllDayChanged;
+    private final boolean isTitleChanged;
+    private final boolean isDateChanged;
+    private final boolean isDaysOfWeekChanged;
+
+    public ScheduleUpdatedEvent(
+            final Long scheduleId,
+            final Long userId,
+            final boolean isAlarmChanged,
+            final boolean isTimeChanged,
+            final boolean isAllDayChanged,
+            final boolean isTitleChanged,
+            final boolean isDateChanged,
+            final boolean isDaysOfWeekChanged) {
+        this.scheduleId = scheduleId;
+        this.userId = userId;
+        this.isAlarmChanged = isAlarmChanged;
+        this.isTimeChanged = isTimeChanged;
+        this.isAllDayChanged = isAllDayChanged;
+        this.isTitleChanged = isTitleChanged;
+        this.isDateChanged = isDateChanged;
+        this.isDaysOfWeekChanged = isDaysOfWeekChanged;
+    }
+
+    public boolean isReminderRelatedChanged() {
+        return isAlarmChanged || isTimeChanged || isAllDayChanged || isTitleChanged
+                || isDateChanged || isDaysOfWeekChanged;
+    }
+}

src/main/java/im/toduck/domain/schedule/domain/service/ScheduleReadService.java

@@ -35,19 +35,19 @@ public class ScheduleReadService {
 	public ScheduleHeadResponse getRangeSchedule(User user, LocalDate startDate, LocalDate endDate) {
 		List<ScheduleHeadResponse.ScheduleHeadDto> scheduleHeadDtos = new ArrayList<>();
 		scheduleRepository.findSchedules(user.getId(), startDate, endDate)
-			.forEach(schedule -> {
-				List<ScheduleRecord> scheduleRecordList = scheduleRecordRepository
-					.findByScheduleAndBetweenStartDateAndEndDate(schedule.getId(), startDate, endDate);
-				scheduleHeadDtos.add(ScheduleMapper.toScheduleHeadDto(schedule, scheduleRecordList));
-			});
+				.forEach(schedule -> {
+					List<ScheduleRecord> scheduleRecordList = scheduleRecordRepository
+							.findByScheduleAndBetweenStartDateAndEndDate(schedule.getId(), startDate, endDate);
+					scheduleHeadDtos.add(ScheduleMapper.toScheduleHeadDto(schedule, scheduleRecordList));
+				});
 		return ScheduleMapper.toScheduleHeadResponse(startDate, endDate, scheduleHeadDtos);
 	}
 
 	@Transactional(readOnly = true)
 	public ScheduleInfoResponse getSchedule(Long scheduleRecordId) {
 		return scheduleRecordRepository.findScheduleRecordFetchJoinSchedule(scheduleRecordId)
-			.map(ScheduleMapper::toScheduleInfoResponse)
-			.orElseThrow(() -> CommonException.from(ExceptionCode.NOT_FOUND_SCHEDULE_RECORD));
+				.map(ScheduleMapper::toScheduleInfoResponse)
+				.orElseThrow(() -> CommonException.from(ExceptionCode.NOT_FOUND_SCHEDULE_RECORD));
 	}
 
 	public Optional<Schedule> getScheduleById(Long scheduleId) {
@@ -56,7 +56,7 @@ public Optional<Schedule> getScheduleById(Long scheduleId) {
 
 	public Schedule validateScheduleById(Long scheduleId) {
 		return scheduleRepository.findById(scheduleId)
-			.orElseThrow(() -> CommonException.from(ExceptionCode.NOT_FOUND_SCHEDULE));
+				.orElseThrow(() -> CommonException.from(ExceptionCode.NOT_FOUND_SCHEDULE));
 	}
 
 	@Transactional(readOnly = true)
@@ -80,16 +80,19 @@ public long getSchedulesCountByDateRange(final LocalDate startDate, final LocalD
 
 	@Transactional(readOnly = true)
 	public Map<LocalDate, Long> getSchedulesCountByDateRangeGroupByDate(
-		final LocalDate startDate,
-		final LocalDate endDate
-	) {
+			final LocalDate startDate,
+			final LocalDate endDate) {
 		LocalDateTime startDateTime = startDate.atStartOfDay();
 		LocalDateTime endDateTime = endDate.atTime(LocalTime.MAX);
 
 		List<DailyCount> dailyCounts = scheduleRepository.countByCreatedAtBetweenGroupByDate(
-			startDateTime, endDateTime
-		);
+				startDateTime, endDateTime);
 
 		return dailyCounts.stream().collect(Collectors.toMap(DailyCount::date, DailyCount::count));
 	}
+
+	@Transactional(readOnly = true)
+	public List<Schedule> findActiveSchedulesWithAlarmForDates(final LocalDate startDate, final LocalDate endDate) {
+		return scheduleRepository.findActiveSchedulesWithAlarmForDates(startDate, endDate);
+	}
 }