update sample files

0.3.0

.github/workflows/build.yml

@@ -1,16 +0,0 @@
-name: Build
-
-on: [push]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v1
-        with:
-          java-version: 11
-      - name: Build with Gradle
-        run: ./gradlew build

.github/workflows/build_and_publish.yml

@@ -0,0 +1,27 @@
+name: Build
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v1
+        with:
+          java-version: 11
+      - name: Rewrite version
+        run: |
+          branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
+          cat gradle.properties | sed -e "s/^version=\([0-9\.]*\)/version=\1-branch_$branch-build${{ github.run_number }}/" > gradle.properties.tmp
+          rm gradle.properties
+          mv gradle.properties.tmp gradle.properties
+      - name: Build
+        run: ./gradlew build
+      - name: Publish
+        continue-on-error: true
+        run: ./gradlew publishAllPublicationsToGiteaRepository
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}

.github/workflows/docker-publish.yml

@@ -0,0 +1,28 @@
+name: Docker
+
+on: [push]
+
+jobs:
+  publishing:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+      - name: Rewrite version
+        run: |
+          branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
+          if [[ "$branch" != "master" ]]; then
+            cat gradle.properties | sed -e "s/^version=\([0-9\.]*\)/version=\1-branch_$branch-build${{ github.run_number }}/" > gradle.properties.tmp
+            rm gradle.properties
+            mv gradle.properties.tmp gradle.properties
+          fi
+      - name: Log into registry
+        uses: docker/login-action@28218f9b04b4f3f62068d7b6ce6ca5b26e35336c
+        with:
+          username: ${{ secrets.DOCKER_LOGIN }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Deploy
+        run: ./gradlew build && cd ./runner && ./nonsudo_deploy.sh

CHANGELOG.md

@@ -0,0 +1,61 @@
+# PlaguPoster
+
+## 0.3.0
+
+* `Versions`:
+  * `tgbotapi`: `9.1.0`
+  * `plagubot`: `7.1.0`
+  * `plagubot-plugins`: `0.14.0`
+
+## 0.2.3
+
+* Add opportunity to use several target chat ids
+* Update dependencies
+
+## 0.2.2
+
+* `GarbageCollector`:
+  * Now on start will all clearing job done
+
+## 0.2.1
+
+* `Versions`:
+  * `kotlin`: `1.8.21`
+  * `tgbotapi`: `7.1.2`
+  * `plagubot`: `5.1.2`
+  * `microutils`: `0.18.1`
+  * `kslog`: `1.1.1`
+  * `plagubot.plugins`: `0.11.2`
+  * `psql`: `42.6.0`
+
+## 0.2.0
+
+* `Versions`:
+  * `tgbotapi`: `7.1.0`
+  * `plagubot`: `5.1.0`
+  * `krontab`: `1.0.0`
+  * `plagubot.plugins`: `0.11.0`
+
+## 0.1.2
+
+* `Versions`:
+  * `kotlin`: `1.8.20`
+  * `plagubot`: `5.0.2`
+  * `microutils`: `0.17.8`
+  * `kslog`: `1.1.1`
+  * `plagubot.plugins`: `0.10.2`
+  * `psql`: `42.6.0`
+
+## 0.1.1
+
+* Update dependencies
+* `Triggers`
+  * `SelectorWithTimer`
+    * Opportunity to get schedule of posts using `publishing_autoschedule` command
+
+## 0.0.10
+
+## 0.0.9
+
+* Update dependencies
+

build.gradle

@@ -23,4 +23,4 @@ allprojects {
 }
 
 apply from: "./extensions.gradle"
-// apply from: "./github_release.gradle"
+apply from: "./github_release.gradle"

changelog_parser.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+function parse() {
+    version="$1"
+
+    while IFS= read -r line && [ -z "`echo "$line" | grep -e "^#\+ $version"`" ]
+    do
+        : # do nothing
+    done
+
+    while IFS= read -r line && [ -z "`echo "$line" | grep -e "^#\+"`" ]
+    do
+        echo "$line"
+    done
+}
+
+version="$1"
+file="$2"
+
+if [ -n "$file" ]; then
+  parse "$version" < "$file"
+else
+  parse "$version"
+fi

common/build.gradle

@@ -11,7 +11,9 @@ kotlin {
             dependencies {
                 api libs.tgbotapi
                 api libs.microutils.repos.common
+                api libs.microutils.repos.cache
                 api libs.kslog
+                api libs.microutils.koin
             }
         }
         jvmMain {

common/src/commonMain/kotlin/ChatConfig.kt

@@ -1,6 +1,5 @@
 package dev.inmo.plaguposter.common
 
-import dev.inmo.tgbotapi.types.ChatId
 import dev.inmo.tgbotapi.types.FullChatIdentifierSerializer
 import dev.inmo.tgbotapi.types.IdChatIdentifier
 import kotlinx.serialization.SerialName
@@ -10,14 +9,26 @@ import kotlinx.serialization.Serializable
 data class ChatConfig(
     @SerialName("targetChat")
     @Serializable(FullChatIdentifierSerializer::class)
-    val targetChatId: IdChatIdentifier,
+    val targetChatId: IdChatIdentifier? = null,
     @SerialName("sourceChat")
     @Serializable(FullChatIdentifierSerializer::class)
     val sourceChatId: IdChatIdentifier,
     @SerialName("cacheChat")
     @Serializable(FullChatIdentifierSerializer::class)
-    val cacheChatId: IdChatIdentifier
+    val cacheChatId: IdChatIdentifier,
+    @SerialName("targetChats")
+    val targetChatIds: List<@Serializable(FullChatIdentifierSerializer::class) IdChatIdentifier> = emptyList(),
 ) {
+    val allTargetChatIds by lazy {
+        listOfNotNull(targetChatId) + targetChatIds
+    }
+
+    init {
+        require(targetChatId != null || targetChatIds.isNotEmpty()) {
+            "One of fields, 'targetChat' or 'targetChats' should be presented"
+        }
+    }
+
     fun check(chatId: IdChatIdentifier) = when (chatId) {
         targetChatId,
         sourceChatId,

common/src/commonMain/kotlin/CommonMessagesCommandsFilter.kt

@@ -2,13 +2,14 @@ package dev.inmo.plaguposter.common
 
 import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.CommonMessageFilterExcludeMediaGroups
 import dev.inmo.tgbotapi.extensions.behaviour_builder.utils.SimpleFilter
+import dev.inmo.tgbotapi.extensions.utils.contentMessageOrNull
 import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
+import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.message.abstracts.*
+import dev.inmo.tgbotapi.types.message.content.TextContent
 import dev.inmo.tgbotapi.types.message.textsources.BotCommandTextSource
 
 val FirstSourceIsCommandsFilter = SimpleFilter<Message> {
-    it is ContentMessage<*> && it.content.textContentOrNull() ?.textSources ?.firstOrNull {
-        it is BotCommandTextSource
-    } != null
+    it.contentMessageOrNull() ?.withContentOrNull<TextContent>() ?.content ?.textSources ?.firstOrNull() is BotCommandTextSource
 }

common/src/commonMain/kotlin/DateTimeSerializer.kt

@@ -1,6 +1,6 @@
 package dev.inmo.plaguposter.common
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.Serializer
 import kotlinx.serialization.builtins.serializer
@@ -8,7 +8,6 @@ import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 
-@Serializer(DateTime::class)
 object DateTimeSerializer : KSerializer<DateTime> {
     override val descriptor: SerialDescriptor = Double.serializer().descriptor
     override fun deserialize(decoder: Decoder): DateTime = DateTime(decoder.decodeDouble())

common/src/commonMain/kotlin/UseCache.kt

@@ -0,0 +1,16 @@
+package dev.inmo.plaguposter.common
+
+import org.koin.core.Koin
+import org.koin.core.module.Module
+import org.koin.core.qualifier.named
+import org.koin.core.scope.Scope
+
+val Scope.useCache: Boolean
+    get() = getOrNull(named("useCache")) ?: false
+
+val Koin.useCache: Boolean
+    get() = getOrNull(named("useCache")) ?: false
+
+fun Module.useCache(useCache: Boolean) {
+    single(named("useCache")) { useCache }
+}

common/src/jvmMain/kotlin/CommonPlugin.kt

@@ -1,6 +1,5 @@
 package dev.inmo.plaguposter.common
 
-import dev.inmo.kslog.common.i
 import dev.inmo.kslog.common.iS
 import dev.inmo.kslog.common.logger
 import dev.inmo.plagubot.Plugin
@@ -10,6 +9,8 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.booleanOrNull
 import org.jetbrains.exposed.sql.Database
 import org.koin.core.Koin
 import org.koin.core.module.Module
@@ -18,12 +19,14 @@ object CommonPlugin : Plugin {
     private val Log = logger
     override fun Module.setupDI(database: Database, params: JsonObject) {
         single { CoroutineScope(Dispatchers.Default + SupervisorJob()) }
+        val useCache = (params["useCache"] as? JsonPrimitive) ?.booleanOrNull ?: true
+        useCache(useCache)
     }
 
     override suspend fun BehaviourContext.setupBotPlugin(koin: Koin) {
         val config = koin.get<ChatConfig>()
 
-        Log.iS { "Target chat info: ${getChat(config.targetChatId)}" }
+        Log.iS { "Target chats info: ${config.allTargetChatIds.map { getChat(it) }.joinToString()}" }
         Log.iS { "Source chat info: ${getChat(config.sourceChatId)}" }
         Log.iS { "Cache chat info: ${getChat(config.cacheChatId)}" }
     }

extensions.gradle

@@ -20,6 +20,6 @@ allprojects {
 
         defaultAndroidSettingsPresetPath = "${rootProject.projectDir.absolutePath}/defaultAndroidSettings.gradle"
 
-        // publishGradlePath = "${rootProject.projectDir.absolutePath}/publish.gradle"
+        publishGradlePath = "${rootProject.projectDir.absolutePath}/publish.gradle"
     }
 }

github_release.gradle

@@ -0,0 +1,31 @@
+private String getCurrentVersionChangelog() {
+    OutputStream changelogDataOS = new ByteArrayOutputStream()
+    exec {
+        commandLine 'chmod', "+x", './changelog_parser.sh'
+    }
+    exec {
+        standardOutput = changelogDataOS
+        commandLine './changelog_parser.sh', "${project.version}", 'CHANGELOG.md'
+    }
+
+    return changelogDataOS.toString().trim()
+}
+
+if (new File(projectDir, "secret.gradle").exists()) {
+    apply from: './secret.gradle'
+    apply plugin: "com.github.breadmoirai.github-release"
+
+    githubRelease {
+        token "${project.property('GITHUB_RELEASE_TOKEN')}"
+
+        owner "InsanusMokrassar"
+        repo "PlaguPoster"
+
+        tagName "v${project.version}"
+        releaseName "${project.version}"
+        targetCommitish "${project.version}"
+
+        body getCurrentVersionChangelog()
+    }
+}
+

gradle.properties

@@ -10,4 +10,4 @@ android.enableJetifier=true
 # Project data
 
 group=dev.inmo
-version=0.0.8
+version=0.4.0

gradle/libs.versions.toml

@@ -1,19 +1,18 @@
 [versions]
 
-kotlin = "1.7.22"
-kotlin-serialization = "1.4.1"
+kotlin = "1.8.22"
+kotlin-serialization = "1.5.1"
 
-plagubot = "3.2.1"
-tgbotapi = "4.2.1"
-microutils = "0.16.1"
-kslog = "0.5.4"
-krontab = "0.8.5"
-tgbotapi-libraries = "0.6.5"
-plagubot-plugins = "0.6.4"
+plagubot = "7.2.1"
+tgbotapi = "9.2.1"
+microutils = "0.19.9"
+kslog = "1.1.2"
+krontab = "2.1.2"
+plagubot-plugins = "0.15.1"
 
-dokka = "1.7.20"
+dokka = "1.8.20"
 
-psql = "42.5.0"
+psql = "42.6.0"
 
 [libraries]
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

mppJavaProject.gradle

@@ -1,7 +1,7 @@
 project.version = "$version"
 project.group = "$group"
 
-// apply from: "$publishGradlePath"
+apply from: "$publishGradlePath"
 
 kotlin {
     jvm {

mppJsProject.gradle

@@ -1,7 +1,7 @@
 project.version = "$version"
 project.group = "$group"
 
-// apply from: "$publishGradlePath"
+apply from: "$publishGradlePath"
 
 kotlin {
     js (IR) {

mppProjectWithSerialization.gradle

@@ -1,7 +1,7 @@
 project.version = "$version"
 project.group = "$group"
 
-// apply from: "$publishGradlePath"
+apply from: "$publishGradlePath"
 
 kotlin {
     jvm()

posts/panel/src/jvmMain/kotlin/Plugin.kt

@@ -4,6 +4,9 @@ import com.benasher44.uuid.uuid4
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.koin.getAllDistinct
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.cached
+import dev.inmo.micro_utils.repos.cache.full.cached
 import dev.inmo.micro_utils.repos.deleteById
 import dev.inmo.micro_utils.repos.id
 import dev.inmo.micro_utils.repos.set
@@ -12,6 +15,7 @@ import dev.inmo.micro_utils.repos.value
 import dev.inmo.plagubot.Plugin
 import dev.inmo.plaguposter.common.ChatConfig
 import dev.inmo.plaguposter.common.UnsuccessfulSymbol
+import dev.inmo.plaguposter.common.useCache
 import dev.inmo.plaguposter.posts.models.PostId
 import dev.inmo.plaguposter.posts.panel.repos.PostsMessages
 import dev.inmo.plaguposter.posts.repo.PostsRepo
@@ -93,7 +97,12 @@ object Plugin : Plugin {
         val chatsConfig = koin.get<ChatConfig>()
         val config = koin.getOrNull<Config>() ?: Config()
         val api = koin.get<PanelButtonsAPI>()
-        val postsMessages = PostsMessages(koin.get(), koin.get())
+        val basePostsMessages = PostsMessages(koin.get(), koin.get())
+        val postsMessages = if (koin.useCache) {
+            basePostsMessages.cached(FullKVCache(), koin.get())
+        } else {
+            basePostsMessages
+        }
 
         postsRepo.newObjectsFlow.subscribeSafelyWithoutExceptions(this) {
             val firstContent = it.content.first()

posts/src/commonMain/kotlin/models/Post.kt

@@ -1,6 +1,6 @@
 package dev.inmo.plaguposter.posts.models
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.plaguposter.common.DateTimeSerializer
 import dev.inmo.tgbotapi.types.ChatId
 import kotlinx.serialization.Serializable

posts/src/commonMain/kotlin/repo/ReadPostsRepo.kt

@@ -1,6 +1,6 @@
 package dev.inmo.plaguposter.posts.repo
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.micro_utils.repos.ReadCRUDRepo
 import dev.inmo.plaguposter.posts.models.*
 import dev.inmo.tgbotapi.types.ChatId

posts/src/commonMain/kotlin/sending/PostPublisher.kt

@@ -18,7 +18,7 @@ class PostPublisher(
     private val bot: TelegramBot,
     private val postsRepo: PostsRepo,
     private val cachingChatId: IdChatIdentifier,
-    private val targetChatId: IdChatIdentifier,
+    private val targetChatIds: List<IdChatIdentifier>,
     private val deleteAfterPosting: Boolean = true
 ) {
     suspend fun publish(postId: PostId) {
@@ -38,17 +38,19 @@ class PostPublisher(
 
         sortedMessagesContents.forEach { (_, contents) ->
             contents.singleOrNull() ?.also {
-                runCatching {
-                    bot.copyMessage(targetChatId, it.chatId, it.messageId)
-                }.onFailure { _ ->
+                targetChatIds.forEach { targetChatId ->
                     runCatching {
-                        bot.forwardMessage(
-                            it.chatId,
-                            targetChatId,
-                            it.messageId
-                        )
-                    }.onSuccess {
-                        bot.copyMessage(targetChatId, it)
+                        bot.copyMessage(targetChatId, it.chatId, it.messageId)
+                    }.onFailure { _ ->
+                        runCatching {
+                            bot.forwardMessage(
+                                it.chatId,
+                                targetChatId,
+                                it.messageId
+                            )
+                        }.onSuccess {
+                            bot.copyMessage(targetChatId, it)
+                        }
                     }
                 }
                 return@forEach
@@ -57,17 +59,23 @@ class PostPublisher(
                 it.order to (bot.forwardMessage(toChatId = cachingChatId, fromChatId = it.chatId, messageId = it.messageId).contentMessageOrNull() ?: return@mapNotNull null)
             }.sortedBy { it.first }.mapNotNull { (_, forwardedMessage) ->
                 forwardedMessage.withContentOrNull<MediaGroupPartContent>() ?: null.also { _ ->
-                    bot.copyMessage(targetChatId, forwardedMessage)
+                    targetChatIds.forEach { targetChatId ->
+                        bot.copyMessage(targetChatId, forwardedMessage)
+                    }
                 }
             }
             resultContents.singleOrNull() ?.also {
-                bot.copyMessage(targetChatId, it)
+                targetChatIds.forEach { targetChatId ->
+                    bot.copyMessage(targetChatId, it)
+                }
                 return@forEach
             } ?: resultContents.chunked(mediaCountInMediaGroup.last).forEach {
-                bot.send(
-                    targetChatId,
-                    it.map { it.content.toMediaGroupMemberTelegramMedia() }
-                )
+                targetChatIds.forEach { targetChatId ->
+                    bot.send(
+                        targetChatId,
+                        it.map { it.content.toMediaGroupMemberTelegramMedia() }
+                    )
+                }
             }
         }
 

posts/src/jvmMain/kotlin/Plugin.kt

@@ -4,6 +4,7 @@ import dev.inmo.kslog.common.logger
 import dev.inmo.kslog.common.w
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.koin.singleWithBinds
 import dev.inmo.micro_utils.repos.deleteById
 import dev.inmo.plagubot.Plugin
 import dev.inmo.plaguposter.common.SuccessfulSymbol
@@ -13,6 +14,8 @@ import dev.inmo.plaguposter.common.ChatConfig
 import dev.inmo.plagubot.plugins.inline.queries.models.Format
 import dev.inmo.plagubot.plugins.inline.queries.models.OfferTemplate
 import dev.inmo.plagubot.plugins.inline.queries.repos.InlineTemplatesRepo
+import dev.inmo.plaguposter.common.useCache
+import dev.inmo.plaguposter.posts.cached.CachedPostsRepo
 import dev.inmo.plaguposter.posts.repo.*
 import dev.inmo.plaguposter.posts.sending.PostPublisher
 import dev.inmo.tgbotapi.extensions.api.delete
@@ -26,7 +29,6 @@ import kotlinx.serialization.json.*
 import org.jetbrains.exposed.sql.Database
 import org.koin.core.Koin
 import org.koin.core.module.Module
-import org.koin.dsl.binds
 
 object Plugin : Plugin {
     @Serializable
@@ -44,14 +46,19 @@ object Plugin : Plugin {
         }
         single { get<Json>().decodeFromJsonElement(Config.serializer(), configJson) }
         single { get<Config>().chats }
-        single { ExposedPostsRepo(database) } binds arrayOf(
-            PostsRepo::class,
-            ReadPostsRepo::class,
-            WritePostsRepo::class,
-        )
+        single { ExposedPostsRepo(database) }
+        singleWithBinds<PostsRepo> {
+            val base = get<ExposedPostsRepo>()
+
+            if (useCache) {
+                CachedPostsRepo(base, get())
+            } else {
+                base
+            }
+        }
         single {
             val config = get<Config>()
-            PostPublisher(get(), get(), config.chats.cacheChatId, config.chats.targetChatId, config.deleteAfterPublishing)
+            PostPublisher(get(), get(), config.chats.cacheChatId, config.chats.allTargetChatIds, config.deleteAfterPublishing)
         }
     }
 

posts/src/jvmMain/kotlin/cached/CachedPostsRepo.kt

@@ -0,0 +1,50 @@
+package dev.inmo.plaguposter.posts.cached
+
+import korlibs.time.DateTime
+import dev.inmo.micro_utils.pagination.FirstPagePagination
+import dev.inmo.micro_utils.pagination.firstPageWithOneElementPagination
+import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
+import dev.inmo.micro_utils.repos.CRUDRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.full.FullCRUDCacheRepo
+import dev.inmo.plaguposter.posts.models.NewPost
+import dev.inmo.plaguposter.posts.models.PostContentInfo
+import dev.inmo.plaguposter.posts.models.PostId
+import dev.inmo.plaguposter.posts.models.RegisteredPost
+import dev.inmo.plaguposter.posts.repo.PostsRepo
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.MessageIdentifier
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+
+class CachedPostsRepo(
+    private val parentRepo: PostsRepo,
+    private val scope: CoroutineScope,
+    private val kvCache: FullKVCache<PostId, RegisteredPost> = FullKVCache()
+) : PostsRepo, CRUDRepo<RegisteredPost, PostId, NewPost> by FullCRUDCacheRepo(
+    parentRepo,
+    kvCache,
+    scope,
+    skipStartInvalidate = false,
+    { it.id }
+) {
+    override val removedPostsFlow: Flow<RegisteredPost> by parentRepo::removedPostsFlow
+
+    override suspend fun getIdByChatAndMessage(chatId: IdChatIdentifier, messageId: MessageIdentifier): PostId? {
+        doForAllWithNextPaging(firstPageWithOneElementPagination) {
+            kvCache.values(it).also {
+                it.results.forEach {
+                    return it.takeIf {
+                        it.content.any { it.chatId == chatId && it.messageId == messageId }
+                    } ?.id ?: return@forEach
+                }
+            }
+        }
+
+        return null
+    }
+
+    override suspend fun getPostCreationTime(postId: PostId): DateTime? = getById(postId) ?.created
+
+    override suspend fun getFirstMessageInfo(postId: PostId): PostContentInfo? = getById(postId) ?.content ?.firstOrNull()
+}

posts/src/jvmMain/kotlin/exposed/ExposedPostsRepo.kt

@@ -1,7 +1,7 @@
 package dev.inmo.plaguposter.posts.exposed
 
 import com.benasher44.uuid.uuid4
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.micro_utils.repos.KeyValuesRepo
 import dev.inmo.micro_utils.repos.UpdatedValuePair
 import dev.inmo.micro_utils.repos.exposed.AbstractExposedCRUDRepo

posts_registrar/src/jvmMain/kotlin/Plugin.kt

@@ -18,85 +18,95 @@ import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextWithFSM
 import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.strictlyOn
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.utils.extensions.raw.text
 import dev.inmo.tgbotapi.extensions.utils.extensions.sameChat
 import dev.inmo.tgbotapi.extensions.utils.extensions.sameMessage
-import dev.inmo.tgbotapi.extensions.utils.formatting.buildEntities
 import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
-import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
-import dev.inmo.tgbotapi.types.message.content.MediaGroupContent
-import dev.inmo.tgbotapi.types.message.content.MessageContent
 import dev.inmo.tgbotapi.utils.regular
+import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.*
 import kotlinx.serialization.Serializable
 import org.koin.core.Koin
 
 @Serializable
 object Plugin : Plugin {
+    @Serializable
+    data class Config(
+        val useInlineFinishingOpportunity: Boolean = true
+    )
+
     override suspend fun BehaviourContextWithFSM<State>.setupBotPlugin(koin: Koin) {
         val config = koin.get<ChatConfig>()
         val postsRepo = koin.get<PostsRepo>()
 
-        strictlyOn {state: RegistrationState.InProcess ->
+        strictlyOn { state: RegistrationState.InProcess ->
             val buttonUuid = "finish"
 
-            val messageToDelete = send(
-                state.context,
-                dev.inmo.tgbotapi.utils.buildEntities {
-                    if (state.messages.isNotEmpty()) {
-                        regular("Your message(s) has been registered. You may send new ones or push \"Finish\" to finalize your post")
+            val suggestionMessageDeferred = async {
+                send(
+                    state.context,
+                    dev.inmo.tgbotapi.utils.buildEntities {
+                        if (state.messages.isNotEmpty()) {
+                            regular("Your message(s) has been registered. You may send new ones or push \"Finish\" to finalize your post")
+                        } else {
+                            regular("Ok, send me your messages for new post")
+                        }
+                    },
+                    replyMarkup = if (state.messages.isNotEmpty()) {
+                        flatInlineKeyboard {
+                            dataButton(
+                                "Finish",
+                                buttonUuid
+                            )
+                        }
                     } else {
-                        regular("Ok, send me your messages for new post")
+                        null
                     }
-                },
-                replyMarkup = if (state.messages.isNotEmpty()) {
-                    flatInlineKeyboard {
-                        dataButton(
-                            "Finish",
-                            buttonUuid
-                        )
-                    }
-                } else {
-                    null
-                }
-            )
+                )
+            }
 
-            val newMessagesInfo = firstOf {
+            firstOf {
                 add {
-                    listOf(
-                        waitContentMessage().filter {
-                            it.chat.id == state.context && it.content.textContentOrNull() ?.text != "/finish_post"
-                        }.take(1).first()
-                    )
+                    val receivedMessage = waitAnyContentMessage().filter {
+                        it.sameChat(state.context)
+                    }.first()
+
+                    when  {
+                        receivedMessage.content.textContentOrNull() ?.text == "/finish_post" -> {
+                            val messageToDelete = suggestionMessageDeferred.await()
+                            edit(messageToDelete, "Ok, finishing your request")
+                            RegistrationState.Finish(
+                                state.context,
+                                state.messages
+                            )
+                        }
+                        else -> {
+                            RegistrationState.InProcess(
+                                state.context,
+                                state.messages + PostContentInfo.fromMessage(receivedMessage)
+                            ).also {
+                                runCatchingSafely {
+                                    suggestionMessageDeferred.cancel()
+                                }
+                                runCatchingSafely {
+                                    delete(suggestionMessageDeferred.await())
+                                }
+                            }
+                        }
+                    }
                 }
                 add {
+                    val messageToDelete = suggestionMessageDeferred.await()
                     val finishPressed = waitMessageDataCallbackQuery().filter {
                         it.message.sameMessage(messageToDelete) && it.data == buttonUuid
                     }.first()
-                    emptyList<ContentMessage<MessageContent>>()
-                }
-                add {
-                    val finishPressed = waitTextMessage().filter {
-                        it.sameChat(messageToDelete) && it.content.text == "/finish_post"
-                    }.first()
-                    emptyList<ContentMessage<MessageContent>>()
-                }
-            }.ifEmpty {
-                edit(messageToDelete, "Ok, finishing your request")
-                return@strictlyOn RegistrationState.Finish(
-                    state.context,
-                    state.messages
-                )
-            }.flatMap {
-                PostContentInfo.fromMessage(it)
-            }
 
-            RegistrationState.InProcess(
-                state.context,
-                state.messages + newMessagesInfo
-            ).also {
-                delete(messageToDelete)
+                    edit(messageToDelete, "Ok, finishing your request")
+                    RegistrationState.Finish(
+                        state.context,
+                        state.messages
+                    )
+                }
             }
         }
 
@@ -109,12 +119,12 @@ object Plugin : Plugin {
             null
         }
 
-        onCommand("start_post", initialFilter = { it.chat.id == config.sourceChatId }) {
+        onCommand("start_post", initialFilter = { it.sameChat(config.sourceChatId) }) {
             startChain(RegistrationState.InProcess(it.chat.id, emptyList()))
         }
 
         onContentMessage(
-            initialFilter = { it.chat.id == config.sourceChatId && !FirstSourceIsCommandsFilter(it) }
+            initialFilter = { it.sameChat(config.sourceChatId) && !FirstSourceIsCommandsFilter(it) }
         ) {
             startChain(RegistrationState.Finish(it.chat.id, PostContentInfo.fromMessage(it)))
         }

publish.gradle

@@ -0,0 +1,82 @@
+apply plugin: 'maven-publish'
+
+task javadocsJar(type: Jar) {
+    classifier = 'javadoc'
+}
+
+publishing {
+    publications.all {
+        artifact javadocsJar
+
+        pom {
+            description = "${project.name}"
+            name = "${project.name}"
+            url = "https://github.com/InsanusMokrassar/PlaguPoster"
+
+            scm {
+                developerConnection = "scm:git:[fetch=]https://github.com/InsanusMokrassar/PlaguPoster.git[push=]https://github.com/InsanusMokrassar/PlaguPoster.git"
+                url = "https://github.com/InsanusMokrassar/PlaguPoster.git"
+            }
+
+            developers {
+                
+                    developer {
+                        id = "InsanusMokrassar"
+                        name = "Aleksei Ovsiannikov"
+                        email = "ovsyannikov.alexey95@gmail.com"
+                    }
+                
+            }
+
+            licenses {
+                
+            }
+        }
+        repositories {
+            if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
+                maven {
+                    name = "Gitea"
+                    url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
+            
+                    credentials(HttpHeaderCredentials) {
+                        name = "Authorization"
+                        value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
+                    }
+            
+                    authentication {
+                        header(HttpHeaderAuthentication)
+                    }
+            
+                }
+            }
+            if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+                maven {
+                    name = "sonatype"
+                    url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+            
+                    credentials {
+                        username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+                        password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+                    }
+            
+                }
+            }
+        }
+    }
+}
+    
+if (project.hasProperty("signing.gnupg.keyName")) {
+    apply plugin: 'signing'
+    
+    signing {
+        useGpgCmd()
+    
+        sign publishing.publications
+    }
+    
+    task signAll {
+        tasks.withType(Sign).forEach {
+            dependsOn(it)
+        }
+    }
+}

publish.kpsb

@@ -0,0 +1 @@
+{"licenses":[],"mavenConfig":{"name":"${project.name}","description":"${project.name}","url":"https://github.com/InsanusMokrassar/PlaguPoster","vcsUrl":"https://github.com/InsanusMokrassar/PlaguPoster.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"Gitea","url":"https://git.inmo.dev/api/packages/InsanusMokrassar/maven","credsType":{"type":"dev.inmo.kmppscriptbuilder.core.models.MavenPublishingRepository.CredentialsType.HttpHeaderCredentials","headerName":"Authorization","headerValueProperty":"GITEA_TOKEN"}},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}

ratings/gc/src/jvmMain/kotlin/Plugin.kt

@@ -1,18 +1,19 @@
 package dev.inmo.plaguposter.ratings.gc
 
-import com.soywiz.klock.milliseconds
-import com.soywiz.klock.seconds
+import korlibs.time.DateTime
+import korlibs.time.seconds
 import dev.inmo.krontab.KrontabTemplate
 import dev.inmo.krontab.toSchedule
-import dev.inmo.krontab.utils.asFlow
+import dev.inmo.krontab.utils.asFlowWithDelays
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.plagubot.Plugin
+import dev.inmo.plaguposter.posts.models.PostId
 import dev.inmo.plaguposter.posts.repo.PostsRepo
 import dev.inmo.plaguposter.ratings.models.Rating
 import dev.inmo.plaguposter.ratings.repo.RatingsRepo
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
-import dev.inmo.tgbotapi.types.MilliSeconds
 import dev.inmo.tgbotapi.types.Seconds
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.*
@@ -43,21 +44,35 @@ object Plugin : Plugin {
         val config = koin.get<Config>()
 
         config.immediateDrop ?.let { toDrop ->
-            ratingsRepo.onNewValue.subscribeSafelyWithoutExceptions(this) {
-                if (it.value <= toDrop) {
-                    postsRepo.deleteById(it.id)
+            suspend fun checkAndOptionallyDrop(postId: PostId, rating: Rating) {
+                if (rating <= toDrop) {
+                    postsRepo.deleteById(postId)
                 }
             }
+            ratingsRepo.getAll().forEach {
+                runCatchingSafely {
+                    checkAndOptionallyDrop(it.key, it.value)
+                }
+            }
+            ratingsRepo.onNewValue.subscribeSafelyWithoutExceptions(this) {
+                checkAndOptionallyDrop(it.first, it.second)
+            }
         }
         config.autoclear ?.let { autoclear ->
-            autoclear.autoClearKrontab.toSchedule().asFlow().subscribeSafelyWithoutExceptions(scope) {
-                val dropCreatedBefore = it - (autoclear.skipPostAge ?: 0).seconds
+            suspend fun doAutoClear() {
+                val dropCreatedBefore = DateTime.now() - (autoclear.skipPostAge ?: 0).seconds
                 ratingsRepo.getPostsWithRatingLessEq(autoclear.rating).keys.forEach {
                     if ((postsRepo.getPostCreationTime(it) ?: return@forEach) < dropCreatedBefore) {
                         postsRepo.deleteById(it)
                     }
                 }
             }
+            runCatchingSafely {
+                doAutoClear()
+            }
+            autoclear.autoClearKrontab.toSchedule().asFlowWithDelays().subscribeSafelyWithoutExceptions(scope) {
+                doAutoClear()
+            }
         }
     }
 }

ratings/selector/src/commonMain/kotlin/DefaultSelector.kt

@@ -1,6 +1,6 @@
 package dev.inmo.plaguposter.ratings.selector
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.plaguposter.posts.models.PostId
 import dev.inmo.plaguposter.posts.repo.PostsRepo
 import dev.inmo.plaguposter.ratings.repo.RatingsRepo
@@ -11,11 +11,11 @@ class DefaultSelector (
     private val ratingsRepo: RatingsRepo,
     private val postsRepo: PostsRepo
 ) : Selector {
-    override suspend fun take(n: Int, now: DateTime): List<PostId> {
+    override suspend fun take(n: Int, now: DateTime, exclude: List<PostId>): List<PostId> {
         val result = mutableListOf<PostId>()
 
         do {
-            val selected = config.active(now.time) ?.rating ?.select(ratingsRepo, postsRepo, result, now) ?: break
+            val selected = config.active(now.time) ?.rating ?.select(ratingsRepo, postsRepo, result + exclude, now) ?: break
             result.add(selected)
         } while (result.size < n)
 

ratings/selector/src/commonMain/kotlin/Selector.kt

@@ -1,8 +1,8 @@
 package dev.inmo.plaguposter.ratings.selector
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.plaguposter.posts.models.PostId
 
 interface Selector {
-    suspend fun take(n: Int = 1, now: DateTime = DateTime.now()): List<PostId>
+    suspend fun take(n: Int = 1, now: DateTime = DateTime.now(), exclude: List<PostId> = emptyList()): List<PostId>
 }

ratings/selector/src/commonMain/kotlin/models/RatingConfig.kt

@@ -1,7 +1,7 @@
 package dev.inmo.plaguposter.ratings.selector.models
 
-import com.soywiz.klock.DateTime
-import com.soywiz.klock.seconds
+import korlibs.time.DateTime
+import korlibs.time.seconds
 import dev.inmo.micro_utils.pagination.FirstPagePagination
 import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.utils.getAllByWithNextPaging

ratings/selector/src/commonMain/kotlin/models/SelectorConfig.kt

@@ -1,7 +1,7 @@
 package dev.inmo.plaguposter.ratings.selector.models
 
-import com.soywiz.klock.DateTime
-import com.soywiz.klock.Time
+import korlibs.time.DateTime
+import korlibs.time.Time
 import kotlinx.serialization.Serializable
 
 @Serializable

ratings/selector/src/commonMain/kotlin/models/TimeConfig.kt

@@ -1,6 +1,6 @@
 package dev.inmo.plaguposter.ratings.selector.models
 
-import com.soywiz.klock.*
+import korlibs.time.*
 import kotlinx.serialization.*
 import kotlinx.serialization.builtins.serializer
 import kotlinx.serialization.descriptors.SerialDescriptor

ratings/source/src/commonMain/kotlin/buttons/RootButtons.kt

@@ -1,6 +1,9 @@
 package dev.inmo.plaguposter.ratings.source.buttons
 
-import com.soywiz.klock.DateFormat
+import korlibs.time.DateFormat
+import dev.inmo.kslog.common.TagLogger
+import dev.inmo.kslog.common.d
+import dev.inmo.kslog.common.i
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.pagination.FirstPagePagination
 import dev.inmo.micro_utils.pagination.Pagination
@@ -63,6 +66,7 @@ suspend fun RatingsRepo.buildRatingButtons(
     postCreationTimeFormat: DateFormat = defaultPostCreationTimeFormat
 ): InlineKeyboardMarkup {
     val postsByRatings = getPosts(rating .. rating, true).keys.paginate(pagination)
+    TagLogger("RatingsButtonsBuilder").i { postsByRatings.results }
     return inlineKeyboard {
         if (postsByRatings.pagesNumber > 1) {
             row {
@@ -75,7 +79,7 @@ suspend fun RatingsRepo.buildRatingButtons(
                 }
             }
         }
-        postsByRatings.results.chunked(rowSize).map {
+        postsByRatings.results.chunked(rowSize).forEach {
             row {
                 it.forEach { postId ->
                     val firstMessageInfo = postsRepo.getFirstMessageInfo(postId) ?: return@forEach

ratings/source/src/commonMain/kotlin/repos/CachedPollsToMessagesInfoRepo.kt

@@ -0,0 +1,14 @@
+package dev.inmo.plaguposter.ratings.source.repos
+
+import dev.inmo.micro_utils.repos.KeyValueRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.full.fullyCached
+import dev.inmo.plaguposter.common.ShortMessageInfo
+import dev.inmo.tgbotapi.types.PollIdentifier
+import kotlinx.coroutines.CoroutineScope
+
+class CachedPollsToMessagesInfoRepo(
+    private val repo: PollsToMessagesInfoRepo,
+    private val scope: CoroutineScope,
+    private val kvCache: FullKVCache<PollIdentifier, ShortMessageInfo> = FullKVCache()
+) : PollsToMessagesInfoRepo, KeyValueRepo<PollIdentifier, ShortMessageInfo> by repo.fullyCached(kvCache, scope)

ratings/source/src/commonMain/kotlin/repos/CachedPollsToPostsIdsRepo.kt

@@ -0,0 +1,14 @@
+package dev.inmo.plaguposter.ratings.source.repos
+
+import dev.inmo.micro_utils.repos.KeyValueRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.full.fullyCached
+import dev.inmo.plaguposter.posts.models.PostId
+import dev.inmo.tgbotapi.types.PollIdentifier
+import kotlinx.coroutines.CoroutineScope
+
+class CachedPollsToPostsIdsRepo(
+    private val repo: PollsToPostsIdsRepo,
+    private val scope: CoroutineScope,
+    private val kvCache: FullKVCache<PollIdentifier, PostId> = FullKVCache()
+) : PollsToPostsIdsRepo, KeyValueRepo<PollIdentifier, PostId> by repo.fullyCached(kvCache, scope)

ratings/source/src/jvmMain/kotlin/Plugin.kt

@@ -67,8 +67,29 @@ object Plugin : Plugin {
             get<Json>().decodeFromJsonElement(Config.serializer(), params["ratingsPolls"] ?: error("Unable to load config for rating polls in $params"))
         }
         single<RatingsVariants>(ratingVariantsQualifier) { get<Config>().variants }
-        single<PollsToPostsIdsRepo> { ExposedPollsToPostsIdsRepo(database) }
-        single<PollsToMessagesInfoRepo> { ExposedPollsToMessagesInfoRepo(database) }
+
+        single { ExposedPollsToPostsIdsRepo(database) }
+        single<PollsToPostsIdsRepo> {
+            val base = get<ExposedPollsToPostsIdsRepo>()
+
+            if (useCache) {
+                CachedPollsToPostsIdsRepo(base, get())
+            } else {
+                base
+            }
+        }
+
+        single { ExposedPollsToMessagesInfoRepo(database) }
+        single<PollsToMessagesInfoRepo> {
+            val base = get<ExposedPollsToMessagesInfoRepo>()
+
+            if (useCache) {
+                CachedPollsToMessagesInfoRepo(base, get())
+            } else {
+                base
+            }
+        }
+
         single<VariantTransformer> {
             val ratingsSettings = get<RatingsVariants>(ratingVariantsQualifier)
             VariantTransformer {

ratings/src/commonMain/kotlin/repo/CachedRatingsRepo.kt

@@ -0,0 +1,61 @@
+package dev.inmo.plaguposter.ratings.repo
+
+import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
+import dev.inmo.micro_utils.repos.KeyValueRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.full.FullKeyValueCacheRepo
+import dev.inmo.plaguposter.posts.models.PostId
+import dev.inmo.plaguposter.ratings.models.Rating
+import kotlinx.coroutines.CoroutineScope
+
+class CachedRatingsRepo(
+    private val base: RatingsRepo,
+    private val scope: CoroutineScope,
+    private val kvCache: FullKVCache<PostId, Rating> = FullKVCache()
+) : RatingsRepo, KeyValueRepo<PostId, Rating> by FullKeyValueCacheRepo(base, kvCache, scope) {
+    override suspend fun getPosts(
+        range: ClosedRange<Rating>,
+        reversed: Boolean,
+        count: Int?,
+        exclude: List<PostId>
+    ): Map<PostId, Rating> {
+        val result = mutableMapOf<PostId, Rating>()
+
+        doForAllWithNextPaging {
+            kvCache.keys(it).also {
+                it.results.forEach {
+                    val rating = get(it) ?: return@forEach
+                    if (it !in exclude && rating in range) {
+                        result[it] = rating
+                    }
+                }
+            }
+        }
+
+        return result.toMap()
+    }
+
+    override suspend fun getPostsWithRatingGreaterEq(
+        then: Rating,
+        reversed: Boolean,
+        count: Int?,
+        exclude: List<PostId>
+    ): Map<PostId, Rating> = getPosts(
+        then .. Rating(Double.MAX_VALUE),
+        reversed,
+        count,
+        exclude
+    )
+
+    override suspend fun getPostsWithRatingLessEq(
+        then: Rating,
+        reversed: Boolean,
+        count: Int?,
+        exclude: List<PostId>
+    ): Map<PostId, Rating> = getPosts(
+        Rating(Double.MIN_VALUE) .. then,
+        reversed,
+        count,
+        exclude
+    )
+}

ratings/src/jvmMain/kotlin/Plugin.kt

@@ -1,8 +1,10 @@
 package dev.inmo.plaguposter.ratings
 
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.koin.singleWithBinds
 import dev.inmo.micro_utils.repos.unset
 import dev.inmo.plagubot.Plugin
+import dev.inmo.plaguposter.common.useCache
 import dev.inmo.plaguposter.posts.exposed.ExposedPostsRepo
 import dev.inmo.plaguposter.posts.repo.PostsRepo
 import dev.inmo.plaguposter.ratings.exposed.ExposedRatingsRepo
@@ -16,11 +18,16 @@ import org.koin.dsl.binds
 
 object Plugin : Plugin {
     override fun Module.setupDI(database: Database, params: JsonObject) {
-        single { ExposedRatingsRepo(database) } binds arrayOf(
-            RatingsRepo::class,
-            ReadRatingsRepo::class,
-            WriteRatingsRepo::class,
-        )
+        single { ExposedRatingsRepo(database) }
+        singleWithBinds<RatingsRepo> {
+            val base = get<ExposedRatingsRepo>()
+
+            if (useCache) {
+                CachedRatingsRepo(base, get())
+            } else {
+                base
+            }
+        }
     }
 
     override suspend fun BehaviourContext.setupBotPlugin(koin: Koin) {

runner/Dockerfile

@@ -1,4 +1,4 @@
-FROM adoptopenjdk/openjdk11
+FROM bellsoft/liberica-openjdk-alpine:19
 
 USER 1000
 

runner/config.json

@@ -12,6 +12,7 @@
     "dev.inmo.plaguposter.ratings.Plugin",
     "dev.inmo.plaguposter.ratings.source.Plugin",
     "dev.inmo.plaguposter.ratings.selector.Plugin",
+    "dev.inmo.plaguposter.ratings.gc.Plugin",
     "dev.inmo.plaguposter.triggers.selector_with_timer.Plugin",
     "dev.inmo.plagubot.plugins.inline.queries.Plugin",
     "dev.inmo.plaguposter.triggers.command.Plugin",
@@ -25,16 +26,18 @@
     "chats": {
       "targetChat": 12345678,
       "cacheChat": 12345678,
-      "sourceChat": 12345678
+      "sourceChat": 12345678,
+      "targetChats": [12345678],
+      "_note": "You must set targetChat or targetChats with at least one object"
     }
   },
   "ratingsPolls": {
     "variants": {
-      "Круть": 2,
-      "Ок": 1,
-      "Не ок": -1,
-      "Совсем не ок": -2,
-      "Посмотреть результаты": 0
+      "Cool": 2,
+      "Ok": 1,
+      "Not ok": -1,
+      "Inappropriate": -2,
+      "Results": 0
     },
     "autoAttach": true,
     "ratingOfferText": "What do you think about it?"
@@ -72,5 +75,13 @@
   },
   "publish_command": {
     "panelButtonText": "Publish"
+  },
+  "gc": {
+    "autoclear": {
+      "rating": -1,
+      "autoClearKrontab": "0 0 0 * *",
+      "skipPostAge": 86400
+    },
+    "immediateDrop": -6
   }
 }

runner/deploy.sh

@@ -14,8 +14,8 @@ function assert_success() {
 }
 
 app=plaguposter
-version="`grep ../gradle.properties -e "^version=" | grep -e "[0-9.]*" -o`"
-server=docker.io/insanusmokrassar
+version="`grep ../gradle.properties -e "^version=" | sed -e "s/version=\(.*\)/\1/"`"
+server=insanusmokrassar
 
 assert_success ../gradlew build
 assert_success sudo docker build -t $app:"$version" .

runner/nonsudo_deploy.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+function send_notification() {
+    echo "$1"
+}
+
+function assert_success() {
+    "${@}"
+    local status=${?}
+    if [ ${status} -ne 0 ]; then
+        send_notification "### Error ${status} at: ${BASH_LINENO[*]} ###"
+        exit ${status}
+    fi
+}
+
+app=plaguposter
+version="`grep ../gradle.properties -e "^version=" | sed -e "s/version=\(.*\)/\1/"`"
+server=insanusmokrassar
+
+assert_success ../gradlew build
+assert_success docker build -t $app:"$version" .
+assert_success docker tag $app:"$version" $server/$app:$version
+assert_success docker tag $app:"$version" $server/$app:latest
+assert_success docker push $server/$app:$version
+assert_success docker push $server/$app:latest

runner/sample.docker-compose.yml

@@ -0,0 +1,23 @@
+version: "3.4"
+
+services:
+  plaguposter_postgres:
+    image: postgres:15.4-bullseye
+    container_name: "plaguposter_postgres"
+    restart: "unless-stopped"
+    environment:
+      POSTGRES_USER: "test"
+      POSTGRES_PASSWORD: "test"
+      POSTGRES_DB: "test"
+    volumes:
+      - "./db/:/var/lib/postgresql/data"
+    ports:
+      - "127.0.0.1:8091:5432"
+  plaguposter:
+    image: insanusmokrassar/plaguposter:latest
+    container_name: "plaguposter"
+    restart: "unless-stopped"
+    volumes:
+      - "./config.json:/config.json"
+    depends_on:
+      - "plaguposter_postgres"

settings.gradle

@@ -11,7 +11,6 @@ String[] includes = [
     ":ratings:gc",
     ":triggers:command",
     ":triggers:selector_with_timer",
-    ":triggers:selector_with_scheduling",
     ":triggers:timer",
     ":triggers:timer:disablers:ratings",
     ":triggers:timer:disablers:autoposts",

triggers/selector_with_scheduling/build.gradle

@@ -1,16 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.multiplatform"
-    id "org.jetbrains.kotlin.plugin.serialization"
-}
-
-apply from: "$mppProjectWithSerializationPresetPath"
-
-kotlin {
-    sourceSets {
-        commonMain {
-            dependencies {
-                api project(":plaguposter.common")
-            }
-        }
-    }
-}

triggers/selector_with_scheduling/src/commonMain/kotlin/PackageInfo.kt

@@ -1 +0,0 @@
-package dev.inmo.plaguposter.triggers.selector_with_scheduling

triggers/selector_with_scheduling/src/jvmMain/kotlin/Plugin.kt

@@ -1,11 +0,0 @@
-package dev.inmo.plaguposter.triggers.selector_with_scheduling
-
-import dev.inmo.plagubot.Plugin
-import kotlinx.serialization.json.*
-import org.jetbrains.exposed.sql.Database
-import org.koin.core.module.Module
-
-object Plugin : Plugin {
-    override fun Module.setupDI(database: Database, params: JsonObject) {
-    }
-}

triggers/selector_with_scheduling/src/main/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest package="dev.inmo.plaguposter.triggers.selector_with_scheduling"/>

triggers/selector_with_timer/src/commonMain/kotlin/AutopostFilter.kt

@@ -1,6 +1,6 @@
 package dev.inmo.plaguposter.triggers.selector_with_timer
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.plaguposter.posts.models.PostId
 
 fun interface AutopostFilter {

triggers/selector_with_timer/src/jvmMain/kotlin/Plugin.kt

@@ -1,14 +1,43 @@
 package dev.inmo.plaguposter.triggers.selector_with_timer
 
+import korlibs.time.DateFormat
 import dev.inmo.krontab.KrontabTemplate
 import dev.inmo.krontab.toSchedule
-import dev.inmo.krontab.utils.asFlow
+import dev.inmo.krontab.utils.asFlowWithDelays
+import dev.inmo.krontab.utils.asFlowWithoutDelays
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.koin.singleWithRandomQualifier
+import dev.inmo.micro_utils.pagination.FirstPagePagination
+import dev.inmo.micro_utils.pagination.Pagination
+import dev.inmo.micro_utils.pagination.firstIndex
+import dev.inmo.micro_utils.pagination.lastIndexExclusive
 import dev.inmo.plagubot.Plugin
+import dev.inmo.plagubot.plugins.inline.queries.models.Format
+import dev.inmo.plagubot.plugins.inline.queries.models.OfferTemplate
+import dev.inmo.plagubot.plugins.inline.queries.repos.InlineTemplatesRepo
+import dev.inmo.plaguposter.common.ChatConfig
+import dev.inmo.plaguposter.posts.models.PostId
+import dev.inmo.plaguposter.posts.repo.ReadPostsRepo
 import dev.inmo.plaguposter.posts.sending.PostPublisher
 import dev.inmo.plaguposter.ratings.selector.Selector
+import dev.inmo.tgbotapi.extensions.api.answers.answer
+import dev.inmo.tgbotapi.extensions.api.edit.edit
+import dev.inmo.tgbotapi.extensions.api.send.send
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMessageDataCallbackQuery
+import dev.inmo.tgbotapi.extensions.utils.extensions.sameChat
+import dev.inmo.tgbotapi.extensions.utils.formatting.makeLinkToMessage
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.dataButton
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.urlButton
+import dev.inmo.tgbotapi.types.BotCommand
+import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
+import dev.inmo.tgbotapi.utils.row
 import kotlinx.coroutines.FlowPreview
+import kotlinx.coroutines.flow.collectIndexed
+import kotlinx.coroutines.flow.take
 import kotlinx.serialization.*
 import kotlinx.serialization.json.*
 import org.jetbrains.exposed.sql.Database
@@ -16,15 +45,21 @@ import org.koin.core.Koin
 import org.koin.core.module.Module
 
 object Plugin : Plugin {
-    @Serializable
+    private const val pageCallbackDataQueryPrefix = "publishing_autoschedule page"
+    private const val pageCallbackDataQuerySize = 5
+        @Serializable
     internal data class Config(
         @SerialName("krontab")
-        val krontabTemplate: KrontabTemplate
+        val krontabTemplate: KrontabTemplate,
+        val dateTimeFormat: String = "HH:mm:ss, dd.MM.yyyy"
     ) {
         @Transient
         val krontab by lazy {
             krontabTemplate.toSchedule()
         }
+
+        @Transient
+        val format: DateFormat = DateFormat(dateTimeFormat)
     }
     override fun Module.setupDI(database: Database, params: JsonObject) {
         single { get<Json>().decodeFromJsonElement(Config.serializer(), params["timer_trigger"] ?: return@single null) }
@@ -35,12 +70,103 @@ object Plugin : Plugin {
         val publisher = koin.get<PostPublisher>()
         val selector = koin.get<Selector>()
         val filters = koin.getAll<AutopostFilter>().distinct()
-        koin.get<Config>().krontab.asFlow().subscribeSafelyWithoutExceptions(this) { dateTime ->
+        val chatConfig = koin.get<ChatConfig>()
+        val postsRepo = koin.get<ReadPostsRepo>()
+
+        koin.getOrNull<InlineTemplatesRepo>() ?.apply {
+            addTemplate(
+                OfferTemplate(
+                    "Autoschedule buttons",
+                    listOf(
+                        Format(
+                            "/autoschedule_panel"
+                        )
+                    ),
+                    "Show autoscheduling publishing info"
+                )
+            )
+        }
+
+        val krontab = koin.get<Config>().krontab
+        val dateTimeFormat = koin.get<Config>().format
+        krontab.asFlowWithDelays().subscribeSafelyWithoutExceptions(this) { dateTime ->
             selector.take(now = dateTime).forEach { postId ->
                 if (filters.all { it.check(postId, dateTime) }) {
                     publisher.publish(postId)
                 }
             }
         }
+
+        suspend fun buildPage(pagination: Pagination = FirstPagePagination(size = pageCallbackDataQuerySize)): InlineKeyboardMarkup {
+            return inlineKeyboard {
+                row {
+                    if (pagination.page > 1) {
+                        dataButton("⬅️", "${pageCallbackDataQueryPrefix}0")
+                    }
+                    if (pagination.page > 0) {
+                        dataButton("◀️", "${pageCallbackDataQueryPrefix}${pagination.page - 1}")
+                    }
+
+                    dataButton("\uD83D\uDD04 ${pagination.page}", "${pageCallbackDataQueryPrefix}${pagination.page}")
+                    dataButton("▶️", "${pageCallbackDataQueryPrefix}${pagination.page + 1}")
+                }
+
+                val selected = mutableListOf<PostId>()
+                krontab.asFlowWithoutDelays().take(pagination.lastIndexExclusive).collectIndexed { i, dateTime ->
+                    val postId = selector.take(now = dateTime, exclude = selected).firstOrNull() ?.also { postId ->
+                        if (filters.all { it.check(postId, dateTime) }) {
+                            selected.add(postId)
+                        } else {
+                            return@collectIndexed
+                        }
+                    }
+
+                    val post = postsRepo.getFirstMessageInfo(postId ?: return@collectIndexed)
+                    if (i < pagination.firstIndex || post == null) {
+                        return@collectIndexed
+                    }
+
+                    row {
+                        urlButton(
+                            dateTime.local.format(dateTimeFormat),
+                            makeLinkToMessage(post.chatId, post.messageId)
+                        )
+                    }
+                }
+            }
+        }
+
+        onCommand("autoschedule_panel", initialFilter = { it.sameChat(chatConfig.sourceChatId) }) {
+            val keyboard = buildPage()
+
+            runCatchingSafely {
+                edit(it, replyMarkup = keyboard) {
+                    +"Your schedule:"
+                }
+            }.onFailure { _ ->
+                send(it.chat, replyMarkup = keyboard) {
+                    +"Your schedule:"
+                }
+            }
+        }
+
+        onMessageDataCallbackQuery(
+            Regex("^$pageCallbackDataQueryPrefix\\d+"),
+            initialFilter = { it.message.sameChat(chatConfig.sourceChatId) }
+        ) {
+            val page = it.data.removePrefix(pageCallbackDataQueryPrefix).toIntOrNull() ?: let { _ ->
+                answer(it)
+                return@onMessageDataCallbackQuery
+            }
+
+            runCatchingSafely {
+                edit(
+                    it.message,
+                    replyMarkup = buildPage(Pagination(page, size = pageCallbackDataQuerySize))
+                )
+            }.onFailure { _ ->
+                answer(it)
+            }
+        }
     }
 }

triggers/timer/src/commonMain/kotlin/ButtonsBuilder.kt

@@ -1,10 +1,10 @@
 package dev.inmo.plaguposter.triggers.timer
 
-import com.soywiz.klock.DateFormat
-import com.soywiz.klock.DateTime
-import com.soywiz.klock.DateTimeTz
-import com.soywiz.klock.Month
-import com.soywiz.klock.Year
+import korlibs.time.DateFormat
+import korlibs.time.DateTime
+import korlibs.time.DateTimeTz
+import korlibs.time.Month
+import korlibs.time.Year
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.repos.unset
 import dev.inmo.plaguposter.common.SuccessfulSymbol

triggers/timer/src/commonMain/kotlin/NearestAvailablePublishingTime.kt

@@ -1,7 +1,7 @@
 package dev.inmo.plaguposter.triggers.timer
 
-import com.soywiz.klock.DateTime
-import com.soywiz.klock.minutes
+import korlibs.time.DateTime
+import korlibs.time.minutes
 
 fun nearestAvailableTimerTime() = (DateTime.now() + 1.minutes).copyDayOfMonth(
     milliseconds = 0,

triggers/timer/src/commonMain/kotlin/TimersHandler.kt

@@ -1,6 +1,6 @@
 package dev.inmo.plaguposter.triggers.timer
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import dev.inmo.micro_utils.coroutines.plus
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions

triggers/timer/src/commonMain/kotlin/TimersRepo.kt

@@ -1,6 +1,6 @@
 package dev.inmo.plaguposter.triggers.timer
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.micro_utils.repos.KeyValueRepo
 import dev.inmo.plaguposter.posts.models.PostId
 

triggers/timer/src/jvmMain/kotlin/Plugin.kt

@@ -1,6 +1,6 @@
 package dev.inmo.plaguposter.triggers.timer
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.koin.singleWithRandomQualifierAndBinds

triggers/timer/src/jvmMain/kotlin/repo/ExposedTimersRepo.kt

@@ -1,6 +1,6 @@
 package dev.inmo.plaguposter.triggers.timer.repo
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.micro_utils.common.firstNotNull
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.pagination.paginate