wip

Cargo.toml

@@ -2,15 +2,21 @@
 name = "telegram-leetbot"
 version = "0.1.0"
 authors = ["Andreas Larsen <andreas@northcode.no>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
-telegram-bot = "0.6.1"
+chrono = "0.4.19"
-futures = "*"
+pretty_env_logger = "0.4.0"
-tokio-core = "*"
+regex = "1.6.0"
-serde = "1.0"
+# frankenstein = { version = "0.19.0", features = ["async-http-client"] }
-serde_json = "1.0"
+sqlx = { version = "0.6", features = [ "runtime-tokio-rustls", "postgres", "chrono" ] }
-chrono = "0.4.6"
+teloxide = { version = "0.10.1", features = [ "macros" ] }
+thiserror = "1.0.31"
+# futures = "*"
+tokio = { version = "1", features = [ "full" ] }
+# serde = "1.0"
+# serde_json = "1.0"
+# chrono = "0.4.19"
 
-[patch.crates-io]
+# [patch.crates-io]
-openssl = { git = "https://github.com/ishitatsuyuki/rust-openssl", branch = "0.9.x" }
+# openssl = { git = "https://github.com/ishitatsuyuki/rust-openssl", branch = "0.9.x" }

run-db.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+podman run -d -p 5432:5432 -e POSTGRES_USER=leetbot -e POSTGRES_PASSWORD=leetbot docker.io/postgres

src/lib.rs

@@ -0,0 +1,17 @@
+use chrono::{Local, NaiveTime};
+
+
+pub fn text_is_leet(text: &str) -> bool {
+    text.eq_ignore_ascii_case("leet") || text == "l33t" || text == "1337"
+}
+
+pub fn time_is_leet() -> bool {
+    let now = Local::now().time();
+    let leet = NaiveTime::from_hms(13,37,30);
+
+    let allowed_timegap = 30;
+
+    let distance = now - leet;
+
+    distance.num_seconds().abs() <= allowed_timegap
+}

src/main.rs

@@ -1,142 +1,204 @@
-extern crate telegram_bot;
+mod lib;
-extern crate futures;
-extern crate tokio_core;
-extern crate serde;
-extern crate serde_json;
-extern crate chrono;
 
-use std::io::Read;
+use crate::lib::*;
-use std::io::Write;
-use crate::futures::Stream;
-use tokio_core::reactor::Core;
-use std::env;
-use telegram_bot::*;
 
-use chrono::prelude::*;
+use chrono::{NaiveDateTime, Local};
+use tokio;
 
-use std::sync::*;
+use teloxide::{prelude::*, RequestError, dispatching::UpdateFilterExt, utils::command::BotCommands};
-use std::collections::HashMap;
 
-const SCORE_FILE_PATH : &str = "score.json";
+use sqlx::{postgres::PgPoolOptions, PgPool};
-
+use thiserror::Error;
-fn main() {
-    let mut core = Core::new().unwrap();
-
-    let token = env::var("TELEGRAM_BOT_TOKEN").unwrap();
-    let api = Api::configure(token).build(core.handle()).unwrap();
-
-    let leet_time = NaiveTime::from_hms(13, 37, 30);
-
-    let scores : Arc<Mutex<HashMap<String, usize>>> = Arc::new(Mutex::new(HashMap::new()));
-    let time_scored : Arc<Mutex<HashMap<String, DateTime<Local>>>> = Arc::new(Mutex::new(HashMap::new()));
-
-    {
-        if let Ok(mut score_file) = std::fs::File::open(SCORE_FILE_PATH) {
-
-            let mut json_str = String::new();
-
-            score_file.read_to_string(&mut json_str).expect("Failed to read score file");
-
-            let mut map = scores.lock().unwrap();
-
-            *map = serde_json::from_str(&json_str).expect("Failed to deserialize scores");
-        }
-    }
-
-    {
-        let scores = scores.clone();
-
-        std::thread::spawn(move || {
-            loop {
-                {
-                    let map = scores.lock().unwrap();
-
-                    let json_str = serde_json::to_string(&*map).unwrap();
-
-                    let mut score_file = std::fs::File::create(SCORE_FILE_PATH).expect("Unable to open or create file");
-
-                    score_file.write_all(json_str.as_bytes()).expect("unable to write to score file!");
-                }
-
-                println!("written score file");
-                
-                std::thread::sleep(std::time::Duration::from_secs(5*60));
-            }
-        });
-    }
 
 
-    let future = api.stream().for_each(|update| {
+async fn init_pg_pool() -> Result<PgPool, sqlx::Error> {
-        if let UpdateKind::Message(message) = update.kind {
+    let pool = PgPoolOptions::new()
-            if let MessageKind::Text {ref data, ..} = message.kind {
+        .max_connections(5)
-                println!("<{}>: {}", message.from.first_name, data);
+        .connect("postgres://leetbot:leetbot@localhost:5432/leetbot").await?;
 
-                let current_time = Local::now().time();
+    Ok(pool)
-
+}
-                let allowed_timegap = 30;
+
-
+
-                if data.to_lowercase() == "leet" || data == "1337" {
+async fn setup_tables(pool: &PgPool) -> Result<(), sqlx::Error> {
-                    dbg!(data);
+    sqlx::query("create table if not exists leet_log (
-
+id int generated always as identity,
-                    let leet_distance = (current_time - leet_time).num_seconds().abs();
+username varchar(255) not null,
-
+log_time timestamp not null
-                    if leet_distance > allowed_timegap {
+)")
-                        api.spawn(message.text_reply(
+        .execute(pool)
-                            "It is not leet right now".to_string()
+        .await?;
-                        ));
+
-                    } else {
+    Ok(())
-
+}
-                        let mut time_scored_map = time_scored.lock().unwrap();
+
-
+#[derive(Debug,Error)]
-                        let time_scored = time_scored_map.entry(message.from.first_name.clone()).or_insert(Local.timestamp(0,0));
+enum LeetError {
-
+    #[error("It's not leet right now")]
-                        let time_scored_distance = (Local::now() - *time_scored).num_seconds().abs();
+    NotLeet,
-
+    #[error("Already hit leet for today")]
-                        if time_scored_distance < allowed_timegap * 4 {
+    AlreadyHitLeet,
-                            api.spawn(message.text_reply(
+    #[error("Sql error while checking for leet status: {0}")]
-                                    "You already hit leet today you dumbass, don't try to cheat!".to_string()
+    DbError(#[from] sqlx::Error)
-                                    ));
+}
-                        } else {
+
-                            let mut map = scores.lock().unwrap();
+async fn check_leet(username: &str, pool: &PgPool) -> Result<(), LeetError> {
-
+    // if ! time_is_leet() {
-                            let entry = map.entry(message.from.first_name.clone()).or_insert(0);
+    // 	return Err(LeetError::NotLeet);
-
+    // }
-                            *entry += 1;
+
-                            *time_scored = Local::now();
+    let now = Local::now().naive_local();
-
+
-                            api.spawn(message.text_reply(
+    let latest_leet : Option<(i32, String, NaiveDateTime)> = sqlx::query_as("select * from leet_log where username = $1 order by log_time desc")
-                                    format!("{} just hit leet! New score: {}", message.from.first_name, *entry)
+        .bind(username)
-                                    ));
+        .fetch_optional(pool)
-
+        .await?;
-                            let current_leet_count = time_scored_map.iter().filter(|(_,t)| (**t - Local::now()).num_seconds().abs() < allowed_timegap * 2).count();
+
-
+    if let Some(latest_leet) = latest_leet {
-                            if current_leet_count == 3 {
+	let distance = now - latest_leet.2;
-                                api.spawn(message.chat.text("OH BABY A TRIPPLE!!!"));
+
-                            }
+	if distance.num_hours() < 24 {
-
+	    return Err(LeetError::AlreadyHitLeet);
-                        }
+	}
-                    }
+    }
-
+
-                } else if data == "-score" {
+    Ok(())
-                    let map = scores.lock().unwrap();
+}
-
+
-                    let json = serde_json::to_string(&*map).unwrap();
+#[derive(BotCommands, Clone)]
-
+#[command(rename = "lowercase", description = "score commands")]
-                    api.spawn(message.text_reply(
+enum LeetCommand {
-                        format!("Score json: {}", json)
+    #[command(description = "get scores")]
-                    ));
+    Scores
-                } else if data == "-time" {
+}
-                    
+
-                    api.spawn(message.text_reply(
+#[tokio::main]
-                        format!("local time: {}, leet time: {}, time distance to leet: {:#?}", current_time, leet_time, (current_time - leet_time).num_seconds())
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
-                    ));
+    pretty_env_logger::init();
-                }
+
-
+    let pg_pool = init_pg_pool().await?;
-            }
+
-        }
+    setup_tables(&pg_pool).await?;
-
+
-        Ok(())
+    let telegram_token = std::env::var("TELEGRAM_BOT_TOKEN")
-    });
+        .expect("TELEGRAM_TOKEN env not set!");
-
+
-    core.run(future).unwrap();
+    let bot = Bot::new(&telegram_token).auto_send();
+
+    let handler = Update::filter_message()
+        .branch(dptree::entry()
+		.filter_command::<LeetCommand>()
+		.endpoint(leet_command_handler))
+        .branch(dptree::entry()
+		.filter(filter_leet)
+		.endpoint(leet_message_handler))
+	;
+    
+    Dispatcher::builder(bot, handler)
+        .dependencies(dptree::deps![pg_pool])
+        .default_handler(|upd| async move {
+	    println!("unhandled update: {:?}", upd);
+	})
+        .error_handler(LoggingErrorHandler::with_custom_text("error during dispatch"))
+        .enable_ctrlc_handler()
+        .build()
+        .dispatch()
+        .await;
+
+    Ok(())
+}
+
+#[derive(Error,Debug)]
+enum MessageHandlerError {
+    #[error("Telegram request error {0}")]
+    Request(#[from] RequestError),
+    #[error("No sender for message!")]
+    NoFrom,
+    #[error("Sender has no username!")]
+    NoUsername,
+    #[error("Internal sql error {0}")]
+    Db(#[from] sqlx::Error),
+    #[error("No score for user in db")]
+    NoScore,
+}
+
+fn message_ok() -> Result<(), MessageHandlerError> {
+    Ok(respond(())?)
+}
+
+fn filter_leet(message: Message) -> bool {
+    let text = match message.text() {
+	Some(t) => t,
+	None => { return false; }
+    };
+
+    return text_is_leet(text);
+}
+
+async fn leet_command_handler(message: Message, cmd: LeetCommand, bot: AutoSend<Bot>, pool: PgPool) -> Result<(), MessageHandlerError> {
+
+    match cmd {
+        LeetCommand::Scores => {
+	    let scores = get_scores(&pool).await?;
+
+	    let scores_str = scores.into_iter().map(|(name,score)| format!(" {}: {}\n", name, score)).collect::<String>();
+
+	    let msg = format!("Leet scores:\n{}", scores_str);
+
+	    bot.send_message(message.chat.id, msg).await?;
+	}
+    }
+
+    message_ok()
+}
+
+async fn leet_message_handler(message: Message, bot: AutoSend<Bot>, pool: PgPool) -> Result<(), MessageHandlerError> {
+
+    let username = message.from()
+	.ok_or(MessageHandlerError::NoFrom)?
+	.username.clone()
+	.ok_or(MessageHandlerError::NoUsername)?;
+
+    let leet_check = check_leet(&username, &pool).await;
+
+    if let Err(e) = leet_check {
+	match e {
+	    LeetError::NotLeet => bot.send_message(message.chat.id, "it is not leet right now").await?,
+	    LeetError::AlreadyHitLeet => bot.send_message(message.chat.id, "you already hit leet today!").await?,
+	    LeetError::DbError(e) => {
+		bot.send_message(message.chat.id, "internal sql error").await?;
+		return Err(MessageHandlerError::Db(e));
+	    }
+	};
+	return message_ok();
+    }
+
+    log_leet(&username, &pool).await?;
+
+    let scores = get_scores(&pool).await?;
+
+    let user_score = scores.iter().find(|(u,_)| u == &username).ok_or(MessageHandlerError::NoScore)?.1;
+
+    let msg = format!("{} just hit leet! New score: {}", username, user_score);
+
+    bot.send_message(message.chat.id, msg).await?;
+
+    message_ok()
+}
+
+async fn log_leet(username: &str, pool: &PgPool) -> Result<(), sqlx::Error> {
+    sqlx::query("insert into leet_log (username, log_time) values ($1, now())")
+        .bind(username)
+        .execute(pool)
+        .await?;
+
+    Ok(())
+}
+
+async fn get_scores(pool: &PgPool) -> Result<Vec<(String,i64)>, sqlx::Error> {
+    let score: Vec<_> = sqlx::query_as("select username, count(username) as score from leet_log group by username")
+        .fetch_all(pool)
+        .await?;
+
+    Ok(score)
 }