fix(filamento): caps +notify and use hex representation for avatar metadata id

3 files changed, 29 insertions, 20 deletions

diff --git a/filamento/src/caps.rs b/filamento/src/caps.rs
index b3464d1..819e669 100644
--- a/filamento/src/caps.rs
+++ b/filamento/src/caps.rs
@@ -35,13 +35,13 @@ pub fn client_info() -> Info {
     Info {
         node: None,
         features: vec![
-            "http://jabber.org/protocol/disco#items".to_string(),
-            "http://jabber.org/protocol/disco#info".to_string(),
             "http://jabber.org/protocol/caps".to_string(),
-            "http://jabber.org/protocol/nick".to_string(),
+            "http://jabber.org/protocol/disco#info".to_string(),
+            "http://jabber.org/protocol/disco#items".to_string(),
             "http://jabber.org/protocol/nick+notify".to_string(),
             "urn:xmpp:avatar:metadata+notify".to_string(),
         ],
+        // "http://jabber.org/protocol/nick".to_string(),
         identities: vec![Identity {
             name: Some("filamento 0.1.0".to_string()),
             category: Category::Client(identity::Client::PC),
diff --git a/filamento/src/logic/online.rs b/filamento/src/logic/online.rs
index 745adc1..5b57f84 100644
--- a/filamento/src/logic/online.rs
+++ b/filamento/src/logic/online.rs
@@ -906,7 +906,7 @@ pub async fn handle_change_avatar<Fs: FileStore + Clone>(logic: &ClientLogic<Fs>
             let mut sha1 = Sha1::new();
             sha1.update(&data_png);
             let sha1_result = sha1.finalize();
-            let hash = BASE64_STANDARD.encode(sha1_result);
+            let hash = hex::encode(sha1_result);
 
             // encode the image data as base64
             let data_b64 = BASE64_STANDARD.encode(data_png.clone());
diff --git a/filamento/src/logic/process_stanza.rs b/filamento/src/logic/process_stanza.rs
index c383d70..7142144 100644
--- a/filamento/src/logic/process_stanza.rs
+++ b/filamento/src/logic/process_stanza.rs
@@ -268,14 +268,17 @@ pub async fn recv_message<Fs: FileStore + Clone>(
                             match items.items {
                                 ItemsType::Item(items) => {
                                     if let Some(item) = items.first() {
+                                        debug!("found item");
                                         match &item.item {
                                             Some(Content::AvatarMetadata(metadata)) => {
+                                                debug!("found metadata");
                                                 // check if user avatar has been deleted
                                                 if let Some(metadata) = metadata
                                                     .info
                                                     .iter()
                                                     .find(|info| info.url.is_none())
                                                 {
+                                                    debug!("checking if user avatar has changed");
                                                     // check if user avatar has changed
                                                     match logic
                                                         .db()
@@ -296,8 +299,9 @@ pub async fn recv_message<Fs: FileStore + Clone>(
                                                                             logic.handle_error(MessageRecvError::AvatarUpdate(e).into()).await;
                                                                     }
                                                                 }
+                                                            }
 
-                                                                match logic
+                                                            match logic
                                                                     .file_store()
                                                                     .is_stored(&metadata.id)
                                                                     .await
@@ -311,28 +315,32 @@ pub async fn recv_message<Fs: FileStore + Clone>(
                                                                         let pep_item = logic.client().get_pep_item(Some(from.as_bare()), "urn:xmpp:avatar:data".to_string(), metadata.id.clone()).await.map_err(|err| Into::<AvatarUpdateError<Fs>>::into(err))?;
                                                                         match pep_item {
                                                                             crate::pep::Item::AvatarData(data) => {
-                                                                                let data = data.map(|data| data.data_b64).unwrap_or_default();
+                                                                                let data = data.map(|data| data.data_b64).unwrap_or_default().replace("\n", "");
                                                                                 // TODO: these should all be in a separate avatarupdate function
+                                                                                debug!("got avatar data");
                                                                                 match BASE64_STANDARD.decode(data) {
                                                                                     Ok(data) => {
                                                                                         let mut hasher = Sha1::new();
                                                                                         hasher.update(&data);
-                                                                                        let received_data_hash = BASE64_STANDARD.encode(hasher.finalize());
-                                                                                        if received_data_hash == metadata.id {
+                                                                                        let received_data_hash = hex::encode(hasher.finalize());
+                                                                                        debug!("received_data_hash: {}, metadata_id: {}", received_data_hash, metadata.id);
+                                                                                        if received_data_hash.to_lowercase() == metadata.id.to_lowercase() {
                                                                                             if let Err(e) = logic.file_store().store(&received_data_hash, &data).await {
                                                                                                 logic.handle_error(Error::MessageRecv(MessageRecvError::AvatarUpdate(AvatarUpdateError::FileStore(e)))).await;
                                                                                             }
-                                                                                            logic
-                                                                                            .update_sender()
-                                                                                            .send(
-                                                                                                UpdateMessage::AvatarChanged {
-                                                                                                    jid: from.as_bare(),
-                                                                                                    id: Some(
-                                                                                                        metadata.id.clone(),
-                                                                                                    ),
-                                                                                                },
-                                                                                            )
-                                                                                            .await;
+                                                                                            if changed {
+                                                                                                logic
+                                                                                                .update_sender()
+                                                                                                .send(
+                                                                                                    UpdateMessage::AvatarChanged {
+                                                                                                        jid: from.as_bare(),
+                                                                                                        id: Some(
+                                                                                                            metadata.id.clone(),
+                                                                                                        ),
+                                                                                                    },
+                                                                                                )
+                                                                                                .await;
+                                                                                            }
                                                                                         }
                                                                                     },
                                                                                     Err(e) => {
@@ -347,6 +355,7 @@ pub async fn recv_message<Fs: FileStore + Clone>(
                                                                     }
                                                                     Ok(true) => {
                                                                         // just send the update
+                                                                        if changed {
                                                                         logic
                                                                         .update_sender()
                                                                         .send(
@@ -359,10 +368,10 @@ pub async fn recv_message<Fs: FileStore + Clone>(
                                                                         )
                                                                         .await;
                                                                     }
+                                                                    }
                                                                     Err(e) => {
                                                                         logic.handle_error(Error::MessageRecv(MessageRecvError::AvatarUpdate(e))).await;
                                                                     }
-                                                                }
                                                             }
                                                         }
                                                         Err(e) => {