Configure allowed number of years back, whether or not to include current year, and initialize sleepingpill cache at startup

Author: chrissearle

backend/src/main/kotlin/no/java/cupcake/Application.kt

@@ -66,6 +66,8 @@ private fun Application.sleepingPillService(bringService: BringService): Sleepin
         client = sleepingPillClient(config),
         bringService = bringService,
         cacheTimeoutSeconds = config.cacheTtlSeconds,
+        maxPastYears = config.maxPastYears,
+        includeCurrentYear = config.includeCurrentYear,
     )
 }
 

backend/src/main/kotlin/no/java/cupcake/config/SleepingPillConfig.kt

@@ -5,4 +5,6 @@ data class SleepingPillConfig(
     val password: String,
     val rootUrl: String,
     val cacheTtlSeconds: Long,
+    val maxPastYears: Long = 3,
+    val includeCurrentYear: Boolean = false
 )

backend/src/main/kotlin/no/java/cupcake/sleepingpill/Conference.kt

@@ -4,6 +4,7 @@ import arrow.core.raise.either
 import arrow.core.raise.ensure
 import kotlinx.serialization.Serializable
 import no.java.cupcake.api.ConferenceIdRequired
+import java.time.Year
 
 @Serializable
 data class Conference(
@@ -18,7 +19,9 @@ data class SleepingPillConference(
     val slug: String,
     val id: String,
     val slottimes: String?,
-)
+) {
+    val year: Year get() = Year.of(name.substringAfterLast(" ").toInt())
+}
 
 @Serializable
 data class SleepingPillConferences(

backend/src/main/kotlin/no/java/cupcake/sleepingpill/SleepingPillService.kt

@@ -19,11 +19,13 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.async
 import kotlinx.coroutines.future.asCompletableFuture
 import kotlinx.coroutines.future.await
+import kotlinx.coroutines.runBlocking
 import no.java.cupcake.api.ApiError
 import no.java.cupcake.api.ErrorResponse
 import no.java.cupcake.api.SleepingPillCallFailed
 import no.java.cupcake.bring.BringService
 import java.time.Duration
+import java.time.Year
 
 private val logger = KotlinLogging.logger {}
 
@@ -36,37 +38,45 @@ class SleepingPillService(
     private val bringService: BringService,
     cacheTimeoutSeconds: Long,
     private val cacheScope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO),
+    private val maxPastYears: Long,
+    private val includeCurrentYear: Boolean,
 ) {
-    private val ttl: Duration =
-        if (cacheTimeoutSeconds <= 0) Duration.ZERO else Duration.ofSeconds(cacheTimeoutSeconds)
+    private val ttl: Duration = if (cacheTimeoutSeconds <= 0) Duration.ZERO else Duration.ofSeconds(cacheTimeoutSeconds)
 
     private val conferencesCache: AsyncLoadingCache<String, List<Conference>> =
-        Caffeine
-            .newBuilder()
-            .apply { if (!ttl.isZero) expireAfterWrite(ttl) }
-            .buildAsync { _, _ ->
-                cacheScope
-                    .async {
-                        uncachedConferencesEither().fold(
-                            ifLeft = { throw ApiErrorException(it) },
-                            ifRight = { it },
-                        )
-                    }.asCompletableFuture()
-            }
+        Caffeine.newBuilder().apply { if (!ttl.isZero) expireAfterWrite(ttl) }.buildAsync { _, _ ->
+            cacheScope
+                .async {
+                    uncachedConferencesEither().fold(
+                        ifLeft = { throw ApiErrorException(it) },
+                        ifRight = { it },
+                    )
+                }.asCompletableFuture()
+        }
 
     private val sessionsCache: AsyncLoadingCache<ConferenceId, List<Session>> =
-        Caffeine
-            .newBuilder()
-            .apply { if (!ttl.isZero) expireAfterWrite(ttl) }
-            .buildAsync { id, _ ->
-                cacheScope
-                    .async {
-                        uncachedSessionsEither(id).fold(
-                            ifLeft = { throw ApiErrorException(it) },
-                            ifRight = { it },
-                        )
-                    }.asCompletableFuture()
+        Caffeine.newBuilder().apply { if (!ttl.isZero) expireAfterWrite(ttl) }.buildAsync { id, _ ->
+            cacheScope
+                .async {
+                    uncachedSessionsEither(id).fold(
+                        ifLeft = { throw ApiErrorException(it) },
+                        ifRight = { it },
+                    )
+                }.asCompletableFuture()
+        }
+
+    init {
+        runBlocking {
+            either {
+                val conferences = conferences()
+                conferences.forEach { conference ->
+                    sessions(ConferenceId(conference.id).bind())
+                }
+            }.onLeft { error ->
+                logger.warn { "Failed to initialize conferences cache: $error" }
             }
+        }
+    }
 
     private suspend fun uncachedConferencesEither(): Either<ApiError, List<Conference>> =
         either {
@@ -76,7 +86,10 @@ class SleepingPillService(
                 .body<SleepingPillConferences>()
                 .conferences
                 .filterNot { rejectSlugs.contains(it.slug) }
-                .map {
+                .filter {
+                    val now = Year.now()
+                    it.year.isAfter(now.minusYears(maxPastYears + 1)) && (includeCurrentYear || it.year.isBefore(now))
+                }.map {
                     Conference(
                         name = it.name,
                         slug = it.slug,

backend/src/main/resources/application.conf

@@ -31,6 +31,8 @@ sleepingpill {
   password = ${?SP_PASSWORD}
   cache_ttl_seconds = 3600
   cache_ttl_seconds = ${?SP_CACHE_TTL_SECONDS}
+  max_past_years = 3
+  include_current_year = true
 }
 
 bring {

backend/src/test/kotlin/no/java/cupcake/TestExtensions.kt

@@ -101,6 +101,8 @@ fun buildSleepingPillService(
         client = client ?: buildClient(buildMockEngine(fixture, block)),
         bringService = bringService ?: buildBringService(fixture = "/postal_codes.json", postalCodeUrl = "/test"),
         cacheTimeoutSeconds = 10,
+        maxPastYears = 3,
+        includeCurrentYear = true,
     )
 
 fun buildBringService(