Merge pull request 'Add quick and dirty command to allow admins to make the bot say stuff' (#22) from feature/arbitrary-messaging into main

Reviewed-on: #22

.gitea/workflows/deploy.yaml

@@ -8,19 +8,17 @@ on:
 jobs:
   build:
     runs-on: rust
+    container:
+      options: --dns 172.16.255.254
     env:
       GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
     steps:
       - name: Checkout
         uses: actions/checkout@v3
-      - name: Pre-seed known_hosts (Badgey)
-        run: mkdir -pv ~/.ssh && ssh-keyscan -t rsa badgey >> ~/.ssh/known_hosts
-      - name: Pre-seed known_hosts (M5)
-        run: mkdir -pv ~/.ssh && ssh-keyscan -t rsa m5-computer >> ~/.ssh/known_hosts
       - name: Build (Release)
         run: cargo build --release --color=always
       - name: Archive artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: badgey
           path: target/release/badgey
@@ -35,19 +33,23 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v3
       - name: Download artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v3
         with:
           name: badgey
-      - name: Seed config file
+      - name: Pre-seed known_hosts
-        uses: cschleiden/replace-tokens@v1.2
+        run: mkdir -pv ~/.ssh && ssh-keyscan -t rsa $BOT_SERVER_HOSTNAME >> ~/.ssh/known_hosts
+        env:
+          BOT_SERVER_HOSTNAME: ${{ vars[format('{0}_SERVER_HOSTNAME', matrix.bot)] }}
+      - uses: cschleiden/replace-tokens@v1.2
         with:
           files: config/production.badgey.json
         env:
-          BOT_NICKNAME: ${{ vars[format('{0}_BOT_NICKNAME', matrix.bot) }}
+          BOT_NICKNAME: ${{ vars[format('{0}_BOT_NICKNAME', matrix.bot)] }}
-          LOG_CHANNEL_ID: ${{ vars[format('{0}_LOG_CHANNEL_ID', matrix.bot) }}
+          BOT_IDENTIFIER: ${{ vars[format('{0}_SERVER_HOSTNAME', matrix.bot)] }}
+          LOG_CHANNEL_ID: ${{ vars[format('{0}_LOG_CHANNEL_ID', matrix.bot)] }}
           POSTGRES_HOST: ${{ vars.POSTGRES_HOST }}
           POSTGRES_USER: ${{ vars.POSTGRES_USER }}
-          POSTGRES_DATABASE_NAME: ${{ vars[format('{0}_POSTGRES_DATABASE_NAME', matrix.bot) }}
+          POSTGRES_DATABASE_NAME: ${{ vars[format('{0}_POSTGRES_DATABASE_NAME', matrix.bot)] }}
           POSTGRES_PASSWORD: ${{ secrets.POSTGRES_PASSWORD }}
           WEATHER_API_KEY: ${{ secrets.WEATHER_API_KEY }}
           DOGPICS_API_KEY: ${{ secrets.DOGPICS_API_KEY }}
@@ -55,4 +57,4 @@ jobs:
       - name: Seed SSH key for deploy
         run: echo "${{ secrets.DEPLOY_KEY }}" | tr -d '\r' > ~/.ssh/id_rsa && chmod 0600 ~/.ssh/id_rsa
       - name: Deploy
-        run: bash cicd/deploy.sh ${{ matrix.bot }}
+        run: bash cicd/deploy.sh ${{ vars[format('{0}_SERVER_HOSTNAME', matrix.bot)] }}

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "badgey"
-version = "4.1.0"
+version = "4.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -21,7 +21,12 @@ poise = { version = "0.5.*", features = [ "cache" ] }
 rand = { version = "0.8.5", features = [ "small_rng" ] }
 regex = "1.9.5"
 rust-i18n = "3.1.2"
+to_markdown_table = "0.1.5"
 tokio = { version = "1.16.1", features = ["sync", "macros", "rt-multi-thread"] }
+url = "2.5.2"
+serde = { version = "1.0.210", features = ["derive"] }
+reqwest = "0.12.9"
+serde_json = "1.0.132"
 
 [package.metadata.i18n]
 # The available locales for your application, default: ["en"].

cicd/deploy.sh

@@ -2,8 +2,11 @@
 
 bot=$(echo "$1" | tr '[:upper:]' '[:lower:]')
 
+echo "Running deploy for bot ${bot}"
+
 ssh badgey@$bot sudo /usr/bin/systemctl stop $bot
-rsync -avP badgey badgey@$bot:/srv/$bot/
+rsync -avP badgey badgey@$bot:/srv/$bot/$bot
 rsync -avP config badgey@$bot:/srv/$bot/
 rsync -avP txt badgey@$bot:/srv/$bot/
+ssh badgey@$bot chmod a+x /srv/$bot/$bot
 ssh badgey@$bot sudo /usr/bin/systemctl start $bot

config/production.badgey.json

@@ -44,6 +44,10 @@
             "source_uri": "https://api.nasa.gov/planetary/apod?api_key=NZfKclpoaO9HnvfvaCjeJ3csDecvIqNiABVw2YvN",
             "cache_name": "nasa_apod",
             "cache_mode": "NoCache"
+        },
+        "f1": {
+            "source_uri": "https://api.jolpi.ca/ergast/f1",
+            "cache_mode": "NoCache"
         }
     }
 }

migrations/2024-10-13-104402_quarantine-channels/down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS "quarantine_channels";

migrations/2024-10-13-104402_quarantine-channels/up.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS "quarantine_channels" (
+    id SERIAL PRIMARY KEY,
+    qc_role_id BIGINT NOT NULL,
+    qc_channel_id BIGINT NOT NULL
+);

migrations/2025-02-17-204047_channels-table/down.sql

@@ -0,0 +1,18 @@
+ALTER TABLE IF EXISTS "channels"
+    RENAME TO "quarantine_channels";
+
+-- Make the quarantine channels table hold more generic channel info
+ALTER TABLE IF EXISTS "quarantine_channels"
+    RENAME COLUMN "channel_id" TO "qc_channel_id";
+
+-- Channels with this flag should retain old qc behaviour
+ALTER TABLE IF EXISTS "quarantine_channels"
+    DROP COLUMN "is_quarantine_channel";
+
+-- Setting flag to false allows channels to be excluded from XP even if not QC (though QC channels via the above flag imply this flag too)
+ALTER TABLE IF EXISTS "quarantine_channels"
+    DROP COLUMN "is_valid_for_xp";
+
+-- Ensure that the role ID can be null for non-qc channels
+ALTER TABLE IF EXISTS "quarantine_channels"
+    ALTER COLUMN "qc_role_id" SET NOT NULL;

migrations/2025-02-17-204047_channels-table/up.sql

@@ -0,0 +1,19 @@
+-- Make the quarantine channels table hold more generic channel info
+ALTER TABLE IF EXISTS "quarantine_channels"
+    RENAME COLUMN "qc_channel_id" TO "channel_id";
+
+-- Channels with this flag should retain old qc behaviour
+ALTER TABLE IF EXISTS "quarantine_channels"
+    ADD COLUMN "is_quarantine_channel" BOOL NOT NULL DEFAULT FALSE;
+
+-- Setting flag to false allows channels to be excluded from XP even if not QC (though QC channels via the above flag imply this flag too)
+ALTER TABLE IF EXISTS "quarantine_channels"
+    ADD COLUMN "is_valid_for_xp" BOOL NOT NULL DEFAULT TRUE;
+
+-- Ensure that the role ID can be null for non-qc channels
+ALTER TABLE IF EXISTS "quarantine_channels"
+    ALTER COLUMN "qc_role_id" DROP NOT NULL;
+
+-- Rename table to something more suitable
+ALTER TABLE IF EXISTS "quarantine_channels"
+    RENAME TO "channels";

shell.nix

@@ -4,5 +4,6 @@ pkgs.mkShell {
         openssl
         postgresql
         pkg-config
+        diesel-cli
     ];
-}
+}

src/badgey/commands/custom_responses.rs

@@ -1,73 +1,91 @@
-use poise::serenity_prelude as serenity;
+use poise::serenity_prelude as serenity;
-
+
-use manifold::error::{ManifoldError, ManifoldResult};
+use manifold::error::{ManifoldError, ManifoldResult};
-use manifold::{ManifoldContext, ManifoldData};
+use manifold::{ManifoldContext, ManifoldData};
-use poise::serenity_prelude::Mentionable;
+use poise::serenity_prelude::{CreateEmbed, Mentionable};
-use crate::badgey::models::custom_response::{CustomResponse, CustomResponseInserter};
+use url::Url;
-
+use crate::badgey::models::custom_response::{CustomResponse, CustomResponseInserter};
-
+
-#[poise::command(slash_command, prefix_command, required_permissions = "MODERATE_MEMBERS" )]
+
-async fn add_custom_response(ctx: ManifoldContext<'_>, target: serenity::User, trigger: String, response: String) -> ManifoldResult<()> {
+#[poise::command(slash_command, prefix_command, required_permissions = "MODERATE_MEMBERS" )]
-    let db = &ctx.data().database;
+async fn add_custom_response(ctx: ManifoldContext<'_>, target: serenity::User, trigger: String, response: String) -> ManifoldResult<()> {
-
+    let db = &ctx.data().database;
-    match CustomResponseInserter::new(trigger, response, target, ctx.author().clone()).insert(db) {
+
-        Ok(_) => ctx.reply(t!("commands.custom_response.added")).await?,
+    match CustomResponseInserter::new(trigger, response, target, ctx.author().clone()).insert(db) {
-        Err(e) => ctx.reply(t!("commands.custom_response.added.error", error = e)).await?,
+        Ok(_) => ctx.reply(t!("commands.custom_response.added")).await?,
-    };
+        Err(e) => ctx.reply(t!("commands.custom_response.added.error", error = e)).await?,
-
+    };
-    Ok(())
+
-}
+    Ok(())
-
+}
-#[poise::command(slash_command, prefix_command, required_permissions = "MODERATE_MEMBERS")]
+
-async fn remove_custom_response(ctx: ManifoldContext<'_>, id: i32) -> ManifoldResult<()> {
+#[poise::command(slash_command, prefix_command, required_permissions = "MODERATE_MEMBERS")]
-    let db = &ctx.data().database;
+async fn remove_custom_response(ctx: ManifoldContext<'_>, id: i32) -> ManifoldResult<()> {
-
+    let db = &ctx.data().database;
-    let mut response = CustomResponse::find_by_id(db, &id)?;
+
-
+    let mut response = CustomResponse::find_by_id(db, &id)?;
-    response.deleted = Some(true);
+
-    response.insert(db)?;
+    response.deleted = Some(true);
-
+    response.insert(db)?;
-    ctx.reply(t!("commands.custom_response.marked_deleted", response_id=id)).await?;
+
-
+    ctx.reply(t!("commands.custom_response.marked_deleted", response_id=id)).await?;
-    Ok(())
+
-}
+    Ok(())
-
+}
-#[poise::command(slash_command, prefix_command, required_permissions = "MODERATE_MEMBERS")]
+
-async fn undelete_custom_response(ctx: ManifoldContext<'_>, id: i32) -> ManifoldResult<()> {
+#[poise::command(slash_command, prefix_command, required_permissions = "MODERATE_MEMBERS")]
-    let db = &ctx.data().database;
+async fn undelete_custom_response(ctx: ManifoldContext<'_>, id: i32) -> ManifoldResult<()> {
-
+    let db = &ctx.data().database;
-    let mut response = CustomResponse::find_by_id(db, &id)?;
+
-
+    let mut response = CustomResponse::find_by_id(db, &id)?;
-    if let Some(_) = response.deleted {
+
-        response.deleted = None;
+    if let Some(_) = response.deleted {
-        response.insert(db)?;
+        response.deleted = None;
-        ctx.reply(t!("commands.custom_response.marked_undeleted", response_id=id)).await?;
+        response.insert(db)?;
-    } else {
+        ctx.reply(t!("commands.custom_response.marked_undeleted", response_id=id)).await?;
-        ctx.reply(t!("commands.custom_response.undelete_error_not_deleted", response_id=id)).await?;
+    } else {
-    }
+        ctx.reply(t!("commands.custom_response.undelete_error_not_deleted", response_id=id)).await?;
-
+    }
-    Ok(())
+
-}
+    Ok(())
-
+}
-#[poise::command(slash_command, prefix_command, required_permissions = "MODERATE_MEMBERS")]
+
-async fn list_custom_responses_for_user(ctx: ManifoldContext<'_>, target: serenity::User) -> ManifoldResult<()> {
+#[poise::command(slash_command, prefix_command, required_permissions = "MODERATE_MEMBERS")]
-    let db = &ctx.data().database;
+async fn list_custom_responses_for_user(ctx: ManifoldContext<'_>, target: serenity::User) -> ManifoldResult<()> {
-
+    let db = &ctx.data().database;
-    let mut answer: String = "".to_string();
+    let userinfo = &ctx.data().user_info.lock().await;
-
+
-    CustomResponse::find_by_user(db, &target)?.iter().for_each(|f| {
+    let reply_handle = ctx.reply("Retrieving custom responses, please stand by...".to_string()).await?;
-        answer.push_str(format!("{}{}", "\n", f.to_string()).as_str());
+    let mut pages = Vec::<CreateEmbed>::new();
-    });
+    let responses = CustomResponse::find_by_user(db, &target)?;
-
+    let total = responses.len();
-    if answer.len() == 0 {
+
-        answer.push_str("\nNone found");
+    responses.iter().enumerate().for_each(|(i, f)| {
-    }
+        pages.push(CreateEmbed::default()
-
+            .title(format!("Custom Response {item} of {total} for user {target}", item=(i + 1), total=&total, target=target.name))
-    ctx.reply(t!("commands.custom_response.list_user", user = &target.mention(), response_list = answer)).await?;
+            .description(format!("Added by {added_by} on <t:{added_on}:F> (<t:{added_on}:R>)", added_by=userinfo.get(&(f.added_by as u64)).unwrap().username, added_on=f.added_on))
-
+            .field("ID", format!("{id}", id=f.id), true)
-    Ok(())
+            .field("Deleted", format!("{deleted}", deleted=(if f.deleted.unwrap_or(false) {"yes"} else {"no"})), true)
-}
+            .field("Trigger", format!("{trigger}", trigger=f.trigger), true)
-
+            .field("Response", format!("{response}", response=f.response), false)
-pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 4] {
+            .image(format!("{response}", response=Url::parse(&*f.response).unwrap_or("https://example.com".parse().unwrap())))
-    [add_custom_response(), remove_custom_response(), undelete_custom_response(), list_custom_responses_for_user()]
+            .to_owned()
-}
+        )
+    });
+
+    if pages.len() == 0 {
+        ctx.reply(format!("No custom responses found for {target}", target=target.mention())).await?;
+        return Ok(())
+    }
+
+    drop(db);
+    drop(userinfo);
+
+    manifold::helpers::paginate(ctx, reply_handle, pages, 0).await?;
+
+    Ok(())
+}
+
+pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 4] {
+    [add_custom_response(), remove_custom_response(), undelete_custom_response(), list_custom_responses_for_user()]
+}

src/badgey/commands/f1.rs

@@ -0,0 +1,62 @@
+use manifold::error::{ManifoldError, ManifoldResult};
+use manifold::{ManifoldContext, ManifoldData};
+use poise::serenity_prelude::CreateEmbed;
+use to_markdown_table::MarkdownTable;
+use crate::badgey::models::f1::{F1Client, StandingsListType};
+
+#[poise::command(slash_command, prefix_command, subcommands("standings"))]
+async fn f1(_ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
+    Ok(())
+}
+
+#[derive(poise::ChoiceParameter)]
+pub enum Championships {
+    Drivers,
+    Constructors,
+}
+
+#[poise::command(slash_command, prefix_command)]
+async fn standings(ctx: ManifoldContext<'_>, championship: Championships) -> ManifoldResult<()> {
+
+    let config = &ctx.data().bot_config;
+    let f1_api_client = config.services.get("f1").ok_or_else(|| ManifoldError::from("No F1 API client available"))?;
+    let mut embed = CreateEmbed::default();
+
+    if let Some(standings) = f1_api_client.get_standings("current".to_string(), championship.to_string()).await? {
+        let _ = embed.title(format!("F1 {season} {championship} Championship Standings after {round} rounds:", season = standings.season, round = standings.round)).to_owned();
+        let mut leaderboard_headings = Vec::new();
+        let mut leaderboard_rows = Vec::new();
+
+        standings.standings_lists.iter().for_each(|f| {
+            match f {
+                StandingsListType::ConstructorStandings(c) => {
+                    leaderboard_headings = vec!["Pos".to_string(), "Team".to_string(), "Pts".to_string()];
+                    c.constructor_standings.iter().for_each(|r| {
+                        leaderboard_rows.push(vec![r.position_text.clone(), r.constructor.name.clone(), r.points.clone()])
+                    });
+                }
+                StandingsListType::DriversStandings(d) => {
+                    leaderboard_headings = vec!["Pos".to_string(), "Driver".to_string(), "Team".to_string(), "Pts".to_string()];
+                    d.driver_standings.iter().for_each(|r| {
+                        leaderboard_rows.push(vec![r.position_text.clone(), format!("{first} {last}", first = r.driver.given_name.clone(), last = r.driver.family_name.clone()), r.constructors.first().unwrap().name.clone(), r.points.clone()])
+                    });
+                }
+            }
+
+            let leaderboard_table = MarkdownTable::new(Some(leaderboard_headings.clone()), leaderboard_rows.clone()).unwrap();
+
+            embed.description(format!("```{table}```", table=leaderboard_table));
+        });
+    }
+
+    ctx.send(|m| {
+        m.embeds = vec![embed];
+        m
+    }).await?;
+
+    Ok(())
+}
+
+pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 1] {
+    [f1()]
+}

src/badgey/commands/mod.rs

@@ -5,12 +5,14 @@ use poise::Command;
 pub mod custom_responses;
 pub mod ranks;
 pub mod moderation;
+pub mod f1;
 
 pub fn collect_commands() -> Vec<Command<ManifoldData, ManifoldError>> {
     commands().into_iter()
         .chain(custom_responses::commands())
         .chain(ranks::commands())
         .chain(moderation::commands())
+        .chain(f1::commands())
         .collect()
 }
 

src/badgey/commands/moderation.rs

@@ -1,6 +1,8 @@
+use built::chrono;
 use manifold::error::{ManifoldError, ManifoldResult};
 use manifold::{ManifoldContext, ManifoldData};
 use poise::serenity_prelude as serenity;
+use crate::badgey::models::quarantine_channel::Channel;
 
 #[poise::command(slash_command, prefix_command, required_permissions = "MODERATE_MEMBERS")]
 async fn void_user(_ctx: ManifoldContext<'_>, _target: serenity::User) -> ManifoldResult<()> {
@@ -22,6 +24,66 @@ async fn record_chronicle(_ctx: ManifoldContext<'_>, _target: serenity::User) ->
     Ok(())
 }
 
-pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 4] {
+#[poise::command(slash_command, prefix_command, required_permissions = "MODERATE_MEMBERS", aliases("sr", "sl"))]
-    [void_user(), unvoid_user(), airlock_user(), record_chronicle()]
+async fn security_record(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
+
+    let author = ctx.author().id;
+    let timestamp = chrono::Utc::now().timestamp();
+    let response_body = format!("```**__Server Security Report__**\n\n**Date:** <t:{timestamp}:f>\n**Moderator(s):** <@{author}>\n**Offending User(s):**\n\n**Description:**\n\n**Actions Taken:**```", timestamp = timestamp, author = author);
+
+    ctx.reply(response_body).await?;
+
+    Ok(())
+}
+
+#[poise::command(slash_command, prefix_command, required_permissions = "MANAGE_GUILD")]
+async fn add_quarantine_channel(ctx: ManifoldContext<'_>, channel: serenity::ChannelId, role: serenity::RoleId) -> ManifoldResult<()> {
+    let qc = Channel::new(Some(role.as_u64().clone() as i64), channel.as_u64().clone() as i64, true, false);
+    qc.insert(&ctx.data().database)?;
+
+    ctx.reply(format!("OK: Quarantine channel <#{channel}> defined with quarantine role <@{role}>", channel = channel, role = role)).await?;
+
+    Ok(())
+}
+
+#[poise::command(slash_command, prefix_command, required_permissions = "MANAGE_GUILD")]
+async fn remove_quarantine_channel(ctx: ManifoldContext<'_>, channel: serenity::ChannelId) -> ManifoldResult<()> {
+    let db = &ctx.data().database;
+    Channel::get_by_channel_id(db, channel.as_u64().clone() as i64)?.remove(db)?;
+
+    ctx.reply(format!("OK: Quarantine channel <#{channel}> is no longer defined.", channel = channel)).await?;
+
+    Ok(())
+}
+
+#[poise::command(slash_command, prefix_command, required_permissions = "MANAGE_GUILD")]
+async fn ignore_channel_for_xp(ctx: ManifoldContext<'_>, channel: serenity::ChannelId) -> ManifoldResult<()> {
+    let qc = Channel::new(None, channel.as_u64().clone() as i64, false, false);
+    qc.insert(&ctx.data().database)?;
+
+    ctx.reply(format!("OK: Channel <#{channel}> will no longer allow users to accrue XP.", channel = channel)).await?;
+
+    Ok(())
+}
+
+#[poise::command(slash_command, prefix_command, required_permissions = "MANAGE_GUILD")]
+async fn unignore_channel_for_xp(ctx: ManifoldContext<'_>, channel: serenity::ChannelId) -> ManifoldResult<()> {
+    let db = &ctx.data().database;
+    Channel::get_by_channel_id(db, channel.as_u64().clone() as i64)?.remove(db)?;
+
+    ctx.reply(format!("OK: Channel <#{channel}> will now permit users to accrue XP.", channel = channel)).await?;
+
+    Ok(())
+}
+
+#[poise::command(slash_command, prefix_command, required_permissions = "ADMINISTRATOR")]
+async fn send_message(ctx: ManifoldContext<'_>, channel: serenity::ChannelId, message: String) -> ManifoldResult<()> {
+
+    channel.say(&ctx, message).await?;
+    ctx.reply(format!("Sent message to channel <#{channel}>", channel=channel)).await?;
+    Ok(())
+}
+
+pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 10] {
+    [void_user(), unvoid_user(), airlock_user(), record_chronicle(), security_record(), add_quarantine_channel(), remove_quarantine_channel(), ignore_channel_for_xp(), unignore_channel_for_xp(), send_message()]
 }

src/badgey/commands/ranks.rs

@@ -1,8 +1,9 @@
 use built::chrono;
 use manifold::error::{ManifoldError, ManifoldResult};
 use manifold::{ManifoldContext, ManifoldData};
-use poise::serenity_prelude::{Mentionable, RoleId};
+use poise::serenity_prelude::{CreateEmbed, Mentionable, RoleId};
-use crate::badgey::models::xp::{Rank, Track, Xp};
+use to_markdown_table::MarkdownTable;
+use crate::badgey::models::xp::{Leaderboard, Rank, Track, Xp};
 
 #[poise::command(prefix_command, slash_command, user_cooldown = 86400)]
 async fn switch_rank_track(ctx: ManifoldContext<'_>, #[description = "Track to switch to: officer or enlisted"] track: String) -> ManifoldResult<()> {
@@ -119,6 +120,57 @@ async fn rank(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
     Ok(())
 }
 
-pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 3] {
+#[poise::command(prefix_command, slash_command)]
-    [switch_rank_track(), freeze_rank(), rank()]
+async fn leaderboard(ctx: ManifoldContext<'_>) -> ManifoldResult<()> {
+
+    let reply_handle = ctx.reply("Retrieving leaderboard, please stand by...".to_string()).await?;
+    let entries_per_page = 20;
+    let mut pages = Vec::<CreateEmbed>::new();
+    let leaderboard = Leaderboard::get_leaderboard(&ctx.data().database)?;
+    let userinfo = ctx.data().user_info.lock().await;
+    let total = leaderboard.rows.len();
+    let pages_needed = (total / entries_per_page) + 1;
+
+    for i in 0..pages_needed {
+        let mut page = CreateEmbed::default()
+            .title(format!("XP Leaderboard Page {page} of {total_pages}", page=(i + 1), total_pages=&pages_needed)).to_owned();
+
+        let offset = i*entries_per_page;
+        let mut leaderboard_rows = Vec::new();
+
+        leaderboard.rows.iter().skip(offset).enumerate().for_each(|(j, f)| {
+            // cap at per-page limit
+            if j >= entries_per_page {
+                return;
+            }
+
+            let mut row = f.to_owned();
+            row.rank = (j + 1 + offset) as i32;
+            row.user_name = userinfo.get(&(row.uid as u64)).unwrap().username.clone();
+
+            leaderboard_rows.push(row);
+        });
+
+        let leaderboard_table = MarkdownTable::new(Some(vec!["Rank".to_string(), "User".to_string(), "XP".to_string()]), leaderboard_rows)?;
+
+        page.description(format!("```{table}```", table=leaderboard_table));
+
+        pages.push(page);
+    }
+
+    if pages.len() == 0 {
+        ctx.reply("No leaderboard entries yet!".to_string()).await?;
+        return Ok(())
+    }
+
+    // Release our mutex lock on this object before the paginate call to avoid holding a lock on it for the full paginate interaction listener timeout duration
+    drop(userinfo);
+
+    manifold::helpers::paginate(ctx, reply_handle, pages, 0).await?;
+
+    Ok(())
+}
+
+pub fn commands() -> [poise::Command<ManifoldData, ManifoldError>; 4] {
+    [switch_rank_track(), freeze_rank(), rank(), leaderboard()]
 }

src/badgey/events.rs

@@ -1,15 +1,12 @@
-use built::chrono;
 use manifold::error::{ManifoldError, ManifoldResult};
 use manifold::events::EventHandler;
 use manifold::ManifoldData;
 use poise::{async_trait, FrameworkContext, Event};
-use poise::serenity_prelude::{Context, Mentionable, Message, RoleId};
+use poise::serenity_prelude::{Context, Member, Message};
-use rand::rngs::SmallRng;
+use crate::badgey::handlers;
-use rand::{Rng, SeedableRng};
 use crate::badgey::models::custom_response::CustomResponse;
 
-use crate::badgey::models::xp::{Rank, Xp};
+use crate::badgey::models::xp::Xp;
-
 
 pub struct BadgeyHandler {
 
@@ -19,6 +16,7 @@ pub struct BadgeyHandler {
 impl EventHandler for BadgeyHandler {
     async fn listen(ctx: &Context, framework_ctx: FrameworkContext<'_, ManifoldData, ManifoldError>, event: &Event<'_>) -> ManifoldResult<()> {
         match event {
+            Event::GuildMemberUpdate { old_if_available, new } => BadgeyHandler::guild_member_update(&ctx, &framework_ctx, old_if_available, new).await,
             Event::Message { new_message } => BadgeyHandler::message(&ctx, &framework_ctx, new_message).await,
             _ => Ok(())
         }
@@ -26,73 +24,27 @@ impl EventHandler for BadgeyHandler {
 }
 
 impl BadgeyHandler {
+    pub async fn guild_member_update (ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, old_if_available: &Option<Member>, new: &Member) -> ManifoldResult<()> {
+
+        handlers::airlock::airlock_handler(ctx, fctx, old_if_available, new).await?;
+
+        Ok(())
+    }
+
     pub async fn message(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, msg: &Message) -> ManifoldResult<()> {
+
+        // Ignore our own messages
         if msg.author.id == ctx.http.get_current_user().await?.id || msg.content.starts_with(&fctx.user_data().await.bot_config.prefix) {
             return Ok(())
         }
+
         let db = &fctx.user_data().await.database;
 
         if let Ok(r) = CustomResponse::test_content(db, &msg.content_safe(&ctx.cache), &"!".to_string()) {
             msg.channel_id.say(ctx, r.response).await?;
         }
 
-        if fctx.user_data().await.user_info.lock().await.get_mut(&msg.author.id.as_u64()).is_none() {
+        Xp::award(ctx, fctx, msg, &db).await?;
-            debug!("Tried to add XP to a user we don't know about, aborting.");
-            return Ok(())
-        }
-
-        let mut rng = SmallRng::from_entropy();
-        let xp_reward = rng.gen_range(1..30).clone();
-        drop(rng);
-        let user_id_i64 = msg.author.id.as_u64().clone() as i64;
-
-        let mut xp = match Xp::get(db, &user_id_i64) {
-            Ok(x) => x,
-            Err(_) => Xp::new(&user_id_i64)
-        };
-
-        let valid = match xp.last_given_xp {
-            Some(t) => {
-                if (chrono::Utc::now().timestamp() - 60) > t {
-                    true
-                } else {
-                    false
-                }
-            },
-            None => true
-        };
-
-        if valid {
-            xp.last_given_xp = Some(chrono::Utc::now().timestamp());
-            xp.xp_value += &xp_reward;
-            let calculated_level = xp.get_level_from_xp(&db, None);
-
-            if xp.freeze_rank.is_some() {
-                xp.user_current_level = calculated_level.clone();
-                xp.insert(db)?;
-                return Ok(())
-            }
-
-            if (xp.user_current_level != calculated_level) || xp.user_current_level == 1 {
-                if let Some(guild) = msg.guild(&ctx.cache) {
-                    let mut member = guild.member(&ctx, msg.author.id).await?;
-                    let old_role_id = RoleId::from(Rank::get_rank_for_level(db, &xp.user_current_level, &xp.rank_track).unwrap_or(Rank::new()).role_id as u64);
-                    xp.user_current_level = calculated_level;
-                    let new_role = RoleId::from(Rank::get_rank_for_level(db, &calculated_level, &xp.rank_track)?.role_id as u64);
-
-                    if (new_role != old_role_id || xp.user_current_level == 1) && msg.author.has_role(ctx, guild.id, new_role).await? == false {
-                        member.remove_role(ctx, old_role_id).await?;
-                        member.add_role(ctx, new_role).await?;
-
-                        msg.channel_id.say(ctx, format!("{} is now a {}", msg.author.mention(), new_role.mention())).await?;
-                    }
-                } else {
-                    error!("Needed to add level to user, but couldn't get the member from the guild!");
-                }
-            }
-
-            xp.insert(db)?;
-        }
 
         Ok(())
     }

src/badgey/handlers/airlock.rs

@@ -0,0 +1,36 @@
+use manifold::error::{ManifoldError, ManifoldResult};
+use manifold::ManifoldData;
+use poise::FrameworkContext;
+use poise::serenity_prelude::{ChannelId, Context, Member, Mentionable};
+
+use crate::badgey::models::quarantine_channel::Channel;
+
+pub async fn airlock_handler(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, old: &Option<Member>, new: &Member) -> ManifoldResult<()> {
+
+    let db = &fctx.user_data.database;
+
+    // Is this user quarantined?
+    for role in new.roles.iter() {
+        if let Ok(channel) = Channel::get_by_qc_role_id(db, role.as_u64().clone() as i64) {
+            // Was this user JUST added to a quarantine channel?
+            if let Some(m) = old {
+                for role in m.roles.iter() {
+                    if let Ok(_) = Channel::get_by_qc_role_id(db, role.as_u64().clone() as i64) {
+                        // User already had quarantine role, return early
+                        return Ok(())
+                    }
+                }
+
+                let target_channel: ChannelId = ChannelId::from(channel.channel_id as u64);
+
+                // User was just added to a quarantine channel. Post the initial ping message.
+                target_channel.say(ctx, format!("{mention}, please respond to this message", mention = new.mention())).await?;
+                target_channel.await_reply(ctx).author_id(new.user.id).await;
+                target_channel.say(ctx, format!("{mention}, you have been brought to a private area by a server staff member. This does not necessarily mean you have broken the server rules; just that a staff member wishes to discuss something with you in a private and recorded environemnt.\n\nPlease note that the message history of this channel is not visible to you, and if your discord client loses focus on this channel it may then appear empty to you when you return. All message sent will remain visible to staff.\n\nPlease wait - a staff member should arrive shortly to explain why you are here.", mention = new.mention())).await?;
+                return Ok(())
+            }
+        }
+    }
+
+    Ok(())
+}

src/badgey/handlers/mod.rs

@@ -0,0 +1 @@
+pub mod airlock;

src/badgey/mod.rs

@@ -9,6 +9,7 @@ mod commands;
 mod events;
 mod models;
 mod schema;
+mod handlers;
 
 pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("migrations");
 

src/badgey/models/f1.rs

@@ -0,0 +1,230 @@
+use manifold::error::ManifoldResult;
+use manifold::models::fueltank::FuelTank;
+use reqwest::header::CONTENT_TYPE;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct CircuitLocation {
+    pub lat: String,
+    pub long: String,
+    pub locality: String,
+    pub country: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Circuit {
+    pub circuit_id: String,
+    pub url: String,
+    pub circuit_name: String,
+    #[serde(alias = "Location")]
+    pub location: CircuitLocation,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RaceSession {
+    pub date: Option<String>,
+    pub time: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Race {
+    pub season: String,
+    pub round: String,
+    pub url: String,
+    pub race_name: String,
+    #[serde(alias = "Circuit")]
+    pub circuit: Circuit,
+    pub date: String,
+    pub time: Option<String>,
+    pub first_practice: Option<RaceSession>,
+    pub second_practice: Option<RaceSession>,
+    pub third_practice: Option<RaceSession>,
+    pub qualifying: Option<RaceSession>,
+    pub sprint: Option<RaceSession>,
+    pub sprint_qualifying: Option<RaceSession>,
+    pub sprint_shootout: Option<RaceSession>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct PitStop {
+    pub driver_id: String,
+    pub lap: Option<String>,
+    pub stop: Option<String>,
+    pub time: Option<String>,
+    pub duration: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Qualifying {
+    pub number: String,
+    pub position: Option<String>,
+    pub driver: Driver,
+    pub constructor: Constructor,
+    pub q1: Option<String>,
+    pub q2: Option<String>,
+    pub q3: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Timing {
+    pub driver_id: String,
+    pub position: String,
+    pub time: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Lap {
+    pub number: String,
+    pub timings: Vec<Timing>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RaceResult {
+    pub number: String,
+    pub position: String,
+    pub position_text: String,
+    pub points: String,
+    pub driver: Driver,
+    pub constructor: Option<Constructor>,
+    pub grid: Option<String>,
+    pub laps: Option<String>,
+    pub status: Option<String>,
+    pub fastest_lap: Option<Lap>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Constructor {
+    pub constructor_id: Option<String>,
+    pub url: Option<String>,
+    pub name: String,
+    pub nationality: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ConstructorStandings {
+    pub position: Option<String>,
+    pub position_text: String,
+    pub points: String,
+    pub wins: String,
+    #[serde(alias = "Constructor")]
+    pub constructor: Constructor,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Driver {
+    pub driver_id: String,
+    pub permanent_number: Option<String>,
+    pub code: Option<String>,
+    pub url: Option<String>,
+    pub given_name: String,
+    pub family_name: String,
+    pub date_of_birth: Option<String>,
+    pub nationality: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct DriverStandings {
+    pub position: Option<String>,
+    pub position_text: String,
+    pub points: String,
+    pub wins: String,
+    #[serde(alias = "Driver")]
+    pub driver: Driver,
+    #[serde(alias = "Constructors")]
+    pub constructors: Vec<Constructor>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct DriverStandingsList {
+    pub season: String,
+    pub round: String,
+    #[serde(alias = "DriverStandings")]
+    pub driver_standings: Vec<DriverStandings>
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ConstructorStandingsList {
+    pub season: String,
+    pub round: String,
+    #[serde(alias = "ConstructorStandings")]
+    pub constructor_standings: Vec<ConstructorStandings>
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(untagged, rename_all_fields = "camelCase")]
+pub enum StandingsListType {
+    ConstructorStandings(ConstructorStandingsList),
+    DriversStandings(DriverStandingsList)
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct StandingsTable {
+    pub season: String,
+    pub round: String,
+    #[serde(alias = "StandingsLists")]
+    pub standings_lists: Vec<StandingsListType>
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Season {
+    pub season: String,
+    pub url: String,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct F1APIResponse {
+    #[serde(alias = "MRData")]
+    mrdata: MRData,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct MRData {
+    pub series: String,
+    pub xmlns: String,
+    pub url: String,
+    pub limit: String,
+    pub offset: String,
+    pub total: String,
+    #[serde(alias = "StandingsTable")]
+    pub standings_table: Option<StandingsTable>
+}
+
+pub type F1 = FuelTank;
+
+pub trait F1Client {
+    async fn get_standings(&self, season: String, championship: String) -> ManifoldResult<Option<StandingsTable>>;
+}
+
+impl F1Client for F1 {
+    async fn get_standings(&self, season: String, championship: String) -> ManifoldResult<Option<StandingsTable>> {
+        let base_url = format!("{base}/{season}/{championship}tandings/", base = self.source_uri, season = season, championship = championship.to_lowercase());
+        let client = reqwest::Client::new();
+        let response = client.get(base_url)
+            .header(CONTENT_TYPE, "application/json")
+            .send()
+            .await?
+            .text()
+            .await?;
+
+        let decoded_result: F1APIResponse = serde_json::from_str(&*response)?;
+
+        Ok(decoded_result.mrdata.standings_table)
+    }
+}

src/badgey/models/mod.rs

@@ -1,2 +1,4 @@
 pub mod custom_response;
 pub mod xp;
+pub mod quarantine_channel;
+pub mod f1;

src/badgey/models/quarantine_channel.rs

@@ -0,0 +1,59 @@
+use diesel::{insert_into, Identifiable, Insertable, QueryDsl, Queryable, RunQueryDsl, Selectable};
+use diesel::dsl::delete;
+use diesel::prelude::*;
+use manifold::Db;
+use manifold::error::{ManifoldError, ManifoldResult};
+use crate::badgey::schema::channels as channel_table;
+use crate::badgey::schema::*;
+
+#[derive(Queryable, Selectable, Identifiable, Insertable, Debug, Clone)]
+#[diesel(table_name = channels)]
+pub struct Channel {
+    #[diesel(deserialize_as = i32)]
+    pub id: Option<i32>,
+    pub qc_role_id: Option<i64>,
+    pub channel_id: i64,
+    pub is_quarantine_channel: bool,
+    pub is_valid_for_xp: bool,
+}
+
+impl Channel {
+    pub fn new(qc_role_id: Option<i64>, channel_id: i64, is_quarantine_channel: bool, is_valid_for_xp: bool) -> Self {
+        Channel {
+            id: None,
+            qc_role_id,
+            channel_id,
+            is_quarantine_channel,
+            is_valid_for_xp,
+        }
+    }
+
+    pub fn insert(&self, conn: &Db) -> ManifoldResult<usize> {
+        insert_into(channel_table::dsl::channels)
+            .values(self)
+            .execute(&mut conn.get()?)
+            .map_err(|e| ManifoldError::from(e))
+    }
+
+    pub fn remove(&self, conn: &Db) -> ManifoldResult<usize> {
+        Ok(delete(channel_table::dsl::channels)
+            .filter(channel_table::qc_role_id.eq(self.qc_role_id))
+            .execute(&mut conn.get()?)?)
+    }
+
+    pub fn get_by_channel_id(conn: &Db, needle: i64) -> ManifoldResult<Self> {
+        Ok(channel_table::dsl::channels
+            .filter(channel_table::channel_id.eq(needle))
+            .limit(1)
+            .select(Channel::as_select())
+            .get_result(&mut conn.get()?)?)
+    }
+
+    pub fn get_by_qc_role_id(conn: &Db, needle: i64) -> ManifoldResult<Self> {
+        Ok(channel_table::dsl::channels
+            .filter(channel_table::qc_role_id.eq(needle))
+            .limit(1)
+            .select(Channel::as_select())
+            .get_result(&mut conn.get()?)?)
+    }
+}

src/badgey/models/xp.rs

@@ -1,11 +1,17 @@
 use built::chrono;
 use diesel::prelude::*;
 use diesel::insert_into;
-use manifold::Db;
+use rand::rngs::SmallRng;
+use rand::{Rng, SeedableRng};
+use to_markdown_table::{TableRow};
+
+use manifold::{Db, ManifoldData};
 use manifold::error::{ManifoldError, ManifoldResult};
 use manifold::models::user::UserInfo;
 use manifold::schema::userinfo;
-
+use poise::FrameworkContext;
+use poise::serenity_prelude::{Context, Mentionable, Message, RoleId};
+use crate::badgey::models::quarantine_channel::Channel;
 use crate::badgey::schema::xp as xp_table;
 use crate::badgey::schema::*;
 
@@ -22,7 +28,7 @@ pub struct Xp {
     pub rank_track: i64,
     pub rank_track_last_changed: Option<i64>,
     pub freeze_rank: Option<i64>,
-    pub freeze_rank_last_changed: Option<i64>
+    pub freeze_rank_last_changed: Option<i64>,
 }
 
 #[derive(Queryable, Selectable, Identifiable, Debug, Clone)]
@@ -44,6 +50,47 @@ pub struct Track {
     pub xp_award_range_max: i32,
 }
 
+pub struct Leaderboard {
+    pub rows: Vec<LeaderboardRow>
+}
+
+#[derive(Clone)]
+pub struct LeaderboardRow {
+    pub rank: i32,
+    pub uid: i64,
+    pub user_name: String,
+    pub value: i64,
+}
+
+impl Into<TableRow> for LeaderboardRow {
+    fn into(self) -> TableRow {
+        TableRow::new(vec![self.rank.to_string(), self.user_name, self.value.to_string()])
+    }
+}
+
+impl From<&Xp> for LeaderboardRow {
+    fn from(value: &Xp) -> Self {
+        LeaderboardRow {
+            rank: 0,
+            uid: value.user_id,
+            user_name: "".to_string(),
+            value: value.xp_value,
+        }
+    }
+}
+
+impl Leaderboard {
+    pub fn get_leaderboard(conn: &Db) -> ManifoldResult<Self> {
+        let xp_rows: Vec<LeaderboardRow> = xp_table::dsl::xp
+            .order_by(xp::xp_value.desc())
+            .load::<Xp>(&mut conn.get()?)?.iter().map(|x| {LeaderboardRow::from(x)}).collect();
+
+        Ok(Leaderboard {
+            rows: xp_rows
+        })
+    }
+}
+
 impl Xp {
     pub fn new(user_id: &i64) -> Self {
         Self {
@@ -113,6 +160,70 @@ impl Xp {
 
         Ok(())
     }
+
+    pub async fn award(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, msg: &Message, db: &Db) -> ManifoldResult<()>{
+        if fctx.user_data().await.user_info.lock().await.get_mut(&msg.author.id.as_u64()).is_none() {
+            debug!("Tried to add XP to a user we don't know about, aborting.");
+            return Ok(())
+        }
+
+        let mut rng = SmallRng::from_entropy();
+        let xp_reward = rng.gen_range(1..30).clone();
+        drop(rng);
+        let user_id_i64 = msg.author.id.as_u64().clone() as i64;
+        let channel_id_i64 = msg.channel_id.as_u64().clone() as i64;
+
+        let mut valid_channel = true;
+
+        if let Ok(c) = Channel::get_by_channel_id(&fctx.user_data.database, channel_id_i64) {
+            valid_channel = c.is_valid_for_xp && !c.is_quarantine_channel;
+        }
+
+        let mut xp = match Xp::get(db, &user_id_i64) {
+            Ok(x) => x,
+            Err(_) => Xp::new(&user_id_i64)
+        };
+
+        let valid_user = match xp.last_given_xp {
+            Some(t) => (chrono::Utc::now().timestamp() - 60) > t,
+            None => true
+        };
+
+        if valid_user && valid_channel {
+            xp.last_given_xp = Some(chrono::Utc::now().timestamp());
+            xp.xp_value += &xp_reward;
+            let calculated_level = xp.get_level_from_xp(&db, None);
+
+            if xp.freeze_rank.is_some() {
+                xp.user_current_level = calculated_level.clone();
+                xp.insert(db)?;
+                return Ok(())
+            }
+
+            if (xp.user_current_level != calculated_level) || xp.user_current_level == 1 {
+                if let Some(guild) = msg.guild(&ctx.cache) {
+                    let mut member = guild.member(&ctx, msg.author.id).await?;
+                    let old_role_id = RoleId::from(Rank::get_rank_for_level(db, &xp.user_current_level, &xp.rank_track).unwrap_or(Rank::new()).role_id as u64);
+                    xp.user_current_level = calculated_level;
+                    let new_role = RoleId::from(Rank::get_rank_for_level(db, &calculated_level, &xp.rank_track)?.role_id as u64);
+
+                    if (new_role != old_role_id || xp.user_current_level == 1) && msg.author.has_role(ctx, guild.id, new_role).await? == false {
+                        member.remove_role(ctx, old_role_id).await?;
+                        member.add_role(ctx, new_role).await?;
+
+                        msg.channel_id.say(ctx, format!("{} is now a {}", msg.author.mention(), new_role.mention())).await?;
+                    }
+                } else {
+                    error!("Needed to add level to user, but couldn't get the member from the guild!");
+                }
+            }
+
+            xp.insert(db)?;
+
+        }
+
+        Ok(())
+    }
 }
 
 impl Rank {

src/badgey/schema.rs

@@ -1,5 +1,15 @@
 // @generated automatically by Diesel CLI.
 
+diesel::table! {
+    channels (id) {
+        id -> Int4,
+        qc_role_id -> Nullable<Int8>,
+        channel_id -> Int8,
+        is_quarantine_channel -> Bool,
+        is_valid_for_xp -> Bool,
+    }
+}
+
 diesel::table! {
     custom_responses (id) {
         id -> Int4,
@@ -64,6 +74,7 @@ diesel::joinable!(custom_responses -> userinfo (added_for));
 diesel::joinable!(xp -> userinfo (user_id));
 
 diesel::allow_tables_to_appear_in_same_query!(
+    channels,
     custom_responses,
     ranks,
     tracks,