Finish refactoring

2025-08-10 21:15:53 -03:00
parent f123282699
commit a004fe2308
50 changed files with 2639 additions and 587 deletions
@@ -0,0 +1,204 @@
+use async_trait::async_trait;
+use scc::HashSet;
+use twilight_model::id::Id;
+
+use crate::{
+    database::models::{Call, Channel},
+    framework::commands::{Command, CommandError, context::CommandContext},
+    state::State,
+    utils::Bye,
+};
+
+#[derive(Default, Debug)]
+pub struct CallCommand {
+    /// A set of channel IDs that are currently searching for a call. This works as a lock for two
+    /// users not to use p.call at the same time in the same channel, as it could create a race
+    /// condition. IDs are removed from this set once the DB is properly updated with the channel's
+    /// state, meaning that not all searching channels will be in this set at all times.
+    channel_lock: HashSet<u64>,
+}
+
+impl CallCommand {
+    pub fn new() -> Self {
+        Self {
+            channel_lock: HashSet::new(),
+        }
+    }
+}
+
+#[async_trait]
+impl Command<State> for CallCommand {
+    fn name(&self) -> &'static str {
+        "call"
+    }
+
+    fn aliases(&self) -> &'static [&'static str] {
+        &["c"]
+    }
+
+    async fn execute(
+        &self,
+        ctx: CommandContext<'_, State>,
+        _args: &str,
+    ) -> Result<(), CommandError> {
+        let channel = Channel::get_or_create_by_id(
+            ctx.event.channel_id.get(),
+            &ctx.rt.state.db,
+            &ctx.rt.http,
+        )
+        .await
+        .inspect_err(|e| {
+            log::error!("Failed to get or create channel: {e:?}");
+        })
+        .map_err(|_| CommandError::DatabaseQueryFailed)?;
+
+        if channel.is_searching || self.channel_lock.contains(&ctx.event.channel_id.get()) {
+            ctx.send()
+                .content(format!(
+                    "☎️ You are already searching for a call! Use `{}hangup` to hang up the phone.",
+                    ctx.prefix
+                ))
+                .await
+                .map_err(|_| CommandError::MessageSendingFailed)?;
+
+            return Ok(());
+        }
+
+        if channel.call_id.is_some() {
+            ctx.send()
+                .content(format!("☎️ You are already on a call! Use `{}hangup` to hang up the phone, or `{}skip` to skip to the next call.", ctx.prefix, ctx.prefix))
+                .await
+                .map_err(|_| CommandError::MessageSendingFailed)?;
+
+            return Ok(());
+        }
+
+        self.channel_lock
+            .insert_async(ctx.event.channel_id.get())
+            .await
+            .bye();
+
+        let call = Call::start(&channel, &ctx.rt.state.db)
+            .await
+            .inspect_err(|e| {
+                log::error!("Failed to start call: {e:?}");
+                self.channel_lock.remove(&ctx.event.channel_id.get());
+            })
+            .map_err(|_| CommandError::DatabaseQueryFailed)?;
+
+        self.channel_lock
+            .remove_async(&ctx.event.channel_id.get())
+            .await;
+
+        if let Some(call) = call {
+            ctx.send().content("☎️ Call connected. Say hi!").await.bye();
+            ctx.rt
+                .http
+                .create_message(Id::new(call.other_party_channel_id(channel.id)))
+                .content("☎️ Call connected. Say hi!")
+                .await
+                .bye();
+        } else {
+            ctx.send()
+                .content("☎️ Searching for a call...")
+                .await
+                .map_err(|_| CommandError::MessageSendingFailed)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct HangupCommand;
+
+#[async_trait]
+impl Command<State> for HangupCommand {
+    fn name(&self) -> &'static str {
+        "hangup"
+    }
+
+    fn aliases(&self) -> &'static [&'static str] {
+        &["h", "hang"]
+    }
+
+    async fn execute(
+        &self,
+        ctx: CommandContext<'_, State>,
+        _args: &str,
+    ) -> Result<(), CommandError> {
+        let Some(channel) = Channel::get_by_id(ctx.event.channel_id.get(), &ctx.rt.state.db)
+            .await
+            .inspect_err(|e| log::error!("Failed to get channel: {e:?}"))
+            .map_err(|_| CommandError::DatabaseQueryFailed)?
+        else {
+            ctx.send()
+                .content(format!(
+                    "❌ You're not on a call! Use `{}call` to start one.",
+                    ctx.prefix
+                ))
+                .await
+                .map_err(|_| CommandError::MessageSendingFailed)?;
+
+            return Ok(());
+        };
+
+        if channel.is_searching {
+            channel
+                .cancel_search(&ctx.rt.state.db)
+                .await
+                .inspect_err(|e| {
+                    log::error!("Failed to cancel search: {e:?}");
+                })
+                .map_err(|_| CommandError::DatabaseQueryFailed)?;
+
+            ctx.send()
+                .content("☎️ The phone was hung up.")
+                .await
+                .map_err(|_| CommandError::MessageSendingFailed)?;
+
+            return Ok(());
+        }
+
+        if let Some(call_id) = channel.call_id {
+            let Some(call) = Call::get_by_id(call_id, &ctx.rt.state.db)
+                .await
+                .inspect_err(|e| log::error!("Failed to get call: {e:?}"))
+                .map_err(|_| CommandError::DatabaseQueryFailed)?
+            else {
+                ctx.send()
+                    .content("❌ Call not found.")
+                    .await
+                    .map_err(|_| CommandError::MessageSendingFailed)?;
+
+                return Err(CommandError::DatabaseInconsistentState);
+            };
+
+            call.hangup(&ctx.rt.state.db)
+                .await
+                .inspect_err(|e| log::error!("Failed to hang up call: {e:?}"))
+                .map_err(|_| CommandError::DatabaseQueryFailed)?;
+
+            ctx.send().content("☎️ You hung up the phone.").await.bye();
+
+            ctx.rt
+                .http
+                .create_message(Id::new(call.other_party_channel_id(channel.id)))
+                .content("☎️ The other party hung up the phone.")
+                .await
+                .map_err(|_| CommandError::MessageSendingFailed)?;
+        } else {
+            ctx.send()
+                .content(format!(
+                    "❌ You're not on a call! Use `{}call` to start one.",
+                    ctx.prefix
+                ))
+                .await
+                .map_err(|_| CommandError::MessageSendingFailed)?;
+
+            return Ok(());
+        }
+
+        Ok(())
+    }
+}