migrations/2025-04-10-120721_media_table/down.sql

@@ -1,2 +0,0 @@
-DROP TABLE media;
-

migrations/2025-04-10-120721_media_table/up.sql

@@ -1,6 +0,0 @@
-CREATE TABLE media (
-    id SERIAL PRIMARY KEY,
-    token VARCHAR NOT NULL,
-    media_type VARCHAR NOT NULL,
-    file_id VARCHAR NOT NULL
-);

src/admin.rs

@@ -71,9 +71,8 @@ pub async fn secret_command_handler(
     admin_password: String,
 ) -> Result<(), teloxide::RequestError> {
     println!("Admin Pass: {}", admin_password);
-    let tguser = msg.from.clone().unwrap();
     let user = db
-        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
+        .get_or_init_user(msg.from.clone().unwrap().id.0 as i64)
         .await;
     println!("MSG: {}", msg.html_text().unwrap());
     match cmd {

src/db.rs

@@ -62,7 +62,7 @@ impl DB {
             .unwrap();
     }
 
-    pub async fn get_or_init_user(&mut self, userid: i64, firstname: &str) -> User {
+    pub async fn get_or_init_user(&mut self, userid: i64) -> User {
         use self::schema::users::dsl::*;
         let connection = &mut self.pool.get().await.unwrap();
 
@@ -76,11 +76,7 @@ impl DB {
         match user {
             Some(existing_user) => existing_user,
             None => diesel::insert_into(users)
-                .values((
-                    id.eq(userid as i64),
-                    is_admin.eq(false),
-                    first_name.eq(firstname),
-                ))
+                .values((id.eq(userid as i64), is_admin.eq(false)))
                 .get_result(connection)
                 .await
                 .unwrap(),
@@ -216,48 +212,4 @@ impl DB {
 
         Ok(new_event)
     }
-
-    pub async fn get_media(
-        &mut self,
-        literal: &str,
-    ) -> Result<Vec<Media>, Box<dyn std::error::Error>> {
-        use self::schema::media::dsl::*;
-        let conn = &mut self.pool.get().await.unwrap();
-
-        let media_items = media.filter(token.eq(literal)).load::<Media>(conn).await?;
-
-        Ok(media_items)
-    }
-
-    pub async fn drop_media(&mut self, literal: &str) -> Result<usize, Box<dyn std::error::Error>> {
-        use self::schema::media::dsl::*;
-        let conn = &mut self.pool.get().await.unwrap();
-
-        let deleted_count = diesel::delete(media.filter(token.eq(literal)))
-            .execute(conn)
-            .await?;
-
-        Ok(deleted_count)
-    }
-
-    pub async fn add_media(
-        &mut self,
-        literal: &str,
-        mediatype: String,
-        fileid: i64,
-    ) -> Result<Media, Box<dyn std::error::Error>> {
-        use self::schema::media::dsl::*;
-        let conn = &mut self.pool.get().await.unwrap();
-
-        let new_media = diesel::insert_into(media)
-            .values((
-                token.eq(literal),
-                media_type.eq(mediatype),
-                file_id.eq(fileid),
-            ))
-            .get_result::<Media>(conn)
-            .await?;
-
-        Ok(new_media)
-    }
 }

src/db/models.rs

@@ -24,15 +24,6 @@ pub struct Literal {
     pub value: String,
 }
 
-#[derive(Queryable, Debug, Identifiable)]
-#[diesel(table_name = media)]
-pub struct Media {
-    pub id: i32,
-    pub token: String,
-    pub media_type: String,
-    pub file_id: String,
-}
-
 #[derive(Queryable, Debug, Identifiable)]
 #[diesel(table_name = messages)]
 pub struct Message {

src/db/schema.rs

@@ -16,15 +16,6 @@ diesel::table! {
     }
 }
 
-diesel::table! {
-    media (id) {
-        id -> Int4,
-        token -> Varchar,
-        media_type -> Varchar,
-        file_id -> Varchar,
-    }
-}
-
 diesel::table! {
     messages (id) {
         id -> Int4,
@@ -75,7 +66,6 @@ diesel::joinable!(reservations -> users (user_id));
 diesel::allow_tables_to_appear_in_same_query!(
     events,
     literals,
-    media,
     messages,
     reservations,
     teloxide_dialogues,

src/main.rs

@@ -11,10 +11,8 @@ use db::schema::events;
 use envconfig::Envconfig;
 use serde::{Deserialize, Serialize};
 use teloxide::dispatching::dialogue::serializer::Json;
-use teloxide::dispatching::dialogue::{GetChatId, InMemStorage, PostgresStorage};
-use teloxide::types::{
-    InlineKeyboardButton, InlineKeyboardMarkup, MediaKind, MessageKind, ReplyMarkup,
-};
+use teloxide::dispatching::dialogue::{InMemStorage, PostgresStorage};
+use teloxide::types::{InlineKeyboardButton, InlineKeyboardMarkup};
 use teloxide::{
     payloads::SendMessageSetters,
     prelude::*,
@@ -92,23 +90,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .inspect(|u: Update| {
             eprintln!("{u:#?}"); // Print the update to the console with inspect
         })
-        .branch(Update::filter_callback_query().endpoint(callback_handler))
         .branch(command_handler(config))
         .branch(
             Update::filter_message()
                 .filter_async(async |msg: Message, mut db: DB| {
-                    let tguser = msg.from.unwrap();
-                    let user = db
-                        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
-                        .await;
+                    let user = db.get_or_init_user(msg.from.unwrap().id.0 as i64).await;
                     user.is_admin
                 })
                 .enter_dialogue::<Message, PostgresStorage<Json>, State>()
                 .branch(
                     Update::filter_message()
-                        .filter(|msg: Message| {
-                            msg.text().unwrap_or("").to_lowercase().as_str() == "edit"
-                        })
+                        .filter(|msg: Message| msg.text().unwrap_or("") == "edit")
                         .endpoint(edit_msg_cmd_handler),
                 )
                 .branch(dptree::case![State::Edit { literal, lang }].endpoint(edit_msg_handler)),
@@ -125,35 +117,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-async fn callback_handler(
-    bot: Bot,
-    mut db: DB,
-    q: CallbackQuery,
-) -> Result<(), teloxide::RequestError> {
-    bot.answer_callback_query(&q.id).await?;
-
-    if let Some(ref data) = q.data {
-        match data.as_str() {
-            "more_info" => {
-                answer_message(
-                    &bot,
-                    q.chat_id()
-                        .clone()
-                        .map(|i| i.0)
-                        .unwrap_or(q.from.id.0 as i64),
-                    &mut db,
-                    "more_info",
-                    None as Option<InlineKeyboardMarkup>,
-                )
-                .await?
-            }
-            _ => {} // do nothing, yet
-        }
-    }
-
-    Ok(())
-}
-
 async fn edit_msg_cmd_handler(
     bot: Bot,
     mut db: DB,
@@ -202,28 +165,16 @@ async fn edit_msg_handler(
     (literal, lang): (String, String),
     msg: Message,
 ) -> Result<(), teloxide::RequestError> {
-    use teloxide::utils::render::Renderer;
-
-    let chat_id = msg.chat.id;
-    println!("Type: {:#?}", msg.kind);
-    let msg = if let MessageKind::Common(msg) = msg.kind {
-        msg
-    } else {
-        println!("Not a Common, somehow");
-        return Ok(());
-    };
-
-    match msg.media_kind {
-        MediaKind::Text(text) => {
-            let html_text = Renderer::new(&text.text, &text.entities).as_html();
-            db.set_literal(&literal, &html_text).await.unwrap();
-            bot.send_message(chat_id, "Updated text of message!")
-                .await?;
+    match msg.html_text() {
+        Some(text) => {
+            db.set_literal(&literal, &text).await.unwrap();
+            bot.send_message(msg.chat.id, "Updated text of message!")
+                .await
+                .unwrap();
             dialogue.exit().await.unwrap();
         }
-        _ => {
-            bot.send_message(chat_id, "this type of message is not supported yet")
-                .await?;
+        None => {
+            bot.send_message(msg.chat.id, "Send text!").await.unwrap();
         }
     }
 
@@ -253,10 +204,7 @@ fn command_handler(
         .branch(
             dptree::entry()
                 .filter_async(async |msg: Message, mut db: DB| {
-                    let tguser = msg.from.unwrap();
-                    let user = db
-                        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
-                        .await;
+                    let user = db.get_or_init_user(msg.from.unwrap().id.0 as i64).await;
                     user.is_admin
                 })
                 .filter_command::<AdminCommands>()
@@ -270,22 +218,27 @@ async fn user_command_handler(
     msg: Message,
     cmd: UserCommands,
 ) -> Result<(), teloxide::RequestError> {
-    let tguser = msg.from.clone().unwrap();
     let user = db
-        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
+        .get_or_init_user(msg.from.clone().unwrap().id.0 as i64)
         .await;
     println!("MSG: {}", msg.html_text().unwrap());
     match cmd {
         UserCommands::Start => {
-            let mut db2 = db.clone();
-            answer_message(
-                &bot,
-                msg.chat.id.0,
-                &mut db,
-                "start",
-                Some(make_start_buttons(&mut db2).await),
-            )
-            .await
+            let literal = "start";
+            let text = db
+                .get_literal_value(literal)
+                .await
+                .unwrap()
+                .unwrap_or("Please, set content of this message".into());
+            let msg = bot
+                .send_message(msg.chat.id, text)
+                .reply_markup(make_start_buttons(&mut db).await)
+                .parse_mode(teloxide::types::ParseMode::Html)
+                .await?;
+            db.set_message_literal(msg.chat.id.0, msg.id.0, literal)
+                .await
+                .unwrap();
+            Ok(())
         }
         UserCommands::Help => {
             bot.send_message(msg.chat.id, UserCommands::descriptions().to_string())
@@ -295,32 +248,6 @@ async fn user_command_handler(
     }
 }
 
-async fn answer_message<RM: Into<ReplyMarkup>>(
-    bot: &Bot,
-    chat_id: i64,
-    db: &mut DB,
-    literal: &str,
-    keyboard: Option<RM>,
-) -> Result<(), teloxide::RequestError> {
-    let text = db
-        .get_literal_value(literal)
-        .await
-        .unwrap()
-        .unwrap_or("Please, set content of this message".into());
-    let msg = bot.send_message(ChatId(chat_id), text);
-    let msg = match keyboard {
-        Some(kbd) => msg.reply_markup(kbd),
-        None => msg,
-    };
-    let msg = msg.parse_mode(teloxide::types::ParseMode::Html);
-    println!("ENTS: {:?}", msg.entities);
-    let msg = msg.await?;
-    db.set_message_literal(msg.chat.id.0, msg.id.0, literal)
-        .await
-        .unwrap();
-    Ok(())
-}
-
 async fn make_start_buttons(db: &mut DB) -> InlineKeyboardMarkup {
     let mut buttons: Vec<Vec<InlineKeyboardButton>> = db
         .get_all_events()