interactions to delete a newly created reminder

src/models/reminder.rs

@@ -11,6 +11,9 @@ use crate::{
 };
 
 use num_integer::Integer;
+use ring::hmac;
+use std::convert::{TryFrom, TryInto};
+use std::env;
 
 fn longhand_displacement(seconds: u64) -> String {
     let (days, seconds) = seconds.div_rem(&DAY);
@@ -31,13 +34,14 @@ fn longhand_displacement(seconds: u64) -> String {
     sections.join(", ")
 }
 
+#[derive(Debug)]
 pub struct Reminder {
     pub id: u32,
     pub uid: String,
     pub channel: u64,
     pub utc_time: NaiveDateTime,
     pub interval: Option<u32>,
-    pub expires: NaiveDateTime,
+    pub expires: Option<NaiveDateTime>,
     pub enabled: bool,
     pub content: String,
     pub embed_description: String,
@@ -45,6 +49,80 @@ pub struct Reminder {
 }
 
 impl Reminder {
+    pub async fn from_uid(ctx: &Context, uid: String) -> Option<Self> {
+        let pool = ctx.data.read().await.get::<SQLPool>().cloned().unwrap();
+
+        sqlx::query_as_unchecked!(
+            Self,
+            "
+SELECT
+    reminders.id,
+    reminders.uid,
+    channels.channel,
+    reminders.utc_time,
+    reminders.interval,
+    reminders.expires,
+    reminders.enabled,
+    reminders.content,
+    reminders.embed_description,
+    users.user AS set_by
+FROM
+    reminders
+INNER JOIN
+    channels
+ON
+    reminders.channel_id = channels.id
+LEFT JOIN
+    users
+ON
+    reminders.set_by = users.id
+WHERE
+    reminders.uid = ?
+            ",
+            uid
+        )
+        .fetch_one(&pool)
+        .await
+        .ok()
+    }
+
+    pub async fn from_id(ctx: &Context, id: u32) -> Option<Self> {
+        let pool = ctx.data.read().await.get::<SQLPool>().cloned().unwrap();
+
+        sqlx::query_as_unchecked!(
+            Self,
+            "
+SELECT
+    reminders.id,
+    reminders.uid,
+    channels.channel,
+    reminders.utc_time,
+    reminders.interval,
+    reminders.expires,
+    reminders.enabled,
+    reminders.content,
+    reminders.embed_description,
+    users.user AS set_by
+FROM
+    reminders
+INNER JOIN
+    channels
+ON
+    reminders.channel_id = channels.id
+LEFT JOIN
+    users
+ON
+    reminders.set_by = users.id
+WHERE
+    reminders.id = ?
+            ",
+            id
+        )
+        .fetch_one(&pool)
+        .await
+        .ok()
+    }
+
     pub async fn from_channel<C: Into<ChannelId>>(
         ctx: &Context,
         channel_id: C,
@@ -249,6 +327,127 @@ WHERE
             )
         }
     }
+
+    pub async fn from_interaction<U: Into<u64>>(
+        ctx: &Context,
+        member_id: U,
+        payload: String,
+    ) -> Result<(Self, ReminderAction), InteractionError> {
+        let sections = payload.split(".").collect::<Vec<&str>>();
+
+        if sections.len() != 3 {
+            Err(InteractionError::InvalidFormat)
+        } else {
+            let action = ReminderAction::try_from(sections[0])
+                .map_err(|_| InteractionError::InvalidAction)?;
+
+            let reminder_id = u32::from_le_bytes(
+                base64::decode(sections[1])
+                    .map_err(|_| InteractionError::InvalidBase64)?
+                    .try_into()
+                    .map_err(|_| InteractionError::InvalidSize)?,
+            );
+
+            if let Some(reminder) = Self::from_id(ctx, reminder_id).await {
+                if reminder.signed_action(member_id, action) == payload {
+                    Ok((reminder, action))
+                } else {
+                    Err(InteractionError::SignatureMismatch)
+                }
+            } else {
+                Err(InteractionError::NoReminder)
+            }
+        }
+    }
+
+    pub fn signed_action<U: Into<u64>>(&self, member_id: U, action: ReminderAction) -> String {
+        let s_key = hmac::Key::new(
+            hmac::HMAC_SHA256,
+            env::var("SECRET_KEY")
+                .expect("No SECRET_KEY provided")
+                .as_bytes(),
+        );
+
+        let mut context = hmac::Context::with_key(&s_key);
+
+        context.update(&self.id.to_le_bytes());
+        context.update(&member_id.into().to_le_bytes());
+
+        let signature = context.sign();
+
+        format!(
+            "{}.{}.{}",
+            action.to_string(),
+            base64::encode(self.id.to_le_bytes()),
+            base64::encode(&signature)
+        )
+    }
+
+    pub async fn delete(&self, ctx: &Context) {
+        let pool = ctx.data.read().await.get::<SQLPool>().cloned().unwrap();
+
+        sqlx::query!(
+            "
+DELETE FROM reminders WHERE id = ?
+            ",
+            self.id
+        )
+        .execute(&pool)
+        .await
+        .unwrap();
+    }
+}
+
+#[derive(Debug)]
+pub enum InteractionError {
+    InvalidFormat,
+    InvalidBase64,
+    InvalidSize,
+    NoReminder,
+    SignatureMismatch,
+    InvalidAction,
+}
+
+impl ToString for InteractionError {
+    fn to_string(&self) -> String {
+        match self {
+            InteractionError::InvalidFormat => {
+                String::from("The interaction data was improperly formatted")
+            }
+            InteractionError::InvalidBase64 => String::from("The interaction data was invalid"),
+            InteractionError::InvalidSize => String::from("The interaction data was invalid"),
+            InteractionError::NoReminder => String::from("Reminder could not be found"),
+            InteractionError::SignatureMismatch => {
+                String::from("Only the user who did the command can use interactions")
+            }
+            InteractionError::InvalidAction => String::from("The action was invalid"),
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum ReminderAction {
+    Delete,
+}
+
+impl ToString for ReminderAction {
+    fn to_string(&self) -> String {
+        match self {
+            Self::Delete => String::from("del"),
+        }
+    }
+}
+
+impl TryFrom<&str> for ReminderAction {
+    type Error = ();
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+            "del" => Ok(Self::Delete),
+
+            _ => Err(()),
+        }
+    }
 }
 
 enum TimeDisplayType {