tetratto/crates/core/src/database/message_reactions.rs

use oiseau::{cache::Cache, query_rows};
use crate::model::{
    Error, Result,
    auth::{Notification, User},
    permissions::FinePermission,
    channels::MessageReaction,
};
use crate::{auto_method, DataManager};

use oiseau::{PostgresRow, execute, get, query_row, params};

impl DataManager {
    /// Get a [`MessageReaction`] from an SQL row.
    pub(crate) fn get_message_reaction_from_row(x: &PostgresRow) -> MessageReaction {
        MessageReaction {
            id: get!(x->0(i64)) as usize,
            created: get!(x->1(i64)) as usize,
            owner: get!(x->2(i64)) as usize,
            message: get!(x->3(i64)) as usize,
            emoji: get!(x->4(String)),
        }
    }

    auto_method!(get_message_reaction_by_id()@get_message_reaction_from_row -> "SELECT * FROM message_reactions WHERE id = $1" --name="message_reaction" --returns=MessageReaction --cache-key-tmpl="atto.message_reaction:{}");

    /// Get message_reactions by `owner` and `message`.
    pub async fn get_message_reactions_by_owner_message(
        &self,
        owner: usize,
        message: usize,
    ) -> Result<Vec<MessageReaction>> {
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = query_rows!(
            &conn,
            "SELECT * FROM message_reactions WHERE owner = $1 AND message = $2",
            &[&(owner as i64), &(message as i64)],
            |x| { Self::get_message_reaction_from_row(x) }
        );

        if res.is_err() {
            return Err(Error::GeneralNotFound("message_reaction".to_string()));
        }

        Ok(res.unwrap())
    }

    /// Get a message_reaction by `owner`, `message`, and `emoji`.
    pub async fn get_message_reaction_by_owner_message_emoji(
        &self,
        owner: usize,
        message: usize,
        emoji: &str,
    ) -> Result<MessageReaction> {
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = query_row!(
            &conn,
            "SELECT * FROM message_reactions WHERE owner = $1 AND message = $2 AND emoji = $3",
            params![&(owner as i64), &(message as i64), &emoji],
            |x| { Ok(Self::get_message_reaction_from_row(x)) }
        );

        if res.is_err() {
            return Err(Error::GeneralNotFound("message_reaction".to_string()));
        }

        Ok(res.unwrap())
    }

    /// Create a new message_reaction in the database.
    ///
    /// # Arguments
    /// * `data` - a mock [`MessageReaction`] object to insert
    pub async fn create_message_reaction(&self, data: MessageReaction, user: &User) -> Result<()> {
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let mut message = self.get_message_by_id(data.message).await?;
        let channel = self.get_channel_by_id(message.channel).await?;

        // ...
        let res = execute!(
            &conn,
            "INSERT INTO message_reactions VALUES ($1, $2, $3, $4, $5)",
            params![
                &(data.id as i64),
                &(data.created as i64),
                &(data.owner as i64),
                &(data.message as i64),
                &data.emoji
            ]
        );

        if let Err(e) = res {
            return Err(Error::DatabaseError(e.to_string()));
        }

        // incr corresponding
        if let Some(x) = message.reactions.get(&data.emoji) {
            message.reactions.insert(data.emoji.clone(), x + 1);
        } else {
            message.reactions.insert(data.emoji.clone(), 1);
        }

        self.update_message_reactions(message.id, message.reactions)
            .await?;

        // send notif
        if message.owner != user.id {
            self
                .create_notification(Notification::new(
                    "Your message has received a reaction!".to_string(),
                    format!(
                        "[@{}](/api/v1/auth/user/find/{}) has reacted \"{}\" to your [message](/chats/{}/{}?message={})!",
                        user.username, user.id, data.emoji, channel.community, channel.id, message.id
                    ),
                    message.owner,
                ))
                .await?;
        }

        // return
        Ok(())
    }

    pub async fn delete_message_reaction(&self, id: usize, user: &User) -> Result<()> {
        let message_reaction = self.get_message_reaction_by_id(id).await?;

        if user.id != message_reaction.owner
            && !user.permissions.check(FinePermission::MANAGE_REACTIONS)
        {
            return Err(Error::NotAllowed);
        }

        let mut message = self.get_message_by_id(message_reaction.message).await?;

        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = execute!(
            &conn,
            "DELETE FROM message_reactions WHERE id = $1",
            &[&(id as i64)]
        );

        if let Err(e) = res {
            return Err(Error::DatabaseError(e.to_string()));
        }

        self.0
            .1
            .remove(format!("atto.message_reaction:{}", id))
            .await;

        // decr message reaction count
        if let Some(x) = message.reactions.get(&message_reaction.emoji) {
            if *x == 1 {
                // there are no 0 of this reaction
                message.reactions.remove(&message_reaction.emoji);
            } else {
                // decr 1
                message.reactions.insert(message_reaction.emoji, x - 1);
            }
        }

        self.update_message_reactions(message.id, message.reactions)
            .await?;

        // return
        Ok(())
    }
}