Fix /sql command a lot.

Cargo.toml

@@ -33,4 +33,6 @@ subprocess = "0.2.6"
 serde_json = "1.0"
 markov = "1.1.0"
 rand = "0.7.3"
-mystem = "0.2"
+mystem = "0.2.1"
+async-trait = "0.1.42"
+sqlparser = "0.7.0"

src/commands.rs

@@ -1,17 +1,184 @@
+#![allow(unused_variables)]
 use crate::db;
 use crate::errors::Error;
+use crate::errors::Error::{SQLITE3Error, SQLInvalidCommand};
+use async_trait::async_trait;
 use html_escape::encode_text;
 use markov::Chain;
+use mystem::Case::Nominative;
 use mystem::Gender::Feminine;
 use mystem::MyStem;
-use mystem::Tense::{Past, Inpresent};
+use mystem::Person::First;
+use mystem::Tense::{Inpresent, Past};
 use rand::seq::SliceRandom;
 use rand::Rng;
 use regex::Regex;
+use sqlparser::ast::Statement;
+use sqlparser::dialect::GenericDialect;
+use sqlparser::parser::Parser;
 use telegram_bot::prelude::*;
 use telegram_bot::{Api, Message, ParseMode};
 
-pub(crate) async fn here(api: Api, message: Message) -> Result<(), Error> {
+pub struct Here {
+    pub data: String,
+}
+pub struct Top {
+    pub data: String,
+}
+pub struct MarkovAll {
+    pub data: String,
+}
+pub struct Markov {
+    pub data: String,
+}
+pub struct Omedeto {
+    pub data: String,
+}
+pub struct Sql {
+    pub data: String,
+}
+
+#[async_trait]
+pub trait Execute {
+    async fn exec(&self, api: &Api, message: &Message) -> Result<(), Error>;
+    async fn exec_with_result(&self, api: &Api, message: &Message) -> Result<String, Error>;
+    async fn exec_mystem(
+        &self,
+        api: &Api,
+        message: &Message,
+        mystem: &mut MyStem,
+    ) -> Result<(), Error>;
+}
+
+#[async_trait]
+impl Execute for Sql {
+    async fn exec(&self, api: &Api, message: &Message) -> Result<(), Error> {
+        unimplemented!()
+    }
+
+    async fn exec_with_result(&self, api: &Api, message: &Message) -> Result<String, Error> {
+        let mut sql = self.data.clone();
+        let is_head = if sql.starts_with('-') {
+            sql = sql.replacen("-", "", 1);
+            false
+        } else {
+            true
+        };
+        let dialect = GenericDialect {};
+        let ast: Vec<Statement> = match Parser::parse_sql(&dialect, &sql) {
+            Ok(ast) => ast,
+            Err(_) => {
+                warn!("Invalid SQL - {}", sql);
+                return Err(SQLInvalidCommand);
+            }
+        };
+        match ast.len() {
+            l if l > 1 => {
+                return Err(Error::SQLBannedCommand(
+                    "🚫 One statement per message allowed 🚫".into(),
+                ))
+            }
+            _ => (),
+        }
+        match ast[0] {
+            sqlparser::ast::Statement::Query { .. } => {}
+            _ => {
+                return Err(Error::SQLBannedCommand(
+                    "🚫 SELECT requests allowed only 🚫".into(),
+                ))
+            }
+        }
+
+        let conn = db::open()?;
+        let mut stmt = conn.prepare_cached(&sql)?;
+
+        let mut rows = match stmt.query(rusqlite::NO_PARAMS) {
+            Err(e) => return Err(SQLITE3Error(e)),
+            Ok(rows) => rows,
+        };
+
+        let mut res: Vec<Vec<String>> = match rows.column_names() {
+            Some(n) => vec![n
+                .into_iter()
+                .map(|s| {
+                    let t = String::from(s);
+                    if t.len() > 10 {
+                        "EMSGSIZE".to_string()
+                    } else {
+                        t
+                    }
+                })
+                .collect()],
+            None => return Err(SQLInvalidCommand),
+        };
+
+        let index_count = match rows.column_count() {
+            Some(c) => c,
+            None => return Err(SQLInvalidCommand),
+        };
+        while let Some(row) = rows.next().unwrap() {
+            let mut tmp: Vec<String> = Vec::new();
+            for i in 0..index_count {
+                match row.get(i).unwrap_or(None) {
+                    Some(rusqlite::types::Value::Text(t)) => tmp.push(t),
+                    Some(rusqlite::types::Value::Integer(t)) => tmp.push(t.to_string()),
+                    Some(rusqlite::types::Value::Blob(_)) => tmp.push("Binary".to_string()),
+                    Some(rusqlite::types::Value::Real(t)) => tmp.push(t.to_string()),
+                    Some(rusqlite::types::Value::Null) => tmp.push("Null".to_string()),
+                    None => tmp.push("Null".to_string()),
+                };
+            }
+            res.push(tmp);
+        }
+        if res.len() > 100 {
+            return Err(Error::SQLResultTooLong(
+                "SQL result too long. Lines limit is 100. Use LIMIT".to_string(),
+            ));
+        }
+        // add Header
+        let mut msg = if is_head {
+            let mut x = String::from("<b>");
+            for head in res[0].iter() {
+                x = format!("{} {}", x, head);
+            }
+            format!("{}{}", x, "</b>\n")
+        } else {
+            String::new()
+        };
+
+        // remove header
+        res.remove(0);
+
+        msg = format!("{}{}", msg, "<pre>");
+        for line in res.iter() {
+            for field in line.iter() {
+                msg = format!("{}{}", msg, format!("{} ", field));
+            }
+            msg = format!("{}{}", msg, "\n");
+        }
+        msg = format!("{}{}", msg, "</pre>");
+        msg = if msg.len() > 4096 {
+            "🚫 Result is too big. Use LIMIT 🚫".into()
+        } else {
+            msg
+        };
+        Ok(msg)
+    }
+
+    #[allow(unused_variables)]
+    async fn exec_mystem(
+        &self,
+        api: &Api,
+        message: &Message,
+        mystem: &mut MyStem,
+    ) -> Result<(), Error> {
+        unimplemented!()
+    }
+}
+
+#[async_trait]
+impl Execute for Here {
+    async fn exec(&self, api: &Api, message: &Message) -> Result<(), Error> {
         let members: Vec<telegram_bot::User> = db::get_members(message.chat.id()).unwrap();
         for u in &members {
             debug!("Found user {:?} in chat {}", u, message.chat.id());
@@ -36,12 +203,27 @@ pub(crate) async fn here(api: Api, message: Message) -> Result<(), Error> {
             Ok(_) => debug!("/here command sent to {}", message.chat.id()),
             Err(_) => warn!("/here command sent failed to {}", message.chat.id()),
         }
-    //api.send(message.chat.text("Text to message chat")).await?;
-    //api.send(message.from.text("Private text")).await?;
         Ok(())
     }
 
-pub(crate) async fn top(api: Api, message: Message) -> Result<(), Error> {
+    async fn exec_with_result(&self, api: &Api, message: &Message) -> Result<String, Error> {
+        unimplemented!()
+    }
+
+    #[allow(unused_variables)]
+    async fn exec_mystem(
+        &self,
+        api: &Api,
+        message: &Message,
+        mystem: &mut MyStem,
+    ) -> Result<(), Error> {
+        unimplemented!()
+    }
+}
+
+#[async_trait]
+impl Execute for Top {
+    async fn exec(&self, api: &Api, message: &Message) -> Result<(), Error> {
         let top = db::get_top(&message).await?;
         let mut msg = "<b>Your top using words:</b>\n<pre>".to_string();
         let mut counter = 1;
@@ -60,12 +242,27 @@ pub(crate) async fn top(api: Api, message: Message) -> Result<(), Error> {
             Ok(_) => debug!("/top command sent to {}", message.chat.id()),
             Err(_) => warn!("/top command sent failed to {}", message.chat.id()),
         }
-    //api.send(message.chat.text("Text to message chat")).await?;
-    //api.send(message.from.text("Private text")).await?;
         Ok(())
     }
 
-pub(crate) async fn markov_all(api: Api, message: Message) -> Result<(), Error> {
+    async fn exec_with_result(&self, api: &Api, message: &Message) -> Result<String, Error> {
+        unimplemented!()
+    }
+
+    #[allow(unused_variables)]
+    async fn exec_mystem(
+        &self,
+        api: &Api,
+        message: &Message,
+        mystem: &mut MyStem,
+    ) -> Result<(), Error> {
+        unimplemented!()
+    }
+}
+
+#[async_trait]
+impl Execute for MarkovAll {
+    async fn exec(&self, api: &Api, message: &Message) -> Result<(), Error> {
         let messages = db::get_messages_random_all().await?;
         let mut chain = Chain::new();
         chain.feed(messages);
@@ -86,7 +283,24 @@ pub(crate) async fn markov_all(api: Api, message: Message) -> Result<(), Error>
         Ok(())
     }
 
-pub(crate) async fn markov(api: Api, message: Message) -> Result<(), Error> {
+    async fn exec_with_result(&self, api: &Api, message: &Message) -> Result<String, Error> {
+        unimplemented!()
+    }
+
+    #[allow(unused_variables)]
+    async fn exec_mystem(
+        &self,
+        api: &Api,
+        message: &Message,
+        mystem: &mut MyStem,
+    ) -> Result<(), Error> {
+        unimplemented!()
+    }
+}
+
+#[async_trait]
+impl Execute for Markov {
+    async fn exec(&self, api: &Api, message: &Message) -> Result<(), Error> {
         let messages = db::get_messages_random_group(&message).await?;
         let mut chain = Chain::new();
         chain.feed(messages);
@@ -107,33 +321,79 @@ pub(crate) async fn markov(api: Api, message: Message) -> Result<(), Error> {
         Ok(())
     }
 
-pub(crate) async fn omedeto(api: Api, message: Message, mystem: &mut MyStem) -> Result<(), Error> {
+    async fn exec_with_result(&self, api: &Api, message: &Message) -> Result<String, Error> {
+        unimplemented!()
+    }
+
+    #[allow(unused_variables)]
+    async fn exec_mystem(
+        &self,
+        api: &Api,
+        message: &Message,
+        mystem: &mut MyStem,
+    ) -> Result<(), Error> {
+        unimplemented!()
+    }
+}
+
+#[async_trait]
+impl Execute for Omedeto {
+    #[allow(unused_variables)]
+    async fn exec(&self, api: &Api, message: &Message) -> Result<(), Error> {
+        unimplemented!()
+    }
+
+    async fn exec_with_result(&self, api: &Api, message: &Message) -> Result<String, Error> {
+        unimplemented!()
+    }
+
+    #[warn(unused_must_use)]
+    async fn exec_mystem(
+        &self,
+        api: &Api,
+        message: &Message,
+        mystem: &mut MyStem,
+    ) -> Result<(), Error> {
         let all_msg = db::get_messages_user_all(&message).await?;
-    let re = Regex::new(r"^[яЯ] [а-яА-Я]+(-[а-яА-Я]+(_[а-яА-Я]+)*)*$").unwrap();
+        let re = Regex::new(r"^[яЯ] [а-яА-Я]+(-[а-яА-Я]+(_[а-яА-Я]+)*)*").unwrap();
         let mut nouns: Vec<String> = all_msg
-        .clone()
-        .into_iter()
+            .iter()
             .filter(|m| re.is_match(m))
             .map(|m| m.split(' ').map(|s| s.to_string()).collect::<Vec<String>>()[1].clone())
             .filter(|m| {
                 let stem = mystem.stemming(m.clone()).unwrap_or_default();
+                if stem.is_empty() {
+                    false
+                } else if stem[0].lex.is_empty() {
+                    false
+                } else {
                     match stem[0].lex[0].grammem.part_of_speech {
-                mystem::PartOfSpeech::Noun => true,
+                        mystem::PartOfSpeech::Noun => stem[0].lex[0]
+                            .grammem
+                            .facts
+                            .contains(&mystem::Fact::Case(Nominative)),
                         _ => false,
                     }
+                }
             })
+            .map(|w| w.replace(|z| z == '.' || z == ',', ""))
             .collect();
         nouns.sort();
         nouns.dedup();
         nouns.shuffle(&mut rand::thread_rng());
+        //debug!("Found {} nouns. {:#?}", nouns.len(), nouns);
 
         let mut verbs_p: Vec<String> = all_msg
-        .clone()
-        .into_iter()
+            .iter()
             .filter(|m| re.is_match(m))
             .map(|m| m.split(' ').map(|s| s.to_string()).collect::<Vec<String>>()[1].clone())
             .filter(|m| {
                 let stem = mystem.stemming(m.clone()).unwrap_or_default();
+                if stem.is_empty() {
+                    false
+                } else if stem[0].lex.is_empty() {
+                    false
+                } else {
                     match stem[0].lex[0].grammem.part_of_speech {
                         mystem::PartOfSpeech::Verb => stem[0].lex[0]
                             .grammem
@@ -141,84 +401,143 @@ pub(crate) async fn omedeto(api: Api, message: Message, mystem: &mut MyStem) ->
                             .contains(&mystem::Fact::Tense(Past)),
                         _ => false,
                     }
+                }
             })
+            .map(|w| w.replace(|z| z == '.' || z == ',', ""))
             .collect();
         verbs_p.sort();
         verbs_p.dedup();
         verbs_p.shuffle(&mut rand::thread_rng());
+        //debug!("Found {} past verbs. {:#?}", verbs_p.len(), verbs_p);
 
         let mut verbs_i: Vec<String> = all_msg
-        .clone()
-        .into_iter()
+            .iter()
             .filter(|m| re.is_match(m))
             .map(|m| m.split(' ').map(|s| s.to_string()).collect::<Vec<String>>()[1].clone())
             .filter(|m| {
                 let stem = mystem.stemming(m.clone()).unwrap_or_default();
+                if stem.is_empty() {
+                    false
+                } else if stem[0].lex.is_empty() {
+                    false
+                } else {
                     match stem[0].lex[0].grammem.part_of_speech {
-                mystem::PartOfSpeech::Verb => stem[0].lex[0]
+                        mystem::PartOfSpeech::Verb => {
+                            stem[0].lex[0]
                                 .grammem
                                 .facts
-                    .contains(&mystem::Fact::Tense(Inpresent)),
+                                .contains(&mystem::Fact::Tense(Inpresent))
+                                && stem[0].lex[0]
+                                    .grammem
+                                    .facts
+                                    .contains(&mystem::Fact::Person(First))
+                        }
                         _ => false,
                     }
+                }
             })
+            .map(|w| w.replace(|z| z == '.' || z == ',', ""))
             .collect();
         verbs_i.sort();
         verbs_i.dedup();
         verbs_i.shuffle(&mut rand::thread_rng());
+        //debug!("Found {} inpresent verbs. {:#?}", verbs_i.len(), verbs_i);
 
         if nouns.is_empty() {
             nouns.push(message.from.first_name.to_string());
         }
         let start: Vec<String> = vec![
-        "С новыйм годом.".into(),
+            "С новым годом".into(),
             "С НГ тебя".into(),
             "Поздравляю".into(),
             "Поздравляю с НГ".into(),
         ];
+        let placeholders: Vec<String> = vec![
+            "[ДАННЫЕ УДАЛЕНЫ]".into(),
+            "[СЕКРЕТНО]".into(),
+            "[НЕТ ДАННЫХ]".into(),
+            "[ОШИБКА ДОСТУПА]".into(),
+        ];
         //debug!("Nouns: {:#?}", nouns);
         //debug!("Verbs: {:#?}", verbs);
 
-    let fem = if mystem
-        .stemming(message.from.first_name.to_string())
-        .unwrap()[0]
-        .lex
-        .is_empty()
-    {
-        false
+        let fem = {
+            let mut fm = 0;
+            let mut mu = 0;
+            all_msg
+                .clone()
+                .into_iter()
+                .filter(|m| re.is_match(m))
+                .map(|m| m.split(' ').map(|s| s.to_string()).collect::<Vec<String>>()[1].clone())
+                .map(|m| {
+                    let stem = mystem.stemming(m.clone()).unwrap_or_default();
+                    if stem.is_empty() {
+                        ()
+                    } else if stem[0].lex.is_empty() {
+                        ()
                     } else {
-        if mystem
-            .stemming(message.from.first_name.to_string())
-            .unwrap()[0]
-            .lex[0]
+                        match stem[0].lex[0].grammem.part_of_speech {
+                            mystem::PartOfSpeech::Verb => {
+                                match stem[0].lex[0]
+                                    .grammem
+                                    .facts
+                                    .contains(&mystem::Fact::Tense(Past))
+                                {
+                                    true => {
+                                        if stem[0].lex[0]
                                             .grammem
                                             .facts
                                             .contains(&mystem::Fact::Gender(Feminine))
                                         {
+                                            fm = fm + 1;
+                                        } else {
+                                            mu = mu + 1;
+                                        }
+                                    }
+                                    false => (),
+                                }
+                            }
+                            _ => (),
+                        }
+                    }
+                })
+                .for_each(drop);
+            //debug!("fm - {}, mu - {}", fm, mu);
+            if fm >= mu {
                 true
             } else {
                 false
             }
         };
+        //debug!("Is Feminine - {}", fem);
         let result = format!(
             "{} {} известн{} как {}, {}, а так же конечно {}. В прошедшем году ты часто давал{} нам знать, что ты {}, {} и {}. Нередко ты говорил{} я {}, я {} или даже я {}. =*",
             start.choose(&mut rand::thread_rng()).unwrap(),
             message.from.first_name.to_string(),
             { if fem { "ая" } else { "ый" } },
-        nouns.pop().unwrap_or("=(".to_string()),
-        nouns.pop().unwrap_or("=(".to_string()),
-        nouns.pop().unwrap_or("=(".to_string()),
+            nouns.pop().unwrap_or(placeholders.choose(&mut rand::thread_rng()).unwrap().to_string()),
+            nouns.pop().unwrap_or(placeholders.choose(&mut rand::thread_rng()).unwrap().to_string()),
+            nouns.pop().unwrap_or(placeholders.choose(&mut rand::thread_rng()).unwrap().to_string()),
             { if fem { "а" } else { "" } },
-        verbs_p.pop().unwrap_or("=(".to_string()),
-        verbs_p.pop().unwrap_or("=(".to_string()),
-        verbs_p.pop().unwrap_or("=(".to_string()),
+            verbs_p.pop().unwrap_or(placeholders.choose(&mut rand::thread_rng()).unwrap().to_string()),
+            verbs_p.pop().unwrap_or(placeholders.choose(&mut rand::thread_rng()).unwrap().to_string()),
+            verbs_p.pop().unwrap_or(placeholders.choose(&mut rand::thread_rng()).unwrap().to_string()),
             { if fem { "а" } else { "" } },
-        verbs_i.pop().unwrap_or("=(".to_string()),
-        verbs_i.pop().unwrap_or("=(".to_string()),
-        verbs_i.pop().unwrap_or("=(".to_string()),
-
+            verbs_i.pop().unwrap_or(placeholders.choose(&mut rand::thread_rng()).unwrap().to_string()),
+            verbs_i.pop().unwrap_or(placeholders.choose(&mut rand::thread_rng()).unwrap().to_string()),
+            verbs_i.pop().unwrap_or(placeholders.choose(&mut rand::thread_rng()).unwrap().to_string()),
         );
-    debug!("{:?}", result);
-    // '^я [а-яА-Я]+(-[а-яА-Я]+(_[а-яА-Я]+)*)*$'
+        match api
+            .send(
+                message
+                    .text_reply(result.trim())
+                    .parse_mode(ParseMode::Html),
+            )
+            .await
+        {
+            Ok(_) => debug!("/omedeto command sent to {}", message.chat.id()),
+            Err(_) => warn!("/omedeto command sent failed to {}", message.chat.id()),
+        }
         Ok(())
     }
+}

src/db.rs

@@ -1,6 +1,5 @@
 use crate::errors;
 use crate::utils;
-use futures::StreamExt;
 use rusqlite::{named_params, params, Connection, Error, Result};
 use std::time::SystemTime;
 use telegram_bot::*;
@@ -82,7 +81,7 @@ pub(crate) fn get_conf(id: telegram_bot::ChatId) -> Result<Conf, errors::Error>
     }
 }
 
-/*
+#[allow(dead_code)]
 pub(crate) fn get_confs() -> Result<Vec<Conf>> {
     let conn = open()?;
     let mut stmt = conn.prepare("SELECT id, title, date FROM conf")?;
@@ -101,7 +100,7 @@ pub(crate) fn get_confs() -> Result<Vec<Conf>> {
 
     Ok(confs)
 }
- */
+
 pub(crate) async fn get_messages_random_all() -> Result<Vec<String>, Error> {
     let conn = open()?;
     let mut stmt = conn.prepare_cached("SELECT text FROM messages ORDER BY RANDOM() LIMIT 50")?;
@@ -136,6 +135,7 @@ pub(crate) async fn get_messages_random_group(
     Ok(messages)
 }
 
+#[allow(dead_code)]
 pub(crate) async fn get_messages_user_group(
     message: &telegram_bot::Message,
 ) -> Result<Vec<String>, Error> {
@@ -345,7 +345,6 @@ pub(crate) async fn get_file(file_id: String) -> Result<i64, errors::Error> {
             Ok(id) => Ok(id),
             Err(_) => Err(errors::Error::FileNotFound),
         };
-
     file_rowid
 }
 
@@ -400,6 +399,7 @@ async fn add_relation(word_id: i64, msg_id: i64, message: &Message) -> Result<i6
     Ok(rowid)
 }
 
+#[allow(unused_must_use)]
 pub(crate) async fn add_sentence(
     message: &telegram_bot::Message,
     mystem: &mut mystem::MyStem,

src/errors.rs

@@ -20,7 +20,11 @@ pub enum Error {
     JsonParseError(serde_error),
     PopenError(popen_error),
     MystemError(mystem_error),
+    SQLBannedCommand(String),
+    SQLInvalidCommand,
+    SQLResultTooLong(String),
 }
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "An error occurred.")

src/handlers.rs

@@ -1,4 +1,5 @@
-use crate::commands;
+//use crate::commands::Command;
+use crate::commands::{Execute, Here, Markov, MarkovAll, Omedeto, Sql, Top};
 use crate::db;
 use crate::errors;
 use crate::utils;
@@ -24,13 +25,76 @@ pub async fn handler(
                 data
             );
             db::add_sentence(&message, mystem).await?;
-            match data.as_str() {
-                "/here" => commands::here(api, message).await?,
-                "/top" => commands::top(api, message).await?,
-                "/stat" => commands::top(api, message).await?,
-                "/markov_all" => commands::markov_all(api, message).await?,
-                "/markov" => commands::markov(api, message).await?,
-                "/omedeto" => commands::omedeto(api, message, mystem).await?,
+            let cleaned_message = data.replace(&format!("@{}", me.clone().username.unwrap()), "");
+            match cleaned_message.as_str() {
+                s if s.contains("/here") => {
+                    Here {
+                        data: "".to_string(),
+                    }
+                    .exec(&api, &message)
+                    .await?
+                }
+                s if s.to_string().starts_with("/sql") => match {
+                    Sql {
+                        data: s.replace("/sql ", ""),
+                    }
+                    .exec_with_result(&api, &message)
+                    .await
+                } {
+                    Ok(msg) => {
+                        let _ = api
+                            .send(
+                                message
+                                    .text_reply(msg)
+                                    .parse_mode(ParseMode::Html),
+                            )
+                            .await?;
+                    },
+                    Err(e) => {
+                        let _ = api
+                            .send(
+                                message
+                                    .text_reply(format!("Error: {:#?}", e))
+                                    .parse_mode(ParseMode::Html),
+                            )
+                            .await?;
+                    }
+                },
+                "/top" => {
+                    Top {
+                        data: "".to_string(),
+                    }
+                    .exec(&api, &message)
+                    .await?
+                }
+                "/stat" => {
+                    Top {
+                        data: "".to_string(),
+                    }
+                    .exec(&api, &message)
+                    .await?
+                }
+                "/markov_all" => {
+                    MarkovAll {
+                        data: "".to_string(),
+                    }
+                    .exec(&api, &message)
+                    .await?
+                }
+                "/markov" => {
+                    Markov {
+                        data: "".to_string(),
+                    }
+                    .exec(&api, &message)
+                    .await?
+                }
+                "/omedeto" => {
+                    Omedeto {
+                        data: "".to_string(),
+                    }
+                    .exec_mystem(&api, &message, mystem)
+                    .await?
+                }
                 _ => (),
             }
         }

src/main.rs

@@ -49,7 +49,12 @@ async fn main() -> Result<(), errors::Error> {
         if let UpdateKind::Message(message) = update.kind {
             db::add_conf(message.clone()).await?;
             db::add_user(message.clone()).await?;
-            handlers::handler(api.clone(), message, token.clone(), &mut mystem, me.clone()).await?;
+            match handlers::handler(api.clone(), message, token.clone(), &mut mystem, me.clone())
+                .await
+            {
+                Ok(_) => {}
+                Err(e) => warn!("An error occurred handling command. {:?}", e),
+            }
         }
     }
     Ok(())