From 1305aa75fe4e7e2092d45f686a4fe2d3e59a2e4d Mon Sep 17 00:00:00 2001
From: Sumeet Chhetri <sumeet.chhetri@gmail.com>
Date: Sun, 31 May 2020 16:11:07 +0530
Subject: [PATCH] Added support for text/unknown-text msg handlers

---
 src/bot.rs | 50 ++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 46 insertions(+), 4 deletions(-)

diff --git a/src/bot.rs b/src/bot.rs
index 0486db2..2f67ad8 100644
--- a/src/bot.rs
+++ b/src/bot.rs
@@ -173,7 +173,8 @@ pub struct Bot {
     update_interval: u64,
     timeout: u64,
     pub handlers: HashMap<String, UnboundedSender<(RequestHandle, objects::Message)>>,
-    pub unknown_handler: Option<UnboundedSender<(RequestHandle, objects::Message)>>,
+    pub unknown_cmd_handler: Option<UnboundedSender<(RequestHandle, objects::Message)>>,
+    pub unknown_text_handler: Option<UnboundedSender<(RequestHandle, objects::Message)>>,
     pub callback_handler: Option<UnboundedSender<(RequestHandle, objects::CallbackQuery)>>,
     pub inline_handler: Option<UnboundedSender<(RequestHandle, objects::InlineQuery)>>
 }
@@ -192,7 +193,8 @@ impl Bot {
             update_interval: 2000,
             timeout: 3600,
             handlers: HashMap::new(),
-            unknown_handler: None,
+            unknown_cmd_handler: None,
+            unknown_text_handler: None,
             callback_handler: None,
             inline_handler: None
         }
@@ -237,11 +239,32 @@ impl Bot {
         receiver.map_err(|_| Error::from(ErrorKind::Channel))
     }
 
+    /// Creates a new text based command and returns a stream which will yield a message when the text is sent
+    pub fn new_text(
+        &mut self,
+        cmd: &str,
+    ) -> impl Stream<Item = (RequestHandle, objects::Message), Error = Error> {
+        let (sender, receiver) = mpsc::unbounded();
+
+        self.handlers.insert(cmd.into(), sender);
+
+        receiver.map_err(|_| Error::from(ErrorKind::Channel))
+    }
+
+    /// Returns a stream which will yield a message when none of previously registered text based command matches
+    pub fn unknown_text(&mut self) -> impl Stream<Item = (RequestHandle, objects::Message), Error = Error> {
+        let (sender, receiver) = mpsc::unbounded();
+
+        self.unknown_text_handler = Some(sender);
+
+        receiver.then(|x| x.map_err(|_| Error::from(ErrorKind::Channel)))
+    }
+
     /// Returns a stream which will yield a message when none of previously registered commands matches
     pub fn unknown_cmd(&mut self) -> impl Stream<Item = (RequestHandle, objects::Message), Error = Error> {
         let (sender, receiver) = mpsc::unbounded();
 
-        self.unknown_handler = Some(sender);
+        self.unknown_cmd_handler = Some(sender);
 
         receiver.then(|x| x.map_err(|_| Error::from(ErrorKind::Channel)))
     }
@@ -342,12 +365,31 @@ impl Bot {
                                 sndr = Some(sender.clone());
                                 message.text = Some(content.collect::<Vec<&str>>().join(" "));
                             } else if let Some(ref sender) =
-                                self.unknown_handler
+                                self.unknown_cmd_handler
                             {
                                 sndr = Some(sender.clone());
                             }
                         }
                     }
+                } else if let Some(text) = message.text.clone() {
+                    let mut content = text.split_whitespace();
+                    if let Some(cmd) = content.next() {
+                        if let Some(sender) = self.handlers.get(cmd)
+                        {
+                            sndr = Some(sender.clone());
+                            message.text = Some(content.collect::<Vec<&str>>().join(" "));
+                        }
+                        else if let Some(ref sender) = self.unknown_text_handler
+                        {
+                            sndr = Some(sender.clone());
+                            message.text = Some(content.collect::<Vec<&str>>().join(" "));
+                        }
+                    }
+                    else if let Some(ref sender) = self.unknown_text_handler
+                    {
+                        sndr = Some(sender.clone());
+                        message.text = Some(content.collect::<Vec<&str>>().join(" "));
+                    }
                 }
             }