Merge branch 'master' into 1.0.0

CHANGELOG.md

@@ -47,6 +47,22 @@ __All the `tgbotapi.extensions.*` packages have been removed__
 * `BehaviourBuilder`:
     * `SimpleFilter` now is a `fun interface` instead of just callback (fix of [#546](https://github.com/InsanusMokrassar/TelegramBotAPI/issues/546))
 
+## 0.38.20
+
+* `BehaviourBuilder FSM`:
+    * Hotfixes
+* `WebApps`:
+    * New extension `TelegramBot#answerWebAppQuery`
+    * New function `handleResult`
+
+## 0.38.19
+
+* `BehaviourBuilder`:
+    * Hotfixes
+* `BehaviourBuilder FSM`:
+    * `BehaviourContextWithFSMBuilder` deprecated in favor to `BehaviourContextWithFSM`
+    * Now it is possible to define additional handlers in subcontexts of `BehaviourBuilderWithFSM`
+
 ## 0.38.18
 
 * `Core`:

tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourContextWithFSM.kt

@@ -9,6 +9,8 @@ import dev.inmo.micro_utils.coroutines.accumulatorFlow
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.*
+import kotlin.jvm.JvmName
+import kotlin.reflect.KClass
 
 /**
  * Interface which combine [BehaviourContext] and [StatesMachine]. Subcontext of triggers and states contexts must have
@@ -26,10 +28,31 @@ interface BehaviourContextWithFSM<T : State> : BehaviourContext, StatesMachine<T
         handlers: List<BehaviourWithFSMStateHandlerHolder<*, T>>
     ): T? {
         return handlers.firstOrNull { it.checkHandleable(state) } ?.run {
-            handleState(contextUpdatesFlow, state)
+            doInSubContext(updatesUpstreamFlow = contextUpdatesFlow) {
+                handleState(state)
+            }
         }
     }
 
+    /**
+     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
+     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
+     *
+     * @see BehaviourWithFSMStateHandlerHolder
+     * @see onStateOrSubstate
+     */
+    fun <I : T> add(kClass: KClass<I>, strict: Boolean = false, handler: BehaviourWithFSMStateHandler<I, T>)
+
+    /**
+     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
+     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
+     * requirements
+     *
+     * @see BehaviourWithFSMStateHandlerHolder
+     * @see strictlyOn
+     */
+    fun <I : T> addStrict(kClass: KClass<I>, handler: BehaviourWithFSMStateHandler<I, T>) = add(kClass, strict = true, handler)
+
     override fun copy(
         bot: TelegramBot,
         scope: CoroutineScope,
@@ -48,6 +71,28 @@ interface BehaviourContextWithFSM<T : State> : BehaviourContext, StatesMachine<T
     }
 }
 
+
+/**
+ * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
+ * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
+ *
+ * @see BehaviourWithFSMStateHandlerHolder
+ * @see BehaviourContextWithFSM.add
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+inline fun <reified I : O, O: State> BehaviourContextWithFSM<O>.onStateOrSubstate(handler: BehaviourWithFSMStateHandler<I, O>) = add(I::class, strict = false, handler)
+
+/**
+ * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
+ * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
+ * requirements
+ *
+ * @see BehaviourWithFSMStateHandlerHolder
+ * @see BehaviourContextWithFSM.addStrict
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+inline fun <reified I : O, O: State> BehaviourContextWithFSM<O>.strictlyOn(handler: BehaviourWithFSMStateHandler<I, O>) = addStrict(I::class, handler)
+
 /**
  * Default realization of [BehaviourContextWithFSM]. It uses [behaviourContext] as a base for this object as
  * [BehaviourContext], but managing substates contexts updates for avoiding of updates lost between states
@@ -58,6 +103,9 @@ class DefaultBehaviourContextWithFSM<T : State>(
     private val handlers: List<BehaviourWithFSMStateHandlerHolder<*, T>>
 ) : BehaviourContext by behaviourContext, BehaviourContextWithFSM<T> {
     private val updatesFlows = mutableMapOf<Any, Flow<Update>>()
+    private val additionalHandlers = mutableListOf<BehaviourWithFSMStateHandlerHolder<*, T>>()
+    private var actualHandlersList = additionalHandlers + handlers
+
     private fun getContextUpdatesFlow(context: Any) = updatesFlows.getOrPut(context) {
         allUpdatesFlow.accumulatorFlow(scope)
     }
@@ -65,12 +113,17 @@ class DefaultBehaviourContextWithFSM<T : State>(
     override suspend fun StatesMachine<in T>.handleState(state: T): T? = launchStateHandling(
         state,
         allUpdatesFlow,
-        handlers
+        actualHandlersList
     )
 
+    override fun <I : T> add(kClass: KClass<I>, strict: Boolean, handler: BehaviourWithFSMStateHandler<I, T>) {
+        additionalHandlers.add(BehaviourWithFSMStateHandlerHolder(kClass, strict, handler))
+        actualHandlersList = additionalHandlers + handlers
+    }
+
     override fun start(scope: CoroutineScope): Job = scope.launchSafelyWithoutExceptions {
         val statePerformer: suspend (T) -> Unit = { state: T ->
-            val newState = launchStateHandling(state, getContextUpdatesFlow(state.context), handlers)
+            val newState = launchStateHandling(state, getContextUpdatesFlow(state.context), actualHandlersList)
             if (newState != null) {
                 statesManager.update(state, newState)
             } else {
@@ -94,6 +147,26 @@ class DefaultBehaviourContextWithFSM<T : State>(
             launch { statePerformer(it) }
         }
     }
+    /**
+     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
+     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
+     *
+     * @see BehaviourWithFSMStateHandlerHolder
+     * @see BehaviourContextWithFSM.add
+     */
+    @Suppress("MemberVisibilityCanBePrivate")
+    inline fun <reified I : T> onStateOrSubstate(handler: BehaviourWithFSMStateHandler<I, T>) = add(I::class, strict = false, handler)
+
+    /**
+     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
+     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
+     * requirements
+     *
+     * @see BehaviourWithFSMStateHandlerHolder
+     * @see BehaviourContextWithFSM.addStrict
+     */
+    @Suppress("MemberVisibilityCanBePrivate")
+    inline fun <reified I : T> strictlyOn(handler: BehaviourWithFSMStateHandler<I, T>) = addStrict(I::class, handler)
 
     override suspend fun startChain(state: T) {
         statesManager.startChain(state)
@@ -106,7 +179,7 @@ class DefaultBehaviourContextWithFSM<T : State>(
         onBufferOverflow: BufferOverflow,
         upstreamUpdatesFlow: Flow<Update>?,
         updatesFilter: BehaviourContextAndTypeReceiver<Boolean, Update>?
-    ): BehaviourContextWithFSM<T> = BehaviourContextWithFSM(
+    ): DefaultBehaviourContextWithFSM<T> = BehaviourContextWithFSM(
         behaviourContext.copy(bot, scope, broadcastChannelsSize, onBufferOverflow, upstreamUpdatesFlow, updatesFilter),
         handlers,
         statesManager

tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourContextWithFSMBuilder.kt

@@ -14,70 +14,8 @@ import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.Flow
 import kotlin.reflect.KClass
 
-class BehaviourContextWithFSMBuilder<T : State> internal constructor(
-    private val resultBehaviourContext: BehaviourContextWithFSM<T>,
-    private val handlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>>
-) : BehaviourContextWithFSM<T> by resultBehaviourContext {
-    internal constructor(
-        baseBehaviourContext: BehaviourContext,
-        statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-        handlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf()
-    ) : this(DefaultBehaviourContextWithFSM(baseBehaviourContext, statesManager, handlers), handlers)
-
-    /**
-     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
-     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see onStateOrSubstate
-     */
-    fun <I : T> add(kClass: KClass<I>, handler: BehaviourWithFSMStateHandler<I, T>) {
-        handlers.add(BehaviourWithFSMStateHandlerHolder(kClass, false, handler))
-    }
-
-    /**
-     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
-     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
-     * requirements
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see strictlyOn
-     */
-    fun <I : T> addStrict(kClass: KClass<I>, handler: BehaviourWithFSMStateHandler<I, T>) {
-        handlers.add(BehaviourWithFSMStateHandlerHolder(kClass, true, handler))
-    }
-
-
-    /**
-     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
-     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see BehaviourContextWithFSMBuilder.add
-     */
-    @Suppress("MemberVisibilityCanBePrivate")
-    inline fun <reified I : T> onStateOrSubstate(handler: BehaviourWithFSMStateHandler<I, T>) {
-        add(I::class, handler)
-    }
-
-    /**
-     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
-     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
-     * requirements
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see BehaviourContextWithFSMBuilder.addStrict
-     */
-    @Suppress("MemberVisibilityCanBePrivate")
-    inline fun <reified I : T> strictlyOn(handler: BehaviourWithFSMStateHandler<I, T>) {
-        addStrict(I::class, handler)
-    }
-
-    /**
-     * Returns completed [resultBehaviourContext], [handlers] and [statesManager]
-     */
-    internal fun build() = resultBehaviourContext
-}
+@Deprecated("Will be removed soon")
+typealias BehaviourContextWithFSMBuilder<T> = BehaviourContextWithFSM<T>
 
 /**
  * Creates [BehaviourContextWithFSM] via creating of [DefaultBehaviourContext] with [this] as [TelegramBot],
@@ -94,17 +32,17 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
     scope: CoroutineScope = defaultCoroutineScopeProvider(),
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
-): BehaviourContextWithFSM<T> = BehaviourContextWithFSMBuilder(
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
+): DefaultBehaviourContextWithFSM<T> = BehaviourContextWithFSM(
     DefaultBehaviourContext(
         this,
         defaultExceptionsHandler ?.let { scope + ContextSafelyExceptionHandler(it) } ?: scope,
         upstreamUpdatesFlow = upstreamUpdatesFlow
     ),
-    statesManager,
-    presetHandlers
-).apply { block() }.build()
+    presetHandlers,
+    statesManager
+).apply { block() }
 
 /**
  * Use [buildBehaviourWithFSM] to create [BehaviourContextWithFSM] and launch getting of updates
@@ -116,9 +54,9 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
     scope: CoroutineScope = defaultCoroutineScopeProvider(),
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
-): Pair<BehaviourContextWithFSM<T>, Job> = buildBehaviourWithFSM(
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
+): Pair<DefaultBehaviourContextWithFSM<T>, Job> = buildBehaviourWithFSM(
     upstreamUpdatesFlow,
     scope,
     defaultExceptionsHandler,
@@ -147,8 +85,8 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
  * @see BehaviourContext
  * @see BehaviourContextWithFSM
  * @see longPolling
- * @see BehaviourContextWithFSMBuilder.strictlyOn
- * @see BehaviourContextWithFSMBuilder.onStateOrSubstate
+ * @see BehaviourContextWithFSM.strictlyOn
+ * @see BehaviourContextWithFSM.onStateOrSubstate
  */
 @PreviewFeature
 suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
@@ -156,17 +94,17 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
     scope: CoroutineScope = defaultCoroutineScopeProvider(),
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
-): BehaviourContextWithFSM<T> = BehaviourContextWithFSMBuilder(
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
+): DefaultBehaviourContextWithFSM<T> = BehaviourContextWithFSM(
     DefaultBehaviourContext(
         this,
         defaultExceptionsHandler ?.let { scope + ContextSafelyExceptionHandler(it) } ?: scope,
         upstreamUpdatesFlow = flowUpdatesFilter.allUpdatesFlow
     ),
-    statesManager,
-    presetHandlers
-).apply { block() }.build()
+    presetHandlers,
+    statesManager
+).apply { block() }
 
 /**
  * Use [buildBehaviourWithFSM] to create [BehaviourContextWithFSM] and launch getting of updates
@@ -176,16 +114,16 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
  * @see buildBehaviourWithFSMAndStartLongPolling
  * @see BehaviourContext
  * @see longPolling
- * @see BehaviourContextWithFSMBuilder.strictlyOn
- * @see BehaviourContextWithFSMBuilder.onStateOrSubstate
+ * @see BehaviourContextWithFSM.strictlyOn
+ * @see BehaviourContextWithFSM.onStateOrSubstate
  */
 @PreviewFeature
 suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
     scope: CoroutineScope = defaultCoroutineScopeProvider(),
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ) = FlowsUpdatesFilter().let {
     buildBehaviourWithFSM(
         it,

tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourWithFSMStateHandlerHolder.kt

@@ -34,20 +34,11 @@ class BehaviourWithFSMStateHandlerHolder<I : O, O : State>(
 
     /**
      * Handling of state :)
-     *
-     * @param contextUpdatesFlow This [Flow] will be used as source of updates. By contract, this [Flow] must be common
-     * for all [State]s of incoming [state] [State.context] and for the whole chain inside of [BehaviourContextWithFSM]
      */
     suspend fun BehaviourContextWithFSM<in O>.handleState(
-        contextUpdatesFlow: Flow<Update>,
         state: O
-    ): O? {
-        val subscope = scope.LinkedSupervisorScope()
-        return with(copy(scope = subscope, upstreamUpdatesFlow = contextUpdatesFlow)) {
-            with(delegateTo) {
-                handleState(state as I)
-            }
-        }
+    ): O? = with(delegateTo) {
+        handleState(state as I)
     }
 }
 

tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/TelegramBotWithFSM.kt

@@ -37,9 +37,9 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSM(
     builder: KtorRequestsExecutorBuilder.() -> Unit = {},
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
     testServer: Boolean = false,
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ): TelegramBot = telegramBot(
     token,
     apiUrl,
@@ -74,9 +74,9 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSMAndStartLongPolling(
     builder: KtorRequestsExecutorBuilder.() -> Unit = {},
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
     testServer: Boolean = false,
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ): Pair<TelegramBot, Job> {
     return telegramBot(
         token,

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/requests/answers/AnswerWebAppQuery.kt

@@ -6,6 +6,9 @@ import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.abstracts.InlineQ
 import dev.inmo.tgbotapi.types.webapps.query.SentWebAppMessage
 import kotlinx.serialization.*
 
+/**
+ * @param webAppQueryId [dev.inmo.tgbotapi.webapps.WebAppInitData.queryId]
+ */
 @Serializable
 data class AnswerWebAppQuery(
     @SerialName(webAppQueryIdField)

tgbotapi.webapps/src/jsMain/kotlin/dev/inmo/tgbotapi/webapps/AnswerWebAppQuery.kt

@@ -0,0 +1,11 @@
+package dev.inmo.tgbotapi.webapps
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.answers.AnswerWebAppQuery
+import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.abstracts.InlineQueryResult
+
+suspend fun TelegramBot.answerWebAppQuery(
+    result: InlineQueryResult
+) = webApp.initDataUnsafe.queryId ?.let {
+    execute(AnswerWebAppQuery(it, result))
+}

tgbotapi.webapps/src/jsMain/kotlin/dev/inmo/tgbotapi/webapps/SendData.kt

@@ -0,0 +1,18 @@
+package dev.inmo.tgbotapi.webapps
+
+import dev.inmo.tgbotapi.types.WebAppQueryId
+
+/**
+ * @param onSendData Should return the data which must be used in [WebApp.sendData]. If returns null, data will not be sent
+ * @param onAnswerWebAppQuery In case if [WebAppInitData.queryId] is presented in [WebApp.initDataUnsafe], will be called
+ * that callback. Before and after calling of this callback will not be used any method of answering to the telegram
+ * system, so, you must use something like [answerWebAppQuery] by yourself to send the result
+ */
+inline fun handleResult(
+    onSendData: () -> String?,
+    onAnswerWebAppQuery: (WebAppQueryId) -> Unit
+) {
+    webApp.initDataUnsafe.queryId ?.let {
+        onAnswerWebAppQuery(it)
+    } ?: webApp.sendData(onSendData() ?: return)
+}