[Feature] Bloomed & RAIN_FORECAST_ALERT Push Notification

pida-clients/weather-client/src/main/kotlin/com/pida/client/weather/WeatherServiceImpl.kt

@@ -9,6 +9,7 @@ import com.pida.weather.Weather
 import com.pida.weather.WeatherLocation
 import com.pida.weather.WeatherService
 import org.springframework.stereotype.Service
+import java.time.LocalDate
 import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter
 import kotlin.math.abs
@@ -21,34 +22,37 @@ class WeatherServiceImpl(
     private val kmaWeatherClient: KmaWeatherClient,
 ) : WeatherService {
     private val logger by logger()
+    private val dateFormatter = DateTimeFormatter.ofPattern("yyyyMMdd")
 
     override fun getWeather(location: WeatherLocation): Weather {
-        val (baseDate, baseTime) = kmaWeatherClient.getLatestBaseTime()
+        val items = fetchForecastItems(location)
+        return parseWeatherResponse(items, location)
+    }
 
-        logger.info(
-            "Fetching weather for location: lat=${location.latitude}, lon=${location.longitude}, nx=${location.nx}, ny=${location.ny}",
-        )
+    override fun getTomorrowMaxPrecipitationProbability(location: WeatherLocation): Int {
+        val items = fetchForecastItems(location)
 
-        val response =
-            try {
-                kmaWeatherClient.getVilageForecast(baseDate, baseTime, location.nx, location.ny)
-            } catch (error: Exception) {
-                logger.error("Failed to fetch weather forecast", error)
-                throw ErrorException(ErrorType.WEATHER_API_CALL_FAILED)
-            }
+        if (items.isEmpty()) {
+            logger.warn("KMA response contains no forecast items for nx=${location.nx}, ny=${location.ny}")
+            throw ErrorException(ErrorType.WEATHER_DATA_NOT_AVAILABLE)
+        }
+
+        val tomorrowDate = LocalDate.now().plusDays(1).format(dateFormatter)
 
-        return parseWeatherResponse(response, location)
+        return items
+            .asSequence()
+            .filter { it.category == "POP" && it.fcstDate == tomorrowDate }
+            .mapNotNull { it.fcstValue.toIntOrNull() }
+            .maxOrNull() ?: 0
     }
 
     /**
      * 기상청 API 응답을 Weather 도메인 모델로 변환
      */
     private fun parseWeatherResponse(
-        response: KmaWeatherResponse,
+        items: List<KmaWeatherResponse.Item>,
         location: WeatherLocation,
     ): Weather {
-        val items = response.response.body.items.item
-
         if (items.isEmpty()) {
             logger.warn("KMA response contains no forecast items for nx=${location.nx}, ny=${location.ny}")
             throw ErrorException(ErrorType.WEATHER_DATA_NOT_AVAILABLE)
@@ -102,6 +106,24 @@ class WeatherServiceImpl(
         )
     }
 
+    private fun fetchForecastItems(location: WeatherLocation): List<KmaWeatherResponse.Item> {
+        val (baseDate, baseTime) = kmaWeatherClient.getLatestBaseTime()
+
+        logger.info(
+            "Fetching weather for location: lat=${location.latitude}, lon=${location.longitude}, nx=${location.nx}, ny=${location.ny}",
+        )
+
+        val response =
+            try {
+                kmaWeatherClient.getVilageForecast(baseDate, baseTime, location.nx, location.ny)
+            } catch (error: Exception) {
+                logger.error("Failed to fetch weather forecast", error)
+                throw ErrorException(ErrorType.WEATHER_API_CALL_FAILED)
+            }
+
+        return response.response.body.items.item
+    }
+
     /**
      * 예보 일시 파싱 (yyyyMMddHHmm -> LocalDateTime)
      */

pida-core/core-api/build.gradle.kts

@@ -36,6 +36,7 @@ dependencies {
     implementation(libs.spring.boot.starter.web)
     implementation(libs.spring.boot.starter.aop)
     implementation(libs.spring.boot.starter.validation)
+    compileOnly(libs.redisson)
 
     // Security
     implementation(libs.spring.boot.starter.security)

pida-core/core-api/src/main/kotlin/com/pida/presentation/v1/notification/NotificationTestController.kt

@@ -1,11 +1,17 @@
 package com.pida.presentation.v1.notification
 
+import com.pida.notification.bloomed.BloomedNotificationService
+import com.pida.notification.bloomedspot.BloomedSpotNotificationService
+import com.pida.notification.rain.RainForecastNotificationService
 import com.pida.notification.weekday.WeekdayNotificationService
 import com.pida.notification.weekend.WeekendNotificationService
+import com.pida.notification.withered.WitheredNotificationService
+import com.pida.support.geo.Region
 import io.swagger.v3.oas.annotations.Operation
 import io.swagger.v3.oas.annotations.tags.Tag
 import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.RestController
 import java.time.LocalDateTime
 
@@ -15,6 +21,10 @@ import java.time.LocalDateTime
 class NotificationTestController(
     private val weekendNotificationService: WeekendNotificationService,
     private val weekdayNotificationService: WeekdayNotificationService,
+    private val witheredNotificationService: WitheredNotificationService,
+    private val bloomedNotificationService: BloomedNotificationService,
+    private val bloomedSpotNotificationService: BloomedSpotNotificationService,
+    private val rainForecastNotificationService: RainForecastNotificationService,
 ) {
     @PostMapping("/weekend-notification")
     @Operation(
@@ -48,6 +58,83 @@ class NotificationTestController(
         )
     }
 
+    @PostMapping("/withered-notification")
+    @Operation(
+        summary = "저물었어요 알림 수동 트리거",
+        description =
+            "WITHERED 상태 푸시 알림을 수동으로 발송합니다. (테스트용)\n\n" +
+                "각 지역별 WITHERED 투표 비율을 확인하여 30% 이상인 지역의 사용자들에게 알림을 발송합니다.",
+    )
+    fun triggerWitheredNotification(): NotificationTriggerResponse {
+        val startTime = LocalDateTime.now()
+
+        witheredNotificationService.sendWitheredNotifications()
+
+        return NotificationTriggerResponse(
+            message = "Withered notification triggered successfully",
+            triggeredAt = startTime,
+        )
+    }
+
+    @PostMapping("/bloomed-notification")
+    @Operation(
+        summary = "만개했어요 알림 수동 트리거",
+        description =
+            "BLOOMED 상태 푸시 알림을 수동으로 발송합니다. (테스트용)\n\n" +
+                "입력한 지역의 사용자들에게 BLOOMED 알림을 수동 발송합니다.",
+    )
+    fun triggerBloomedNotification(
+        @RequestParam region: Region,
+    ): NotificationTriggerResponse {
+        val startTime = LocalDateTime.now()
+
+        bloomedNotificationService.sendBloomedNotificationForRegion(region)
+
+        return NotificationTriggerResponse(
+            message = "Bloomed notification triggered successfully",
+            triggeredAt = startTime,
+        )
+    }
+
+    @PostMapping("/bloomed-spot-notification")
+    @Operation(
+        summary = "벚꽃길 만개 이벤트 알림 수동 트리거",
+        description =
+            "특정 벚꽃길의 BLOOMED 투표 이벤트 알림을 수동 발송합니다. (테스트용)\n\n" +
+                "조건: 반경 3km 내 위치 권한 허용 사용자\n" +
+                "제외: 당일 이미 푸시 수신 사용자, 해당 벚꽃길 시즌 내 알림 기수신 사용자",
+    )
+    fun triggerBloomedSpotNotification(
+        @RequestParam spotId: Long,
+    ): NotificationTriggerResponse {
+        val startTime = LocalDateTime.now()
+
+        bloomedSpotNotificationService.sendBloomedSpotNotification(spotId)
+
+        return NotificationTriggerResponse(
+            message = "Bloomed spot notification triggered successfully",
+            triggeredAt = startTime,
+        )
+    }
+
+    @PostMapping("/rain-forecast-notification")
+    @Operation(
+        summary = "비 예보 알림 수동 트리거",
+        description =
+            "내일 POP(강수확률) 최대값이 60 이상인 위치의 사용자에게 비 예보 알림을 수동 발송합니다. (테스트용)\n\n" +
+                "제외 조건: 당일 다른 푸시 수신 사용자, 당주 이미 비 예보 알림 수신 사용자",
+    )
+    fun triggerRainForecastNotification(): NotificationTriggerResponse {
+        val startTime = LocalDateTime.now()
+
+        rainForecastNotificationService.sendRainForecastNotifications()
+
+        return NotificationTriggerResponse(
+            message = "Rain forecast notification triggered successfully",
+            triggeredAt = startTime,
+        )
+    }
+
     data class NotificationTriggerResponse(
         val message: String,
         val triggeredAt: LocalDateTime,

pida-core/core-api/src/main/kotlin/com/pida/scheduler/BloomedNotificationScheduler.kt

@@ -0,0 +1,28 @@
+package com.pida.scheduler
+
+import com.pida.notification.bloomed.BloomedNotificationService
+import com.pida.support.extension.logger
+import org.springframework.scheduling.annotation.Scheduled
+import org.springframework.stereotype.Component
+
+/**
+ * 만개했어요 알림 스케줄러
+ *
+ * 매일 오전 9시에 실행하여 BLOOMED 비율 80% 이상 지역 알림을 발송합니다.
+ * 하루 1회만 실행되도록 중복 실행을 방지합니다.
+ */
+@Component
+class BloomedNotificationScheduler(
+    private val bloomedNotificationService: BloomedNotificationService,
+) : DailyNotificationScheduler() {
+    private val logger by logger()
+
+    @Scheduled(cron = "0 0 9 * * *")
+    fun executeBloomedNotification() =
+        executeOncePerDay(
+            logger = logger,
+            failureMessage = "Failed to execute bloomed notification scheduler",
+        ) {
+            bloomedNotificationService.sendBloomedNotifications()
+        }
+}

pida-core/core-api/src/main/kotlin/com/pida/scheduler/EveningNotificationScheduler.kt

@@ -0,0 +1,70 @@
+package com.pida.scheduler
+
+import com.pida.notification.rain.RainForecastNotificationService
+import com.pida.support.extension.logger
+import org.springframework.scheduling.annotation.Scheduled
+import org.springframework.stereotype.Component
+import java.time.DayOfWeek
+import java.time.LocalDate
+
+/**
+ * 저녁 푸시 알림 오케스트레이터
+ *
+ * 매일 18:00에 실행되며 분산 락 아래에서 실행 순서를 고정합니다.
+ */
+@Component
+class EveningNotificationScheduler(
+    private val notificationExecutionLock: NotificationExecutionLock,
+    private val weekdayNotificationScheduler: WeekdayNotificationScheduler,
+    private val rainForecastNotificationService: RainForecastNotificationService,
+) {
+    private val logger by logger()
+
+    @Scheduled(cron = "0 0 18 * * *")
+    fun executeEveningNotifications() {
+        val today = LocalDate.now()
+        val result =
+            notificationExecutionLock.runWithEveningLock(date = today) {
+                executeInOrder(today)
+            }
+
+        when (result) {
+            NotificationExecutionLock.ExecutionResult.ACQUIRED -> {
+                logger.info("Evening notification orchestration completed with distributed lock: date=$today")
+            }
+
+            NotificationExecutionLock.ExecutionResult.SKIPPED_BY_CONTENTION -> {
+                logger.info("Skipped evening notification orchestration due to lock contention: date=$today")
+            }
+
+            NotificationExecutionLock.ExecutionResult.FAIL_OPEN -> {
+                logger.warn("Evening notification orchestration executed in fail-open mode: date=$today")
+            }
+        }
+    }
+
+    private fun executeInOrder(today: LocalDate) {
+        if (isWeekday(today.dayOfWeek)) {
+            weekdayNotificationScheduler.executeWeekdayNotification(today)
+        } else {
+            logger.info("Skipping weekday notification flow on weekend: ${today.dayOfWeek}")
+        }
+
+        runSchedulerSafely(
+            logger = logger,
+            failureMessage = "Failed to execute rain forecast notification scheduler",
+        ) {
+            rainForecastNotificationService.sendRainForecastNotifications()
+        }
+    }
+
+    private fun isWeekday(dayOfWeek: DayOfWeek): Boolean =
+        dayOfWeek in
+            setOf(
+                DayOfWeek.MONDAY,
+                DayOfWeek.TUESDAY,
+                DayOfWeek.WEDNESDAY,
+                DayOfWeek.THURSDAY,
+                DayOfWeek.FRIDAY,
+            )
+}

pida-core/core-api/src/main/kotlin/com/pida/scheduler/NotificationExecutionLock.kt

@@ -0,0 +1,89 @@
+package com.pida.scheduler
+
+import com.pida.support.extension.logger
+import org.redisson.api.RedissonClient
+import org.springframework.beans.factory.annotation.Qualifier
+import org.springframework.stereotype.Component
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+import java.util.concurrent.TimeUnit
+
+/**
+ * 저녁 알림 스케줄러 실행 경합 방지를 위한 분산 락
+ */
+@Component
+class NotificationExecutionLock(
+    @param:Qualifier("coreRedissonClient")
+    private val redissonClient: RedissonClient,
+) {
+    private val logger by logger()
+
+    companion object {
+        private val DATE_FORMATTER: DateTimeFormatter = DateTimeFormatter.BASIC_ISO_DATE
+        private const val LOCK_KEY_PREFIX = "notification:evening"
+        private const val WAIT_SECONDS = 1L
+        private const val LEASE_SECONDS = 3600L
+    }
+
+    enum class ExecutionResult {
+        ACQUIRED,
+        SKIPPED_BY_CONTENTION,
+        FAIL_OPEN,
+    }
+
+    fun runWithEveningLock(
+        date: LocalDate = LocalDate.now(),
+        action: () -> Unit,
+    ): ExecutionResult {
+        val lockKey = "$LOCK_KEY_PREFIX:${date.format(DATE_FORMATTER)}"
+
+        val lock =
+            try {
+                redissonClient.getLock(lockKey)
+            } catch (error: RuntimeException) {
+                logger.error(
+                    "Failed to create evening notification lock. Executing action with fail-open: key=$lockKey, date=$date, errorType=${error::class.simpleName}",
+                    error,
+                )
+                action()
+                return ExecutionResult.FAIL_OPEN
+            }
+
+        val acquired =
+            try {
+                lock.tryLock(WAIT_SECONDS, LEASE_SECONDS, TimeUnit.SECONDS)
+            } catch (error: InterruptedException) {
+                Thread.currentThread().interrupt()
+                logger.warn("Interrupted while acquiring evening notification lock: $lockKey", error)
+                return ExecutionResult.SKIPPED_BY_CONTENTION
+            } catch (error: RuntimeException) {
+                logger.error(
+                    "Failed to acquire evening notification lock. Executing action with fail-open: key=$lockKey, date=$date, errorType=${error::class.simpleName}",
+                    error,
+                )
+                action()
+                return ExecutionResult.FAIL_OPEN
+            }
+
+        if (!acquired) {
+            logger.info("Skipped evening notifications due to lock contention: $lockKey")
+            return ExecutionResult.SKIPPED_BY_CONTENTION
+        }
+
+        return try {
+            action()
+            ExecutionResult.ACQUIRED
+        } finally {
+            runCatching {
+                if (lock.isHeldByCurrentThread) {
+                    lock.unlock()
+                }
+            }.onFailure { error ->
+                logger.warn(
+                    "Failed to release evening notification lock: $lockKey, errorType=${error::class.simpleName}",
+                    error,
+                )
+            }
+        }
+    }
+}