fix: make sure that wolves data is pulled in before roles are ran

src/bin/update_data.rs

@@ -1,8 +1,4 @@
-use skynet_discord_bot::{db_init, get_config, get_server_config_bulk, Config, ServerMembers, Servers, Wolves};
+use skynet_discord_bot::{db_init, get_config, get_data::get_wolves};
-
-use serde::{Deserialize, Serialize};
-use serenity::model::id::GuildId;
-use sqlx::{Pool, Sqlite};
 
 #[tokio::main]
 async fn main() {
@@ -15,109 +11,3 @@ async fn main() {
   // handle wolves api here
   get_wolves(&db, &config).await;
 }
-
-#[derive(Deserialize, Serialize, Debug)]
-struct WolvesResultUser {
-  committee: String,
-  wolves_id: String,
-  first_name: String,
-  last_name: String,
-  contact_email: String,
-  student_id: Option<String>,
-  note: Option<String>,
-  expiry: String,
-  requested: String,
-  approved: String,
-  sitename: String,
-  domain: String,
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-struct WolvesResult {
-  success: i8,
-  result: Vec<WolvesResultUser>,
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-struct WolvesResultLocal {
-  pub id_wolves: String,
-  pub email: String,
-  pub expiry: String,
-}
-async fn get_wolves(db: &Pool<Sqlite>, config: &Config) {
-  for server_config in get_server_config_bulk(db).await {
-    let Servers {
-      server,
-      wolves_api,
-      ..
-    } = server_config;
-
-    for user in get_wolves_sub(config, &wolves_api).await {
-      add_users_wolves(db, &server, &user).await;
-    }
-  }
-}
-
-async fn get_wolves_sub(config: &Config, wolves_api: &str) -> Vec<WolvesResultUser> {
-  if config.wolves_url.is_empty() {
-    return vec![];
-  }
-
-  // get wolves data
-  if let Ok(mut res) = surf::post(&config.wolves_url).header("X-AM-Identity", wolves_api).await {
-    if let Ok(WolvesResult {
-      success,
-      result,
-    }) = res.body_json().await
-    {
-      if success != 1 {
-        return vec![];
-      }
-
-      return result;
-    }
-  }
-
-  vec![]
-}
-
-async fn add_users_wolves(db: &Pool<Sqlite>, server: &GuildId, user: &WolvesResultUser) {
-  // expiry
-  match sqlx::query_as::<_, Wolves>(
-    "
-      INSERT INTO wolves (id_wolves, email)
-      VALUES ($1, $2)
-      ON CONFLICT(id_wolves) DO UPDATE SET email = $2
-    ",
-  )
-  .bind(&user.wolves_id)
-  .bind(&user.contact_email)
-  .fetch_optional(db)
-  .await
-  {
-    Ok(_) => {}
-    Err(e) => {
-      println!("Failure to insert into Wolves {:?}", user);
-      println!("{:?}", e);
-    }
-  }
-
-  match sqlx::query_as::<_, ServerMembers>(
-    "
-      INSERT OR REPLACE INTO server_members (server, id_wolves, expiry)
-      VALUES (?1, ?2, ?3)
-    ",
-  )
-  .bind(*server.as_u64() as i64)
-  .bind(&user.wolves_id)
-  .bind(&user.expiry)
-  .fetch_optional(db)
-  .await
-  {
-    Ok(_) => {}
-    Err(e) => {
-      println!("Failure to insert into ServerMembers {}  {:?}", server.as_u64(), user);
-      println!("{:?}", e);
-    }
-  }
-}

src/bin/update_users.rs

@@ -4,7 +4,7 @@ use serenity::{
   model::gateway::{GatewayIntents, Ready},
   Client,
 };
-use skynet_discord_bot::{db_init, get_config, get_server_config_bulk, update_server, Config, DataBase};
+use skynet_discord_bot::{db_init, get_config, get_server_config_bulk, set_roles::update_server, Config, DataBase};
 use std::{process, sync::Arc};
 use tokio::sync::RwLock;
 

src/commands/add_server.rs

@@ -6,7 +6,8 @@ use serenity::{
     prelude::{command::CommandOptionType, interaction::application_command::CommandDataOptionValue},
   },
 };
-use skynet_discord_bot::{get_server_config, update_server, DataBase, Servers};
+use skynet_discord_bot::get_data::get_wolves;
+use skynet_discord_bot::{get_server_config, set_roles::update_server, Config, DataBase, Servers};
 use sqlx::{Error, Pool, Sqlite};
 
 pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
@@ -172,6 +173,15 @@ async fn add_server(db: &Pool<Sqlite>, ctx: &Context, server: &Servers) -> Resul
 
   // update all users
   if update {
+    let config_lock = {
+      let data_read = ctx.data.read().await;
+      data_read.get::<Config>().expect("Expected Config in TypeMap.").clone()
+    };
+    let config = config_lock.read().await;
+
+    // handle wolves api here
+    get_wolves(db, &config).await;
+
     let mut roles_remove = vec![];
     if current_remove {
       roles_remove.push(current_role)

src/lib.rs

@@ -379,6 +379,8 @@ pub fn random_string(len: usize) -> String {
   thread_rng().sample_iter(&Alphanumeric).take(len).map(char::from).collect()
 }
 
+pub mod set_roles {
+  use super::*;
   pub async fn update_server(db: &Pool<Sqlite>, ctx: &Context, server: &Servers, remove_roles: &[Option<RoleId>]) {
     let Servers {
       server,
@@ -493,3 +495,114 @@ async fn set_server_numbers(db: &Pool<Sqlite>, server: &GuildId, past: i64, curr
       }
     }
   }
+}
+
+pub mod get_data {
+  use super::*;
+
+  #[derive(Deserialize, Serialize, Debug)]
+  struct WolvesResultUser {
+    committee: String,
+    wolves_id: String,
+    first_name: String,
+    last_name: String,
+    contact_email: String,
+    student_id: Option<String>,
+    note: Option<String>,
+    expiry: String,
+    requested: String,
+    approved: String,
+    sitename: String,
+    domain: String,
+  }
+
+  #[derive(Deserialize, Serialize, Debug)]
+  struct WolvesResult {
+    success: i8,
+    result: Vec<WolvesResultUser>,
+  }
+
+  #[derive(Deserialize, Serialize, Debug)]
+  struct WolvesResultLocal {
+    pub id_wolves: String,
+    pub email: String,
+    pub expiry: String,
+  }
+  pub async fn get_wolves(db: &Pool<Sqlite>, config: &Config) {
+    for server_config in get_server_config_bulk(db).await {
+      let Servers {
+        server,
+        wolves_api,
+        ..
+      } = server_config;
+
+      for user in get_wolves_sub(config, &wolves_api).await {
+        add_users_wolves(db, &server, &user).await;
+      }
+    }
+  }
+
+  async fn get_wolves_sub(config: &Config, wolves_api: &str) -> Vec<WolvesResultUser> {
+    if config.wolves_url.is_empty() {
+      return vec![];
+    }
+
+    // get wolves data
+    if let Ok(mut res) = surf::post(&config.wolves_url).header("X-AM-Identity", wolves_api).await {
+      if let Ok(WolvesResult {
+        success,
+        result,
+      }) = res.body_json().await
+      {
+        if success != 1 {
+          return vec![];
+        }
+
+        return result;
+      }
+    }
+
+    vec![]
+  }
+
+  async fn add_users_wolves(db: &Pool<Sqlite>, server: &GuildId, user: &WolvesResultUser) {
+    // expiry
+    match sqlx::query_as::<_, Wolves>(
+      "
+      INSERT INTO wolves (id_wolves, email)
+      VALUES ($1, $2)
+      ON CONFLICT(id_wolves) DO UPDATE SET email = $2
+    ",
+    )
+    .bind(&user.wolves_id)
+    .bind(&user.contact_email)
+    .fetch_optional(db)
+    .await
+    {
+      Ok(_) => {}
+      Err(e) => {
+        println!("Failure to insert into Wolves {:?}", user);
+        println!("{:?}", e);
+      }
+    }
+
+    match sqlx::query_as::<_, ServerMembers>(
+      "
+      INSERT OR REPLACE INTO server_members (server, id_wolves, expiry)
+      VALUES (?1, ?2, ?3)
+    ",
+    )
+    .bind(*server.as_u64() as i64)
+    .bind(&user.wolves_id)
+    .bind(&user.expiry)
+    .fetch_optional(db)
+    .await
+    {
+      Ok(_) => {}
+      Err(e) => {
+        println!("Failure to insert into ServerMembers {}  {:?}", server.as_u64(), user);
+        println!("{:?}", e);
+      }
+    }
+  }
+}