feat: fixes

Author: SRetip

src/callback_handler.rs

@@ -0,0 +1,43 @@
+use teloxide::{types::CallbackQuery, Bot};
+
+use crate::{
+    command::go_function, get_duplet_by_id, get_user_by_chat_id, update_duplet, HandlerResult, UserReact, DupletStatus,
+};
+
+pub async fn callback_handler(
+    bot: Bot,
+    q: CallbackQuery,
+    pool: sqlx::Pool<sqlx::Postgres>,
+) -> HandlerResult {
+    if let Some(data) = q.data {
+        if let Some(data) = data.split_once("_") {
+            let mut duplet = get_duplet_by_id(&pool, data.0).await?;
+            match data.1 {
+                "like" => {
+                    if duplet.first_user_react == UserReact::None {
+                        duplet.first_user_react = UserReact::Like;
+                    } else {
+                        duplet.second_user_react = UserReact::Like;
+                        duplet.status = DupletStatus::Match;
+                    }
+                }
+                "dislike" => {
+                    if duplet.first_user_react == UserReact::None {
+                        duplet.first_user_react = UserReact::Dislike;
+                    } else {
+                        duplet.second_user_react = UserReact::Dislike;
+                        duplet.status = DupletStatus::Mismatch;
+                    }
+                }
+                _ => return Ok(()),
+            }
+            update_duplet(&pool, &duplet).await?;
+            if let Some(message) = q.message {
+                if let Some(user) = get_user_by_chat_id(&pool, message.chat.id.0).await? {
+                    go_function(user, &pool, &bot, message.chat.id).await?;
+                }
+            }
+        }
+    }
+    Ok(())
+}

src/command.rs

@@ -0,0 +1,97 @@
+use teloxide::{
+    requests::Requester,
+    types::{ChatId, InlineKeyboardButton, InlineKeyboardMarkup, Message},
+    utils::command::BotCommands,
+    Bot,
+};
+
+use crate::{
+    get_needed_user, get_user_by_chat_id, get_user_matches_string, HandlerResult, MyDialogue,
+    State, User,
+};
+use teloxide::payloads::SendMessageSetters;
+
+use anyhow::Result;
+
+#[derive(Clone, BotCommands)]
+#[command(rename_rule = "lowercase")]
+pub enum Command {
+    Start,
+    Settings,
+    Go,
+    Matches,
+}
+
+pub async fn command_handler(
+    bot: Bot,
+    dialogue: MyDialogue,
+    msg: Message,
+    cmd: Command,
+    pool: sqlx::Pool<sqlx::Postgres>,
+) -> HandlerResult {
+    let chat_id = msg.chat.id.0;
+    let user = get_user_by_chat_id(&pool, chat_id).await?;
+    match cmd {
+        Command::Start => {
+            dialogue.update(State::GetAge(User::default())).await?;
+            bot.send_message(msg.chat.id, "First enter your age")
+                .await?;
+        }
+        Command::Settings => {
+            if let Some(_) = user {
+                dialogue.update(State::GetAge(User::default())).await?;
+                bot.send_message(msg.chat.id, "Reset registration.").await?;
+                bot.send_message(msg.chat.id, "First enter your age")
+                    .await?;
+            } else {
+                bot.send_message(msg.chat.id, "Register first").await?;
+            }
+        }
+        Command::Go => {
+            if let Some(user) = user {
+                go_function(user, &pool, &bot, msg.chat.id).await?;
+            } else {
+                bot.send_message(msg.chat.id, "Register first").await?;
+            }
+        }
+        Command::Matches => {
+            if let Some(user) = user {
+                let message = get_user_matches_string(&pool, user.chat_id, msg.chat.id.0).await?;
+                bot.send_message(msg.chat.id, message).await?;
+            } else {
+                bot.send_message(msg.chat.id, "Register first").await?;
+            }
+        }
+    }
+    Ok(())
+}
+
+pub async fn go_function(
+    user: User,
+    pool: &sqlx::Pool<sqlx::Postgres>,
+    bot: &Bot,
+    chat_id: ChatId,
+) -> Result<()> {
+    if let Some(u) = get_needed_user(&pool, user).await? {
+        let keyboard = vec![vec![
+            InlineKeyboardButton::callback("like", format!("{}_like", u.duplet_id)),
+            InlineKeyboardButton::callback("dislike", format!("{}_dislike", u.duplet_id)),
+        ]];
+        bot.send_message(
+            chat_id,
+            format!(
+                "name - {},\nage - {},\ncity - {},\ngender - {},\nabout - {}",
+                u.name, u.age, u.city, u.gender, u.about
+            ),
+        )
+        .reply_markup(InlineKeyboardMarkup::new(keyboard))
+        .await?;
+    } else {
+        bot.send_message(
+            chat_id,
+            "There's no one suitable at the moment, try later with /go",
+        )
+        .await?;
+    }
+    Ok(())
+}

src/domain.rs

@@ -0,0 +1,99 @@
+use serde::{Deserialize, Serialize};
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+pub struct User {
+    pub chat_id: i64,
+    pub age: i32,
+    pub gender: String,
+    pub city: String,
+    pub name: String,
+    pub telegram_name: String,
+    pub about: String,
+    pub interested_min_age: i32,
+    pub interested_max_age: i32,
+    pub interested_gender: String,
+}
+
+#[derive(Debug, sqlx::FromRow)]
+pub struct Duplet {
+    pub id: String,
+    pub first_user_id: i64,
+    pub first_user_react: UserReact,
+    pub second_user_id: i64,
+    pub second_user_react: UserReact,
+    pub status: DupletStatus,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+pub struct PublicDuplet {
+    pub partner_name: String,
+    pub partner_telegram_name: String,
+}
+
+pub struct PublicUserAndDuplet {
+    pub name: String,
+    pub age: i32,
+    pub city: String,
+    pub gender: String,
+    pub about: String,
+    pub duplet_id: String,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub enum State {
+    GetAge(User),
+    GetGender(User),
+    GetCity(User),
+    GetName(User),
+    GetAbout(User),
+    GetInterestedMinAge(User),
+    GetInterestedMaxAge(User),
+    GetInterestedGender(User),
+    Ready,
+}
+
+impl Default for State {
+    fn default() -> Self {
+        State::GetAge(User::default())
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, sqlx::Type, Clone, Copy)]
+pub enum UserReact{
+    Like,
+    Dislike,
+    None,
+}
+
+impl From<String> for UserReact {
+    fn from(value: String) -> Self {
+        match value.as_str() {
+            "Like" => UserReact::Like,
+            "Dislike" => UserReact::Dislike,
+            "None" => UserReact::None,
+            _ => UserReact::None,
+        }
+    }
+}
+
+
+
+#[derive(Debug, PartialEq, Eq, sqlx::Type, Clone, Copy)]
+pub enum DupletStatus {
+    InProcess,
+    Match, 
+    Mismatch, 
+    Prepared,
+}
+
+impl From<String> for DupletStatus {
+    fn from(value: String) -> Self {
+        match value.as_str() {
+            "InProcess" => DupletStatus::InProcess,
+            "Match" => DupletStatus::Match,
+            "Mismatch" => DupletStatus::Mismatch,
+            "Prepared" => DupletStatus::Prepared,
+            _ => DupletStatus::InProcess,
+        }
+    }
+}
+