add commands for cas and fixes in its work

.github/workflows/publish_package.yml

@@ -8,7 +8,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
       - name: Update version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
@@ -19,7 +19,7 @@ jobs:
           GITHUB_USER: ${{ github.actor }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - name: Publish package
-        run: ./gradlew publishAllPublicationsToGithubPackagesRepository --no-parallel -x signMavenPublication
+        run: ./gradlew publishAllPublicationsToGithubPackagesRepository --no-parallel
         env:
           GITHUBPACKAGES_USER: ${{ github.actor }}
           GITHUBPACKAGES_PASSWORD: ${{ secrets.GITHUB_TOKEN }}

build.gradle

@@ -32,6 +32,14 @@ repositories {
                 password = project.hasProperty("GITHUB_TOKEN") ? project.getProperty("GITHUB_TOKEN") : System.getenv("GITHUB_TOKEN")
             }
         }
+        maven {
+            name = "GitHubPackages"
+            url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
+            credentials {
+                username = project.hasProperty("GITHUB_USER") ? project.getProperty("GITHUB_USER") : System.getenv("GITHUB_USER")
+                password = project.hasProperty("GITHUB_TOKEN") ? project.getProperty("GITHUB_TOKEN") : System.getenv("GITHUB_TOKEN")
+            }
+        }
     }
 }
 
@@ -43,4 +51,5 @@ dependencies {
     api "dev.inmo:plagubot.plugin:$plagubot_version"
     api "dev.inmo:micro_utils.repos.exposed:$micro_utils_version"
     api "dev.inmo:tgbotapi.libraries.cache.admins.plagubot:$tgbotapi_libraries_version"
+    api "dev.inmo:plagubot.plugins.commands:$commands_version"
 }

gradle.properties

@@ -4,13 +4,14 @@ org.gradle.parallel=true
 kotlin.js.generate.externals=true
 kotlin.incremental=true
 
-kotlin_version=1.4.31
-kotlin_coroutines_version=1.4.3
-kotlin_serialisation_runtime_version=1.1.0
-plagubot_version=0.1.5
+kotlin_version=1.7.10
+kotlin_coroutines_version=1.6.4
+kotlin_serialisation_runtime_version=1.4.0
+plagubot_version=2.3.3
 
-micro_utils_version=0.4.30
-tgbotapi_libraries_version=0.0.2-branch_master-build12
+micro_utils_version=0.12.13
+tgbotapi_libraries_version=0.5.4
+commands_version=0.3.4
 
 project_group=dev.inmo
-project_version=0.1.5
+project_version=0.1.6

gradle/wrapper/gradle-wrapper.properties

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

publish.gradle

@@ -1,6 +1,4 @@
 apply plugin: 'maven-publish'
-apply plugin: 'signing'
-
 
 task javadocJar(type: Jar) {
     from javadoc
@@ -76,7 +74,18 @@ publishing {
     }
 }
 
-signing {
-    useGpgCmd()
-    sign publishing.publications
+if (project.hasProperty("signing.gnupg.keyName")) {
+    apply plugin: 'signing'
+    
+    signing {
+        useGpgCmd()
+    
+        sign publishing.publications
+    }
+    
+    task signAll {
+        tasks.withType(Sign).forEach {
+            dependsOn(it)
+        }
+    }
 }

publish.kpsb

@@ -1 +1 @@
-{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/CaptchaPlaguBotPlugin/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"${project.name}","url":"https://github.com/InsanusMokrassar/CaptchaPlaguBotPlugin","vcsUrl":"https://github.com/InsanusMokrassar/CaptchaPlaguBotPlugin.git","includeGpgSigning":true,"developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/CaptchaPlaguBotPlugin"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}]},"type":"JVM"}
+{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/CaptchaPlaguBotPlugin/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"${project.name}","url":"https://github.com/InsanusMokrassar/CaptchaPlaguBotPlugin","vcsUrl":"https://github.com/InsanusMokrassar/CaptchaPlaguBotPlugin.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/CaptchaPlaguBotPlugin"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}},"type":"JVM"}

src/main/kotlin/dev/inmo/plagubot/plugins/captcha/Plugin.kt

@@ -1,158 +1,247 @@
 package dev.inmo.plagubot.plugins.captcha
 
+import com.benasher44.uuid.uuid4
 import dev.inmo.micro_utils.coroutines.*
 import dev.inmo.micro_utils.repos.create
 import dev.inmo.plagubot.Plugin
+import dev.inmo.plagubot.plugins.captcha.cas.CASChecker
+import dev.inmo.plagubot.plugins.captcha.cas.KtorCASChecker
 import dev.inmo.plagubot.plugins.captcha.db.CaptchaChatsSettingsRepo
+import dev.inmo.plagubot.plugins.captcha.provider.*
 import dev.inmo.plagubot.plugins.captcha.settings.ChatSettings
-import dev.inmo.tgbotapi.bot.TelegramBot
-import dev.inmo.tgbotapi.extensions.api.answers.answerCallbackQuery
+import dev.inmo.plagubot.plugins.commands.BotCommandFullInfo
+import dev.inmo.plagubot.plugins.commands.CommandsKeeperKey
 import dev.inmo.tgbotapi.extensions.api.chat.members.*
+import dev.inmo.tgbotapi.extensions.api.delete
 import dev.inmo.tgbotapi.extensions.api.deleteMessage
-import dev.inmo.tgbotapi.extensions.api.edit.ReplyMarkup.editMessageReplyMarkup
-import dev.inmo.tgbotapi.extensions.api.send.media.reply
-import dev.inmo.tgbotapi.extensions.api.send.sendDice
-import dev.inmo.tgbotapi.extensions.api.send.sendTextMessage
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitBaseInlineQuery
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitDataCallbackQuery
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onNewChatMembers
 import dev.inmo.tgbotapi.extensions.utils.*
-import dev.inmo.tgbotapi.extensions.utils.formatting.buildEntities
-import dev.inmo.tgbotapi.extensions.utils.formatting.regular
-import dev.inmo.tgbotapi.extensions.utils.shortcuts.executeUnsafe
+import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithParams
 import dev.inmo.tgbotapi.libraries.cache.admins.*
-import dev.inmo.tgbotapi.requests.DeleteMessage
 import dev.inmo.tgbotapi.types.BotCommand
-import dev.inmo.tgbotapi.types.MessageEntity.textsources.mention
-import dev.inmo.tgbotapi.types.User
-import dev.inmo.tgbotapi.types.chat.ChatPermissions
-import dev.inmo.tgbotapi.types.chat.LeftRestrictionsChatPermissions
-import dev.inmo.tgbotapi.types.chat.abstracts.Chat
-import dev.inmo.tgbotapi.types.chat.abstracts.PublicChat
-import dev.inmo.tgbotapi.types.dice.SlotMachineDiceAnimationType
-import dev.inmo.tgbotapi.types.message.abstracts.*
-import dev.inmo.tgbotapi.types.message.content.abstracts.MessageContent
+import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.commands.BotCommandScope
+import dev.inmo.tgbotapi.utils.link
+import dev.inmo.tgbotapi.utils.mention
+import io.ktor.client.HttpClient
 import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.toList
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonObject
 import org.jetbrains.exposed.sql.Database
+import org.koin.core.Koin
+import org.koin.core.module.Module
+import org.koin.core.qualifier.named
+import org.koin.dsl.binds
 
 private const val enableAutoDeleteCommands = "captcha_auto_delete_commands_on"
 private const val disableAutoDeleteCommands = "captcha_auto_delete_commands_off"
+private const val enableAutoDeleteServiceMessages = "captcha_auto_delete_events_on"
+private const val disableAutoDeleteServiceMessages = "captcha_auto_delete_events_off"
+
+private const val enableSlotMachineCaptcha = "captcha_use_slot_machine"
+private const val enableSimpleCaptcha = "captcha_use_simple"
+private const val enableExpressionCaptcha = "captcha_use_expression"
+private const val disableCaptcha = "disable_captcha"
+private const val enableCaptcha = "enable_captcha"
+
+private val enableDisableKickOnUnsuccess = Regex("captcha_(enable|disable)_kick")
+private const val enableKickOnUnsuccess = "captcha_enable_kick"
+private const val disableKickOnUnsuccess = "captcha_disable_kick"
+private const val enableCAS = "captcha_enable_cas"
+private const val disableCAS = "captcha_disable_cas"
+
+private val changeCaptchaMethodCommandRegex = Regex(
+    "captcha_use_((slot_machine)|(simple)|(expression))"
+)
 
 @Serializable
 class CaptchaBotPlugin : Plugin {
-    override suspend fun getCommands(): List<BotCommand> = listOf(
-        BotCommand(
-            enableAutoDeleteCommands,
-            "Enable auto removing of commands addressed to captcha plugin"
-        ),
-        BotCommand(
-            disableAutoDeleteCommands,
-            "Disable auto removing of commands addressed to captcha plugin"
-        )
-    )
 
-    override suspend fun BehaviourContext.invoke(
-        database: Database,
-        params: Map<String, Any>
-    ) {
-        val repo = CaptchaChatsSettingsRepo(database)
-        val adminsAPI = params.adminsPlugin ?.adminsAPI(database)
+    override fun Module.setupDI(database: Database, params: JsonObject) {
+        single { CaptchaChatsSettingsRepo(database) }
+
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(enableAutoDeleteCommands, "Enable auto removing of commands addressed to captcha plugin")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(disableAutoDeleteCommands, "Disable auto removing of commands addressed to captcha plugin")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(enableAutoDeleteServiceMessages, "Enable auto removing of users joined messages")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(disableAutoDeleteServiceMessages, "Disable auto removing of users joined messages")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(enableSlotMachineCaptcha, "Change captcha method to slot machine")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(enableSimpleCaptcha, "Change captcha method to simple button")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(disableCaptcha, "Disable captcha for chat")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(enableCaptcha, "Enable captcha for chat")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(enableExpressionCaptcha, "Change captcha method to expressions")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(enableKickOnUnsuccess, "Not solved captcha users will be kicked from the chat")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(disableKickOnUnsuccess, "Not solved captcha users will NOT be kicked from the chat")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(enableCAS, "Users banned in CAS will fail captcha automatically")
+            )
+        }
+        single(named(uuid4().toString())) {
+            BotCommandFullInfo(
+                CommandsKeeperKey(BotCommandScope.AllChatAdministrators),
+                BotCommand(disableCAS, "Users banned in CAS will NOT fail captcha automatically")
+            )
+        }
+        single {
+            KtorCASChecker(
+                HttpClient(),
+                get()
+            )
+        } binds arrayOf(
+            CASChecker::class
+        )
+    }
+
+    override suspend fun BehaviourContext.setupBotPlugin(koin: Koin) {
+        val repo: CaptchaChatsSettingsRepo by koin.inject()
+        val adminsAPI = koin.getOrNull<AdminsCacheAPI>()
+        val casChecker = koin.get<CASChecker>()
+
         suspend fun Chat.settings() = repo.getById(id) ?: repo.create(ChatSettings(id)).first()
 
         onNewChatMembers(
-            additionalFilter = {
-                it.chat.asPublicChat() != null
-            },
-            includeFilterByChatInBehaviourSubContext = false
-        ) {
-            safelyWithoutExceptions { deleteMessage(it) }
-            val eventDateTime = it.date
-            val chat = it.chat.requirePublicChat()
-            val newUsers = it.chatEvent.members
+            initialFilter = {
+                it.chat is GroupChat
+            }
+        ) { msg ->
+            val settings = msg.chat.settings()
+            if (!settings.enabled) return@onNewChatMembers
+
+            safelyWithoutExceptions {
+                if (settings.autoRemoveEvents) {
+                    deleteMessage(msg)
+                }
+            }
+            val chat = msg.chat.groupChatOrThrow()
+            var newUsers = msg.chatEvent.members
             newUsers.forEach { user ->
                 restrictChatMember(
                     chat,
                     user,
-                    permissions = ChatPermissions()
+                    permissions = RestrictionsChatPermissions
                 )
             }
-            val settings = it.chat.settings() ?: return@onNewChatMembers
-            val userBanDateTime = eventDateTime + settings.checkTimeSpan
-            val authorized = Channel<User>(newUsers.size)
-            val messagesToDelete = Channel<Message>(Channel.UNLIMITED)
-            val subContexts = newUsers.map {
-                doInSubContext(stopOnCompletion = false) {
-                    val sentMessage = sendTextMessage(
-                        chat,
-                        buildEntities {
-                            +it.mention(it.firstName)
-                            regular(", ${settings.captchaText}")
-                        }
-                    ).also { messagesToDelete.send(it) }
-                    val sentDice = sendDice(
-                        sentMessage.chat,
-                        SlotMachineDiceAnimationType,
-                        replyToMessageId = sentMessage.messageId,
-                        replyMarkup = slotMachineReplyMarkup()
-                    ).also { messagesToDelete.send(it) }
-                    val reels = sentDice.content.dice.calculateSlotMachineResult()!!
-                    val leftToClick = mutableListOf(
-                        reels.left.asSlotMachineReelImage.text,
-                        reels.center.asSlotMachineReelImage.text,
-                        reels.right.asSlotMachineReelImage.text
-                    )
-
-                    launch {
-                        val clicked = arrayOf<String?>(null, null, null)
-                        while (leftToClick.isNotEmpty()) {
-                            val userClicked = waitDataCallbackQuery { if (user.id == it.id) this else null }.first()
-                            if (userClicked.data == leftToClick.first()) {
-                                clicked[3 - leftToClick.size] = leftToClick.removeAt(0)
-                                if (clicked.contains(null)) {
-                                    safelyWithoutExceptions { answerCallbackQuery(userClicked, "Ok, next one") }
-                                    editMessageReplyMarkup(sentDice, slotMachineReplyMarkup(clicked[0], clicked[1], clicked[2]))
-                                } else {
-                                    safelyWithoutExceptions { answerCallbackQuery(userClicked, "Thank you and welcome", showAlert = true) }
-                                    safelyWithoutExceptions { deleteMessage(sentMessage) }
-                                    safelyWithoutExceptions { deleteMessage(sentDice) }
+            newUsers = if (settings.casEnabled) {
+                newUsers.filterNot { user ->
+                    casChecker.isBanned(user.id).also { isBanned ->
+                        runCatchingSafely {
+                            if (isBanned) {
+                                reply(
+                                    msg
+                                ) {
+                                    +"User " + mention(user) + " is banned in " + link("CAS System", "https://cas.chat/query?u=${user.id.chatId}")
+                                }
+                                if (settings.kickOnUnsuccess) {
+                                    banChatMember(msg.chat.id, user)
                                 }
-                            } else {
-                                safelyWithoutExceptions { answerCallbackQuery(userClicked, "Nope") }
                             }
                         }
-                        authorized.send(it)
-                        safelyWithoutExceptions { restrictChatMember(chat, it, permissions = LeftRestrictionsChatPermissions) }
-                        stop()
                     }
-
-                    this to it
                 }
+            } else {
+                newUsers
             }
+            val defaultChatPermissions = LeftRestrictionsChatPermissions
 
-            delay((userBanDateTime - eventDateTime).millisecondsLong)
-
-            authorized.close()
-            val authorizedUsers = authorized.toList()
-
-            subContexts.forEach { (context, user) ->
-                if (user !in authorizedUsers) {
-                    context.stop()
-                    safelyWithoutExceptions { kickChatMember(chat, user) }
-                }
-            }
-            messagesToDelete.close()
-            for (message in messagesToDelete) {
-                executeUnsafe(DeleteMessage(message.chat.id, message.messageId), retries = 0)
+            with (settings.captchaProvider) {
+                doAction(msg.date, chat, newUsers, defaultChatPermissions, adminsAPI, settings.kickOnUnsuccess)
             }
         }
 
         if (adminsAPI != null) {
+            onCommand(changeCaptchaMethodCommandRegex) {
+                it.doAfterVerification(adminsAPI) {
+                    val settings = it.chat.settings()
+                    if (settings.autoRemoveCommands) {
+                        safelyWithoutExceptions { deleteMessage(it) }
+                    }
+                    val commands = it.parseCommandsWithParams()
+                    val changeCommand = commands.keys.first {
+                        println(it)
+                        changeCaptchaMethodCommandRegex.matches(it)
+                    }
+                    println(changeCommand)
+                    val captcha = when {
+                        changeCommand.startsWith(enableSimpleCaptcha) -> SimpleCaptchaProvider()
+                        changeCommand.startsWith(enableExpressionCaptcha) -> ExpressionCaptchaProvider()
+                        changeCommand.startsWith(enableSlotMachineCaptcha) -> SlotMachineCaptchaProvider()
+                        else -> return@doAfterVerification
+                    }
+                    val newSettings = settings.copy(captchaProvider = captcha)
+                    if (repo.contains(it.chat.id)) {
+                        repo.update(it.chat.id, newSettings)
+                    } else {
+                        repo.create(newSettings)
+                    }
+                    sendMessage(it.chat, "Settings updated").also { sent ->
+                        delay(5000L)
+
+                        if (settings.autoRemoveCommands) {
+                            deleteMessage(sent)
+                        }
+                    }
+                }
+            }
+
             onCommand(
                 enableAutoDeleteCommands,
                 requireOnlyCommandInMessage = false
@@ -181,6 +270,162 @@ class CaptchaBotPlugin : Plugin {
                     )
                 }
             }
+
+            onCommand(disableCaptcha) { message ->
+                message.doAfterVerification(adminsAPI) {
+                    val settings = message.chat.settings()
+
+                    repo.update(
+                        message.chat.id,
+                        settings.copy(enabled = false)
+                    )
+
+                    reply(message, "Captcha has been disabled")
+
+                    if (settings.autoRemoveCommands) {
+                        deleteMessage(message)
+                    }
+                }
+            }
+
+            onCommand(enableCaptcha) { message ->
+                message.doAfterVerification(adminsAPI) {
+                    val settings = message.chat.settings()
+
+                    repo.update(
+                        message.chat.id,
+                        settings.copy(enabled = true)
+                    )
+
+                    reply(message, "Captcha has been enabled")
+
+                    if (settings.autoRemoveCommands) {
+                        deleteMessage(message)
+                    }
+                }
+            }
+
+            onCommand(enableAutoDeleteServiceMessages) { message ->
+                message.doAfterVerification(adminsAPI) {
+                    val settings = message.chat.settings()
+
+                    repo.update(
+                        message.chat.id,
+                        settings.copy(autoRemoveEvents = true)
+                    )
+
+                    reply(message, "Ok, user joined service messages will be deleted")
+
+                    if (settings.autoRemoveCommands) {
+                        deleteMessage(message)
+                    }
+                }
+            }
+
+            onCommand(disableAutoDeleteServiceMessages) { message ->
+                message.doAfterVerification(adminsAPI) {
+                    val settings = message.chat.settings()
+
+                    repo.update(
+                        message.chat.id,
+                        settings.copy(autoRemoveEvents = false)
+                    )
+
+                    reply(message, "Ok, user joined service messages will not be deleted")
+
+                    if (settings.autoRemoveCommands) {
+                        deleteMessage(message)
+                    }
+                }
+            }
+
+            onCommand(enableKickOnUnsuccess) { message ->
+                message.doAfterVerification(adminsAPI) {
+                    val settings = message.chat.settings()
+
+                    repo.update(
+                        message.chat.id,
+                        settings.copy(kickOnUnsuccess = true)
+                    )
+
+                    reply(message, "Ok, new users didn't passed captcha will be kicked").apply {
+                        launchSafelyWithoutExceptions {
+                            delay(5000L)
+                            delete(this@apply)
+                        }
+                    }
+
+                    if (settings.autoRemoveCommands) {
+                        deleteMessage(message)
+                    }
+                }
+            }
+
+            onCommand(disableKickOnUnsuccess) { message ->
+                message.doAfterVerification(adminsAPI) {
+                    val settings = message.chat.settings()
+
+                    repo.update(
+                        message.chat.id,
+                        settings.copy(kickOnUnsuccess = false)
+                    )
+
+                    reply(message, "Ok, new users didn't passed captcha will NOT be kicked").apply {
+                        launchSafelyWithoutExceptions {
+                            delay(5000L)
+                            delete(this@apply)
+                        }
+                    }
+
+                    if (settings.autoRemoveCommands) {
+                        deleteMessage(message)
+                    }
+                }
+            }
+
+            onCommand(enableCAS) { message ->
+                message.doAfterVerification(adminsAPI) {
+                    val settings = message.chat.settings()
+
+                    repo.update(
+                        message.chat.id,
+                        settings.copy(casEnabled = true)
+                    )
+
+                    reply(message, "Ok, CAS banned user will automatically fail captcha").apply {
+                        launchSafelyWithoutExceptions {
+                            delay(5000L)
+                            delete(this@apply)
+                        }
+                    }
+
+                    if (settings.autoRemoveCommands) {
+                        deleteMessage(message)
+                    }
+                }
+            }
+
+            onCommand(disableCAS) { message ->
+                message.doAfterVerification(adminsAPI) {
+                    val settings = message.chat.settings()
+
+                    repo.update(
+                        message.chat.id,
+                        settings.copy(casEnabled = false)
+                    )
+
+                    reply(message, "Ok, CAS banned user will NOT automatically fail captcha").apply {
+                        launchSafelyWithoutExceptions {
+                            delay(5000L)
+                            delete(this@apply)
+                        }
+                    }
+
+                    if (settings.autoRemoveCommands) {
+                        deleteMessage(message)
+                    }
+                }
+            }
         }
     }
 }

src/main/kotlin/dev/inmo/plagubot/plugins/captcha/SlotMachineAnswersMarkup.kt

@@ -1,29 +1,30 @@
 package dev.inmo.plagubot.plugins.captcha
 
+import dev.inmo.plagubot.plugins.captcha.provider.cancelData
 import dev.inmo.tgbotapi.extensions.utils.SlotMachineReelImage
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
+import dev.inmo.tgbotapi.libraries.cache.admins.AdminsCacheAPI
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardButtons.CallbackDataInlineKeyboardButton
+import dev.inmo.tgbotapi.types.buttons.InlineKeyboardButtons.InlineKeyboardButton
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 
 infix fun String.startingOf(target: String) = target.startsWith(this)
 
-fun slotMachineReplyMarkup(
-    first: String? = null,
-    second: String? = null,
-    third: String? = null,
-): InlineKeyboardMarkup {
-    val texts = when {
-        first == null -> SlotMachineReelImage.values().map {
-            CallbackDataInlineKeyboardButton("${it.text}**", it.text)
-        }
-        second == null -> SlotMachineReelImage.values().map {
-            CallbackDataInlineKeyboardButton("$first${it.text}*", it.text)
-        }
-        third == null -> SlotMachineReelImage.values().map {
-            CallbackDataInlineKeyboardButton("$first$second${it.text}", it.text)
-        }
-        else -> listOf(CallbackDataInlineKeyboardButton("$first$second$third", "$first$second$third"))
+private val buttonsPreset: List<List<InlineKeyboardButton>> = SlotMachineReelImage.values().toList().chunked(2).map {
+    it.map {
+        CallbackDataInlineKeyboardButton(it.text, it.text)
+    }
+}
+
+fun slotMachineReplyMarkup(
+    adminCancelButton: Boolean = false
+): InlineKeyboardMarkup {
+    return inlineKeyboard {
+        buttonsPreset.forEach(::add)
+        if (adminCancelButton) {
+            row {
+                dataButton("Cancel (Admins only)", cancelData)
+            }
+        }
     }
-    return InlineKeyboardMarkup(
-        texts.chunked(2)
-    )
 }

src/main/kotlin/dev/inmo/plagubot/plugins/captcha/cas/CASChecker.kt

@@ -0,0 +1,7 @@
+package dev.inmo.plagubot.plugins.captcha.cas
+
+import dev.inmo.tgbotapi.types.UserId
+
+interface CASChecker {
+    suspend fun isBanned(userId: UserId): Boolean
+}

src/main/kotlin/dev/inmo/plagubot/plugins/captcha/cas/KtorCASChecker.kt

@@ -0,0 +1,24 @@
+package dev.inmo.plagubot.plugins.captcha.cas
+
+import dev.inmo.tgbotapi.types.UserId
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.request.get
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+
+class KtorCASChecker(
+    private val httpClient: HttpClient,
+    private val json: Json
+) : CASChecker {
+    @Serializable
+    private data class CheckResponse(
+        val ok: Boolean
+    )
+    override suspend fun isBanned(userId: UserId): Boolean = httpClient.get(
+        "https://api.cas.chat/check?user_id=${userId.chatId}"
+    ).body<String>().let {
+        json.decodeFromString(CheckResponse.serializer(), it)
+    }.ok
+
+}

src/main/kotlin/dev/inmo/plagubot/plugins/captcha/db/CaptchaChatsSettingsRepo.kt

@@ -1,13 +1,25 @@
 package dev.inmo.plagubot.plugins.captcha.db
 
+import dev.inmo.micro_utils.coroutines.launchSynchronously
 import dev.inmo.micro_utils.repos.exposed.*
-import dev.inmo.micro_utils.repos.exposed.keyvalue.ExposedKeyValueRepo
+import dev.inmo.micro_utils.repos.versions.VersionsRepo
+import dev.inmo.plagubot.plugins.captcha.provider.CaptchaProvider
+import dev.inmo.plagubot.plugins.captcha.provider.SimpleCaptchaProvider
 import dev.inmo.plagubot.plugins.captcha.settings.*
 import dev.inmo.tgbotapi.types.ChatId
 import dev.inmo.tgbotapi.types.toChatId
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.serialization.json.Json
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.statements.InsertStatement
 import org.jetbrains.exposed.sql.statements.UpdateStatement
+import org.jetbrains.exposed.sql.transactions.transaction
+
+private val captchaProviderSerialFormat = Json {
+    ignoreUnknownKeys = true
+}
+
+private val defaultCaptchaProviderValue = captchaProviderSerialFormat.encodeToString(CaptchaProvider.serializer(), SimpleCaptchaProvider())
 
 class CaptchaChatsSettingsRepo(
     override val database: Database
@@ -15,47 +27,57 @@ class CaptchaChatsSettingsRepo(
     tableName = "CaptchaChatsSettingsRepo"
 ) {
     private val chatIdColumn = long("chatId")
-    private val checkTimeSecondsColumn = integer("checkTime")
-    private val solveCaptchaTextColumn = text("solveCaptchaText")
+    private val captchaProviderColumn = text("captchaProvider").apply {
+        default(defaultCaptchaProviderValue)
+    }
     private val autoRemoveCommandsColumn = bool("autoRemoveCommands")
+    private val autoRemoveEventsColumn = bool("autoRemoveEvents").apply { default(true) }
+    private val enabledColumn = bool("enabled").default(true)
+    private val kickOnUnsuccessColumn = bool("kick").default(true)
 
     override val primaryKey = PrimaryKey(chatIdColumn)
 
     override val selectByIds: SqlExpressionBuilder.(List<ChatId>) -> Op<Boolean> = {
         chatIdColumn.inList(it.map { it.chatId })
     }
-    override val InsertStatement<Number>.asObject: ChatSettings
-        get() = TODO("Not yet implemented")
 
     override fun insert(value: ChatSettings, it: InsertStatement<Number>) {
         it[chatIdColumn] = value.chatId.chatId
-        it[checkTimeSecondsColumn] = value.checkTime
-        it[solveCaptchaTextColumn] = value.captchaText
+        it[captchaProviderColumn] = captchaProviderSerialFormat.encodeToString(CaptchaProvider.serializer(), value.captchaProvider)
         it[autoRemoveCommandsColumn] = value.autoRemoveCommands
+        it[autoRemoveEventsColumn] = value.autoRemoveEvents
+        it[enabledColumn] = value.enabled
+        it[kickOnUnsuccessColumn] = value.kickOnUnsuccess
     }
 
     override fun update(id: ChatId, value: ChatSettings, it: UpdateStatement) {
         if (id.chatId == value.chatId.chatId) {
-            it[checkTimeSecondsColumn] = value.checkTime
-            it[solveCaptchaTextColumn] = value.captchaText
+            it[captchaProviderColumn] = captchaProviderSerialFormat.encodeToString(CaptchaProvider.serializer(), value.captchaProvider)
             it[autoRemoveCommandsColumn] = value.autoRemoveCommands
+            it[autoRemoveEventsColumn] = value.autoRemoveEvents
+            it[enabledColumn] = value.enabled
+            it[kickOnUnsuccessColumn] = value.kickOnUnsuccess
         }
     }
 
     override fun InsertStatement<Number>.asObject(value: ChatSettings): ChatSettings = ChatSettings(
-        get(chatIdColumn).toChatId(),
-        get(checkTimeSecondsColumn),
-        get(solveCaptchaTextColumn),
-        get(autoRemoveCommandsColumn)
+        chatId = get(chatIdColumn).toChatId(),
+        captchaProvider = captchaProviderSerialFormat.decodeFromString(CaptchaProvider.serializer(), get(captchaProviderColumn)),
+        autoRemoveCommands = get(autoRemoveCommandsColumn),
+        autoRemoveEvents = get(autoRemoveEventsColumn),
+        enabled = get(enabledColumn),
+        kickOnUnsuccess = get(kickOnUnsuccessColumn)
     )
 
     override val selectById: SqlExpressionBuilder.(ChatId) -> Op<Boolean> = { chatIdColumn.eq(it.chatId) }
     override val ResultRow.asObject: ChatSettings
         get() = ChatSettings(
-            get(chatIdColumn).toChatId(),
-            get(checkTimeSecondsColumn),
-            get(solveCaptchaTextColumn),
-            get(autoRemoveCommandsColumn)
+            chatId = get(chatIdColumn).toChatId(),
+            captchaProvider = captchaProviderSerialFormat.decodeFromString(CaptchaProvider.serializer(), get(captchaProviderColumn)),
+            autoRemoveCommands = get(autoRemoveCommandsColumn),
+            autoRemoveEvents = get(autoRemoveEventsColumn),
+            enabled = get(enabledColumn),
+            kickOnUnsuccess = get(kickOnUnsuccessColumn)
         )
 
     init {

src/main/kotlin/dev/inmo/plagubot/plugins/captcha/provider/CaptchaProvider.kt

@@ -0,0 +1,506 @@
+package dev.inmo.plagubot.plugins.captcha.provider
+
+import com.benasher44.uuid.uuid4
+import com.soywiz.klock.*
+import dev.inmo.kslog.common.e
+import dev.inmo.kslog.common.logger
+import dev.inmo.micro_utils.coroutines.*
+import dev.inmo.plagubot.plugins.captcha.slotMachineReplyMarkup
+import dev.inmo.tgbotapi.extensions.api.answers.answer
+import dev.inmo.tgbotapi.extensions.api.answers.answerCallbackQuery
+import dev.inmo.tgbotapi.extensions.api.chat.members.*
+import dev.inmo.tgbotapi.extensions.api.delete
+import dev.inmo.tgbotapi.extensions.api.deleteMessage
+import dev.inmo.tgbotapi.extensions.api.edit.edit
+import dev.inmo.tgbotapi.extensions.api.edit.reply_markup.editMessageReplyMarkup
+import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitMessageDataCallbackQuery
+import dev.inmo.tgbotapi.extensions.utils.asSlotMachineReelImage
+import dev.inmo.tgbotapi.extensions.utils.calculateSlotMachineResult
+import dev.inmo.tgbotapi.extensions.utils.extensions.sameMessage
+import dev.inmo.tgbotapi.extensions.utils.shortcuts.executeUnsafe
+import dev.inmo.tgbotapi.extensions.utils.shortcuts.sentMessages
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
+import dev.inmo.tgbotapi.libraries.cache.admins.AdminsCacheAPI
+import dev.inmo.tgbotapi.requests.DeleteMessage
+import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.buttons.InlineKeyboardButtons.CallbackDataInlineKeyboardButton
+import dev.inmo.tgbotapi.types.chat.ChatPermissions
+import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.chat.User
+import dev.inmo.tgbotapi.types.dice.SlotMachineDiceAnimationType
+import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.utils.*
+import dev.inmo.tgbotapi.utils.EntitiesBuilder
+import dev.inmo.tgbotapi.utils.bold
+import dev.inmo.tgbotapi.utils.regular
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.toList
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient
+import kotlin.random.Random
+
+@Serializable
+sealed class CaptchaProvider {
+    abstract val checkTimeSpan: TimeSpan
+
+    interface CaptchaProviderWorker {
+        suspend fun BehaviourContext.doCaptcha(): Boolean
+
+        suspend fun BehaviourContext.onCloseCaptcha(passed: Boolean)
+    }
+
+    protected abstract suspend fun allocateWorker(
+        eventDateTime: DateTime,
+        chat: GroupChat,
+        user: User,
+        leftRestrictionsPermissions: ChatPermissions,
+        adminsApi: AdminsCacheAPI?,
+        kickOnUnsuccess: Boolean
+    ): CaptchaProviderWorker
+
+    suspend fun BehaviourContext.doAction(
+        eventDateTime: DateTime,
+        chat: GroupChat,
+        newUsers: List<User>,
+        leftRestrictionsPermissions: ChatPermissions,
+        adminsApi: AdminsCacheAPI?,
+        kickOnUnsuccess: Boolean
+    ) {
+        val userBanDateTime = eventDateTime + checkTimeSpan
+        newUsers.map { user ->
+            launch {
+                createSubContextAndDoWithUpdatesFilter {
+                    val worker = allocateWorker(
+                        eventDateTime,
+                        chat,
+                        user,
+                        leftRestrictionsPermissions,
+                        adminsApi,
+                        kickOnUnsuccess
+                    )
+                    val deferred = async {
+                        runCatchingSafely {
+                            with(worker) {
+                                doCaptcha()
+                            }
+                        }.onFailure {
+                            this@CaptchaProvider.logger.e("Unable to do captcha", it)
+                        }.getOrElse { false }
+                    }
+
+                    val subscope = LinkedSupervisorScope()
+                    subscope.launch {
+                        delay((userBanDateTime - eventDateTime).millisecondsLong)
+                        subscope.cancel()
+                    }
+                    subscope.launch {
+                        deferred.await()
+                        subscope.cancel()
+                    }
+
+                    subscope.coroutineContext.job.join()
+
+                    val passed = runCatching {
+                        deferred.getCompleted()
+                    }.onFailure {
+                        deferred.cancel()
+                    }.getOrElse { false }
+
+                    when {
+                        passed -> {
+                            safelyWithoutExceptions {
+                                restrictChatMember(
+                                    chat,
+                                    user,
+                                    permissions = leftRestrictionsPermissions
+                                )
+                            }
+                        }
+                        else -> {
+                            send(chat, " ") {
+                                +"User" + mention(user) + underline("didn't passed") + "captcha"
+                            }
+                            if (kickOnUnsuccess) {
+                                banUser(chat, user, leftRestrictionsPermissions)
+                            }
+                        }
+                    }
+                    with(worker) {
+                        onCloseCaptcha(passed)
+                    }
+                }
+            }
+        }.joinAll()
+    }
+}
+
+internal const val cancelData = "cancel"
+
+private fun EntitiesBuilder.mention(user: User, defaultName: String = "User"): EntitiesBuilder {
+    return mention(
+        listOfNotNull(
+            user.lastName.takeIf { it.isNotBlank() }, user.firstName.takeIf { it.isNotBlank() }
+        ).takeIf {
+            it.isNotEmpty()
+        }?.joinToString(" ") ?: defaultName,
+        user
+    )
+}
+
+private suspend fun BehaviourContext.sendAdminCanceledMessage(
+    chat: Chat,
+    captchaSolver: User,
+    admin: User
+) {
+    safelyWithoutExceptions {
+        send(
+            chat
+        ) {
+            mention(admin, "Admin")
+            regular(" cancelled captcha for ")
+            mention(captchaSolver)
+        }
+    }
+}
+
+private suspend fun BehaviourContext.banUser(
+    chat: PublicChat,
+    user: User,
+    leftRestrictionsPermissions: ChatPermissions,
+    onFailure: suspend BehaviourContext.(Throwable) -> Unit = {
+        safelyWithResult {
+            send(
+                chat
+            ) {
+                mention(user)
+                +"failed captcha"
+            }
+        }
+    }
+): Result<Boolean> = safelyWithResult {
+    restrictChatMember(chat, user, permissions = leftRestrictionsPermissions)
+    banChatMember(chat, user)
+}.onFailure {
+    onFailure(it)
+}
+
+@Serializable
+data class SlotMachineCaptchaProvider(
+    val checkTimeSeconds: Seconds = 60,
+    val captchaText: String = "Solve this captcha: "
+) : CaptchaProvider() {
+    @Transient
+    override val checkTimeSpan = checkTimeSeconds.seconds
+
+    private inner class Worker(
+        private val chat: GroupChat,
+        private val user: User,
+        private val adminsApi: AdminsCacheAPI?
+    ) : CaptchaProviderWorker {
+        private val messagesToDelete = mutableListOf<Message>()
+
+        override suspend fun BehaviourContext.doCaptcha(): Boolean {
+            val baseBuilder: EntitiesBuilderBody = {
+                mention(user)
+                regular(", $captchaText")
+            }
+            val sentMessage = send(
+                chat
+            ) {
+                baseBuilder()
+                +": ✖✖✖"
+            }.also { messagesToDelete.add(it) }
+            val sentDice = sendDice(
+                sentMessage.chat,
+                SlotMachineDiceAnimationType,
+                replyToMessageId = sentMessage.messageId,
+                replyMarkup = slotMachineReplyMarkup(adminsApi != null)
+            ).also { messagesToDelete.add(it) }
+            val reels = sentDice.content.dice.calculateSlotMachineResult()!!
+            val leftToClick = mutableListOf(
+                reels.left.asSlotMachineReelImage.text,
+                reels.center.asSlotMachineReelImage.text,
+                reels.right.asSlotMachineReelImage.text
+            )
+            val clicked = mutableListOf<String>()
+            fun buildTemplate() = "${clicked.joinToString("")}${leftToClick.joinToString("") { "✖" }}"
+
+            waitMessageDataCallbackQuery().filter {
+                when {
+                    !it.message.sameMessage(sentDice) -> false
+                    it.data == cancelData && adminsApi ?.isAdmin(chat.id, it.user.id) == true -> return@filter true
+                    it.data == cancelData && adminsApi ?.isAdmin(chat.id, it.user.id) != true -> {
+                        answer(
+                            it,
+                            "This button is only for admins"
+                        )
+                        false
+                    }
+                    it.user.id != user.id -> {
+                        answer(it, "This button is not for you")
+                        false
+                    }
+                    it.data != leftToClick.first() -> {
+                        answer(it, "Nope")
+                        false
+                    }
+                    else -> {
+                        clicked.add(leftToClick.removeFirst())
+                        answer(it, "Ok, next one")
+                        edit(sentMessage) {
+                            baseBuilder()
+                            +": ${buildTemplate()}"
+                        }
+                        leftToClick.isEmpty()
+                    }
+                }
+            }.first()
+
+            return true
+        }
+
+        override suspend fun BehaviourContext.onCloseCaptcha(passed: Boolean) {
+            while (messagesToDelete.isNotEmpty()) {
+                runCatchingSafely { delete(messagesToDelete.removeFirst()) }
+            }
+        }
+
+    }
+
+    override suspend fun allocateWorker(
+        eventDateTime: DateTime,
+        chat: GroupChat,
+        user: User,
+        leftRestrictionsPermissions: ChatPermissions,
+        adminsApi: AdminsCacheAPI?,
+        kickOnUnsuccess: Boolean
+    ): CaptchaProviderWorker = Worker(chat, user, adminsApi)
+}
+
+@Serializable
+data class SimpleCaptchaProvider(
+    val checkTimeSeconds: Seconds = 60,
+    val captchaText: String = "press this button to pass captcha:",
+    val buttonText: String = "Press me\uD83D\uDE0A"
+) : CaptchaProvider() {
+    @Transient
+    override val checkTimeSpan = checkTimeSeconds.seconds
+
+    private inner class Worker(
+        private val chat: GroupChat,
+        private val user: User,
+        private val adminsApi: AdminsCacheAPI?
+    ) : CaptchaProviderWorker {
+        private var sentMessage: Message? = null
+        override suspend fun BehaviourContext.doCaptcha(): Boolean {
+            val callbackData = uuid4().toString()
+            val sentMessage = send(
+                chat,
+                replyMarkup = inlineKeyboard {
+                    row {
+                        dataButton(buttonText, callbackData)
+                    }
+                    if (adminsApi != null) {
+                        row {
+                            dataButton("Cancel (Admins only)", cancelData)
+                        }
+                    }
+                }
+            ) {
+                mention(user)
+                regular(", $captchaText")
+            }
+            this@Worker.sentMessage = sentMessage
+
+            val pushed = waitMessageDataCallbackQuery().filter {
+                when {
+                    !it.message.sameMessage(sentMessage) -> false
+                    it.data == callbackData && it.user.id == user.id -> true
+                    it.data == cancelData && (adminsApi ?.isAdmin(chat.id, it.user.id) == true) -> true
+                    it.data == callbackData -> {
+                        answer(it, "This button is not for you")
+                        false
+                    }
+                    it.data == cancelData -> {
+                        answer(it, "This button is for admins only")
+                        false
+                    }
+                    else -> false
+                }
+            }.first()
+
+            answer(
+                pushed,
+                when (pushed.data) {
+                    cancelData -> "You have cancelled captcha"
+                    else -> "Ok, thanks"
+                }
+            )
+
+            return true
+        }
+
+        override suspend fun BehaviourContext.onCloseCaptcha(passed: Boolean) {
+            sentMessage ?.let {
+                delete(it)
+            }
+        }
+
+    }
+
+    override suspend fun allocateWorker(
+        eventDateTime: DateTime,
+        chat: GroupChat,
+        user: User,
+        leftRestrictionsPermissions: ChatPermissions,
+        adminsApi: AdminsCacheAPI?,
+        kickOnUnsuccess: Boolean
+    ): CaptchaProviderWorker = Worker(chat, user, adminsApi)
+}
+
+private object ExpressionBuilder {
+    sealed class ExpressionOperation {
+        object PlusExpressionOperation : ExpressionOperation() {
+            override fun asString(): String = "+"
+
+            override fun Int.perform(other: Int): Int = plus(other)
+        }
+
+        object MinusExpressionOperation : ExpressionOperation() {
+            override fun asString(): String = "-"
+
+            override fun Int.perform(other: Int): Int = minus(other)
+        }
+
+        abstract fun asString(): String
+        abstract fun Int.perform(other: Int): Int
+    }
+
+    private val experssions =
+        listOf(ExpressionOperation.PlusExpressionOperation, ExpressionOperation.MinusExpressionOperation)
+
+    private fun createNumber(max: Int) = Random.nextInt(max + 1)
+    fun generateResult(max: Int, operationsNumber: Int = 1): Int {
+        val operations = (0 until operationsNumber).map { experssions.random() }
+        var current = createNumber(max)
+        operations.forEach {
+            val rightOne = createNumber(max)
+            current = it.run { current.perform(rightOne) }
+        }
+        return current
+    }
+
+    fun createExpression(max: Int, operationsNumber: Int = 1): Pair<Int, String> {
+        val operations = (0 until operationsNumber).map { experssions.random() }
+        var current = createNumber(max)
+        var numbersString = "$current"
+        operations.forEach {
+            val rightOne = createNumber(max)
+            current = it.run { current.perform(rightOne) }
+            numbersString += " ${it.asString()} $rightOne"
+        }
+        return current to numbersString
+    }
+}
+
+@Serializable
+data class ExpressionCaptchaProvider(
+    val checkTimeSeconds: Seconds = 60,
+    val captchaText: String = "Solve next captcha:",
+    val leftRetriesText: String = "Nope, left retries: ",
+    val maxPerNumber: Int = 10,
+    val operations: Int = 2,
+    val answers: Int = 6,
+    val attempts: Int = 3
+) : CaptchaProvider() {
+    @Transient
+    override val checkTimeSpan = checkTimeSeconds.seconds
+
+    private inner class Worker(
+        private val chat: GroupChat,
+        private val user: User,
+        private val adminsApi: AdminsCacheAPI?
+    ) : CaptchaProviderWorker {
+        private var sentMessage: Message? = null
+        override suspend fun BehaviourContext.doCaptcha(): Boolean {
+            val callbackData = ExpressionBuilder.createExpression(
+                maxPerNumber,
+                operations
+            )
+            val correctAnswer = callbackData.first.toString()
+            val answers = (0 until answers - 1).map {
+                ExpressionBuilder.generateResult(maxPerNumber, operations)
+            }.toMutableList().also { orderedAnswers ->
+                val correctAnswerPosition = Random.nextInt(orderedAnswers.size)
+                orderedAnswers.add(correctAnswerPosition, callbackData.first)
+            }.toList()
+            val sentMessage = send(
+                chat,
+                replyMarkup = inlineKeyboard {
+                    answers.map {
+                        CallbackDataInlineKeyboardButton(it.toString(), it.toString())
+                    }.chunked(3).forEach(::add)
+                    if (adminsApi != null) {
+                        row {
+                            dataButton("Cancel (Admins only)", cancelData)
+                        }
+                    }
+                }
+            ) {
+                mention(user)
+                regular(", $captchaText ")
+                bold(callbackData.second)
+            }.also {
+                sentMessage = it
+            }
+
+            var leftAttempts = attempts
+            return waitMessageDataCallbackQuery().takeWhile { leftAttempts > 0 }.map { query ->
+                val baseCheck = query.message.messageId == sentMessage.messageId
+                val dataCorrect = (query.user.id == user.id && query.data == correctAnswer)
+                val adminCanceled = (query.data == cancelData && (adminsApi?.isAdmin(
+                    sentMessage.chat.id,
+                    query.user.id
+                )) == true)
+                baseCheck && if (dataCorrect || adminCanceled) {
+                    if (adminCanceled) {
+                        sendAdminCanceledMessage(
+                            sentMessage.chat,
+                            user,
+                            query.user
+                        )
+                    }
+                    true
+                } else {
+                    leftAttempts--
+                    if (leftAttempts > 0) {
+                        answerCallbackQuery(query, leftRetriesText + leftAttempts)
+                    }
+                    false
+                }
+            }.firstOrNull() ?: false
+        }
+
+        override suspend fun BehaviourContext.onCloseCaptcha(passed: Boolean) {
+            sentMessage ?.let {
+                delete(it)
+            }
+        }
+    }
+
+    override suspend fun allocateWorker(
+        eventDateTime: DateTime,
+        chat: GroupChat,
+        user: User,
+        leftRestrictionsPermissions: ChatPermissions,
+        adminsApi: AdminsCacheAPI?,
+        kickOnUnsuccess: Boolean
+    ): CaptchaProviderWorker = Worker(chat, user, adminsApi)
+}
+

src/main/kotlin/dev/inmo/plagubot/plugins/captcha/settings/ChatSettings.kt

@@ -1,18 +1,17 @@
 package dev.inmo.plagubot.plugins.captcha.settings
 
-import com.soywiz.klock.TimeSpan
+import dev.inmo.plagubot.plugins.captcha.provider.CaptchaProvider
+import dev.inmo.plagubot.plugins.captcha.provider.SimpleCaptchaProvider
 import dev.inmo.tgbotapi.types.ChatId
-import dev.inmo.tgbotapi.types.Seconds
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.Transient
 
 @Serializable
 data class ChatSettings(
     val chatId: ChatId,
-    val checkTime: Seconds = 60,
-    val captchaText: String = "solve next captcha:",
-    val autoRemoveCommands: Boolean = false
-) {
-    @Transient
-    val checkTimeSpan = TimeSpan(checkTime * 1000.0)
-}
+    val captchaProvider: CaptchaProvider = SimpleCaptchaProvider(),
+    val autoRemoveCommands: Boolean = false,
+    val autoRemoveEvents: Boolean = true,
+    val kickOnUnsuccess: Boolean = true,
+    val enabled: Boolean = true,
+    val casEnabled: Boolean = false
+)