feat: impl option set_bot_commands which updates the Telegram-side …

…bot's command list

- allows the user not to worry about their commands not being known.

lib/ferogram/src/client.rs

@@ -10,7 +10,9 @@
 
 use std::path::Path;
 
-use grammers_client::{session::Session, Config, InitParams, ReconnectionPolicy, SignInError};
+use grammers_client::{
+    grammers_tl_types as tl, session::Session, Config, InitParams, ReconnectionPolicy, SignInError,
+};
 use grammers_mtsender::ServerAddr;
 
 use crate::{di, utils::prompt, Context, Dispatcher, ErrorHandler, Result};
@@ -29,6 +31,8 @@ pub struct Client {
 
     /// Whether the client is connected.
     is_connected: bool,
+    /// Whether is to update Telegram's bot commands.
+    set_bot_commands: bool,
     /// Wheter is to wait for a `Ctrl + C` signal to close the connection and exit the app.
     wait_for_ctrl_c: bool,
 
@@ -240,6 +244,35 @@ impl Client {
         let err_handler = self.err_handler;
         let ready_handler = self.ready_handler;
 
+        if self.set_bot_commands {
+            let mut commands = Vec::new();
+
+            let command_filters = dispatcher.get_commands();
+            for command_filter in command_filters.into_iter() {
+                let patterns = command_filter
+                    .command
+                    .split("|")
+                    .filter(|pattern| pattern.len() > 1)
+                    .collect::<Vec<_>>();
+                let description = command_filter.description;
+
+                for pattern in patterns.iter() {
+                    commands.push(tl::enums::BotCommand::Command(tl::types::BotCommand {
+                        command: pattern.to_string(),
+                        description: description.to_string(),
+                    }));
+                }
+            }
+
+            handle
+                .invoke(&tl::functions::bots::SetBotCommands {
+                    scope: tl::enums::BotCommandScope::Default,
+                    lang_code: "en".to_string(),
+                    commands,
+                })
+                .await?;
+        }
+
         let client = handle.clone();
 
         tokio::task::spawn(async move {
@@ -332,7 +365,9 @@ pub struct ClientBuilder {
     /// The initial parameters.
     init_params: InitParams,
 
-    /// Wheter is to wait for a `Ctrl + C` signal to close the connection and exit the app.
+    /// Whether is to update Telegram's bot commands.
+    set_bot_commands: bool,
+    /// Whether is to wait for a `Ctrl + C` signal to close the connection and exit the app.
     wait_for_ctrl_c: bool,
 
     /// The global error handler.
@@ -409,6 +444,7 @@ impl ClientBuilder {
             session_file: Some(session_file.to_string()),
 
             is_connected: false,
+            set_bot_commands: self.set_bot_commands,
             wait_for_ctrl_c: self.wait_for_ctrl_c,
 
             err_handler: self.err_handler,
@@ -650,6 +686,16 @@ impl ClientBuilder {
         self
     }
 
+    /// Updates the Telegram-side bot's command list by collecting all the commands
+    /// from the dispatcher's handlers.
+    ///
+    /// Only commands that has more than `1` char will be registered.
+    /// Ex: `start`, `help`...
+    pub fn set_bot_commands(mut self) -> Self {
+        self.set_bot_commands = true;
+        self
+    }
+
     /// Sets the reconnection policy.
     ///
     /// Executed when the client loses the connection or the Telegram server closes it.

lib/ferogram/src/dispatcher.rs

@@ -11,7 +11,7 @@
 use grammers_client::{types::Chat, Client, Update};
 use tokio::sync::broadcast::Sender;
 
-use crate::{di, Context, Plugin, Result, Router};
+use crate::{di, filters::Command, Context, Plugin, Result, Router};
 
 /// A dispatcher.
 ///
@@ -123,6 +123,20 @@ impl Dispatcher {
         self
     }
 
+    /// Returns the commands from the routers and plugins.
+    pub(crate) fn get_commands(&self) -> Vec<Command> {
+        let mut commands = Vec::new();
+
+        commands.extend(self.routers.iter().flat_map(|router| router.get_commands()));
+        commands.extend(
+            self.plugins
+                .iter()
+                .flat_map(|plugin| plugin.router.get_commands()),
+        );
+
+        commands
+    }
+
     /// Handle the update sent by Telegram.
     ///
     /// Returns `Ok(())` if the update was handled.

lib/ferogram/src/filter.rs

@@ -8,7 +8,7 @@
 
 //! Filters module.
 
-use std::sync::Arc;
+use std::{any::Any, sync::Arc};
 
 use async_trait::async_trait;
 use futures_util::Future;
@@ -54,6 +54,14 @@ pub trait Filter: CloneFilter + Send + Sync + 'static {
             filter: Box::new(self),
         }
     }
+
+    /// Returns the filter as a `Any` trait object..
+    fn as_any(&self) -> &dyn Any
+    where
+        Self: Sized,
+    {
+        self
+    }
 }
 
 #[async_trait]

lib/ferogram/src/filters/command.rs

@@ -14,7 +14,7 @@ use tokio::sync::Mutex;
 
 use crate::{Filter, Flow};
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Command {
     pub(crate) prefixes: Vec<String>,
     pub(crate) command: String,

lib/ferogram/src/filters/mod.rs

@@ -14,7 +14,7 @@ mod or;
 use std::sync::Arc;
 
 pub(crate) use and::And;
-use command::Command;
+pub(crate) use command::Command;
 use grammers_client::{
     grammers_tl_types as tl,
     types::{Chat, Media},

lib/ferogram/src/handler.rs

@@ -10,7 +10,7 @@
 
 use grammers_client::{Client, Update};
 
-use crate::{di, flow, ErrorHandler, Filter, Flow};
+use crate::{di, filter::Command, flow, ErrorHandler, Filter, Flow};
 
 /// A handler.
 ///
@@ -21,7 +21,9 @@ pub struct Handler {
     update_type: UpdateType,
 
     /// The filter.
-    filter: Option<Box<dyn Filter>>,
+    pub(crate) filter: Option<Box<dyn Filter>>,
+    /// The command.
+    pub(crate) command: Option<Command>,
     /// The endpoint.
     pub(crate) endpoint: Option<di::Endpoint>,
     /// The error handler.
@@ -31,10 +33,13 @@ pub struct Handler {
 impl Handler {
     /// Creates a new [`HandlerType::NewMessage`] handler.
     pub fn new_message<F: Filter>(filter: F) -> Self {
+        let command = filter.as_any().downcast_ref::<Command>().cloned();
+
         Self {
             update_type: UpdateType::NewMessage,
 
             filter: Some(Box::new(filter)),
+            command,
             endpoint: None,
             err_handler: None,
         }
@@ -46,17 +51,21 @@ impl Handler {
             update_type: UpdateType::Raw,
 
             filter: Some(Box::new(filter)),
+            command: None,
             endpoint: None,
             err_handler: None,
         }
     }
 
     /// Creates a new [`HandlerType::MessageEdited`] handler.
     pub fn message_edited<F: Filter>(filter: F) -> Self {
+        let command = filter.as_any().downcast_ref::<Command>().cloned();
+
         Self {
             update_type: UpdateType::MessageEdited,
 
             filter: Some(Box::new(filter)),
+            command,
             endpoint: None,
             err_handler: None,
         }
@@ -68,6 +77,7 @@ impl Handler {
             update_type: UpdateType::MessageDeleted,
 
             filter: Some(Box::new(filter)),
+            command: None,
             endpoint: None,
             err_handler: None,
         }
@@ -79,6 +89,7 @@ impl Handler {
             update_type: UpdateType::CallbackQuery,
 
             filter: Some(Box::new(filter)),
+            command: None,
             endpoint: None,
             err_handler: None,
         }
@@ -90,6 +101,7 @@ impl Handler {
             update_type: UpdateType::InlineQuery,
 
             filter: Some(Box::new(filter)),
+            command: None,
             endpoint: None,
             err_handler: None,
         }
@@ -220,6 +232,7 @@ pub fn then<I, H: di::Handler>(endpoint: impl di::IntoHandler<I, Handler = H>) -
         update_type: UpdateType::Raw,
 
         filter: None,
+        command: None,
         endpoint: Some(Box::new(endpoint.into_handler())),
         err_handler: None,
     }

lib/ferogram/src/router.rs

@@ -11,7 +11,7 @@
 use async_recursion::async_recursion;
 use grammers_client::Update;
 
-use crate::{di::Injector, Handler, Result};
+use crate::{di::Injector, filter::Command, Handler, Result};
 
 /// A router.
 ///
@@ -58,6 +58,20 @@ impl Router {
         self
     }
 
+    /// Returns the commands from the handlers.
+    pub(crate) fn get_commands(&self) -> Vec<Command> {
+        let mut commands = Vec::new();
+
+        commands.extend(
+            self.handlers
+                .iter()
+                .filter_map(|handler| handler.command.clone()),
+        );
+        commands.extend(self.routers.iter().flat_map(|router| router.get_commands()));
+
+        commands
+    }
+
     /// Handle the update sent by Telegram.
     ///
     /// Returns `Ok(())` if the update was handled.