Added new callback types

src/callbacks/delete_message.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 use teloxide::{dispatching::DpHandlerDescription, dptree::Handler};
 
 /// Deletes the message from the callback
-async fn run(bot: Throttle<Bot>, q: CallbackQuery) -> crate::Result<()> {
+pub async fn delete_message(bot: Throttle<Bot>, q: CallbackQuery) -> crate::Result<()> {
     if let Some(msg) = q.message {
         if bot.delete_message(msg.chat.id, msg.id).await.is_err() {
             bot.send_message(msg.chat.id, "Error deleting the message")
@@ -13,14 +13,3 @@ async fn run(bot: Throttle<Bot>, q: CallbackQuery) -> crate::Result<()> {
     bot.answer_callback_query(q.id).await?;
     Ok(())
 }
-
-/// Filters the delete_message callbacks
-fn filter(q: CallbackQuery) -> bool {
-    matches!(q.data.as_deref(), Some("delete_message"))
-}
-
-/// Gets a handler for deleting the message
-#[inline]
-pub fn get_handler() -> Handler<'static, DependencyMap, crate::Result<()>, DpHandlerDescription> {
-    dptree::filter(filter).endpoint(run)
-}

src/callbacks/mod.rs

@@ -1,3 +1,76 @@
 //! This module consists of endpoints to handle callbacks
 
-pub mod delete_message;
+mod delete_message;
+
+pub use delete_message::delete_message;
+
+use crate::errors::InvalidCommand;
+use base64::{engine::general_purpose::STANDARD_NO_PAD as B64_ENGINE, Engine as _};
+use std::str::FromStr;
+use teloxide::types::{CallbackQuery, Message};
+
+type NameHash = [u8; 32];
+
+#[derive(Clone, Copy)]
+pub enum AlterableField {
+    Name,
+    Login,
+    Pass,
+}
+
+#[derive(Clone, Copy)]
+pub enum CallbackCommand {
+    DeleteMessage,
+    Get(NameHash),
+    GetMenu,
+    GetAccounts,
+    Decrypt(NameHash),
+    Hide(NameHash),
+    Alter(NameHash, AlterableField),
+    DeleteAccount(NameHash),
+}
+
+impl CallbackCommand {
+    pub fn from_query(q: CallbackQuery) -> Option<Self> {
+        q.message.as_ref()?;
+        q.data.and_then(|text| text.parse().ok())
+    }
+}
+
+impl FromStr for CallbackCommand {
+    type Err = crate::errors::InvalidCommand;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use AlterableField::*;
+        use CallbackCommand::*;
+
+        match s {
+            "delete_message" => return Ok(DeleteMessage),
+            "get_menu" => return Ok(GetMenu),
+            "get_accounts" => return Ok(GetAccounts),
+            _ => (),
+        };
+
+        let mut substrings = s.split(' ');
+        let (command, name) = match (substrings.next(), substrings.next(), substrings.next()) {
+            (Some(command), Some(name), None) => (command, name),
+            _ => return Err(InvalidCommand::InvalidParams),
+        };
+
+        let mut name_arr = [0; 32];
+        if B64_ENGINE.decode_slice(name, &mut name_arr)? != 32 {
+            return Err(InvalidCommand::OutputTooShort);
+        };
+
+        match command {
+            "get" => Ok(Get(name_arr)),
+            "decrypt" => Ok(Decrypt(name_arr)),
+            "hide" => Ok(Hide(name_arr)),
+            "an" => Ok(Alter(name_arr, Name)),
+            "al" => Ok(Alter(name_arr, Login)),
+            "ap" => Ok(Alter(name_arr, Pass)),
+            "delete" => Ok(DeleteAccount(name_arr)),
+            _ => Err(InvalidCommand::InvalidParams),
+        }
+    }
+}

src/errors.rs

@@ -5,3 +5,13 @@ pub struct NoUserInfo;
 #[derive(thiserror::Error, Debug)]
 #[error("Handler was already used")]
 pub struct HandlerUsed;
+
+#[derive(thiserror::Error, Debug)]
+pub enum InvalidCommand {
+    #[error("Invalid params")]
+    InvalidParams,
+    #[error("Not enough bytes in the name's hash")]
+    OutputTooShort,
+    #[error("Error decoding the values: {0}")]
+    NameDecodingError(#[from] base64::DecodeSliceError),
+}

src/main.rs

@@ -1,3 +1,5 @@
+#![allow(unused)]
+
 mod callbacks;
 mod commands;
 mod default;
@@ -18,6 +20,8 @@ use sea_orm::Database;
 use std::env;
 use teloxide::{adaptors::throttle::Limits, dispatching::dialogue::InMemStorage, filter_command};
 
+use crate::callbacks::CallbackCommand;
+
 fn get_dispatcher(
     token: String,
     db: DatabaseConnection,
@@ -55,8 +59,9 @@ fn get_dispatcher(
         .branch(command_handler)
         .endpoint(default::default);
 
-    let callback_handler =
-        Update::filter_callback_query().chain(callbacks::delete_message::get_handler());
+    let callback_handler = Update::filter_callback_query()
+        .filter_map(CallbackCommand::from_query)
+        .branch(case![CallbackCommand::DeleteMessage].endpoint(callbacks::delete_message));
 
     let handler = dptree::entry()
         .branch(message_handler)

src/markups.rs

@@ -1,4 +1,8 @@
 use crate::prelude::*;
+use base64::{engine::general_purpose::STANDARD as B64_ENGINE, Engine as _};
+use futures::future;
+use itertools::Itertools;
+use sha2::{Digest, Sha256};
 use teloxide::types::{InlineKeyboardButton, InlineKeyboardMarkup, KeyboardButton, KeyboardMarkup};
 
 /// Creates a markup of all user's account names