feat: make configurations optional

Cargo.lock

@@ -1172,9 +1172,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "poise"
-version = "0.5.2"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ca787e4e516076de1995a83ee05fbdfed71d072ea0da3df018318db42a87803"
+checksum = "6d591af1c934c29adda172665f69b837e642d4fee85598baffb95dd98110467d"
 dependencies = [
  "async-trait",
  "derivative",
@@ -1191,9 +1191,9 @@ dependencies = [
 
 [[package]]
 name = "poise_macros"
-version = "0.5.2"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b80c1f4e04114527f9d41ed6bb31707a095276f51bb0aef3ca11f062b25a67c4"
+checksum = "40270099e1527efae99fdc0609d397e76310b529d4980ad38ab14d81803ca0fa"
 dependencies = [
  "darling 0.14.4",
  "proc-macro2",
@@ -1358,7 +1358,7 @@ dependencies = [
 
 [[package]]
 name = "revanced-discord-bot"
-version = "2.3.1"
+version = "2.4.2"
 dependencies = [
  "base64 0.21.0",
  "bson",

Cargo.toml

@@ -1,11 +1,11 @@
 [package]
-authors = ["oSumAtrIX"]
+authors = ["ReVanced"]
 description = "The official Discord bot assisting the ReVanced Discord server."
 homepage = "https://revanced.app"
 license = "GPL-3.0"
 name = "revanced-discord-bot"
 repository = "https://github.com/revanced/revanced-discord-bot"
-version = "2.3.1"
+version = "2.4.2"
 edition = "2021"
 
 [profile.release]

src/model/application.rs

@@ -89,9 +89,9 @@ pub struct Introduction {
 
 #[derive(Serialize, Deserialize)]
 pub struct MessageResponse {
-    pub includes: Includes,
+    pub includes: Option<Includes>,
-    pub excludes: Excludes,
+    pub excludes: Option<Excludes>,
-    pub condition: Condition,
+    pub condition: Option<Condition>,
     pub response: Response,
 }
 
@@ -145,14 +145,14 @@ pub struct Author {
 
 #[derive(Serialize, Deserialize)]
 pub struct Includes {
-    pub channels: Vec<u64>,
+    pub channels: Option<Vec<u64>>,
     #[serde(rename = "match", with = "serde_regex")]
     pub match_field: Vec<Regex>,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct Excludes {
-    pub roles: Vec<u64>,
+    pub roles: Option<Vec<u64>>,
     #[serde(rename = "match", with = "serde_regex")]
     pub match_field: Vec<Regex>,
 }

src/utils/autorespond.rs

@@ -19,92 +19,96 @@ pub async fn auto_respond(ctx: &serenity::Context, new_message: &serenity::Messa
     let message = &new_message.content;
 
     for response in responses {
-        // check if the message was sent in a channel that is included in the responder
+        tracing::log::trace!("d");
-        if !response
+        // check if the channel is whitelisted
-            .includes
+        if let Some(includes) = &response.includes {
-            .channels
+            if let Some(channels) = &includes.channels {
-            .iter()
+                if !channels.contains(&new_message.channel_id.0) {
-            .any(|&channel_id| channel_id == new_message.channel_id.0)
+                    continue;
-        {
+                }
-            continue;
-        }
-
-        // check if the message was sent by a user that is not excluded from the responder
-        let excludes = &response.excludes;
-        let member_roles = &new_message.member.as_ref().unwrap().roles;
-        if excludes.roles.iter().any(|&role_id| {
-            member_roles
-                .iter()
-                .any(|&member_role| role_id == member_role.0)
-        }) {
-            continue;
-        }
-
-        // check if the message does not match any of the excludes
-        if contains_match(&excludes.match_field, message) {
-            continue;
-        }
-
-        // check if the message does match any of the includes
-        if !(contains_match(&response.includes.match_field, message)) {
-            continue;
-        }
-
-        let min_age = response.condition.user.server_age;
-
-        if min_age != 0 {
-            let joined_at = ctx
-                .http
-                .get_member(new_message.guild_id.unwrap().0, new_message.author.id.0)
-                .await
-                .unwrap()
-                .joined_at
-                .unwrap()
-                .unix_timestamp();
-
-            let must_joined_at = DateTime::<Utc>::from_utc(
-                NaiveDateTime::from_timestamp_opt(joined_at, 0).unwrap(),
-                Utc,
-            );
-            let but_joined_at = Utc::now() - Duration::days(min_age);
-
-            if must_joined_at <= but_joined_at {
-                return;
             }
 
-            if let Err(err) = new_message
+            // check if message matches regex
-                .channel_id
+            if !contains_match(&includes.match_field, message) {
-                .send_message(&ctx.http, |m| {
+                tracing::log::trace!("Message does not match regex");
-                    m.reference_message(new_message);
+                continue;
-                    match &response.response.embed {
+            }
-                        Some(embed) => m.embed(|e| {
+        }
-                            e.title(&embed.title)
+
-                                .description(&embed.description)
+        if let Some(excludes) = &response.excludes {
-                                .color(embed.color)
+            // check if the role is blacklisted
-                                .fields(embed.fields.iter().map(|field| {
+            if let Some(roles) = &excludes.roles {
-                                    (field.name.clone(), field.value.clone(), field.inline)
+                let member_roles = &new_message.member.as_ref().unwrap().roles;
-                                }))
+                if roles.iter().any(|&role_id| {
-                                .footer(|f| {
+                    member_roles
-                                    f.text(&embed.footer.text);
+                        .iter()
-                                    f.icon_url(&embed.footer.icon_url)
+                        .any(|&member_role| role_id == member_role.0)
-                                })
+                }) {
-                                .thumbnail(&embed.thumbnail.url)
+                    continue;
-                                .image(&embed.image.url)
+                }
-                                .author(|a| {
+            }
-                                    a.name(&embed.author.name).icon_url(&embed.author.icon_url)
+
-                                })
+            // check if the message is not blacklisted
-                        }),
+            if contains_match(&excludes.match_field, message) {
-                        None => m.content(response.response.message.as_ref().unwrap()),
+                continue;
-                    }
+            }
-                })
+        }
-                .await
+
-            {
+        if let Some(condition) = &response.condition {
-                error!(
+            let min_age = condition.user.server_age;
-                    "Failed to reply to the message from {}. Error: {:?}",
+
-                    new_message.author.tag(),
+            if min_age != 0 {
-                    err
+                let joined_at = ctx
+                    .http
+                    .get_member(new_message.guild_id.unwrap().0, new_message.author.id.0)
+                    .await
+                    .unwrap()
+                    .joined_at
+                    .unwrap()
+                    .unix_timestamp();
+
+                let must_joined_at = DateTime::<Utc>::from_utc(
+                    NaiveDateTime::from_timestamp_opt(joined_at, 0).unwrap(),
+                    Utc,
                 );
+                let but_joined_at = Utc::now() - Duration::days(min_age);
+
+                if must_joined_at <= but_joined_at {
+                    continue;
+                }
             }
         }
+
+        if let Err(err) = new_message
+            .channel_id
+            .send_message(&ctx.http, |m| {
+                m.reference_message(new_message);
+                match &response.response.embed {
+                    Some(embed) => m.embed(|e| {
+                        e.title(&embed.title)
+                            .description(&embed.description)
+                            .color(embed.color)
+                            .fields(embed.fields.iter().map(|field| {
+                                (field.name.clone(), field.value.clone(), field.inline)
+                            }))
+                            .footer(|f| {
+                                f.text(&embed.footer.text);
+                                f.icon_url(&embed.footer.icon_url)
+                            })
+                            .thumbnail(&embed.thumbnail.url)
+                            .image(&embed.image.url)
+                            .author(|a| a.name(&embed.author.name).icon_url(&embed.author.icon_url))
+                    }),
+                    None => m.content(response.response.message.as_ref().unwrap()),
+                }
+            })
+            .await
+        {
+            error!(
+                "Failed to reply to the message from {}. Error: {:?}",
+                new_message.author.tag(),
+                err
+            );
+        }
     }
 }