feat: verify ui

Author: JayDwee

api/src/dynamo.rs

@@ -30,6 +30,17 @@ pub fn _as_i32(val: Option<&AttributeValue>, default: i32) -> i32 {
     default
 }
 
+pub fn as_u32(val: Option<&AttributeValue>, default: u32) -> u32 {
+    if let Some(v) = val {
+        if let Ok(n) = v.as_n() {
+            if let Ok(n) = n.parse::<u32>() {
+                return n;
+            }
+        }
+    }
+    default
+}
+
 pub fn as_u64(val: Option<&AttributeValue>, default: u64) -> u64 {
     if let Some(v) = val {
         if let Ok(n) = v.as_n() {
@@ -50,13 +61,6 @@ pub fn as_string_vec(val: Option<&AttributeValue>) -> Vec<String> {
                 .collect();
         }
     }
-    // val
-    //         .map(|v| v.as_l())
-    //         .unwrap_or_else(|| Ok(&Vec::<AttributeValue>::new()))
-    //         .unwrap_or_else(|_| &Vec::<AttributeValue>::new())
-    //         .iter()
-    //         .map(|v| as_string(Some(v), &"".to_string()))
-    //         .collect();
     vec![]
 }
 

api/src/guilds/mod.rs

@@ -1,6 +1,6 @@
-use std::collections::HashMap;
+use std::collections::{HashSet};
 use crate::AppState;
-use crate::guilds::models::{Guild, Verify};
+use crate::guilds::models::{Guild, VerifyRole};
 use axum::extract::State;
 use axum::{Extension, Json, Router, extract::Path, routing::get};
 use http::StatusCode;
@@ -14,6 +14,7 @@ use twilight_model::guild::Permissions;
 use twilight_model::id::Id;
 use twilight_model::id::marker::GuildMarker;
 use twilight_model::user::CurrentUser;
+use crate::guilds::tasks::{add_role_to_guild, remove_role_from_guild};
 use crate::utils::{admin_guilds, is_client_admin_guild, ise};
 
 pub mod models;
@@ -66,14 +67,14 @@ async fn post_guilds(
             ..Default::default()
         })
     }
-    
-    for i in 0..guilds.len() {
-        let guild_dsc = app_state.discord_bot.guild(guilds[i].guild_id).await.map_err(ise)?.model().await.map_err(ise)?;
-        guilds[i].name = guild_dsc.name;
-        guilds[i].icon = guild_dsc.icon;
-        guilds[i].save(&app_state.dynamo).await;
+
+    for guild in &mut guilds {
+        let guild_dsc = app_state.discord_bot.guild(guild.guild_id).await.map_err(ise)?.model().await.map_err(ise)?;
+        guild.name = guild_dsc.name;
+        guild.icon = guild_dsc.icon;
+        guild.save(&app_state.dynamo).await;
     }
-    
+
     Ok(Json(json!(guilds)))
 }
 
@@ -134,10 +135,7 @@ async fn get_guilds_id(
             let guild = app_state.discord_bot.guild(guild_id).await.unwrap().model().await.unwrap();
             let new_guild = Guild {
                 guild_id,
-                verify: Verify { roles: vec![], user_links: vec![] },
-                name: guild.name,
-                icon: guild.icon,
-                user_links: HashMap::new()
+                ..Default::default()
             };
             new_guild.save(&app_state.dynamo).await;
             new_guild
@@ -147,15 +145,33 @@ async fn get_guilds_id(
 
 async fn put_guilds_id(
     Path(guild_id): Path<Id<GuildMarker>>,
-    Extension(discord_user): Extension<Arc<twilight_http::Client>>,
+    Extension(current_user): Extension<CurrentUser>,
     State(app_state): State<AppState>,
-    Json(guild_req): Json<models::Guild>,
+    Json(guild_req): Json<Guild>,
 ) -> Result<Json<Value>, StatusCode> {
-    if !utils::is_intersect_admin_guild(guild_id, &discord_user, &app_state.discord_bot).await.map_err(crate::utils::ise)? {
-        warn!("User is not an admin in guild {}", guild_id);
-        return Err(StatusCode::NOT_FOUND);
+    if !is_client_admin_guild(guild_id, &current_user, &app_state.discord_bot).await? {
+        return Err(StatusCode::UNAUTHORIZED);
+    }
+
+    let mut old_guild = match Guild::from_db(guild_id, &app_state.dynamo).await {
+        Some(g) => g,
+        None => return Err(StatusCode::NOT_FOUND),
+    };
+
+    let old_set: HashSet<VerifyRole> = HashSet::from_iter(old_guild.verify.roles.clone());
+    let new_set: HashSet<VerifyRole> = HashSet::from_iter(guild_req.verify.roles);
+
+    let add_roles: HashSet<VerifyRole> = new_set.difference(&old_set).cloned().collect();
+    let remove_roles: HashSet<VerifyRole> = old_set.difference(&new_set).cloned().collect();
+
+    for role in add_roles {
+        add_role_to_guild(&mut old_guild, role, &app_state.discord_bot).await;
+    }
+
+    for role in remove_roles {
+        remove_role_from_guild(&mut old_guild, role.role_id, &app_state.discord_bot).await;
     }
 
-    guild_req.save(&app_state.dynamo).await;
-    Ok(Json(json!(guild_req)))
+    old_guild.save(&app_state.dynamo).await;
+    Ok(Json(json!(old_guild)))
 }

api/src/guilds/models.rs

@@ -1,22 +1,30 @@
-use crate::dynamo::{as_map, as_map_vec, as_string, as_string_opt};
+use crate::dynamo::{as_u32, as_map, as_map_vec, as_string, as_string_opt};
 use aws_sdk_dynamodb::types::{AttributeValue, KeysAndAttributes};
 use http::StatusCode;
 use lambda_http::tracing::error;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use std::hash::Hash;
 use twilight_model::id::Id;
 use twilight_model::id::marker::{GuildMarker, RoleMarker, UserMarker};
 use twilight_model::util::ImageHash;
 use crate::users::models::Link;
 
-#[derive(Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct VerifyRole {
     pub role_id: Id<RoleMarker>,
     pub role_name: Option<String>,
     pub pattern: String,
     pub members: u32,
 }
 
+impl Hash for VerifyRole {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.role_id.hash(state);
+        self.pattern.hash(state);
+    }
+}
+
 impl From<&HashMap<String, AttributeValue>> for VerifyRole {
     fn from(item: &HashMap<String, AttributeValue>) -> Self {
         VerifyRole {
@@ -27,9 +35,7 @@ impl From<&HashMap<String, AttributeValue>> for VerifyRole {
             ),
             role_name: as_string_opt(item.get("role_name")),
             pattern: as_string(item.get("pattern"), &"".to_string()),
-            members: as_string(item.get("members"), &"0".to_string())
-                .parse::<u32>()
-                .unwrap_or(0),
+            members: as_u32(item.get("members"), 0),
         }
     }
 }
@@ -78,20 +84,20 @@ impl From<UserLink> for HashMap<String, AttributeValue> {
 #[derive(Clone, Serialize, Deserialize, PartialEq)]
 pub struct Verify {
     pub roles: Vec<VerifyRole>,
-    pub user_links: Vec<UserLink>
+    pub user_links: HashMap<Id<UserMarker>, Vec<Link>>,
 }
 
 impl From<&HashMap<String, AttributeValue>> for Verify {
     fn from(item: &HashMap<String, AttributeValue>) -> Self {
-        let roles = as_map_vec(item.get("roles"))
+        Verify {
+        roles: as_map_vec(item.get("roles"))
             .into_iter()
             .map(|m| m.into())
-            .collect();
-        let user_links = as_map_vec(item.get("user_links"))
-            .into_iter()
-            .map(|m| m.into())
-            .collect();
-        Verify { roles, user_links }
+            .collect(),
+        user_links: as_map(item.get("user_links")).unwrap_or(&HashMap::new()).iter().map(
+            |(k,v)| (Id::new(k.parse::<u64>().unwrap_or(0)), as_map_vec(Some(v)).iter().map(|&l| l.into()).collect()))
+            .collect()
+        }
     }
 }
 
@@ -100,8 +106,11 @@ impl From<Verify> for HashMap<String, AttributeValue> {
         let mut verify_map = HashMap::new();
         let roles: Vec<AttributeValue> = verify.roles.into_iter().map(|r| AttributeValue::M(r.into())).collect();
         verify_map.insert("roles".to_string(), AttributeValue::L(roles));
-        let user_links: Vec<AttributeValue> = verify.user_links.into_iter().map(|ul| AttributeValue::M(ul.into())).collect();
-        verify_map.insert("user_links".to_string(), AttributeValue::L(user_links));
+
+        verify_map.insert("user_links".to_string(), AttributeValue::M(verify.user_links.iter().map(
+            |(k,v)| (k.to_string(), AttributeValue::L(v.iter().map(|l| AttributeValue::M(l.clone().into())).collect()))
+        ).collect()));
+
         verify_map
     }
 }
@@ -112,17 +121,15 @@ pub struct Guild {
     pub verify: Verify,
     pub name: String,
     pub icon: Option<ImageHash>,
-    pub user_links: HashMap<Id<UserMarker>, Vec<Link>>,
 }
 
 impl Default for Guild {
     fn default() -> Self {
         Guild {
             guild_id: Id::new(1),
-            verify: Verify { roles: vec![], user_links: vec![] },
+            verify: Verify { roles: vec![], user_links: HashMap::new() },
             name: "".to_string(),
             icon: None,
-            user_links: HashMap::new(),
         }
     }
 }
@@ -137,9 +144,6 @@ impl From<&HashMap<String, AttributeValue>> for Guild {
             verify: as_map(item.get("verify")).unwrap().into(),
             name: as_string(item.get("name"), &"".to_string()),
             icon: as_string_opt(item.get("icon")).and_then(|s| ImageHash::parse(s.as_bytes()).ok()),
-            user_links: as_map(item.get("user_links")).unwrap_or(&HashMap::new()).iter().map(
-                |(k,v)| (Id::new(k.parse::<u64>().unwrap_or(0)), as_map_vec(Some(v)).iter().map(|&l| l.into()).collect()))
-                .collect(),
         }
     }
 }

api/src/guilds/tasks.rs

@@ -1,6 +1,6 @@
-use std::collections::HashMap;
-use crate::guilds::models::Guild;
-use crate::utils::retry_on_rl;
+use http::StatusCode;
+use crate::guilds::models::{Guild, VerifyRole};
+use crate::utils::{ise, retry_on_rl};
 use lambda_http::tracing::info;
 use regex::Regex;
 use twilight_model::id::Id;
@@ -37,10 +37,9 @@ pub async fn update_guilds(bot: &twilight_http::Client, dynamo: &aws_sdk_dynamod
         if !found {
             let new_guild = Guild {
                 guild_id: d_guild.id,
-                verify: crate::guilds::models::Verify { roles: vec![], user_links: vec![] },
                 name: d_guild.name.clone(),
                 icon: d_guild.icon,
-                user_links: HashMap::new(),
+                ..Default::default()
             };
             new_guild.save(dynamo).await;
         }
@@ -68,57 +67,69 @@ async fn remove_role_user(
         .await;
 }
 
-pub async fn assign_roles_guild_role(
-    guild_id: Id<GuildMarker>,
+pub async fn remove_role_from_guild(
+    guild: &mut Guild,
     role_id: Id<RoleMarker>,
     bot: &twilight_http::Client,
-    dynamo: &aws_sdk_dynamodb::Client,
 ) {
-    let guild = Guild::from_db(guild_id, dynamo).await.unwrap();
-    let user_links = &guild.verify.user_links;
-    let roles = &guild.verify.roles;
-    let role = roles.iter().find(|r| r.role_id == role_id);
-    if role.is_none() {
+    if !guild.verify.roles.iter().any(|r| r.role_id == role_id) {
         return;
     }
-    for user_link in user_links {
-        if Regex::new(&role.unwrap().pattern)
-            .unwrap()
-            .is_match(&user_link.link_address)
-        {
-            assign_role_user(guild_id, user_link.user_id, role.unwrap().role_id, bot).await;
+    for (&user_id, user_links) in &mut guild.verify.user_links {
+        remove_role_user(guild.guild_id, user_id, role_id, bot).await;
+    }
+    guild.verify.roles.retain(|r| r.role_id != role_id);
+}
+
+pub async fn add_role_to_guild(
+    guild: &mut Guild,
+    mut role: VerifyRole,
+    bot: &twilight_http::Client
+){
+    remove_role_from_guild(guild, role.role_id, bot).await;
+    for (&user_id, user_links) in &mut guild.verify.user_links {
+        for user_link in user_links {
+            if Regex::new(&role.pattern)
+                .unwrap()
+                .is_match(&*user_link.link_address)
+            {
+                assign_role_user(guild.guild_id, user_id, role.role_id, bot).await;
+                role.members += 1;
+                break;
+            }
         }
     }
+    guild.verify.roles.push(role);
 }
 
 pub async fn assign_roles_guild_user_link(
+    enabled: bool,
     link_address: &str,
     user_id: Id<UserMarker>,
-    guild: &Guild,
+    guild: &mut Guild,
     bot: &twilight_http::Client,
-) {
-    let roles = &guild.verify.roles;
-    for role in roles {
-        if Regex::new(&role.pattern)
+) -> Result<(), StatusCode> {
+    let roles = &mut guild.verify.roles;
+    for i in 0..roles.len() {
+        let role = roles.get_mut(i).unwrap();
+        let has_dsc_role = retry_on_rl(|| async { bot.guild_member(guild.guild_id, user_id).await}).await.map_err(ise)?.model().await.map_err(ise)?.roles.contains(&role.role_id);
+        if enabled && Regex::new(&role.pattern)
             .unwrap()
             .is_match(link_address)
         {
-            assign_role_user(guild.guild_id, user_id, role.role_id, bot).await;
-        } else {
-            remove_role_user(guild.guild_id, user_id, role.role_id, bot).await;
+            info!("Assigning role {} to user {}", role.role_id, user_id);
+            if !has_dsc_role {
+                assign_role_user(guild.guild_id, user_id, role.role_id, bot).await;
+                role.members += 1;
+            }
+            } else {
+            info!("Removing role {} from user {}", role.role_id, user_id);
+            if has_dsc_role {
+                remove_role_user(guild.guild_id, user_id, role.role_id, bot).await;
+                role.members -= 1;
+            }
         }
     }
+    Ok(())
 }
 
-pub async fn assign_all_roles_user_guild(
-    user_id: Id<UserMarker>,
-    guild: &Guild,
-    bot: &twilight_http::Client,
-) {
-    let user_links = &guild.verify.user_links;
-    for user_link in user_links {
-        if user_link.user_id == user_id {
-            assign_roles_guild_user_link(&user_link.link_address, user_id, guild, bot).await;
-        }
-    }
-}

api/src/users/links.rs

@@ -86,17 +86,15 @@ async fn post_link(
         .links
         .retain(|l| l.link_address != new_link.link_address);
     for link_guild in &user_model.link_guilds {
-        if !link_guild.enabled {
-            continue;
-        }
-        let guild = Guild::from_db(link_guild.guild_id, &app_state.dynamo).await.unwrap();
+        let mut guild = Guild::from_db(link_guild.guild_id, &app_state.dynamo).await.unwrap();
         crate::guilds::tasks::assign_roles_guild_user_link(
+            link_guild.enabled,
             &new_link.link_address,
             user_id,
-            &guild,
+            &mut guild,
             &app_state.discord_bot,
         )
-        .await;
+        .await?;
     }
     user_model.links.push(new_link);
     user_model.save(&app_state.dynamo).await;