.gitignore

@@ -2,4 +2,3 @@
 **/result
 result/
 result
-.env

.woodpecker.yml

@@ -1,25 +0,0 @@
-pipeline:
-  build:
-    image: alpine:edge
-      - apk add --no-cache git nix --repository=https://dl-cdn.alpinelinux.org/alpine/edge/testing
-      - nix build --extra-experimental-features nix-command --extra-experimental-features flakes .#default
-
-  build-docker-image:
-    when:
-      event: tag
-    image: alpine:edge
-    commands:
-      - echo "system-features = nixos-test benchmark big-parallel uid-range kvm" > /etc/nix/nix.conf
-      - nix build --extra-experimental-features nix-command --extra-experimental-features flakes .#docker
-
-  publish-image:
-    when:
-      event: tag
-    image: git.spacegirl.nl/patrick/plugin-artifact
-    settings:
-      tag: $CI_COMMIT_TAG
-      user: patrick
-      password:
-        from_secret: forgejo_token
-      repo: $CI_REPO
-      image_tar: result

Cargo.toml

@@ -6,11 +6,8 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-async-trait = "0.1.72"
+axum = "0.6.9"
-axum = { version = "0.6.9", features = ["headers", "multipart"] }
-axum-extra = { version = "0.7.5", features = ["cookie-private", "cookie"] }
 chrono = "0.4.23"
-dotenv = "0.15.0"
 futures = "0.3.26"
 reqwest = "0.11.14"
 serde = "1.0.152"

src/htmx.rs

@@ -1,395 +0,0 @@
-use std::collections::HashMap;
-
-pub trait Build {
-    fn build(self) -> String;
-}
-
-#[derive(PartialEq)]
-pub enum Tag {
-    Empty,
-
-    Html,
-    Head,
-    Link,
-    Script,
-    Title,
-    Body,
-    Main,
-    Break,
-
-    Details,
-    Summary,
-
-    Dialog,
-    Article,
-    Header,
-
-    Div,
-
-    Table,
-    TableHead,
-    TableHeader,
-    TableBody,
-    TableRow,
-    TableData,
-
-    Progress,
-
-    Form,
-    Label,
-    FieldSet,
-    Input,
-    Select,
-    Option,
-
-    Nav,
-
-    OrderedList,
-    UnorderedList,
-    ListItem,
-
-    Anchor,
-    Button,
-
-    Header1,
-    Header2,
-    Header3,
-    Header4,
-    Header5,
-    Header6,
-    Strong,
-    Paragraph,
-    JustText,
-}
-
-impl Tag {
-    fn as_str(&self) -> &'static str {
-        match self {
-            Self::Empty => "",
-            Self::JustText => "",
-
-            Self::Html => "html",
-            Self::Head => "head",
-            Self::Link => "link",
-            Self::Script => "script",
-            Self::Title => "title",
-            Self::Body => "body",
-            Self::Main => "main",
-            Self::Break => "break",
-
-            Self::Progress => "progress",
-
-            Self::Details => "details",
-            Self::Summary => "summary",
-
-            Self::Dialog => "dialog",
-            Self::Article => "article",
-            Self::Header => "header",
-
-            Self::Div => "div",
-
-            Self::Table => "table",
-            Self::TableHead => "thead",
-            Self::TableHeader => "th",
-            Self::TableBody => "tbody",
-            Self::TableRow => "tr",
-            Self::TableData => "td",
-
-            Self::Form => "form",
-            Self::Label => "label",
-            Self::FieldSet => "fieldset",
-            Self::Input => "input",
-            Self::Select => "select",
-            Self::Option => "option",
-
-            Self::Nav => "nav",
-
-            Self::OrderedList => "ol",
-            Self::UnorderedList => "ul",
-            Self::ListItem => "li",
-
-            Self::Anchor => "a",
-            Self::Button => "button",
-
-            Self::Header1 => "h1",
-            Self::Header2 => "h2",
-            Self::Header3 => "h3",
-            Self::Header4 => "h4",
-            Self::Header5 => "h5",
-            Self::Header6 => "h6",
-            Self::Strong => "strong",
-            Self::Paragraph => "paragraph",
-        }
-    }
-
-    fn start(&self) -> String {
-        if *self != Self::JustText && *self != Self::Empty {
-            format!("<{}>", self.as_str())
-        } else {
-            String::new()
-        }
-    }
-
-    fn end(&self) -> String {
-        if *self != Self::JustText
-            && *self != Self::Empty
-            && *self != Self::Link
-            && *self != Self::Input
-        {
-            format!("</{}>", self.as_str())
-        } else {
-            String::new()
-        }
-    }
-}
-
-pub enum SwapMethod {
-    InnerHtml,
-    OuterHtml,
-    BeforeEnd,
-    Refresh,
-}
-
-impl SwapMethod {
-    fn as_str(&self) -> &'static str {
-        match self {
-            SwapMethod::InnerHtml => "innerHTML",
-            SwapMethod::OuterHtml => "outerHTML",
-            SwapMethod::BeforeEnd => "beforeend",
-            SwapMethod::Refresh => "refresh",
-        }
-    }
-}
-
-pub struct HtmxBuilder {
-    tag: Tag,
-    attributes: HashMap<String, String>,
-    children: Vec<HtmxBuilder>,
-    text: Option<String>,
-}
-
-impl Build for HtmxBuilder {
-    #[must_use]
-    fn build(self) -> String {
-        let mut string = String::new();
-
-        // TODO: do this better
-        {
-            if self.tag != Tag::JustText && self.tag != Tag::Empty {
-                string.push_str(&format!("<{}", self.tag.as_str()));
-            }
-
-            for (attr, value) in self.attributes {
-                if value.is_empty() {
-                    string.push_str(&format!(" {attr} "));
-                } else {
-                    string.push_str(&format!(" {attr}='{value}' "));
-                }
-            }
-            if self.tag != Tag::JustText && self.tag != Tag::Empty {
-                string.push_str(">");
-            }
-        }
-
-        if let Some(text) = self.text {
-            string.push_str(&text);
-        }
-
-        for child in self.children {
-            string.push_str(&child.build());
-        }
-
-        string.push_str(&self.tag.end());
-
-        string
-    }
-}
-
-impl HtmxBuilder {
-    pub fn new(tag: Tag) -> Self {
-        Self {
-            tag,
-            attributes: HashMap::new(),
-            children: Vec::new(),
-            text: None,
-        }
-    }
-
-    pub fn push_builder(mut self, builder: HtmxBuilder) -> Self {
-        self.children.push(builder);
-        self
-    }
-
-    pub fn attribute(mut self, attr: &str, val: &str) -> Self {
-        self.attributes.insert(attr.to_string(), val.to_string());
-        self
-    }
-
-    pub fn hx_get(mut self, uri: &str) -> Self {
-        self.attribute("hx-get", uri)
-    }
-
-    pub fn hx_post(mut self, uri: &str) -> Self {
-        self.attribute("hx-post", uri)
-    }
-
-    pub fn hx_swap(mut self, swap_method: SwapMethod) -> Self {
-        self.attribute("hx-swap", swap_method.as_str())
-    }
-
-    pub fn hx_trigger(mut self, trigger: &str) -> Self {
-        self.attribute("hx-trigger", trigger)
-    }
-
-    pub fn hx_target(mut self, target: &str) -> Self {
-        self.attribute("hx-target", target)
-    }
-
-    pub fn html<F>(mut self, builder_fn: F) -> Self
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children.push(builder_fn(HtmxBuilder::new(Tag::Html)));
-        self
-    }
-
-    pub fn head<F>(mut self, builder_fn: F) -> Self
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children.push(builder_fn(HtmxBuilder::new(Tag::Head)));
-        self
-    }
-
-    pub fn title(mut self, text: &str) -> HtmxBuilder {
-        self.children.push(HtmxBuilder::new(Tag::Title).text(text));
-        self
-    }
-
-    pub fn body<F>(mut self, builder_fn: F) -> Self
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children.push(builder_fn(HtmxBuilder::new(Tag::Body)));
-        self
-    }
-
-    pub fn script(mut self, src: &str, integrity: Option<&str>) -> Self {
-        let mut b = HtmxBuilder::new(Tag::Script).attribute("src", src);
-
-        if let Some(integrity) = integrity {
-            b = b
-                .attribute("integrity", integrity)
-                .attribute("crossorigin", "anonymous");
-        }
-
-        self.children.push(b);
-        self
-    }
-
-    pub fn style_link(mut self, link: &str) -> Self {
-        self.children.push(
-            HtmxBuilder::new(Tag::Link)
-                .attribute("rel", "stylesheet")
-                .attribute("href", link),
-        );
-        self
-    }
-
-    pub fn flag(mut self, flag: &str) -> Self {
-        self.attributes.insert(flag.to_string(), "".to_string());
-        self
-    }
-
-    pub fn builder<F>(mut self, tag: Tag, builder_fn: F) -> Self
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children.push(builder_fn(HtmxBuilder::new(tag)));
-        self
-    }
-
-    pub fn builder_text(mut self, tag: Tag, text: &str) -> Self {
-        self.children.push(HtmxBuilder::new(tag).text(text));
-        self
-    }
-
-    pub fn nav<F>(mut self, builder_fn: F) -> Self
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children.push(builder_fn(HtmxBuilder::new(Tag::Nav)));
-        self
-    }
-
-    pub fn form<F>(mut self, builder_fn: F) -> HtmxBuilder
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children.push(builder_fn(HtmxBuilder::new(Tag::Form)));
-        self
-    }
-
-    pub fn label<F>(mut self, builder_fn: F) -> HtmxBuilder
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children.push(builder_fn(HtmxBuilder::new(Tag::Label)));
-        self
-    }
-
-    pub fn input<F>(mut self, builder_fn: F) -> HtmxBuilder
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children.push(builder_fn(HtmxBuilder::new(Tag::Input)));
-        self
-    }
-
-    pub fn button<F>(mut self, builder_fn: F) -> HtmxBuilder
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children
-            .push(builder_fn(HtmxBuilder::new(Tag::Button)));
-        self
-    }
-
-    pub fn ul<F>(mut self, builder_fn: F) -> HtmxBuilder
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children
-            .push(builder_fn(HtmxBuilder::new(Tag::UnorderedList)));
-        self
-    }
-
-    pub fn li<F>(mut self, builder_fn: F) -> HtmxBuilder
-    where
-        F: FnOnce(HtmxBuilder) -> HtmxBuilder,
-    {
-        self.children
-            .push(builder_fn(HtmxBuilder::new(Tag::ListItem)));
-        self
-    }
-
-    pub fn link(mut self, text: &str, href: &str) -> HtmxBuilder {
-        // TODO: add href attribute
-        self.children.push(
-            HtmxBuilder::new(Tag::Anchor)
-                .text(text)
-                .attribute("href", href),
-        );
-        self
-    }
-
-    pub fn text(mut self, text: &str) -> HtmxBuilder {
-        self.text = Some(text.to_string());
-        self
-    }
-
-    pub fn strong(mut self, text: &str) -> HtmxBuilder {
-        self.children.push(HtmxBuilder::new(Tag::Strong).text(text));
-        self
-    }
-}

src/main.rs

@@ -3,9 +3,7 @@
 #![feature(async_closure)]
 
 mod auth;
-mod htmx;
 mod media;
-mod page;
 mod routes;
 pub mod settings;
 
@@ -135,18 +133,6 @@ fn spawn_api(settings: Arc<Mutex<Settings>>) {
 
     tokio::spawn(async move {
         let api = Router::new()
-            .route("/", get(page::home))
-            .route("/index.html", get(page::home))
-            .route("/login", get(page::login))
-            .route("/guild/:guild_id", get(page::guild_dashboard))
-            .route(
-                "/v2/intros/add/:guild_id/:channel",
-                post(routes::v2_add_intro_to_user),
-            )
-            .route(
-                "/v2/intros/remove/:guild_id/:channel",
-                post(routes::v2_remove_intro_from_user),
-            )
             .route("/health", get(routes::health))
             .route("/me", get(routes::me))
             .route("/intros/:guild", get(routes::intros))
@@ -162,7 +148,6 @@ fn spawn_api(settings: Arc<Mutex<Settings>>) {
                 post(routes::remove_intro_to_user),
             )
             .route("/auth", get(routes::auth))
-            .route("/v2/auth", get(routes::v2_auth))
             .layer(
                 CorsLayer::new()
                     // TODO: move this to env variable
@@ -170,7 +155,7 @@ fn spawn_api(settings: Arc<Mutex<Settings>>) {
                     .allow_headers(Any)
                     .allow_methods([Method::GET, Method::POST, Method::DELETE]),
             )
-            .with_state(state);
+            .with_state(Arc::new(state));
         let addr = SocketAddr::from(([0, 0, 0, 0], 8100));
         info!("socket listening on {addr}");
         axum::Server::bind(&addr)
@@ -248,29 +233,21 @@ async fn spawn_bot(settings: Arc<Mutex<Settings>>) {
                     info!("Got PlaySound message");
                     let settings = settings.lock().await;
 
-                    let Some(Channel::Guild(channel)) = channel_id.to_channel_cached(&ctx.cache)
+                    let Some(Channel::Guild(channel)) = channel_id.to_channel_cached(&ctx.cache) else {
-                    else {
                         error!("Failed to get cached channel from member!");
                         continue;
                     };
 
-                    let Some(guild_settings) = settings.guilds.get(channel.guild_id.as_u64())
+                    let Some(guild_settings) = settings.guilds.get(channel.guild_id.as_u64()) else {
-                    else {
                         error!("couldn't get guild from id: {}", channel.guild_id.as_u64());
                         continue;
                     };
                     let Some(channel_settings) = guild_settings.channels.get(channel.name()) else {
-                        error!(
+                        error!("couldn't get channel_settings from name: {}", channel.name());
-                            "couldn't get channel_settings from name: {}",
-                            channel.name()
-                        );
                         continue;
                     };
                     let Some(user) = channel_settings.users.get(&member.user.name) else {
-                        error!(
+                        error!("couldn't get user settings from name: {}", &member.user.name);
-                            "couldn't get user settings from name: {}",
-                            &member.user.name
-                        );
                         continue;
                     };
 
@@ -333,8 +310,6 @@ async fn spawn_bot(settings: Arc<Mutex<Settings>>) {
 #[tokio::main]
 #[instrument]
 async fn main() -> std::io::Result<()> {
-    dotenv::dotenv().ok();
-
     tracing_subscriber::fmt::init();
 
     let settings = serde_json::from_str::<Settings>(

src/page.rs

@@ -1,161 +0,0 @@
-use crate::{
-    auth::{self, User},
-    htmx::{Build, HtmxBuilder, SwapMethod, Tag},
-    settings::{ApiState, Intro, IntroFriendlyName},
-};
-use axum::{
-    extract::{Path, State},
-    response::{Html, Redirect},
-};
-use tracing::error;
-
-pub(crate) async fn home(user: Option<User>) -> Redirect {
-    if user.is_some() {
-        Redirect::to("/guild/588149178912473103")
-    } else {
-        Redirect::to("/login")
-    }
-}
-
-fn intro_list<'a>(
-    intros: impl Iterator<Item = (&'a String, &'a Intro)>,
-    label: &str,
-    post: &str,
-) -> HtmxBuilder {
-    HtmxBuilder::new(Tag::Empty).form(|b| {
-        b.attribute("class", "container")
-            .hx_post(post)
-            .attribute("hx-encoding", "multipart/form-data")
-            .builder(Tag::FieldSet, |b| {
-                let mut b = b
-                    .attribute("class", "container")
-                    .attribute("style", "max-height: 20%; overflow-y: scroll");
-                for intro in intros {
-                    b = b.builder(Tag::Label, |b| {
-                        b.builder(Tag::Input, |b| {
-                            b.attribute("type", "checkbox").attribute("name", &intro.0)
-                        })
-                        .builder_text(Tag::Paragraph, intro.1.friendly_name())
-                    });
-                }
-
-                b
-            })
-            .button(|b| b.attribute("type", "submit").text(label))
-    })
-}
-
-pub(crate) async fn guild_dashboard(
-    State(state): State<ApiState>,
-    user: User,
-    Path(guild_id): Path<u64>,
-) -> Result<Html<String>, Redirect> {
-    let settings = state.settings.lock().await;
-
-    let Some(guild) = settings.guilds.get(&guild_id) else {
-        error!(%guild_id, "no such guild");
-        return Err(Redirect::to("/"));
-    };
-    let Some(guild_user) = guild.users.get(&user.name) else {
-        error!(%guild_id, %user.name, "no user in guild");
-        return Err(Redirect::to("/"));
-    };
-
-    let is_moderator = guild_user.permissions.can(auth::Permission::DeleteSounds);
-
-    Ok(Html(
-        HtmxBuilder::new(Tag::Html)
-            .head(|b| {
-                b.title("MemeJoin - Dashboard")
-                .script(
-                    "https://unpkg.com/htmx.org@1.9.3",
-                    Some("sha384-lVb3Rd/Ca0AxaoZg5sACe8FJKF0tnUgR2Kd7ehUOG5GCcROv5uBIZsOqovBAcWua"),
-                )
-                .script("https://unpkg.com/hyperscript.org@0.9.9", None)
-                .style_link("https://cdn.jsdelivr.net/npm/@picocss/pico@1/css/pico.min.css")
-            })
-            .builder(Tag::Nav, |b| {
-                b.builder(Tag::Header1, |b| b.text("MemeJoin - A bot for user intros"))
-                    .builder_text(Tag::Paragraph, &user.name)
-            })
-            .builder(Tag::Main, |b| {
-                if is_moderator {
-                    b.builder(Tag::Article, |b| {
-                        b.builder_text(Tag::Header, "Wow, you're a moderator")
-                    })
-                } else {
-                    b
-                }
-                .builder(Tag::Article, |b| {
-                    let mut b = b.builder_text(Tag::Header, "Guild Settings");
-
-                    for (channel_name, channel_settings) in &guild.channels {
-                        if let Some(channel_user) = channel_settings.users.get(&user.name) {
-                            let current_intros =
-                                channel_user.intros.iter().filter_map(|intro_index| {
-                                    Some((
-                                        &intro_index.index,
-                                        guild.intros.get(&intro_index.index)?,
-                                    ))
-                                });
-                            let available_intros = guild.intros.iter().filter_map(|intro| {
-                                if !channel_user
-                                    .intros
-                                    .iter()
-                                    .any(|intro_index| intro.0 == &intro_index.index)
-                                {
-                                    Some((intro.0, intro.1))
-                                } else {
-                                    None
-                                }
-                            });
-                            b = b
-                                .builder_text(Tag::Strong, channel_name)
-                                .builder(Tag::Div, |b| {
-                                    b.builder_text(Tag::Strong, "Your Current Intros")
-                                        .push_builder(intro_list(
-                                            current_intros,
-                                            "Remove Intro",
-                                            &format!(
-                                                "/v2/intros/remove/{}/{}",
-                                                guild_id, channel_name
-                                            ),
-                                        ))
-                                        .builder_text(Tag::Strong, "Select Intros")
-                                        .push_builder(intro_list(
-                                            available_intros,
-                                            "Add Intro",
-                                            &format!(
-                                                "/v2/intros/add/{}/{}",
-                                                guild_id, channel_name
-                                            ),
-                                        ))
-                                });
-                        }
-                    }
-
-                    b
-                })
-            })
-            .build(),
-    ))
-}
-
-pub(crate) async fn login(State(state): State<ApiState>) -> Html<String> {
-    let authorize_uri = format!("https://discord.com/api/oauth2/authorize?client_id={}&redirect_uri={}/v2/auth&response_type=code&scope=guilds.members.read%20guilds%20identify", state.secrets.client_id, state.origin);
-
-    Html(
-        HtmxBuilder::new(Tag::Html)
-            .head(|b| {
-                b.title("MemeJoin - Login")
-                .script(
-                    "https://unpkg.com/htmx.org@1.9.3",
-                    Some("sha384-lVb3Rd/Ca0AxaoZg5sACe8FJKF0tnUgR2Kd7ehUOG5GCcROv5uBIZsOqovBAcWua"),
-                )
-                .script("https://unpkg.com/hyperscript.org@0.9.9", None)
-                .style_link("https://cdn.jsdelivr.net/npm/@picocss/pico@1/css/pico.min.css")
-            })
-            .link("Login", &authorize_uri)
-            .build(),
-    )
-}

src/routes.rs

@@ -2,23 +2,19 @@ use std::{collections::HashMap, sync::Arc};
 
 use axum::{
     body::Bytes,
-    extract::{Multipart, Path, Query, State},
+    extract::{Path, Query, State},
-    http::{HeaderMap, HeaderValue},
+    http::HeaderMap,
-    response::{IntoResponse, Redirect},
+    response::IntoResponse,
-    Form, Json,
+    Json,
 };
 
-use axum_extra::extract::{cookie::Cookie, CookieJar};
+use reqwest::StatusCode;
-use reqwest::{Proxy, StatusCode};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use tracing::{error, info};
 use uuid::Uuid;
 
-use crate::{
+use crate::{auth, settings::FileIntro};
-    auth::{self, User},
-    settings::FileIntro,
-};
 use crate::{
     media,
     settings::{ApiState, GuildUser, Intro, IntroIndex, UserSettings},
@@ -127,109 +123,8 @@ struct DiscordUserGuild {
     pub owner: bool,
 }
 
-pub(crate) async fn v2_auth(
-    State(state): State<ApiState>,
-    Query(params): Query<HashMap<String, String>>,
-    jar: CookieJar,
-) -> Result<(CookieJar, Redirect), Error> {
-    let Some(code) = params.get("code") else {
-        return Err(Error::Auth("no code".to_string()));
-    };
-
-    info!("attempting to get access token with code {}", code);
-
-    let mut data = HashMap::new();
-
-    let redirect_uri = format!("{}/v2/auth", state.origin);
-    data.insert("client_id", state.secrets.client_id.as_str());
-    data.insert("client_secret", state.secrets.client_secret.as_str());
-    data.insert("grant_type", "authorization_code");
-    data.insert("code", code);
-    data.insert("redirect_uri", &redirect_uri);
-
-    let client = reqwest::Client::new();
-
-    let auth: auth::Discord = client
-        .post("https://discord.com/api/oauth2/token")
-        .form(&data)
-        .send()
-        .await
-        .map_err(|err| Error::Auth(err.to_string()))?
-        .json()
-        .await
-        .map_err(|err| {
-            error!(?err, "auth error");
-            Error::Auth(err.to_string())
-        })?;
-    let token = Uuid::new_v4().to_string();
-
-    // Get authorized username
-    let user: DiscordUser = client
-        .get("https://discord.com/api/v10/users/@me")
-        .bearer_auth(&auth.access_token)
-        .send()
-        .await?
-        .json()
-        .await?;
-
-    // TODO: get bot's guilds so we only save users who are able to use the bot
-    let discord_guilds: Vec<DiscordUserGuild> = client
-        .get("https://discord.com/api/v10/users/@me/guilds")
-        .bearer_auth(&auth.access_token)
-        .send()
-        .await?
-        .json()
-        .await
-        .map_err(|err| Error::Auth(err.to_string()))?;
-
-    let mut settings = state.settings.lock().await;
-    let mut in_a_guild = false;
-    for g in settings.guilds.iter_mut() {
-        let Some(discord_guild) = discord_guilds
-            .iter()
-            .find(|discord_guild| discord_guild.id == g.0.to_string())
-        else {
-            continue;
-        };
-
-        in_a_guild = true;
-
-        if !g.1.users.contains_key(&user.username) {
-            g.1.users.insert(
-                user.username.clone(),
-                GuildUser {
-                    permissions: if discord_guild.owner {
-                        auth::Permissions(auth::Permission::all())
-                    } else {
-                        Default::default()
-                    },
-                },
-            );
-        }
-    }
-
-    if !in_a_guild {
-        return Err(Error::NoGuildFound);
-    }
-
-    settings.auth_users.insert(
-        token.clone(),
-        auth::User {
-            auth,
-            name: user.username.clone(),
-        },
-    );
-    // TODO: add permissions based on roles
-
-    let mut cookie = Cookie::new("access_token", token.clone());
-    cookie.set_path("/");
-    cookie.set_secure(true);
-
-    Ok((jar.add(cookie), Redirect::to("/")))
-}
-
 pub(crate) async fn auth(
-    State(state): State<ApiState>,
+    State(state): State<Arc<ApiState>>,
     Query(params): Query<HashMap<String, String>>,
 ) -> Result<Json<Value>, Error> {
     let Some(code) = params.get("code") else {
@@ -284,10 +179,7 @@ pub(crate) async fn auth(
     for g in settings.guilds.iter_mut() {
         let Some(discord_guild) = discord_guilds
             .iter()
-            .find(|discord_guild| discord_guild.id == g.0.to_string())
+            .find(|discord_guild| discord_guild.id == g.0.to_string()) else { continue; };
-        else {
-            continue;
-        };
 
         in_a_guild = true;
 
@@ -321,118 +213,21 @@ pub(crate) async fn auth(
     Ok(Json(json!({"token": token, "username": user.username})))
 }
 
-pub(crate) async fn v2_add_intro_to_user(
-    State(state): State<ApiState>,
-    Path((guild_id, channel)): Path<(u64, String)>,
-    user: User,
-    mut form_data: Multipart,
-) -> HeaderMap {
-    let mut headers = HeaderMap::new();
-    headers.insert("HX-Refresh", HeaderValue::from_static("true"));
-
-    let mut settings = state.settings.lock().await;
-
-    let Some(guild) = settings.guilds.get_mut(&guild_id) else {
-        return headers;
-    };
-    let Some(channel) = guild.channels.get_mut(&channel) else {
-        return headers;
-    };
-    let Some(channel_user) = channel.users.get_mut(&user.name) else {
-        return headers;
-    };
-
-    while let Ok(Some(field)) = form_data.next_field().await {
-        let Some(field_name) = field.name() else {
-            continue;
-        };
-
-        if !channel_user
-            .intros
-            .iter()
-            .any(|intro| intro.index == field_name)
-        {
-            channel_user.intros.push(IntroIndex {
-                index: field_name.to_string(),
-                volume: 20,
-            });
-        }
-    }
-
-    // TODO: don't save on every change
-    if let Err(err) = settings.save() {
-        error!("Failed to save config: {err:?}");
-    }
-
-    headers
-}
-
-pub(crate) async fn v2_remove_intro_from_user(
-    State(state): State<ApiState>,
-    Path((guild_id, channel)): Path<(u64, String)>,
-    user: User,
-    mut form_data: Multipart,
-) -> HeaderMap {
-    let mut headers = HeaderMap::new();
-    headers.insert("HX-Refresh", HeaderValue::from_static("true"));
-
-    let mut settings = state.settings.lock().await;
-
-    let Some(guild) = settings.guilds.get_mut(&guild_id) else {
-        return headers;
-    };
-    let Some(channel) = guild.channels.get_mut(&channel) else {
-        return headers;
-    };
-    let Some(channel_user) = channel.users.get_mut(&user.name) else {
-        return headers;
-    };
-
-    while let Ok(Some(field)) = form_data.next_field().await {
-        let Some(field_name) = field.name() else {
-            continue;
-        };
-
-        if let Some(index) = channel_user
-            .intros
-            .iter()
-            .position(|intro| intro.index == field_name)
-        {
-            channel_user.intros.remove(index);
-        }
-    }
-
-    // TODO: don't save on every change
-    if let Err(err) = settings.save() {
-        error!("Failed to save config: {err:?}");
-    }
-
-    headers
-}
-
 pub(crate) async fn add_intro_to_user(
-    State(state): State<ApiState>,
+    State(state): State<Arc<ApiState>>,
     headers: HeaderMap,
     Path((guild, channel, intro_index)): Path<(u64, String, String)>,
 ) {
     let mut settings = state.settings.lock().await;
-    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else {
+    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else { return; };
-        return;
-    };
     let user = match settings.auth_users.get(token) {
         Some(user) => user.name.clone(),
         None => return,
     };
 
-    let Some(guild) = settings.guilds.get_mut(&guild) else {
+    let Some(guild) = settings.guilds.get_mut(&guild) else { return; };
-        return;
+    let Some(channel) = guild.channels.get_mut(&channel) else { return; };
-    };
+    let Some(user) = channel.users.get_mut(&user) else { return; };
-    let Some(channel) = guild.channels.get_mut(&channel) else {
-        return;
-    };
-    let Some(user) = channel.users.get_mut(&user) else {
-        return;
-    };
 
     if !user.intros.iter().any(|intro| intro.index == intro_index) {
         user.intros.push(IntroIndex {
@@ -448,28 +243,20 @@ pub(crate) async fn add_intro_to_user(
 }
 
 pub(crate) async fn remove_intro_to_user(
-    State(state): State<ApiState>,
+    State(state): State<Arc<ApiState>>,
     headers: HeaderMap,
     Path((guild, channel, intro_index)): Path<(u64, String, String)>,
 ) {
     let mut settings = state.settings.lock().await;
-    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else {
+    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else { return; };
-        return;
-    };
     let user = match settings.auth_users.get(token) {
         Some(user) => user.name.clone(),
         None => return,
     };
 
-    let Some(guild) = settings.guilds.get_mut(&guild) else {
+    let Some(guild) = settings.guilds.get_mut(&guild) else { return; };
-        return;
+    let Some(channel) = guild.channels.get_mut(&channel) else { return; };
-    };
+    let Some(user) = channel.users.get_mut(&user) else { return; };
-    let Some(channel) = guild.channels.get_mut(&channel) else {
-        return;
-    };
-    let Some(user) = channel.users.get_mut(&user) else {
-        return;
-    };
 
     if let Some(index) = user
         .intros
@@ -485,23 +272,22 @@ pub(crate) async fn remove_intro_to_user(
     }
 }
 
-pub(crate) async fn intros(State(state): State<ApiState>, Path(guild): Path<u64>) -> Json<Value> {
+pub(crate) async fn intros(
+    State(state): State<Arc<ApiState>>,
+    Path(guild): Path<u64>,
+) -> Json<Value> {
     let settings = state.settings.lock().await;
-    let Some(guild) = settings.guilds.get(&guild) else {
+    let Some(guild) = settings.guilds.get(&guild) else { return Json(json!(IntroResponse::NoGuildFound)); };
-        return Json(json!(IntroResponse::NoGuildFound));
-    };
 
     Json(json!(IntroResponse::Intros(&guild.intros)))
 }
 
 pub(crate) async fn me(
-    State(state): State<ApiState>,
+    State(state): State<Arc<ApiState>>,
     headers: HeaderMap,
 ) -> Result<Json<Value>, Error> {
     let mut settings = state.settings.lock().await;
-    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else {
+    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else { return Err(Error::NoUserFound); };
-        return Err(Error::NoUserFound);
-    };
 
     let (username, access_token) = match settings.auth_users.get(token) {
         Some(user) => (user.name.clone(), user.auth.access_token.clone()),
@@ -554,7 +340,7 @@ pub(crate) async fn me(
 }
 
 pub(crate) async fn upload_guild_intro(
-    State(state): State<ApiState>,
+    State(state): State<Arc<ApiState>>,
     Path(guild): Path<u64>,
     Query(mut params): Query<HashMap<String, String>>,
     headers: HeaderMap,
@@ -562,33 +348,23 @@ pub(crate) async fn upload_guild_intro(
 ) -> Result<(), Error> {
     let mut settings = state.settings.lock().await;
 
-    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else {
+    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else { return Err(Error::NoUserFound); };
-        return Err(Error::NoUserFound);
+    let Some(friendly_name) = params.remove("name") else { return Err(Error::InvalidRequest); };
-    };
-    let Some(friendly_name) = params.remove("name") else {
-        return Err(Error::InvalidRequest);
-    };
 
     {
-        let Some(guild) = settings.guilds.get(&guild) else {
+        let Some(guild) = settings.guilds.get(&guild) else { return Err(Error::NoGuildFound); };
-            return Err(Error::NoGuildFound);
-        };
         let auth_user = match settings.auth_users.get(token) {
             Some(user) => user,
             None => return Err(Error::NoUserFound),
         };
-        let Some(guild_user) = guild.users.get(&auth_user.name) else {
+        let Some(guild_user) = guild.users.get(&auth_user.name) else { return Err(Error::NoUserFound) };
-            return Err(Error::NoUserFound);
-        };
 
         if !guild_user.permissions.can(auth::Permission::UploadSounds) {
             return Err(Error::InvalidPermission);
         }
     }
 
-    let Some(guild) = settings.guilds.get_mut(&guild) else {
+    let Some(guild) = settings.guilds.get_mut(&guild) else { return Err(Error::NoGuildFound); };
-        return Err(Error::NoGuildFound);
-    };
     let uuid = Uuid::new_v4().to_string();
     let temp_path = format!("./sounds/temp/{uuid}");
     let dest_path = format!("./sounds/{uuid}.mp3");
@@ -610,43 +386,31 @@ pub(crate) async fn upload_guild_intro(
 }
 
 pub(crate) async fn add_guild_intro(
-    State(state): State<ApiState>,
+    State(state): State<Arc<ApiState>>,
     Path(guild): Path<u64>,
     Query(mut params): Query<HashMap<String, String>>,
     headers: HeaderMap,
 ) -> Result<(), Error> {
     let mut settings = state.settings.lock().await;
     // TODO: make this an impl on HeaderMap
-    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else {
+    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else { return Err(Error::NoUserFound); };
-        return Err(Error::NoUserFound);
+    let Some(url) = params.remove("url") else { return Err(Error::InvalidRequest); };
-    };
+    let Some(friendly_name) = params.remove("name") else { return Err(Error::InvalidRequest); };
-    let Some(url) = params.remove("url") else {
-        return Err(Error::InvalidRequest);
-    };
-    let Some(friendly_name) = params.remove("name") else {
-        return Err(Error::InvalidRequest);
-    };
 
     {
-        let Some(guild) = settings.guilds.get(&guild) else {
+        let Some(guild) = settings.guilds.get(&guild) else { return Err(Error::NoGuildFound); };
-            return Err(Error::NoGuildFound);
-        };
         let auth_user = match settings.auth_users.get(token) {
             Some(user) => user,
             None => return Err(Error::NoUserFound),
         };
-        let Some(guild_user) = guild.users.get(&auth_user.name) else {
+        let Some(guild_user) = guild.users.get(&auth_user.name) else { return Err(Error::NoUserFound) };
-            return Err(Error::NoUserFound);
-        };
 
         if !guild_user.permissions.can(auth::Permission::UploadSounds) {
             return Err(Error::InvalidPermission);
         }
     }
 
-    let Some(guild) = settings.guilds.get_mut(&guild) else {
+    let Some(guild) = settings.guilds.get_mut(&guild) else { return Err(Error::NoGuildFound); };
-        return Err(Error::NoGuildFound);
-    };
 
     let uuid = Uuid::new_v4().to_string();
     let child = tokio::process::Command::new("yt-dlp")
@@ -675,37 +439,29 @@ pub(crate) async fn add_guild_intro(
 }
 
 pub(crate) async fn delete_guild_intro(
-    State(state): State<ApiState>,
+    State(state): State<Arc<ApiState>>,
     Path(guild): Path<u64>,
     headers: HeaderMap,
     Json(body): Json<DeleteIntroRequest>,
 ) -> Result<(), Error> {
     let mut settings = state.settings.lock().await;
     // TODO: make this an impl on HeaderMap
-    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else {
+    let Some(token) = headers.get("token").and_then(|v| v.to_str().ok()) else { return Err(Error::NoUserFound); };
-        return Err(Error::NoUserFound);
-    };
 
     {
-        let Some(guild) = settings.guilds.get(&guild) else {
+        let Some(guild) = settings.guilds.get(&guild) else { return Err(Error::NoGuildFound); };
-            return Err(Error::NoGuildFound);
-        };
         let auth_user = match settings.auth_users.get(token) {
             Some(user) => user,
             None => return Err(Error::NoUserFound),
         };
-        let Some(guild_user) = guild.users.get(&auth_user.name) else {
+        let Some(guild_user) = guild.users.get(&auth_user.name) else { return Err(Error::NoUserFound) };
-            return Err(Error::NoUserFound);
-        };
 
         if !guild_user.permissions.can(auth::Permission::DeleteSounds) {
             return Err(Error::InvalidPermission);
         }
     }
 
-    let Some(guild) = settings.guilds.get_mut(&guild) else {
+    let Some(guild) = settings.guilds.get_mut(&guild) else { return Err(Error::NoGuildFound); };
-        return Err(Error::NoGuildFound);
-    };
 
     // Remove intro from any users
     for channel in guild.channels.iter_mut() {

src/settings.rs

@@ -1,8 +1,6 @@
 use std::{collections::HashMap, sync::Arc};
 
 use crate::auth;
-use axum::{async_trait, extract::FromRequestParts, http::request::Parts, response::Redirect};
-use axum_extra::extract::CookieJar;
 use serde::{Deserialize, Serialize};
 use serenity::prelude::TypeMapKey;
 use tracing::trace;
@@ -10,36 +8,12 @@ use uuid::Uuid;
 
 type UserToken = String;
 
-// TODO: make this is wrapped type so cloning isn't happening
-#[derive(Clone)]
 pub(crate) struct ApiState {
     pub settings: Arc<tokio::sync::Mutex<Settings>>,
     pub secrets: auth::DiscordSecret,
     pub origin: String,
 }
 
-#[async_trait]
-impl FromRequestParts<ApiState> for crate::auth::User {
-    type Rejection = Redirect;
-
-    async fn from_request_parts(
-        Parts { headers, .. }: &mut Parts,
-        state: &ApiState,
-    ) -> Result<Self, Self::Rejection> {
-        let jar = CookieJar::from_headers(&headers);
-
-        if let Some(token) = jar.get("access_token") {
-            match state.settings.lock().await.auth_users.get(token.value()) {
-                // :vomit:
-                Some(user) => Ok(user.clone()),
-                None => Err(Redirect::to("/login")),
-            }
-        } else {
-            Err(Redirect::to("/login"))
-        }
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct Settings {
@@ -96,25 +70,12 @@ pub(crate) struct GuildUser {
     pub(crate) permissions: auth::Permissions,
 }
 
-pub(crate) trait IntroFriendlyName {
-    fn friendly_name(&self) -> &str;
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub(crate) enum Intro {
     File(FileIntro),
     Online(OnlineIntro),
 }
 
-impl IntroFriendlyName for Intro {
-    fn friendly_name(&self) -> &str {
-        match self {
-            Self::File(intro) => intro.friendly_name(),
-            Self::Online(intro) => intro.friendly_name(),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct FileIntro {
@@ -122,12 +83,6 @@ pub(crate) struct FileIntro {
     pub(crate) friendly_name: String,
 }
 
-impl IntroFriendlyName for FileIntro {
-    fn friendly_name(&self) -> &str {
-        &self.friendly_name
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct OnlineIntro {
@@ -135,12 +90,6 @@ pub(crate) struct OnlineIntro {
     pub(crate) friendly_name: String,
 }
 
-impl IntroFriendlyName for OnlineIntro {
-    fn friendly_name(&self) -> &str {
-        &self.friendly_name
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct ChannelSettings {