Added sqlx to connect to sqlite database

.gitignore

@@ -2,10 +2,12 @@
 /target
 
 # Tokens
-# .env
+.env
 
 # Hidden files
 /src/.*
 
 # IDE config
 .vscode
+
+mooverdb.db

src/main.rs

@@ -34,11 +34,12 @@ impl EventHandler for Handler {
     async fn ready(&self, ctx: Context, ready: Ready) {
         println!("{} is connected!", ready.user.name);
 
+        #[cfg(feature="RELEASE")] {
+            use util::debug::hello;
+            hello(ctx.http.clone()).await;
+        }
 
-        // use util::debug::hello;
-        // hello(ctx.http.clone()).await;
-
-        notice::notice_wrapper(ctx).await;
+        // notice::notice_wrapper(ctx).await;
 
         // let scheduler = every(1).day().at(13, 30, 0)
         //     .perform(|| async {
@@ -65,13 +66,13 @@ impl EventHandler for Handler {
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     use anyhow::Context;
-    
+
     let token_str = "TOKEN";
     
     #[cfg(feature="DEBUG")]
     let token_str = "DEBUGTOKEN";
 
-    let token = dotenv_var(token_str).context("No TOKEN in env")?;
+    let token = dotenv_var(token_str).context("TOKEN not found in env")?;
 
     let intents = GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT;
 

src/message_handler.rs

@@ -44,7 +44,7 @@ async fn response(http: Arc<Http>, msg: Message) -> bool {
     const RESPONSES: [&str; 4] = [
         "To som jaaa",
         "Henloooo",
-        "Čo môj?",
+        "No čo je?",
         "Hm?"
     ];
 

src/other/notice.rs

@@ -1,67 +1,109 @@
 use chrono::{Datelike, Local};
-use serenity::prelude::*;
+use serenity::{all::{GuildId, UserId}, http::Http, prelude::*};
 
 use crate::util::debug::send_error;
 
-use anyhow::Result;
+use anyhow::Ok;
+
+use std::sync::Arc;
+
+use crate::util::security::dotenv_var;
+
+use sqlx::{FromRow, Connection, SqliteConnection};
 
 pub async fn notice_wrapper(ctx: Context) {
     match notice(ctx.clone()).await {
-        Ok(_) => return,
         Err(e) => {
             send_error(ctx.http.clone(), e.to_string()).await;
             return;
-        }
+        },
+        Result::Ok(_) => return
     }
 }
 
-struct BirtdayRow {
+async fn announce_event(guild_id: GuildId, name: &str, special_message: &str, http: Arc<Http>) {
+}
+
+async fn celebrate_birthday(guild_id: GuildId, user_id: UserId, nick: &str, http: Arc<Http>) {
+}
+
+#[derive(Clone, FromRow, Debug)]
+struct BirthdayRow {
+    #[sqlx(try_from="i64")]
+    id: u64,
     day: u8,
     month: u8,
     nick: String,
 }
 
-async fn notice(ctx: Context) -> anyhow::Result<()> {
+#[derive(Clone, FromRow, Debug)]
+struct EventRow {
+    #[sqlx(try_from="i64")]
+    guild: u64,
+    name: String,
+    day: u8,
+    month: u8,
+    special_message: String,
+}
+
+async fn notice(ctx: serenity::client::Context) -> anyhow::Result<()> {
+    use anyhow::Context;
+
     let local = Local::now();
     let day = local.day();
     let month = local.month();
 
-    let pool = sqlx::sqlite::SqlitePoolOptions::new()
-        .connect("my.db")
-        .await?;
+    let db_path = dotenv_var("DATABASE_URL").context("DATABASE_URL not found in env")?;
 
-    let birtdays: Vec<BirtdayRow> = sqlx::query_as!(
-        BirtdayRow,
-        "SELECT * FROM birthdays WHERE day=6 AND month=3;"
+    let mut db = SqliteConnection::connect(db_path.as_str()).await?;
+
+    let birtdays = sqlx::query_as::<_, BirthdayRow>(
+        "SELECT * FROM birthdays
+        WHERE day=? AND month=?;"
     )
-    .fetch(&pool)
+    .bind(day)
+    .bind(month)
+    .fetch_all(&mut db)
     .await?;
 
-    // let result = Vec::new();
-    // let stmt = client.conn(|conn| {
-    //     // conn.prepare(format!("SELECT * FROM {db} WHERE day={day} AND month={month};").as_str());
-    //     conn.prepare("SELECT * FROM birthdays WHERE day=6 AND month=3;")
-    // }).await?;
+    let global_events = sqlx::query_as::<_, EventRow>(
+        "SELECT guild, name, day, month, specialMessage from events
+        WHERE day=? AND month=? AND guild=0;"
+    )
+    .bind(day)
+    .bind(month)
+    .fetch_all(&mut db)
+    .await?;
 
-    let rows = stmt.query([])?;
+    let guilds = ctx.http.get_guilds(None, None).await?;
 
-    let result: Vec<BirtdayRow> = Vec::new();
-    while let Some(row) = rows.next()? {
-        let bd = BirtdayRow {
-            day: row.get(1)?,
-            month: row.get(2)?,
-            nick: row.get(3)?,
-        };
-        result.push(bd);
+    for guild in guilds {
+        let guild_id = guild.id;
+
+        for bd in &birtdays {
+            let user_id = UserId::new(bd.id);
+            guild_id.member(ctx.http(), user_id).await?;
+
+            celebrate_birthday(guild_id, user_id, bd.nick.as_str(), ctx.http.clone()).await;
+        }
+
+        for e in &global_events {
+            announce_event(guild_id, e.name.as_str(), e.special_message.as_str(), ctx.http.clone()).await;
+        }
     }
 
-    println!("VALUE: {:?}", result[0].day);
-    // for db in ["birthdays", "events"] {
+    let global_events = sqlx::query_as::<_, EventRow>(
+        "SELECT guild, name, day, month, specialMessage from events
+        WHERE day=? AND month=? AND guild!=0;"
+    )
+    .bind(day)
+    .bind(month)
+    .fetch_all(&mut db)
+    .await?;
 
-    //     // let mut stmt = client.conn(|conn| {
-    //     //     conn.
-    //     // }).await;
-    // }
+    for e in &global_events {
+        announce_event(GuildId::new(e.guild), e.name.as_str(), e.special_message.as_str(), ctx.http.clone()).await;
+    }
 
     Ok(())
 }