first version of adminbot

cache/admins/micro_utils/build.gradle

@@ -0,0 +1,25 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppProjectWithSerializationPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api "dev.inmo:micro_utils.repos.common:$micro_utils_version"
+                api project(":tgbotapi.libraries.cache.admins.common")
+            }
+        }
+        jvmMain {
+            dependencies {
+                api "dev.inmo:micro_utils.repos.exposed:$micro_utils_version"
+                api "org.jetbrains.kotlinx:kotlinx-serialization-cbor:$kotlin_serialisation_core_version"
+                api "org.jetbrains.exposed:exposed-jdbc:$exposed_version"
+            }
+        }
+    }
+}

cache/admins/micro_utils/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/micro_utils/DefaultAdminsCacheAPI.kt

@@ -0,0 +1,62 @@
+package dev.inmo.tgbotapi.libraries.cache.admins.micro_utils
+
+import com.soywiz.klock.DateTime
+import dev.inmo.micro_utils.coroutines.actor
+import dev.inmo.micro_utils.coroutines.safelyWithoutExceptions
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.tgbotapi.libraries.cache.admins.DefaultAdminsCacheAPIRepo
+import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.ChatMember.abstracts.AdministratorChatMember
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
+import kotlin.coroutines.*
+
+private sealed class RepoActions<T> {
+    abstract val toReturn: Continuation<T>
+}
+private class GetUpdateDateTimeRepoAction(
+    val chatId: ChatId,
+    override val toReturn: Continuation<DateTime?>
+) : RepoActions<DateTime?>()
+private class GetChatAdminsRepoAction(
+    val chatId: ChatId,
+    override val toReturn: Continuation<List<AdministratorChatMember>?>
+) : RepoActions<List<AdministratorChatMember>?>()
+private class SetChatAdminsRepoAction(
+    val chatId: ChatId,
+    val newValue: List<AdministratorChatMember>,
+    override val toReturn: Continuation<Unit>
+) : RepoActions<Unit>()
+
+class DefaultAdminsCacheAPIRepo(
+    private val adminsRepo: KeyValuesRepo<ChatId, AdministratorChatMember>,
+    private val updatesRepo: KeyValueRepo<ChatId, MilliSeconds>,
+    private val scope: CoroutineScope
+) : DefaultAdminsCacheAPIRepo {
+    private val actor = scope.actor<RepoActions<*>>(Channel.UNLIMITED) {
+        safelyWithoutExceptions {
+            when (it) {
+                is GetUpdateDateTimeRepoAction -> it.toReturn.resume(
+                    updatesRepo.get(it.chatId) ?.let { DateTime(it.toDouble()) }
+                )
+                is GetChatAdminsRepoAction -> it.toReturn.resume(adminsRepo.getAll(it.chatId))
+                is SetChatAdminsRepoAction -> {
+                    adminsRepo.clear(it.chatId)
+                    adminsRepo.set(it.chatId, it.newValue)
+                    updatesRepo.set(it.chatId, DateTime.now().unixMillisLong)
+                    it.toReturn.resume(Unit)
+                }
+            }
+        }
+    }
+
+    override suspend fun getChatAdmins(chatId: ChatId): List<AdministratorChatMember>? = suspendCoroutine {
+        actor.offer(GetChatAdminsRepoAction(chatId, it))
+    }
+    override suspend fun setChatAdmins(chatId: ChatId, chatMembers: List<AdministratorChatMember>) = suspendCoroutine<Unit> {
+        actor.offer(SetChatAdminsRepoAction(chatId, chatMembers, it))
+    }
+    override suspend fun lastUpdate(chatId: ChatId): DateTime? = suspendCoroutine {
+        actor.offer(GetUpdateDateTimeRepoAction(chatId, it))
+    }
+}

cache/admins/micro_utils/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/micro_utils/DynamicAdminsCacheSettingsAPI.kt

@@ -0,0 +1,31 @@
+package dev.inmo.tgbotapi.libraries.cache.admins.micro_utils
+
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.tgbotapi.libraries.cache.admins.*
+import dev.inmo.tgbotapi.types.ChatId
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.*
+
+class DynamicAdminsCacheSettingsAPI(
+    private val repo: KeyValueRepo<ChatId, AdminsCacheSettings>,
+    private val scope: CoroutineScope
+) : AdminsCacheSettingsAPI, MutableAdminsCacheSettingsAPI {
+    override val chatSettingsUpdatedFlow: SharedFlow<Pair<ChatId, AdminsCacheSettings>>
+        get() = repo.onNewValue.shareIn(scope, SharingStarted.Eagerly)
+
+    override suspend fun setChatSettings(chatId: ChatId, settings: AdminsCacheSettings) {
+        repo.set(chatId, settings)
+    }
+
+    override suspend fun getChatSettings(chatId: ChatId): AdminsCacheSettings {
+        val settings = repo.get(chatId)
+        return if (settings == null) {
+            val newSettings = AdminsCacheSettings()
+            setChatSettings(chatId, newSettings)
+            newSettings
+        } else {
+            settings
+        }
+    }
+}

cache/admins/micro_utils/src/jvmMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/AdminsCacheAPI.kt

@@ -0,0 +1,64 @@
+package dev.inmo.tgbotapi.libraries.cache.admins
+
+import dev.inmo.micro_utils.repos.exposed.keyvalue.ExposedKeyValueRepo
+import dev.inmo.micro_utils.repos.exposed.onetomany.ExposedOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.mappers.withMapper
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.libraries.cache.admins.micro_utils.DefaultAdminsCacheAPIRepo
+import dev.inmo.tgbotapi.libraries.cache.admins.micro_utils.DynamicAdminsCacheSettingsAPI
+import dev.inmo.tgbotapi.types.toChatId
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.serialization.cbor.Cbor
+import kotlinx.serialization.decodeFromByteArray
+import kotlinx.serialization.encodeToByteArray
+import org.jetbrains.exposed.sql.Database
+import org.jetbrains.exposed.sql.statements.api.ExposedBlob
+
+private val serializationFormat = Cbor
+
+fun AdminsCacheAPI(
+    bot: TelegramBot,
+    database: Database,
+    scope: CoroutineScope,
+    repo: dev.inmo.tgbotapi.libraries.cache.admins.DefaultAdminsCacheAPIRepo = DefaultAdminsCacheAPIRepo(
+        ExposedOneToManyKeyValueRepo(
+            database,
+            { long("chatId") },
+            { blob("member") },
+            "AdminsTable"
+        ).withMapper(
+            keyFromToTo = { chatId },
+            valueFromToTo = { ExposedBlob(serializationFormat.encodeToByteArray(this)) },
+            keyToToFrom = { toChatId() },
+            valueToToFrom = { serializationFormat.decodeFromByteArray(bytes) }
+        ),
+        ExposedKeyValueRepo(
+            database,
+            { long("chatId") },
+            { long("datetime") },
+            "AdminsUpdatesTimesTable"
+        ).withMapper(
+            keyFromToTo = { chatId },
+            keyToToFrom = { toChatId() }
+        ),
+        scope
+    ),
+    settingsAPI: AdminsCacheSettingsAPI = DynamicAdminsCacheSettingsAPI(
+        ExposedKeyValueRepo(
+            database,
+            { long("chatId") },
+            { blob("settings") },
+            "DynamicAdminsCacheSettingsAPI"
+        ).withMapper(
+            keyFromToTo = { chatId },
+            valueFromToTo = { ExposedBlob(serializationFormat.encodeToByteArray(this)) },
+            keyToToFrom = { toChatId() },
+            valueToToFrom = { serializationFormat.decodeFromByteArray(bytes) }
+        ),
+        scope
+    )
+) : AdminsCacheAPI = DefaultAdminsCacheAPI(
+    bot,
+    repo,
+    settingsAPI
+)

cache/admins/micro_utils/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.tgbotapi.libraries.cache.admins.micro_utils"/>