Add api struct, progress on functions and such

Author: averwhy

src/dev_commands.rs

@@ -1,3 +1,5 @@
+use crate::utils::agencies::Agency;
+use crate::utils::tracking;
 use crate::{Context, Error};
 use poise::CreateReply;
 use serenity::builder::CreateEmbed;
@@ -34,11 +36,7 @@ pub async fn stop(ctx: Context<'_>) -> Result<(), Error> {
         ctx.msg.react(ctx, '👋').await?;
     }
     let author_name = ctx.author().name.clone();
-    span!(
-        Level::INFO,
-        "{} is shutting down all shards",
-        author_name
-    );
+    span!(Level::INFO, "{} is shutting down all shards", author_name);
     let shard_manager = ctx.framework().shard_manager().clone();
     shard_manager.shutdown_all().await;
     Ok(())
@@ -118,12 +116,25 @@ pub async fn addagency(_ctx: Context<'_>) -> Result<(), Error> {
     hide_in_help,
     subcommands("list")
 )]
-pub async fn track(_ctx: Context<'_>) -> Result<(), Error> {
+pub async fn track(
+    ctx: Context<'_>,
+    agency: String,
+    line: String,
+    station: String,
+) -> Result<(), Error> {
+    // query database with passed in arguments
+    
     Ok(())
 }
 
 /// Shows list of tracked lines or subway stations
-#[poise::command(prefix_command, track_edits, owners_only, hide_in_help)]
+#[poise::command(prefix_command, track_edits, owners_only, hide_in_help)] // TODO: Once done, add back slash command support
 pub async fn list(_ctx: Context<'_>) -> Result<(), Error> {
     Ok(())
 }
+
+/// Gets the ETA of the next train at a specified station
+#[poise::command(prefix_command, track_edits, owners_only, hide_in_help)] // TODO: Once done, add back slash command support
+pub async fn eta(_ctx: Context<'_>) -> Result<(), Error> {
+    Ok(())
+}

src/main.rs

@@ -1,8 +1,8 @@
 use poise::serenity_prelude as serenity;
-use utils::tracking::Tracking;
 use std::{sync::Arc, time::Duration};
 use tracing::{span, Level};
 use utils::database::Client;
+use utils::tracking::Tracking;
 mod utils;
 use crate::utils::config::get as get_config;
 use crate::utils::config::Config;
@@ -20,7 +20,7 @@ type Context<'a> = poise::Context<'a, Data, Error>;
 pub struct Data {
     pub db: database::Client,
     pub config: Config,
-    pub trackings: Vec<Tracking>
+    pub trackings: Vec<Tracking>,
 }
 
 async fn on_error(error: poise::FrameworkError<'_, Data, Error>) {
@@ -112,7 +112,7 @@ async fn main() {
                 Ok(Data {
                     db: Client::new().await.expect("Failed to connect to database"),
                     config,
-                    trackings: Vec::new() // TODO replace
+                    trackings: Vec::new(), // TODO replace
                 })
             })
         })

src/utils/api.rs

@@ -0,0 +1,48 @@
+use crate::serenity::{Command, User, UserId};
+use crate::utils::database::Client;
+use crate::Error;
+use sqlx::Row;
+
+pub struct Api {
+    client: Client,
+}
+
+impl Api {
+    pub fn new(client: Client) -> Self {
+        Self { client }
+    }
+
+    pub async fn build_url(&self, agency_id: i32) -> Result<String, Error> {
+        let result = sqlx::query!(
+            r#"SELECT api_url FROM agencies WHERE id = $1"#,
+            agency_id
+        )
+        .fetch_one(&self.client.pool)
+        .await?;
+        let full_url = format!("https://{}", result.api_url);
+        Ok(full_url)
+    }
+
+    /// Checks the line cache for the line, if not then it will try to get it from the api
+    pub async fn try_line(&self, agency_id: i32, line: String) -> Result<String, Error> {
+        let line_id = sqlx::query!(r#"SELECT line_id FROM agency_line_cache WHERE agency_id = $1 AND LOWER(line_name) = LOWER($2)"#, agency_id, line.to_string()).fetch_one(&self.client.pool)
+            .await?;
+        let api_url = &self.build_url(agency_id);
+        Ok(line_id.line_id) // TODO: This better work
+    }
+
+    /// Attempts to get station data from the given agency, line and station name
+    pub async fn try_station(
+        &self,
+        agency_id: i32,
+        line: String,
+        station: String,
+    ) -> Result<(), Error> {
+        let line = self
+            .try_line(agency_id, line)
+            .await
+            .expect("Could not find any matching lines");
+        // TODO: api call to get station, return results
+        Ok(())
+    }
+}

src/utils/database.rs

@@ -1,13 +1,19 @@
 use crate::get_secrets;
-use crate::serenity::{User, UserId, Command};
+use crate::serenity::{Command, User, UserId};
 use crate::Error;
 use sqlx::postgres::PgPool;
+use sqlx::types::chrono::{DateTime, Utc};
 use tracing::{span, Level};
 
 pub struct Client {
     pub pool: PgPool,
 }
 
+pub struct DbPassenger {
+    pub id: i64,
+    pub created_at: Option<DateTime<Utc>> // This should not be optional but whatever i guess
+}
+
 impl Client {
     pub async fn new() -> Result<Self, sqlx::Error> {
         let secrets = get_secrets();
@@ -27,7 +33,7 @@ impl Client {
     }
 
     /// Adds a user, a.k.a 'Passenger' to the database
-    pub async fn add_user(self: Self, user: User) -> Result<UserId, Error> {
+    pub async fn add_user(&self, user: User) -> Result<UserId, Error> {
         sqlx::query!(
             r#"INSERT INTO users(id) VALUES ( $1 )"#,
             user.id.get() as i32
@@ -39,25 +45,50 @@ impl Client {
     }
 
     /// Gets a user, a.k.a 'Passenger' from the database
-    pub async fn get_user(self: Self, user: User) -> Result<UserId, Error> {
-        sqlx::query!(r#"SELECT * FROM users WHERE id = $1"#, user.id.get() as i32)
+    pub async fn get_user(&self, user: User) -> Result<DbPassenger, Error> {
+        let result = sqlx::query_as!(DbPassenger, r#"SELECT * FROM users WHERE id = $1"#, user.id.get() as i32)
             .fetch_one(&self.pool)
             .await?;
 
-        Ok(user.id)
+        Ok(result)
     }
 
-    pub async fn command_exists(&self, command: Command) -> Result<bool, Error>{
-        sqlx::query!(r#"SELECT * FROM command_stats WHERE command_name = $1"#, command.name)
+    /// Gets an Agency ID by checking short or long name
+    pub async fn get_agency(&self, agency: String) -> Result<i32, Error> {
+        let result = sqlx::query!(
+            r#"SELECT id FROM agencies WHERE LOWER(short_name) = LOWER($1) OR LOWER(long_name) = LOWER($1)"#,
+            agency
+        )
             .fetch_one(&self.pool)
             .await?;
+        Ok(result.id)
+    }
+
+    pub async fn command_exists(&self, command: Command) -> Result<bool, Error> {
+        sqlx::query!(
+            r#"SELECT * FROM command_stats WHERE command_name = $1"#,
+            command.name
+        )
+        .fetch_one(&self.pool)
+        .await?;
         Ok(true)
     }
 
     /// Adds an use to a specified command
     pub async fn update_command(&self, command: Command) -> Result<(), Error> {
-        self.command_exists(command.clone()).await.expect(&format!("Command '{}' does not exist", command.name.to_string()));
+        self.command_exists(command.clone()).await.expect(&format!(
+            "Command '{}' does not exist",
+            command.name.to_string()
+        ));
         sqlx::query!(r#"UPDATE command_stats SET command_count = (command_count + 1) WHERE command_name = $1"#, command.clone().name).execute(&self.pool).await?;
         Ok(())
     }
 }
+
+impl Clone for Client {
+    fn clone(&self) -> Self {
+        Self {
+            pool: self.pool.clone(),
+        }
+    }
+}

src/utils/mod.rs

@@ -1,5 +1,6 @@
 pub mod agencies;
+pub mod api;
 pub mod config;
 pub mod database;
 pub mod secrets;
-pub mod tracking;
+pub mod tracking;

src/utils/tracking.rs

@@ -1,24 +1,23 @@
 use crate::Error;
 use sqlx::types::chrono::{DateTime, Utc};
 
-pub struct Tracking{
+pub struct Tracking {
     pub id: i32,
     pub owner_id: i64,
     pub agency_id: i32,
     pub line_id: i32,
     pub stop_id: Option<i32>,
     pub started_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>
+    pub updated_at: DateTime<Utc>,
 }
 
-impl Tracking{
-    fn new(){
+// With this, we will probably use tokio wakers
 
-    }
+impl Tracking {
+    fn new() {}
 
     /// Gets an update for this tracking, by making the necessary API calls and sending a
-    fn get_update() -> Result<(), Error>{
-
+    fn get_update() -> Result<(), Error> {
         Ok(())
     }
-}
+}