chore: improved vote & login

Author: JayDwee

api/src/guilds/votes/controllers.rs

@@ -53,7 +53,8 @@ struct CreateVoteDto {
     channel_id: Id<ChannelMarker>,
     close_at: Option<DateTime<Utc>>,
     role_list: HashSet<Id<RoleMarker>>,
-    role_list_type: RoleListType
+    role_list_type: RoleListType,
+    is_multi_select: bool,
 }
 
 async fn post_votes(
@@ -84,7 +85,8 @@ async fn post_votes(
         close_at: vote_req.close_at,
         open: true,
         role_list: vote_req.role_list,
-        role_list_type: vote_req.role_list_type
+        role_list_type: vote_req.role_list_type,
+        is_multi_select: vote_req.is_multi_select,
     };
     guild.vote.votes.push(new_vote.clone());
     guild.save(&app_state.dynamo).await;
@@ -163,7 +165,8 @@ async fn post_votes_id_close(
     guild.save(&app_state.dynamo).await;
 
     let vote: &VoteVote = guild.vote.votes.iter().find(|v| v.message_id == message_id).unwrap();
-    let _message = update_message(vote.channel_id, vote.message_id, None, Some(Some(group_to_rows(vote.options.iter().map(|o| {
+    let _message = update_message(vote.channel_id, vote.message_id, Some(Some(&format!("# [CLOSED] {}\n{}\n", vote.title, vote.description))), 
+                                  Some(Some(group_to_rows(vote.options.iter().map(|o| {
         let mut c = o.to_component();
         match c {
             Component::Button(ref mut b) => b.disabled = true,

api/src/guilds/votes/interactions.rs

@@ -1,15 +1,14 @@
 use std::default::Default;
 use axum::Json;
 use http::StatusCode;
-use lambda_http::tracing::info;
 use serde_json::{json, Value};
 use twilight_model::application::interaction::{Interaction, InteractionData};
 use twilight_model::channel::message::MessageFlags;
 use twilight_model::guild::PartialMember;
 use twilight_model::http::interaction::{InteractionResponse, InteractionResponseData, InteractionResponseType};
 use crate::AppState;
 use crate::guilds::models::Guild;
-use crate::guilds::votes::models::{RoleListType, VoteOption, VoteVote};
+use crate::guilds::votes::models::{RoleListType, VoteVote};
 use crate::guilds::votes::utils::VoteOptionComponent;
 
 pub(crate) async fn handle_component_interaction(
@@ -31,16 +30,14 @@ pub(crate) async fn handle_component_interaction(
     let user_id = user.unwrap().id;
 
     let mut guild = Guild::from_db(guild_id.unwrap(), &app_state.dynamo).await.unwrap();
-    info!("guild retreived");
 
-    let VoteVote { options, role_list, role_list_type, .. } = match guild.vote.votes.iter_mut().find(|v| v.message_id == message_id) {
+    let VoteVote { options, role_list, role_list_type,
+        is_multi_select, .. } = match guild.vote.votes.iter_mut().find(|v| v.message_id == message_id) {
         Some(v) => v,
         None => return Err(StatusCode::NOT_FOUND),
     };
-    info!("debug 1");
 
     let role_in_role_list = roles.iter().any(|r| role_list.contains(r));
-    info!("debug 2");
 
     let allowed = match role_list_type {
         RoleListType::BLACKLIST => {
@@ -50,7 +47,6 @@ pub(crate) async fn handle_component_interaction(
             role_in_role_list
         }
     };
-    info!("debug 3");
     if !allowed {
         return Ok(Json(json!(
             InteractionResponse {
@@ -63,31 +59,24 @@ pub(crate) async fn handle_component_interaction(
             }
         )));
     }
-    info!("debug 4");
+    let mut responses = vec![];
 
-    let VoteOption { users, label, .. } = options.iter_mut().find(|o| o.custom_id() == data.custom_id).unwrap();
-    let exists = users.iter().any(|&u| u == user_id);
-    if exists {
-        // Already voted, need to remove.
-        users.retain(|&u| u != user_id);
-
-    } else {
-        users.insert(user_id);
+    for o in options.iter_mut() {
+        if o.users.contains(&user_id) && (data.custom_id == o.custom_id() || !*is_multi_select)  {
+            o.users.remove(&user_id);
+            responses.push(format!("You have removed your vote for {o}."));
+        } else if !o.users.contains(&user_id) && data.custom_id == o.custom_id() {
+            o.users.insert(user_id);
+            responses.push(format!("You have added a vote for {o}."));
+        }
     }
-    let label = label.as_ref().unwrap();
-    let content = Some(if exists {
-        format!("You have removed your vote for {:?}.", label).to_string()
-    } else {
-        format!("You have voted for {:?}.", label).to_string()
-    });
-    info!("guild about to be saved");
     guild.save(&app_state.dynamo).await;
 
     Ok(Json(json!(
         InteractionResponse {
             kind: InteractionResponseType::ChannelMessageWithSource,
             data: Some(InteractionResponseData {
-                content,
+                content: Some(responses.join("\n")),
                 flags: Some(MessageFlags::EPHEMERAL),
                 ..Default::default()
             }),

api/src/guilds/votes/models.rs

@@ -16,6 +16,12 @@ pub struct VoteOption {
     pub users: HashSet<Id<UserMarker>>
 }
 
+impl Display for VoteOption {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.label.as_ref().unwrap())
+    }
+}
+
 impl From<&HashMap<String, AttributeValue>> for VoteOption {
     fn from(item: &HashMap<String, AttributeValue>) -> Self {
         VoteOption {
@@ -59,6 +65,8 @@ impl Display for RoleListType {
     }
 }
 
+fn default_multi_select() -> bool {true}
+
 #[derive(Clone, Serialize, Deserialize, PartialEq)]
 pub struct VoteVote {
     pub message_id: Id<MessageMarker>,
@@ -69,7 +77,9 @@ pub struct VoteVote {
     pub close_at: Option<DateTime<Utc>>,
     pub open: bool,
     pub role_list: HashSet<Id<RoleMarker>>,
-    pub role_list_type: RoleListType
+    pub role_list_type: RoleListType,
+    #[serde(default="default_multi_select")]
+    pub is_multi_select: bool
 }
 
 impl From<&HashMap<String, AttributeValue>> for VoteVote {
@@ -84,6 +94,7 @@ impl From<&HashMap<String, AttributeValue>> for VoteVote {
             open: as_bool(item.get("open"), false),
             role_list: as_u64_set(item.get("role_list")).into_iter().map(|s| Id::new(s)).collect(),
             role_list_type: as_string_opt(item.get("role_list_type")).filter(|v| !v.is_empty()).and_then(|v| serde_json::from_str(&*v).unwrap()).unwrap_or_default(),
+            is_multi_select: as_bool(item.get("is_multi_select"), false),
         }
     }
 }
@@ -100,6 +111,7 @@ impl From<VoteVote> for HashMap<String, AttributeValue> {
         item.insert("open".to_string(), AttributeValue::Bool(vote.open));
         item.insert("role_list".to_string(), AttributeValue::L(vote.role_list.iter().map(|u| AttributeValue::N(u.to_string())).collect()));
         item.insert("role_list_type".to_string(), AttributeValue::S(serde_json::to_string(&vote.role_list_type).unwrap()));
+        item.insert("is_multi_select".to_string(), AttributeValue::Bool(vote.is_multi_select));
         item
     }
 }

api/src/main.rs

@@ -6,7 +6,6 @@ use lambda_http::{run, tracing, Error};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use std::sync::Arc;
-use lambda_http::tracing::info;
 use tower_http::cors::CorsLayer;
 
 mod dynamo;