add: channels, messages

crates/core/src/database/messages.rs

@@ -1,11 +1,23 @@
+use std::collections::HashMap;
+
 use super::*;
 use crate::cache::Cache;
 use crate::model::moderation::AuditLogEntry;
+use crate::model::socket::{SocketMessage, SocketMethod};
 use crate::model::{
     Error, Result, auth::User, permissions::FinePermission,
     communities_permissions::CommunityPermission, channels::Message,
 };
 use crate::{auto_method, execute, get, query_row, query_rows, params};
+use serde::Serialize;
+
+#[derive(Serialize)]
+struct DeleteMessageEvent {
+    pub id: String,
+}
+
+#[cfg(feature = "redis")]
+use redis::Commands;
 
 #[cfg(feature = "sqlite")]
 use rusqlite::Row;
@@ -31,7 +43,35 @@ impl DataManager {
         }
     }
 
-    auto_method!(get_message_by_id(usize)@get_message_from_row -> "SELECT * FROM messages WHERE id = $1" --name="message" --returns=Message --cache-key-tmpl="atto.message:{}");
+    auto_method!(get_message_by_id(usize as i64)@get_message_from_row -> "SELECT * FROM messages WHERE id = $1" --name="message" --returns=Message --cache-key-tmpl="atto.message:{}");
+
+    /// Complete a vector of just messages with their owner as well.
+    pub async fn fill_messages(
+        &self,
+        messages: Vec<Message>,
+        ignore_users: &Vec<usize>,
+    ) -> Result<Vec<(Message, User)>> {
+        let mut out: Vec<(Message, User)> = Vec::new();
+
+        let mut users: HashMap<usize, User> = HashMap::new();
+        for message in messages {
+            let owner = message.owner;
+
+            if ignore_users.contains(&owner) {
+                continue;
+            }
+
+            if let Some(user) = users.get(&owner) {
+                out.push((message, user.clone()));
+            } else {
+                let user = self.get_user_by_id(owner).await?;
+                users.insert(owner, user.clone());
+                out.push((message, user));
+            }
+        }
+
+        Ok(out)
+    }
 
     /// Get all messages by channel (paginated).
     ///
@@ -52,7 +92,7 @@ impl DataManager {
 
         let res = query_rows!(
             &conn,
-            "SELECT * FROM messages WHERE channel = $1 ORDER BY created DESC LIMIT $1 OFFSET $2",
+            "SELECT * FROM messages WHERE channel = $1 ORDER BY created DESC LIMIT $2 OFFSET $3",
             &[&(channel as i64), &(batch as i64), &((page * batch) as i64)],
             |x| { Self::get_message_from_row(x) }
         );
@@ -69,6 +109,14 @@ impl DataManager {
     /// # Arguments
     /// * `data` - a mock [`Message`] object to insert
     pub async fn create_message(&self, data: Message) -> Result<()> {
+        if data.content.len() < 2 {
+            return Err(Error::DataTooLong("content".to_string()));
+        }
+
+        if data.content.len() > 2048 {
+            return Err(Error::DataTooLong("content".to_string()));
+        }
+
         let user = self.get_user_by_id(data.owner).await?;
         let channel = self.get_channel_by_id(data.channel).await?;
 
@@ -77,14 +125,8 @@ impl DataManager {
             .get_membership_by_owner_community(user.id, channel.community)
             .await?;
 
-        if !membership.role.check_member() {
-            return Err(Error::NotAllowed);
-        }
-
         // check user permission to post in channel
-        let role = membership.role.bits();
-
-        if role < channel.minimum_role_write {
+        if !channel.check_post(user.id, Some(membership.role)) {
             return Err(Error::NotAllowed);
         }
 
@@ -112,6 +154,21 @@ impl DataManager {
             return Err(Error::DatabaseError(e.to_string()));
         }
 
+        // post event
+        let mut con = self.2.get_con().await;
+
+        if let Err(e) = con.publish::<usize, String, ()>(
+            data.channel,
+            serde_json::to_string(&SocketMessage {
+                method: SocketMethod::Message,
+                data: serde_json::to_string(&data).unwrap(),
+            })
+            .unwrap(),
+        ) {
+            return Err(Error::MiscError(e.to_string()));
+        }
+
+        // ...
         Ok(())
     }
 
@@ -149,6 +206,22 @@ impl DataManager {
         }
 
         self.2.remove(format!("atto.message:{}", id)).await;
+
+        // post event
+        let mut con = self.2.get_con().await;
+
+        if let Err(e) = con.publish::<usize, String, ()>(
+            message.channel,
+            serde_json::to_string(&SocketMessage {
+                method: SocketMethod::Delete,
+                data: serde_json::to_string(&DeleteMessageEvent { id: id.to_string() }).unwrap(),
+            })
+            .unwrap(),
+        ) {
+            return Err(Error::MiscError(e.to_string()));
+        }
+
+        // ...
         Ok(())
     }