Merge pull request '#40_Improve_Preformance' (#41) from #40_Improve_Preformance into main

Reviewed-on: #41

Closes #40

.forgejo/workflows/check_lfs.yaml

@@ -1,9 +1,7 @@
 on:
-  - pull_request
   - push
   - workflow_dispatch
 
-
 jobs:
   check_lfs:
     # nix/docker

.forgejo/workflows/on_pr.yaml

@@ -0,0 +1,51 @@
+on:
+  - pull_request
+
+jobs:
+  check_lfs:
+    # nix/docker
+    runs-on: nix
+    steps:
+      - uses: https://github.com/MPLew-is/lfs-check-action@1
+
+  # rust code must be formatted for standardisation
+  lint_fmt:
+    # build it using teh base nixos system, helps with caching
+    runs-on: nix
+    steps:
+      # get the repo first
+      - uses: https://code.forgejo.org/actions/checkout@v4
+      - uses: https://forgejo.skynet.ie/Skynet/actions/get_lfs/nix@v8
+        with:
+          server_url: ${{ gitea.server_url }}
+          repository: ${{ gitea.repository }}
+      - run: nix build .#fmt --verbose
+
+  # clippy is incredibly useful for making yer code better
+  lint_clippy:
+    # build it using teh base nixos system, helps with caching
+    runs-on: nix
+    permissions:
+      checks: write
+    steps:
+      # get the repo first
+      - uses: https://code.forgejo.org/actions/checkout@v4
+      - uses: https://forgejo.skynet.ie/Skynet/actions/get_lfs/nix@v8
+        with:
+          server_url: ${{ gitea.server_url }}
+          repository: ${{ gitea.repository }}
+      - run: nix build .#clippy --verbose
+  
+  build:
+    # build it using teh base nixos system, helps with caching
+    runs-on: nix
+    needs: [ lint_fmt, lint_clippy ]
+    steps:
+      # get the repo first
+      - uses: https://code.forgejo.org/actions/checkout@v4
+      - uses: https://forgejo.skynet.ie/Skynet/actions/get_lfs/nix@v8
+        with:
+          server_url: ${{ gitea.server_url }}
+          repository: ${{ gitea.repository }}
+      - name: "Build it locally"
+        run: nix build --verbose

.rustfmt.toml

@@ -7,4 +7,4 @@ fn_params_layout = "Compressed"
 struct_lit_width = 0
 tab_spaces = 2
 use_small_heuristics = "Max"
-#imports_granularity="Crate"
+imports_granularity = "Crate"

Cargo.toml

@@ -4,13 +4,9 @@ version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [[bin]]
 name = "update_data"
 
-[[bin]]
-name = "update_users"
-
 [[bin]]
 name = "update_committee"
 
@@ -38,7 +34,7 @@ surf = "2.3"
 dotenvy = "0.15"
 
 # For sqlite
-sqlx = { version = "0.8", features = [ "runtime-tokio", "sqlite", "migrate" ] }
+sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite", "migrate"] }
 serde_json = { version = "1.0", features = ["raw_value"] }
 
 # create random strings

flake.nix

@@ -152,13 +152,14 @@
 
             # modify these
             scripts = {
-              # every 20 min
+              # every 10 min
               "update_data" = "*:0,10,20,30,40,50";
               # groups are updated every hour, offset from teh ldap
-              "update_users" = "*:05:00";
+              "update_users" = "*:5,15,25,35,45,55";
               # Committee server has its own timer
-              "update_committee" = "*:15:00";
+              "update_committee" = "*:5,15,25,35,45,55";
               # minecraft stuff is updated at 5am
+              # this service does not depend on teh discord cache
               "update_minecraft" = "5:10:00";
               # server icon gets updated daily at midnight
               "update_server-icon" = "0:01:00";

src/bin/cleanup_committee.rs

@@ -1,14 +1,17 @@
-use serenity::all::{ChunkGuildFilter, GuildId};
 use serenity::{
+  all::{ChunkGuildFilter, GuildId, GuildMembersChunkEvent},
   async_trait,
   client::{Context, EventHandler},
-  model::gateway::{GatewayIntents, Ready},
+  model::gateway::GatewayIntents,
   Client,
 };
-use skynet_discord_bot::common::database::{db_init, DataBase};
+use skynet_discord_bot::{
-
+  common::{
-use skynet_discord_bot::common::set_roles::committee::db_roles_get;
+    database::{db_init, DataBase},
-use skynet_discord_bot::{get_config, Config};
+    set_roles::committee::db_roles_get,
+  },
+  get_config, Config,
+};
 use sqlx::{Pool, Sqlite};
 use std::{process, sync::Arc};
 use tokio::sync::RwLock;
@@ -42,7 +45,7 @@ async fn main() {
   }
 
   if let Err(why) = client.start().await {
-    println!("Client error: {:?}", why);
+    println!("Client error: {why:?}");
   }
 }
 
@@ -56,26 +59,25 @@ impl EventHandler for Handler {
     println!("Cache built successfully!");
   }
 
-  async fn ready(&self, ctx: Context, ready: Ready) {
+  async fn guild_members_chunk(&self, ctx: Context, chunk: GuildMembersChunkEvent) {
-    let ctx = Arc::new(ctx);
+    if (chunk.chunk_index + 1) == chunk.chunk_count {
-    println!("{} is connected!", ready.user.name);
+      let db_lock = {
+        let data_read = ctx.data.read().await;
+        data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
+      };
 
-    let db_lock = {
+      let db = db_lock.read().await;
-      let data_read = ctx.data.read().await;
-      data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
-    };
 
-    let db = db_lock.read().await;
+      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;
 
-    let config_lock = {
+      cleanup(&db, &ctx, &config).await;
-      let data_read = ctx.data.read().await;
+      // finish up
-      data_read.get::<Config>().expect("Expected Config in TypeMap.").clone()
+      process::exit(0);
-    };
+    }
-    let config = config_lock.read().await;
-
-    cleanup(&db, &ctx, &config).await;
-    // finish up
-    process::exit(0);
   }
 }
 

src/bin/update_committee.rs

@@ -1,13 +1,17 @@
-use serenity::all::{ChunkGuildFilter, GuildId};
 use serenity::{
+  all::{ChunkGuildFilter, GuildId, GuildMembersChunkEvent},
   async_trait,
   client::{Context, EventHandler},
-  model::gateway::{GatewayIntents, Ready},
+  model::gateway::GatewayIntents,
   Client,
 };
-use skynet_discord_bot::common::database::{db_init, DataBase};
+use skynet_discord_bot::{
-use skynet_discord_bot::common::set_roles::committee;
+  common::{
-use skynet_discord_bot::{get_config, Config};
+    database::{db_init, DataBase},
+    set_roles::committee,
+  },
+  get_config, Config,
+};
 use std::{process, sync::Arc};
 use tokio::sync::RwLock;
 
@@ -36,7 +40,7 @@ async fn main() {
   }
 
   if let Err(why) = client.start().await {
-    println!("Client error: {:?}", why);
+    println!("Client error: {why:?}");
   }
 }
 
@@ -50,14 +54,13 @@ impl EventHandler for Handler {
     println!("Cache built successfully!");
   }
 
-  async fn ready(&self, ctx: Context, ready: Ready) {
+  async fn guild_members_chunk(&self, ctx: Context, chunk: GuildMembersChunkEvent) {
-    let ctx = Arc::new(ctx);
+    if (chunk.chunk_index + 1) == chunk.chunk_count {
-    println!("{} is connected!", ready.user.name);
+      // u[date committee server
+      committee::check_committee(&ctx).await;
 
-    // u[date committee server
+      // finish up
-    committee::check_committee(Arc::clone(&ctx)).await;
+      process::exit(0);
-
+    }
-    // finish up
-    process::exit(0);
   }
 }

src/bin/update_data.rs

@@ -1,14 +1,16 @@
-use serenity::all::{ChunkGuildFilter, GuildId};
 use serenity::{
   async_trait,
   client::{Context, EventHandler},
   model::gateway::{GatewayIntents, Ready},
   Client,
 };
-use skynet_discord_bot::common::database::{db_init, DataBase};
+use skynet_discord_bot::{
-use skynet_discord_bot::common::wolves::cns::get_wolves;
+  common::{
-use skynet_discord_bot::common::wolves::committees::get_cns;
+    database::{db_init, DataBase},
-use skynet_discord_bot::{get_config, Config};
+    wolves::{cns::get_wolves, committees::get_cns},
+  },
+  get_config, Config,
+};
 use std::{process, sync::Arc};
 use tokio::sync::RwLock;
 
@@ -40,20 +42,13 @@ async fn main() {
   }
 
   if let Err(why) = client.start().await {
-    println!("Client error: {:?}", why);
+    println!("Client error: {why:?}");
   }
 }
 
 struct Handler;
 #[async_trait]
 impl EventHandler for Handler {
-  async fn cache_ready(&self, ctx: Context, guilds: Vec<GuildId>) {
-    for guild in guilds {
-      ctx.shard.chunk_guild(guild, Some(2000), false, ChunkGuildFilter::None, None);
-    }
-    println!("Cache built successfully!");
-  }
-
   async fn ready(&self, ctx: Context, ready: Ready) {
     let ctx = Arc::new(ctx);
     println!("{} is connected!", ready.user.name);

src/bin/update_minecraft.rs

@@ -1,6 +1,10 @@
-use skynet_discord_bot::common::database::db_init;
+use skynet_discord_bot::{
-use skynet_discord_bot::common::minecraft::{get_minecraft_config, update_server, whitelist_wipe};
+  common::{
-use skynet_discord_bot::get_config;
+    database::db_init,
+    minecraft::{get_minecraft_config, update_server, whitelist_wipe},
+  },
+  get_config,
+};
 use std::collections::HashSet;
 
 #[tokio::main]

src/bin/update_server-icon.rs

@@ -1,13 +1,14 @@
-use serenity::all::{ChunkGuildFilter, GuildId};
 use serenity::{
   async_trait,
   client::{Context, EventHandler},
   model::gateway::{GatewayIntents, Ready},
   Client,
 };
-use skynet_discord_bot::common::server_icon::{get_config_icons, update_icon};
 use skynet_discord_bot::{
-  common::database::{db_init, DataBase},
+  common::{
+    database::{db_init, DataBase},
+    server_icon::{get_config_icons, update_icon},
+  },
   get_config, Config,
 };
 use std::{process, sync::Arc};
@@ -38,20 +39,13 @@ async fn main() {
   }
 
   if let Err(why) = client.start().await {
-    println!("Client error: {:?}", why);
+    println!("Client error: {why:?}");
   }
 }
 
 struct Handler;
 #[async_trait]
 impl EventHandler for Handler {
-  async fn cache_ready(&self, ctx: Context, guilds: Vec<GuildId>) {
-    for guild in guilds {
-      ctx.shard.chunk_guild(guild, Some(2000), false, ChunkGuildFilter::None, None);
-    }
-    println!("Cache built successfully!");
-  }
-
   async fn ready(&self, ctx: Context, ready: Ready) {
     let ctx = Arc::new(ctx);
     println!("{} is connected!", ready.user.name);

src/bin/update_users.rs

@@ -1,13 +1,17 @@
-use serenity::all::{ChunkGuildFilter, GuildId};
 use serenity::{
+  all::{ChunkGuildFilter, GuildId, GuildMembersChunkEvent},
   async_trait,
   client::{Context, EventHandler},
-  model::gateway::{GatewayIntents, Ready},
+  model::gateway::GatewayIntents,
   Client,
 };
-use skynet_discord_bot::common::database::{db_init, get_server_config_bulk, DataBase};
+use skynet_discord_bot::{
-use skynet_discord_bot::common::set_roles::normal;
+  common::{
-use skynet_discord_bot::{get_config, Config};
+    database::{db_init, get_server_config_bulk, DataBase},
+    set_roles::normal,
+  },
+  get_config, Config,
+};
 use std::{process, sync::Arc};
 use tokio::sync::RwLock;
 
@@ -36,7 +40,7 @@ async fn main() {
   }
 
   if let Err(why) = client.start().await {
-    println!("Client error: {:?}", why);
+    println!("Client error: {why:?}");
   }
 }
 
@@ -50,19 +54,18 @@ impl EventHandler for Handler {
     println!("Cache built successfully!");
   }
 
-  async fn ready(&self, ctx: Context, ready: Ready) {
+  async fn guild_members_chunk(&self, ctx: Context, chunk: GuildMembersChunkEvent) {
-    let ctx = Arc::new(ctx);
+    if (chunk.chunk_index + 1) == chunk.chunk_count {
-    println!("{} is connected!", ready.user.name);
+      // this goes into each server and sets roles for each wolves member
+      check_bulk(&ctx).await;
 
-    // this goes into each server and sets roles for each wolves member
+      // finish up
-    check_bulk(Arc::clone(&ctx)).await;
+      process::exit(0);
-
+    }
-    // finish up
-    process::exit(0);
   }
 }
 
-async fn check_bulk(ctx: Arc<Context>) {
+async fn check_bulk(ctx: &Context) {
   let db_lock = {
     let data_read = ctx.data.read().await;
     data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
@@ -71,6 +74,6 @@ async fn check_bulk(ctx: Arc<Context>) {
   let db = db_lock.read().await;
 
   for server_config in get_server_config_bulk(&db).await {
-    normal::update_server(&ctx, &server_config, &[], &[]).await;
+    normal::update_server(ctx, &server_config, &[], &[]).await;
   }
 }

src/commands/add_server.rs

@@ -1,8 +1,12 @@
-use serenity::all::{CommandDataOption, CommandDataOptionValue, CommandInteraction};
+use serenity::{
-use serenity::client::Context;
+  all::{CommandDataOption, CommandDataOptionValue, CommandInteraction},
-use skynet_discord_bot::common::database::{get_server_config, DataBase, Servers};
+  client::Context,
-use skynet_discord_bot::common::set_roles::normal::update_server;
+};
-use skynet_discord_bot::common::wolves::cns::get_wolves;
+use skynet_discord_bot::common::{
+  database::{get_server_config, DataBase, Servers},
+  set_roles::normal::update_server,
+  wolves::cns::get_wolves,
+};
 use sqlx::{Error, Pool, Sqlite};
 
 pub async fn run(command: &CommandInteraction, ctx: &Context) -> String {
@@ -72,8 +76,8 @@ pub async fn run(command: &CommandInteraction, ctx: &Context) -> String {
   match add_server(&db, ctx, &server_data).await {
     Ok(_) => {}
     Err(e) => {
-      println!("{:?}", e);
+      println!("{e:?}");
-      return format!("Failure to insert into Servers {:?}", server_data);
+      return format!("Failure to insert into Servers {server_data:?}");
     }
   }
 

src/commands/count.rs

@@ -5,8 +5,7 @@ pub mod committee {
   use serenity::all::{
     CommandDataOption, CommandDataOptionValue, CommandInteraction, CommandOptionType, Context, CreateCommand, CreateCommandOption,
   };
-  use skynet_discord_bot::common::database::DataBase;
+  use skynet_discord_bot::common::{database::DataBase, set_roles::committee::db_roles_get};
-  use skynet_discord_bot::common::set_roles::committee::db_roles_get;
 
   pub async fn run(command: &CommandInteraction, ctx: &Context) -> String {
     let sub_options = if let Some(CommandDataOption {
@@ -53,7 +52,7 @@ pub mod committee {
     for (count, name) in cs {
       let leading = if count < 10 { " " } else { "" };
 
-      let line = format!("{}{} {}", leading, count, name);
+      let line = format!("{leading}{count} {name}");
 
       let length = line.len() + 1;
 
@@ -85,9 +84,13 @@ pub mod servers {
   // get the list of all the current clubs/socs
   use serde::{Deserialize, Serialize};
   use serenity::all::{CommandInteraction, CommandOptionType, Context, CreateCommand, CreateCommandOption};
-  use skynet_discord_bot::common::database::{get_server_config_bulk, DataBase};
+  use skynet_discord_bot::{
-  use skynet_discord_bot::common::set_roles::committee::get_committees;
+    common::{
-  use skynet_discord_bot::get_now_iso;
+      database::{get_server_config_bulk, DataBase},
+      set_roles::committee::get_committees,
+    },
+    get_now_iso,
+  };
   use sqlx::{Pool, Sqlite};
   use std::collections::HashMap;
 
@@ -143,7 +146,7 @@ pub mod servers {
         ""
       };
 
-      let line = format!("{}{} {}{} {}", current_leading, current, past_leading, past, name);
+      let line = format!("{current_leading}{current} {past_leading}{past} {name}");
 
       let length = line.len() + 1;
 

src/commands/minecraft.rs

@@ -9,11 +9,17 @@ pub(crate) mod user {
     use super::*;
     use crate::commands::wolves::link::get_server_member_discord;
     use serde::{Deserialize, Serialize};
-    use serenity::all::{CommandDataOption, CommandDataOptionValue, CommandInteraction};
+    use serenity::{
-    use serenity::model::id::UserId;
+      all::{CommandDataOption, CommandDataOptionValue, CommandInteraction},
-    use skynet_discord_bot::common::database::Wolves;
+      model::id::UserId,
-    use skynet_discord_bot::common::minecraft::{whitelist_update, Minecraft};
+    };
-    use skynet_discord_bot::Config;
+    use skynet_discord_bot::{
+      common::{
+        database::Wolves,
+        minecraft::{whitelist_update, Minecraft},
+      },
+      Config,
+    };
     use sqlx::Error;
 
     pub async fn run(command: &CommandInteraction, ctx: &Context) -> String {
@@ -69,14 +75,14 @@ pub(crate) mod user {
           Ok(_) => {}
           Err(e) => {
             dbg!("{:?}", e);
-            return format!("Failure to minecraft username {:?}", username);
+            return format!("Failure to minecraft username {username:?}");
           }
         }
         username_mc = username.to_string();
       } else {
         match get_minecraft_bedrock(username, &config.minecraft_mcprofile).await {
           None => {
-            return format!("No UID found for {:?}", username);
+            return format!("No UID found for {username:?}");
           }
           Some(x) => {
             match add_minecraft_bedrock(&db, &command.user.id, &x.floodgateuid).await {
@@ -185,14 +191,17 @@ pub(crate) mod server {
   use super::*;
 
   pub(crate) mod add {
-    use serenity::all::{CommandDataOption, CommandDataOptionValue, CommandInteraction, CommandOptionType, CreateCommand, CreateCommandOption};
+    use serenity::{
-    use serenity::model::id::GuildId;
+      all::{CommandDataOption, CommandDataOptionValue, CommandInteraction, CommandOptionType, CreateCommand, CreateCommandOption},
+      model::id::GuildId,
+    };
     use sqlx::Error;
     // this is to managfe the server side of commands related to minecraft
     use super::*;
-    use skynet_discord_bot::common::minecraft::update_server;
+    use skynet_discord_bot::{
-    use skynet_discord_bot::common::minecraft::Minecraft;
+      common::minecraft::{update_server, Minecraft},
-    use skynet_discord_bot::Config;
+      Config,
+    };
 
     pub fn register() -> CreateCommand {
       CreateCommand::new("minecraft_add")
@@ -229,7 +238,7 @@ pub(crate) mod server {
       match add_server(&db, &g_id, &server_minecraft).await {
         Ok(_) => {}
         Err(e) => {
-          println!("{:?}", e);
+          println!("{e:?}");
           return format!("Failure to insert into Minecraft {} {}", &g_id, &server_minecraft);
         }
       }
@@ -260,12 +269,14 @@ pub(crate) mod server {
   }
 
   pub(crate) mod list {
-    use serenity::all::CommandInteraction;
+    use serenity::{all::CommandInteraction, builder::CreateCommand, client::Context};
-    use serenity::builder::CreateCommand;
+    use skynet_discord_bot::{
-    use serenity::client::Context;
+      common::{
-    use skynet_discord_bot::common::database::DataBase;
+        database::DataBase,
-    use skynet_discord_bot::common::minecraft::{get_minecraft_config_server, server_information};
+        minecraft::{get_minecraft_config_server, server_information},
-    use skynet_discord_bot::Config;
+      },
+      Config,
+    };
 
     pub fn register() -> CreateCommand {
       CreateCommand::new("minecraft_list")
@@ -320,12 +331,13 @@ pub(crate) mod server {
   }
 
   pub(crate) mod delete {
-    use serenity::all::{CommandDataOption, CommandDataOptionValue, CommandInteraction, CommandOptionType, CreateCommandOption};
+    use serenity::{
-    use serenity::builder::CreateCommand;
+      all::{CommandDataOption, CommandDataOptionValue, CommandInteraction, CommandOptionType, CreateCommandOption},
-    use serenity::client::Context;
+      builder::CreateCommand,
-    use serenity::model::id::GuildId;
+      client::Context,
-    use skynet_discord_bot::common::database::DataBase;
+      model::id::GuildId,
-    use skynet_discord_bot::common::minecraft::Minecraft;
+    };
+    use skynet_discord_bot::common::{database::DataBase, minecraft::Minecraft};
     use sqlx::{Error, Pool, Sqlite};
 
     pub fn register() -> CreateCommand {
@@ -363,7 +375,7 @@ pub(crate) mod server {
       match server_remove(&db, &g_id, &server_minecraft).await {
         Ok(_) => {}
         Err(e) => {
-          println!("{:?}", e);
+          println!("{e:?}");
           return format!("Failure to insert into Minecraft {} {}", &g_id, &server_minecraft);
         }
       }

src/commands/role_adder.rs

@@ -79,8 +79,8 @@ pub mod edit {
     match add_server(&db, &server_data, delete).await {
       Ok(_) => {}
       Err(e) => {
-        println!("{:?}", e);
+        println!("{e:?}");
-        return format!("Failure to insert into Servers {:?}", server_data);
+        return format!("Failure to insert into Servers {server_data:?}");
       }
     }
 
@@ -101,9 +101,9 @@ pub mod edit {
     }
 
     if delete {
-      format!("Removed {} + {} = {}", role_a_name, role_b_name, role_c_name)
+      format!("Removed {role_a_name} + {role_b_name} = {role_c_name}")
     } else {
-      format!("Added {} + {} = {}", role_a_name, role_b_name, role_c_name)
+      format!("Added {role_a_name} + {role_b_name} = {role_c_name}")
     }
   }
 
@@ -142,8 +142,7 @@ pub mod edit {
 pub mod list {}
 
 pub mod tools {
-  use serenity::client::Context;
+  use serenity::{client::Context, model::guild::Member};
-  use serenity::model::guild::Member;
   use skynet_discord_bot::common::database::RoleAdder;
   use sqlx::{Pool, Sqlite};
 
@@ -180,13 +179,13 @@ pub mod tools {
 
       if !roles_add.is_empty() {
         if let Err(e) = new_data.add_roles(&ctx, &roles_add).await {
-          println!("{:?}", e);
+          println!("{e:?}");
         }
       }
 
       if !roles_remove.is_empty() {
         if let Err(e) = new_data.remove_roles(&ctx, &roles_remove).await {
-          println!("{:?}", e);
+          println!("{e:?}");
         }
       }
     }

src/commands/server_icon.rs

@@ -93,7 +93,7 @@ pub(crate) mod user {
         }
       }
 
-      async fn get_current_icon(db: &Pool<Sqlite>) -> Option<ServerIcons> {
+      pub async fn get_current_icon(db: &Pool<Sqlite>) -> Option<ServerIcons> {
         match sqlx::query_as::<_, ServerIcons>(
           "
               SELECT * from server_icons ORDER BY id DESC LIMIT 1
@@ -113,8 +113,10 @@ pub(crate) mod user {
 
     pub(crate) mod festival {
       use serenity::all::{CommandInteraction, Context};
-      use skynet_discord_bot::common::server_icon::{get_config_icons, update_icon::get_festival};
+      use skynet_discord_bot::{
-      use skynet_discord_bot::Config;
+        common::server_icon::{get_config_icons, update_icon::get_festival},
+        Config,
+      };
 
       // use this to return what current festivals are active?
       pub async fn run(_command: &CommandInteraction, ctx: &Context) -> String {
@@ -205,7 +207,7 @@ pub(crate) mod user {
 
         // the `` is so that the numbers will be rendered in monospaced font
         // the <> is to suppress the URL embed
-        let line = format!("``{}{}`` [{}](<{}>)", current_leading, times, name, url);
+        let line = format!("``{current_leading}{times}`` [{name}](<{url}>)");
 
         let length = line.len() + 1;
 

src/commands/wolves.rs

@@ -4,11 +4,16 @@ use lettre::{
   Message, SmtpTransport, Transport,
 };
 use maud::html;
-use serenity::all::CommandOptionType;
+use serenity::{
-use serenity::builder::CreateCommandOption;
+  all::CommandOptionType,
-use serenity::{builder::CreateCommand, client::Context, model::id::UserId};
+  builder::{CreateCommand, CreateCommandOption},
-use skynet_discord_bot::common::database::{DataBase, Wolves, WolvesVerify};
+  client::Context,
-use skynet_discord_bot::{get_now_iso, random_string, Config};
+  model::id::UserId,
+};
+use skynet_discord_bot::{
+  common::database::{DataBase, Wolves, WolvesVerify},
+  get_now_iso, random_string, Config,
+};
 use sqlx::{Pool, Sqlite};
 
 pub mod link {
@@ -110,7 +115,7 @@ pub mod link {
       }
     }
 
-    format!("Verification email sent to {}, it may take up to 15 min for it to arrive. If it takes longer check the Junk folder.", email)
+    format!("Verification email sent to {email}, it may take up to 15 min for it to arrive. If it takes longer check the Junk folder.")
   }
 
   pub async fn get_server_member_discord(db: &Pool<Sqlite>, user: &UserId) -> Option<Wolves> {
@@ -298,11 +303,14 @@ pub mod link_docs {
 pub mod verify {
   use super::*;
   use crate::commands::wolves::link::{db_pending_clear_expired, get_server_member_discord, get_verify_from_db};
-  use serenity::all::{CommandDataOption, CommandDataOptionValue, CommandInteraction};
+  use serenity::{
-  use serenity::model::user::User;
+    all::{CommandDataOption, CommandDataOptionValue, CommandInteraction},
-  use skynet_discord_bot::common::database::get_server_config;
+    model::user::User,
-  use skynet_discord_bot::common::database::{ServerMembersWolves, Servers};
+  };
-  use skynet_discord_bot::common::wolves::committees::Committees;
+  use skynet_discord_bot::common::{
+    database::{get_server_config, ServerMembersWolves, Servers},
+    wolves::committees::Committees,
+  };
   use sqlx::Error;
 
   pub async fn run(command: &CommandInteraction, ctx: &Context) -> String {
@@ -357,12 +365,12 @@ pub mod verify {
             "Discord username linked to Wolves".to_string()
           }
           Err(e) => {
-            println!("{:?}", e);
+            println!("{e:?}");
             "Failed to save, please try /link_wolves again".to_string()
           }
         };
       }
-      Err(e) => println!("{:?}", e),
+      Err(e) => println!("{e:?}"),
     }
 
     "Failed to verify".to_string()
@@ -419,7 +427,7 @@ pub mod verify {
             }
 
             if let Err(e) = member.add_roles(&ctx, &roles).await {
-              println!("{:?}", e);
+              println!("{e:?}");
             }
           }
         }
@@ -435,7 +443,7 @@ pub mod verify {
         WHERE committee LIKE ?1
         "#,
     )
-    .bind(format!("%{}%", wolves_id))
+    .bind(format!("%{wolves_id}%"))
     .fetch_all(db)
     .await
     .unwrap_or_else(|e| {

src/common/database.rs

@@ -1,12 +1,17 @@
 use crate::Config;
 use serde::{Deserialize, Serialize};
-use serenity::model::guild;
+use serenity::{
-use serenity::model::id::{ChannelId, GuildId, RoleId, UserId};
+  model::{
-use serenity::prelude::TypeMapKey;
+    guild,
-use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions, SqliteRow};
+    id::{ChannelId, GuildId, RoleId, UserId},
-use sqlx::{Error, FromRow, Pool, Row, Sqlite};
+  },
-use std::str::FromStr;
+  prelude::TypeMapKey,
-use std::sync::Arc;
+};
+use sqlx::{
+  sqlite::{SqliteConnectOptions, SqlitePoolOptions, SqliteRow},
+  Error, FromRow, Pool, Row, Sqlite,
+};
+use std::{str::FromStr, sync::Arc};
 use tokio::sync::RwLock;
 
 pub struct DataBase;
@@ -220,7 +225,7 @@ pub async fn db_init(config: &Config) -> Result<Pool<Sqlite>, Error> {
   let pool = SqlitePoolOptions::new()
     .max_connections(5)
     .connect_with(
-      SqliteConnectOptions::from_str(&format!("sqlite://{}", database))?
+      SqliteConnectOptions::from_str(&format!("sqlite://{database}"))?
         .foreign_keys(true)
         .create_if_missing(true),
     )

src/common/minecraft.rs

@@ -1,10 +1,7 @@
-use crate::common::set_roles::normal::get_server_member_bulk;
+use crate::{common::set_roles::normal::get_server_member_bulk, Config};
-use crate::Config;
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
-use serde::de::DeserializeOwned;
-use serde::{Deserialize, Serialize};
 use serenity::model::id::GuildId;
-use sqlx::sqlite::SqliteRow;
+use sqlx::{sqlite::SqliteRow, Error, FromRow, Pool, Row, Sqlite};
-use sqlx::{Error, FromRow, Pool, Row, Sqlite};
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Minecraft {
@@ -155,7 +152,7 @@ pub async fn get_minecraft_config_server(db: &Pool<Sqlite>, g_id: GuildId) -> Ve
 }
 
 pub async fn whitelist_update(add: &Vec<(String, bool)>, server: &str, token: &str) {
-  println!("Update whitelist for {}", server);
+  println!("Update whitelist for {server}");
   let url_base = format!("https://panel.games.skynet.ie/api/client/servers/{server}");
   let bearer = format!("Bearer {token}");
 

src/common/renderer.rs

@@ -1,8 +1,10 @@
 // this code is taken from https://github.com/MCorange99/svg2colored-png/tree/main
 // I was unable to figure out how to use usvg myself so younked it from here.
 
-use std::ffi::OsStr;
+use std::{
-use std::path::{Path, PathBuf};
+  ffi::OsStr,
+  path::{Path, PathBuf},
+};
 
 // use clap::builder::OsStr;
 use color_eyre::{eyre::bail, Result};
@@ -177,7 +179,7 @@ impl Renderer {
   }
 
   fn set_color(&self, svg: &str, color: &String) -> String {
-    svg.replace("fill=\"currentColor\"", &format!("fill=\"#{}\"", color))
+    svg.replace("fill=\"currentColor\"", &format!("fill=\"#{color}\""))
   }
 
   fn get_svg_data(&self, fi: &Path) -> Result<String> {

src/common/set_roles.rs

@@ -1,10 +1,21 @@
 pub mod normal {
-  use crate::common::database::{DataBase, ServerMembersWolves, Servers, Wolves};
+  use crate::{
-  use crate::get_now_iso;
+    common::database::{DataBase, ServerMembersWolves, Servers, Wolves},
-  use serenity::client::Context;
+    get_now_iso,
-  use serenity::model::id::{GuildId, RoleId, UserId};
+  };
+  use serenity::{
+    client::Context,
+    model::id::{GuildId, RoleId, UserId},
+  };
   use sqlx::{Pool, Sqlite};
 
+  struct RolesChange {
+    total: i32,
+    new: i32,
+    current_add: i32,
+    current_rem: i32,
+  }
+
   pub async fn update_server(ctx: &Context, server: &Servers, remove_roles: &[Option<RoleId>], members_changed: &[UserId]) {
     let db_lock = {
       let data_read = ctx.data.read().await;
@@ -20,7 +31,12 @@ pub mod normal {
       ..
     } = server;
 
-    let mut roles_set = [0, 0, 0];
+    let mut roles_set = RolesChange {
+      total: 0,
+      new: 0,
+      current_add: 0,
+      current_rem: 0,
+    };
     let mut members = vec![];
 
     for member in get_server_member_bulk(&db, server).await {
@@ -38,22 +54,24 @@ pub mod normal {
         }
 
         if members.contains(&member.user.id) {
+          roles_set.total += 1;
+
           let mut roles = vec![];
 
           if let Some(role) = &role_past {
             if !member.roles.contains(role) {
-              roles_set[0] += 1;
+              roles_set.new += 1;
               roles.push(role.to_owned());
             }
           }
 
           if !member.roles.contains(role_current) {
-            roles_set[1] += 1;
+            roles_set.current_add += 1;
             roles.push(role_current.to_owned());
           }
 
           if let Err(e) = member.add_roles(ctx, &roles).await {
-            println!("{:?}", e);
+            println!("{e:?}");
           }
         } else {
           // old and never
@@ -65,16 +83,16 @@ pub mod normal {
           }
 
           if member.roles.contains(role_current) {
-            roles_set[2] += 1;
+            roles_set.current_rem += 1;
             // if theya re not a current member and have the role then remove it
             if let Err(e) = member.remove_role(ctx, role_current).await {
-              println!("{:?}", e);
+              println!("{e:?}");
             }
           }
         }
         for role in remove_roles.iter().flatten() {
           if let Err(e) = member.remove_role(ctx, role).await {
-            println!("{:?}", e);
+            println!("{e:?}");
           }
         }
       }
@@ -83,7 +101,14 @@ pub mod normal {
     set_server_numbers(&db, server, members_all as i64, members.len() as i64).await;
 
     // small bit of logging to note changes over time
-    println!("{:?} Changes: New: +{}, Current: +{}/-{}", server.get(), roles_set[0], roles_set[1], roles_set[2]);
+    println!(
+      "{:?} Total: {} Changes: New: +{}, Current: +{}/-{}",
+      server.get(),
+      roles_set.total,
+      roles_set.new,
+      roles_set.current_add,
+      roles_set.current_rem
+    );
   }
 
   pub async fn get_server_member_bulk(db: &Pool<Sqlite>, server: &GuildId) -> Vec<ServerMembersWolves> {
@@ -123,7 +148,7 @@ pub mod normal {
       Ok(_) => {}
       Err(e) => {
         println!("Failure to insert into {}", server.get());
-        println!("{:?}", e);
+        println!("{e:?}");
       }
     }
   }
@@ -131,23 +156,24 @@ pub mod normal {
 
 // for updating committee members
 pub mod committee {
-  use crate::common::database::{get_channel_from_row, get_role_from_row, DataBase, Wolves};
+  use crate::{
-  use crate::common::wolves::committees::Committees;
+    common::{
-  use crate::Config;
+      database::{get_channel_from_row, get_role_from_row, DataBase, Wolves},
+      wolves::committees::Committees,
+    },
+    Config,
+  };
   use serde::{Deserialize, Serialize};
-  use serenity::all::EditRole;
+  use serenity::{
-  use serenity::builder::CreateChannel;
+    all::EditRole,
-  use serenity::client::Context;
+    builder::CreateChannel,
-  use serenity::model::channel::ChannelType;
+    client::Context,
-  use serenity::model::guild::Member;
+    model::{channel::ChannelType, guild::Member, id::ChannelId, prelude::RoleId},
-  use serenity::model::id::ChannelId;
+  };
-  use serenity::model::prelude::RoleId;
+  use sqlx::{sqlite::SqliteRow, Error, FromRow, Pool, Row, Sqlite};
-  use sqlx::sqlite::SqliteRow;
-  use sqlx::{Error, FromRow, Pool, Row, Sqlite};
   use std::collections::HashMap;
-  use std::sync::Arc;
 
-  pub async fn check_committee(ctx: Arc<Context>) {
+  pub async fn check_committee(ctx: &Context) {
     let db_lock = {
       let data_read = ctx.data.read().await;
       data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
@@ -166,7 +192,7 @@ pub mod committee {
     // because to use it to update a single user we need to pre-get the members of teh server
     let mut members = server.members(&ctx, None, None).await.unwrap_or_default();
 
-    update_committees(&db, &ctx, &config_global, &mut members).await;
+    update_committees(&db, ctx, &config_global, &mut members).await;
   }
 
   /**
@@ -308,15 +334,11 @@ pub mod committee {
         None => {
           vec![]
         }
-        Some(x) => {
+        Some(x) => x.to_owned(),
-          let mut tmp = x.to_owned();
-          if !tmp.is_empty() {
-            tmp.push(committee_member);
-          }
-          tmp
-        }
       };
 
+      let on_committee = !roles_required.is_empty();
+
       let mut roles_rem = vec![];
       let mut roles_add = vec![];
       // get a list of all the roles to remove from someone
@@ -325,14 +347,25 @@ pub mod committee {
       for role in &roles_current {
         roles_current_id.push(role.id.to_owned());
         if !roles_required.contains(&role.id) {
+          if role.id == committee_member && on_committee {
+            continue;
+          }
+
           roles_rem.push(role.id.to_owned());
         }
       }
 
-      if !roles_required.is_empty() {
+      let has_committee_role = roles_current_id.contains(&committee_member);
+
+      if on_committee && !has_committee_role {
         // if there are committee roles then give the general purporse role
         roles_add.push(committee_member);
+      }
+      if !on_committee && has_committee_role {
+        roles_rem.push(committee_member);
+      }
 
+      if !roles_required.is_empty() {
         if let Some(x) = roles_db.get_mut(&0) {
           x.count += 1;
         }
@@ -351,8 +384,6 @@ pub mod committee {
       if !roles_add.is_empty() {
         // these roles are flavor roles, only there to make folks mentionable
         member.add_roles(&ctx, &roles_add).await.unwrap_or_default();
-      } else {
-        member.remove_roles(&ctx, &[committee_member]).await.unwrap_or_default();
       }
     }
 
@@ -440,8 +471,8 @@ pub mod committee {
     {
       Ok(_) => {}
       Err(e) => {
-        println!("Failure to insert into Wolves {:?}", role);
+        println!("Failure to insert into Wolves {role:?}");
-        println!("{:?}", e);
+        println!("{e:?}");
       }
     }
   }
@@ -458,7 +489,7 @@ pub mod committee {
     .await
     .unwrap_or_else(|e| {
       println!("Failure to get Roles from committee_roles");
-      println!("{:?}", e);
+      println!("{e:?}");
       vec![]
     })
   }

src/common/wolves.rs

@@ -38,8 +38,8 @@ async fn add_users_wolves(db: &Pool<Sqlite>, user: &WolvesResultUserMin) {
   {
     Ok(_) => {}
     Err(e) => {
-      println!("Failure to insert into Wolves {:?}", user);
+      println!("Failure to insert into Wolves {user:?}");
-      println!("{:?}", e);
+      println!("{e:?}");
     }
   }
 }
@@ -48,12 +48,14 @@ async fn add_users_wolves(db: &Pool<Sqlite>, user: &WolvesResultUserMin) {
   This is getting data for Clubs and Socs
 */
 pub mod cns {
-  use crate::common::database::{get_server_config_bulk, DataBase, ServerMembers, ServerMembersWolves, Servers};
+  use crate::{
-  use crate::common::set_roles::normal::update_server;
+    common::{
-  use crate::common::wolves::{add_users_wolves, WolvesResultUserMin};
+      database::{get_server_config_bulk, DataBase, ServerMembers, ServerMembersWolves, Servers},
-  use crate::Config;
+      wolves::{add_users_wolves, WolvesResultUserMin},
-  use serenity::client::Context;
+    },
-  use serenity::model::id::GuildId;
+    Config,
+  };
+  use serenity::{client::Context, model::id::GuildId};
   use sqlx::{Pool, Sqlite};
   use std::collections::BTreeMap;
 
@@ -96,7 +98,6 @@ pub mod cns {
       let existing = existing_tmp.iter().map(|data| (data.id_wolves, data)).collect::<BTreeMap<_, _>>();
 
       // list of users that need to be updated for this server
-      let mut user_to_update = vec![];
       let mut server_name_tmp = None;
       for user in wolves.get_members(wolves_api).await {
         // dbg!(&user.committee);
@@ -115,10 +116,6 @@ pub mod cns {
             add_users_wolves(&db, &WolvesResultUserMin::from(&user)).await;
             if old.expiry != user.expiry {
               add_users_server_members(&db, server, &user).await;
-
-              if let Some(discord_id) = old.discord {
-                user_to_update.push(discord_id);
-              }
             }
           }
         }
@@ -129,9 +126,6 @@ pub mod cns {
           set_server_member(&db, server, cs_id).await;
         }
       }
-      if !user_to_update.is_empty() {
-        update_server(ctx, &server_config, &[], &user_to_update).await;
-      }
     }
   }
 
@@ -151,7 +145,7 @@ pub mod cns {
       Ok(_) => {}
       Err(e) => {
         println!("Failure to set server name {}", server.get());
-        println!("{:?}", e);
+        println!("{e:?}");
       }
     }
   }
@@ -190,7 +184,7 @@ pub mod cns {
       Ok(_) => {}
       Err(e) => {
         println!("Failure to insert into ServerMembers {}  {:?}", server.get(), user);
-        println!("{:?}", e);
+        println!("{e:?}");
       }
     }
   }
@@ -200,8 +194,7 @@ pub mod cns {
   Get and store the data on C&S committees
 */
 pub mod committees {
-  use crate::common::database::DataBase;
+  use crate::{common::database::DataBase, Config};
-  use crate::Config;
   use serenity::client::Context;
   use sqlx::{Pool, Sqlite};
 
@@ -270,8 +263,8 @@ pub mod committees {
     {
       Ok(_) => {}
       Err(e) => {
-        println!("Failure to insert into Committees {:?}", committee);
+        println!("Failure to insert into Committees {committee:?}");
-        println!("{:?}", e);
+        println!("{e:?}");
       }
     }
   }

src/lib.rs

@@ -3,8 +3,10 @@ pub mod common;
 use chrono::{Datelike, SecondsFormat, Utc};
 use dotenvy::dotenv;
 use rand::{distr::Alphanumeric, rng, Rng};
-use serenity::model::id::{ChannelId, GuildId, RoleId};
+use serenity::{
-use serenity::prelude::TypeMapKey;
+  model::id::{ChannelId, GuildId, RoleId},
+  prelude::TypeMapKey,
+};
 use std::{env, sync::Arc};
 use tokio::sync::RwLock;
 

src/main.rs

@@ -1,24 +1,28 @@
 pub mod commands;
 
 use crate::commands::role_adder::tools::on_role_change;
-use serenity::all::{
-  ActivityData, Command, CommandDataOptionValue, CreateMessage, EditInteractionResponse, GuildId, GuildMemberUpdateEvent, Interaction,
-};
 use serenity::{
+  all::{Command, CommandDataOptionValue, CreateMessage, EditInteractionResponse, Interaction},
   async_trait,
   client::{Context, EventHandler},
-  gateway::ChunkGuildFilter,
+  gateway::{ActivityData, ChunkGuildFilter},
   model::{
+    event::GuildMemberUpdateEvent,
     gateway::{GatewayIntents, Ready},
     guild::Member,
+    id::GuildId,
     user::OnlineStatus,
   },
   Client,
 };
-use skynet_discord_bot::common::database::{db_init, get_server_config, get_server_member, DataBase};
+use skynet_discord_bot::{
-use skynet_discord_bot::common::set_roles::committee::update_committees;
+  common::{
-use skynet_discord_bot::common::wolves::committees::Committees;
+    database::{db_init, get_server_config, get_server_member, DataBase},
-use skynet_discord_bot::{get_config, Config};
+    set_roles::committee::update_committees,
+    wolves::committees::Committees,
+  },
+  get_config, Config,
+};
 use sqlx::{Pool, Sqlite};
 use std::sync::Arc;
 use tokio::sync::RwLock;
@@ -77,7 +81,7 @@ impl EventHandler for Handler {
       }
 
       if let Err(e) = new_member.add_roles(&ctx, &roles).await {
-        println!("{:?}", e);
+        println!("{e:?}");
       }
     } else {
       let tmp = get_committee(&db, config_server.wolves_id).await;
@@ -142,7 +146,7 @@ Sign up on [UL Wolves]({}) and go to https://discord.com/channels/{}/{} and use
     {
       Ok(_) => {}
       Err(e) => {
-        println!("{:?}", e)
+        println!("{e:?}")
       }
     }
 
@@ -150,7 +154,7 @@ Sign up on [UL Wolves]({}) and go to https://discord.com/channels/{}/{} and use
     match config.committee_server.set_commands(&ctx.http, vec![commands::count::committee::register()]).await {
       Ok(_) => {}
       Err(e) => {
-        println!("{:?}", e)
+        println!("{e:?}")
       }
     }
 
@@ -169,7 +173,7 @@ Sign up on [UL Wolves]({}) and go to https://discord.com/channels/{}/{} and use
     {
       Ok(_) => {}
       Err(e) => {
-        println!("{:?}", e)
+        println!("{e:?}")
       }
     }
   }
@@ -256,7 +260,7 @@ Sign up on [UL Wolves]({}) and go to https://discord.com/channels/{}/{} and use
       };
 
       if let Err(why) = command.edit_response(&ctx.http, EditInteractionResponse::new().content(content)).await {
-        println!("Cannot respond to slash command: {}", why);
+        println!("Cannot respond to slash command: {why}");
       }
     }
   }
@@ -291,7 +295,7 @@ async fn main() {
   let intents = GatewayIntents::GUILDS | GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT | GatewayIntents::GUILD_MEMBERS;
   // Build our client.
   let mut client = Client::builder(&config.discord_token, intents)
-    .event_handler(Handler {})
+    .event_handler(Handler)
     .cache_settings(serenity::cache::Settings::default())
     .await
     .expect("Error creating client");
@@ -308,6 +312,6 @@ async fn main() {
   // Shards will automatically attempt to reconnect, and will perform
   // exponential backoff until it reconnects.
   if let Err(why) = client.start().await {
-    println!("Client error: {:?}", why);
+    println!("Client error: {why:?}");
   }
 }