wrap database job with spring scheduler

settings.gradle.kts

@@ -9,4 +9,3 @@
 
 rootProject.name = "coding-problems-bot"
 include("telegram-bot")
-include("app-db")

telegram-bot/build.gradle.kts

@@ -1,7 +1,6 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    // Apply the org.jetbrains.kotlin.jvm Plugin to add support for Kotlin.
     id("org.jetbrains.kotlin.jvm") version "1.4.20"
     id("org.springframework.boot") version "2.4.0"
     id("io.spring.dependency-management") version "1.0.10.RELEASE"
@@ -26,10 +25,8 @@ val flexmarkVersion = "0.62.2"
 val h2r2dbcVersion = "0.8.4.RELEASE"
 
 dependencies {
-    // Align versions of all Kotlin components
     implementation(platform("org.jetbrains.kotlin:kotlin-bom"))
 
-    //jackson support
     implementation(platform("com.fasterxml.jackson:jackson-bom:$jacksonVersion"))
     implementation("com.fasterxml.jackson.core:jackson-databind")
     implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
@@ -38,37 +35,30 @@ dependencies {
     implementation("org.jetbrains.kotlin:kotlin-reflect")
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
 
-    // Coroutines support
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$xCoroutinesVersion")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:$xCoroutinesVersion")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")
 
 
-    // Logging framework
     implementation("ch.qos.logback:logback-core:$logbackVersion")
     implementation("ch.qos.logback:logback-classic:$logbackVersion")
     implementation("org.slf4j:slf4j-api:$slf4jVersion")
 
-    // This dependency is used by the application.
     implementation("com.google.guava:guava:29.0-jre")
     implementation("dev.inmo:tgbotapi:$tgbotapiVersion")
     implementation("com.codeborne:selenide:$selenideVersion")
     implementation("com.vladsch.flexmark:flexmark-all:$flexmarkVersion")
-
-    // spring
     implementation("org.springframework.boot:spring-boot-starter-data-r2dbc")
     implementation("org.springframework.boot:spring-boot-starter-webflux")
-
-    // database
     implementation("io.r2dbc:r2dbc-h2:$h2r2dbcVersion")
-    // Use JUnit 5 for testing.
+
     testImplementation(platform("org.junit:junit-bom:$junitVersion"))
     testRuntimeOnly(platform("org.junit:junit-bom:$junitVersion"))
     testImplementation("org.junit.jupiter:junit-jupiter-api")
     testImplementation("org.junit.jupiter:junit-jupiter-params")
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
-
     testImplementation("io.projectreactor:reactor-test")
+    testImplementation("org.springframework.boot:spring-boot-starter-test")
 
 }
 
@@ -83,4 +73,3 @@ tasks {
         useJUnitPlatform()
     }
 }
-

telegram-bot/src/main/kotlin/by/jprof/coding/problems/bot/App.kt

@@ -1,26 +1,10 @@
 package by.jprof.coding.problems.bot
 
-import by.jprof.coding.problems.bot.repository.ProblemRepository
-import by.jprof.coding.problems.bot.scraper.LeetCodeProblemsScraper
-import org.springframework.boot.CommandLineRunner
 import org.springframework.boot.autoconfigure.SpringBootApplication
 import org.springframework.boot.runApplication
 
 @SpringBootApplication
-class App(
-    private val scraper: LeetCodeProblemsScraper,
-    private val problemRepository: ProblemRepository
-) : CommandLineRunner {
-
-
-
-    override fun run(vararg args: String?) {
-        problemRepository.saveAll(scraper.scrapeAllLeetCodeProblems())
-        TODO("finish")
-    }
-
-}
-
+class App
 
 fun main(args: Array<String>) {
     runApplication<App>(*args)

telegram-bot/src/main/kotlin/by/jprof/coding/problems/bot/config/ApplicationConfiguration.kt

@@ -1,20 +1,18 @@
 package by.jprof.coding.problems.bot.config
 
 import dev.inmo.tgbotapi.bot.Ktor.telegramBot
-import dev.inmo.tgbotapi.bot.RequestsExecutor
 import dev.inmo.tgbotapi.bot.TelegramBot
-import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
-import dev.inmo.tgbotapi.types.message.abstracts.Message
-import dev.inmo.tgbotapi.types.message.content.TextContent
 import io.r2dbc.spi.ConnectionFactories
 import io.r2dbc.spi.ConnectionFactory
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
 import org.springframework.data.r2dbc.config.AbstractR2dbcConfiguration
 import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories
+import org.springframework.scheduling.annotation.EnableScheduling
 
 @Configuration
 @EnableR2dbcRepositories
+@EnableScheduling
 class ApplicationConfiguration : AbstractR2dbcConfiguration() {
     companion object {
         val BOT_TOKEN = System.getenv("BOT_TOKEN")!!
@@ -30,4 +28,3 @@ class ApplicationConfiguration : AbstractR2dbcConfiguration() {
     }
 }
 
-val Message.text get() = ((this as? ContentMessage<*>)?.content as? TextContent)?.text

telegram-bot/src/main/kotlin/by/jprof/coding/problems/bot/domain/domain.kt

@@ -1,22 +1,39 @@
 package by.jprof.coding.problems.bot.domain
 
 import org.springframework.data.annotation.Id
+import org.springframework.data.domain.Persistable
 import org.springframework.data.relational.core.mapping.Table
+import java.util.*
 
 
-class Platforms {
-    companion object {
-        const val LEETCODE = "Leetcode"
-    }
+enum class Platform(val platform: String) {
+    LEETCODE("Leetcode")
+}
+
+enum class Messenger(val messenger: String) {
+    TELEGRAM("Telegram")
 }
 
 @Table
 data class Problem(
-    @Id
-    val id: String,
+    @Id @JvmField var id: String,
     val link: String,
     val title: String,
-    val acceptance: Float?,
+    val acceptance: String?,
     val difficulty: String,
-    val platform: String = Platforms.LEETCODE
+    val platform: String = Platform.LEETCODE.platform
+) : Persistable<String> {
+    override fun getId(): String = id
+
+    override fun isNew(): Boolean {
+        val new = id.isEmpty()
+        id = if (new) UUID.randomUUID().toString() else id
+        return new
+    }
+
+}
+
+data class Chat(
+    val id: String,
+    val messenger: String = Messenger.TELEGRAM.messenger
 )

telegram-bot/src/main/kotlin/by/jprof/coding/problems/bot/ext/tgbotapi.kt

@@ -0,0 +1,7 @@
+package by.jprof.coding.problems.bot.ext
+
+import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
+import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.message.content.TextContent
+
+val Message.text get() = ((this as? ContentMessage<*>)?.content as? TextContent)?.text

telegram-bot/src/main/kotlin/by/jprof/coding/problems/bot/hook/WebhookListener.kt

@@ -3,22 +3,22 @@ package by.jprof.coding.problems.bot.hook
 import by.jprof.coding.problems.bot.service.TgUpdateHandlingService
 import dev.inmo.tgbotapi.types.update.abstracts.Update
 import org.springframework.http.HttpStatus
-import org.springframework.http.MediaType
-import org.springframework.web.bind.annotation.RequestMapping
-import org.springframework.web.bind.annotation.RequestMethod
+import org.springframework.http.MediaType.APPLICATION_JSON_VALUE
+import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.ResponseStatus
 import org.springframework.web.bind.annotation.RestController
-import reactor.core.publisher.Mono
 
 @RestController
-@RequestMapping("/")
 class WebhookListener(private val tgUpdateHandlingService: TgUpdateHandlingService) {
+    companion object {
+        private val EMPTY_JSON_BODY = "{}"
+    }
 
-    @RequestMapping(method = [RequestMethod.POST], produces = [MediaType.APPLICATION_JSON_VALUE])
+    @PostMapping(produces = [APPLICATION_JSON_VALUE], consumes = [APPLICATION_JSON_VALUE])
     @ResponseStatus(HttpStatus.OK)
-    suspend fun processUpdate(update: Update) : Mono<String> {
-        tgUpdateHandlingService.handleUpdate(update);
-        return Mono.just("{}")
+    suspend fun processUpdate(update: Update) : String {
+        tgUpdateHandlingService.handleUpdate(update)
+        return EMPTY_JSON_BODY
     }
 
 }

telegram-bot/src/main/kotlin/by/jprof/coding/problems/bot/projection/projection.kt

@@ -0,0 +1,5 @@
+package by.jprof.coding.problems.bot.projection
+
+interface ProblemLink {
+    fun getLink(): String
+}

telegram-bot/src/main/kotlin/by/jprof/coding/problems/bot/repository/ProblemRepository.kt

@@ -1,6 +1,10 @@
 package by.jprof.coding.problems.bot.repository
 
 import by.jprof.coding.problems.bot.domain.Problem
+import by.jprof.coding.problems.bot.projection.ProblemLink
+import kotlinx.coroutines.flow.Flow
 import org.springframework.data.repository.kotlin.CoroutineCrudRepository
 
-interface ProblemRepository : CoroutineCrudRepository<Problem, String>
+interface ProblemRepository : CoroutineCrudRepository<Problem, String> {
+    fun findAllProjectedBy() : Flow<ProblemLink>
+}

telegram-bot/src/main/kotlin/by/jprof/coding/problems/bot/scraper/LeetCodeProblemsScraper.kt

@@ -1,11 +1,11 @@
 package by.jprof.coding.problems.bot.scraper
 
 import by.jprof.coding.problems.bot.domain.Problem
+import com.codeborne.selenide.Selenide.closeWebDriver
 import com.codeborne.selenide.Selenide.open
 import com.vladsch.flexmark.html2md.converter.FlexmarkHtmlConverter
 import org.openqa.selenium.chrome.ChromeDriverService
 import org.springframework.stereotype.Component
-import java.util.*
 import java.util.logging.Level
 import java.util.logging.Logger
 import kotlin.streams.toList
@@ -20,7 +20,7 @@ class LeetCodeProblemsScraper {
         const val BASE_URL = "https://leetcode.com/problemset/algorithms"
     }
 
-    fun scrapeAllLeetCodeProblems() : List<Problem> {
+    fun scrapeAllLeetCodeProblems() : List<Problem> = try {
         configureBrowser()
 
         open(BASE_URL)
@@ -29,17 +29,19 @@ class LeetCodeProblemsScraper {
 
         val rows = findAll("#question-app table tbody.reactable-data tr")
 
-        return rows.stream().map { row ->
+        rows.stream().map { row ->
             val columns = row.findAll("td")
             val anchorTag = columns[2].find("a")
             Problem(
-                id = UUID.randomUUID().toString(),
+                id = "",
                 title = anchorTag.ownText,
-                link = BASE_URL + anchorTag.attr("href")!!,
-                acceptance = columns[4].ownText.toFloat(),
-                difficulty = columns[5].ownText
+                link = anchorTag.attr("href")!!,
+                acceptance = columns[4].ownText,
+                difficulty = columns[5].find("span").ownText
             )
         }.toList()
+    } finally {
+        closeWebDriver()
     }
 
     private fun configureBrowser() {

telegram-bot/src/main/kotlin/by/jprof/coding/problems/bot/service/TgUpdateHandlingService.kt

@@ -1,6 +1,6 @@
 package by.jprof.coding.problems.bot.service
 
-import by.jprof.coding.problems.bot.config.text
+import by.jprof.coding.problems.bot.ext.text
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.extensions.api.send.sendMessage
 import dev.inmo.tgbotapi.types.update.MessageUpdate
@@ -12,7 +12,7 @@ class TgUpdateHandlingService(private val telegramBot: TelegramBot) {
     suspend fun handleUpdate(update: Update) {
         if (update is MessageUpdate) {
             update.data.text?.let {
-                telegramBot.sendMessage(update.data.chat.id, it)
+                telegramBot.sendMessage(update.data.chat.id, "echo $it")
             }
         }
     }