feat: better message handling, pep publish, xep_0172: nick

1 files changed, 61 insertions, 25 deletions

diff --git a/filamento/src/logic/process_stanza.rs b/filamento/src/logic/process_stanza.rs
index b1bc830..2f6644e 100644
--- a/filamento/src/logic/process_stanza.rs
+++ b/filamento/src/logic/process_stanza.rs
@@ -41,38 +41,74 @@ pub async fn recv_message(
     logic: ClientLogic,
     stanza_message: stanza::client::message::Message,
 ) -> Result<Option<UpdateMessage>, MessageRecvError> {
-    if let Some(mut from) = stanza_message.from {
+    if let Some(from) = stanza_message.from {
         // TODO: don't ignore delay from. xep says SHOULD send error if incorrect.
         let timestamp = stanza_message
             .delay
             .map(|delay| delay.stamp)
             .unwrap_or_else(|| Utc::now());
         // TODO: group chat messages
-        let mut message = Message {
-            id: stanza_message
-                .id
-                // TODO: proper id storage
-                .map(|id| Uuid::from_str(&id).unwrap_or_else(|_| Uuid::new_v4()))
-                .unwrap_or_else(|| Uuid::new_v4()),
-            from: from.clone(),
-            timestamp,
-            body: Body {
-                // TODO: should this be an option?
-                body: stanza_message
-                    .body
-                    .map(|body| body.body)
-                    .unwrap_or_default()
-                    .unwrap_or_default(),
-            },
-        };
+
+        // if there is a body, should create chat message
+        if let Some(body) = stanza_message.body {
+            let message = Message {
+                id: stanza_message
+                    .id
+                    // TODO: proper id xep
+                    .map(|id| Uuid::from_str(&id).unwrap_or_else(|_| Uuid::new_v4()))
+                    .unwrap_or_else(|| Uuid::new_v4()),
+                from: from.as_bare(),
+                timestamp,
+                body: Body {
+                    body: body.body.unwrap_or_default(),
+                },
+                delivery: None,
+            };
+
+            // save the message to the database
+            logic.db().upsert_chat_and_user(&from).await?;
+            if let Err(e) = logic
+                .db()
+                .create_message_with_user_resource(message.clone(), from.clone(), from.clone())
+                .await
+            {
+                logic
+                    .handle_error(Error::MessageRecv(MessageRecvError::MessageHistory(e)))
+                    .await;
+            }
+
+            // update the client with the new message
+            logic
+                .update_sender()
+                .send(UpdateMessage::Message {
+                    to: from.as_bare(),
+                    message,
+                })
+                .await;
+        }
+
+        if let Some(nick) = stanza_message.nick {
+            if let Err(e) = logic
+                .db()
+                .upsert_user_nick(from.as_bare(), nick.0.clone())
+                .await
+            {
+                logic
+                    .handle_error(Error::MessageRecv(MessageRecvError::NickUpdate(e)))
+                    .await;
+            }
+
+            logic
+                .update_sender()
+                .send(UpdateMessage::NickChanged {
+                    jid: from.as_bare(),
+                    nick: nick.0,
+                })
+                .await;
+        }
+
+        Ok(None)
         // TODO: can this be more efficient?
-        logic
-            .db()
-            .create_message_with_user_resource_and_chat(message.clone(), from.clone())
-            .await?;
-        message.from = message.from.as_bare();
-        from = from.as_bare();
-        Ok(Some(UpdateMessage::Message { to: from, message }))
     } else {
         Err(MessageRecvError::MissingFrom)
     }