feat: keep track of remote profiles for user directory and local requests

Signed-off-by: strawberry <strawberry@puppygock.gay>

src/service/rooms/state/mod.rs

@@ -8,14 +8,13 @@ pub use data::Data;
 use ruma::{
     api::client::error::ErrorKind,
     events::{
-        room::{create::RoomCreateEventContent, member::MembershipState},
+        room::{create::RoomCreateEventContent, member::RoomMemberEventContent},
         AnyStrippedStateEvent, StateEventType, TimelineEventType,
     },
     serde::Raw,
     state_res::{self, StateMap},
     EventId, OwnedEventId, RoomId, RoomVersionId, UserId,
 };
-use serde::Deserialize;
 use tokio::sync::MutexGuard;
 use tracing::warn;
 
@@ -59,14 +58,9 @@ impl Service {
 
             match pdu.kind {
                 TimelineEventType::RoomMember => {
-                    #[derive(Deserialize)]
-                    struct ExtractMembership {
-                        membership: MembershipState,
-                    }
-
-                    let membership =
-                        match serde_json::from_str::<ExtractMembership>(pdu.content.get()) {
-                            Ok(e) => e.membership,
+                    let membership_event =
+                        match serde_json::from_str::<RoomMemberEventContent>(pdu.content.get()) {
+                            Ok(e) => e,
                             Err(_) => continue,
                         };
 
@@ -83,7 +77,14 @@ impl Service {
                     services()
                         .rooms
                         .state_cache
-                        .update_membership(room_id, &user_id, membership, &pdu.sender, None, false)
+                        .update_membership(
+                            room_id,
+                            &user_id,
+                            membership_event,
+                            &pdu.sender,
+                            None,
+                            false,
+                        )
                         .await?;
                 }
                 TimelineEventType::SpaceChild => {

src/service/rooms/state_cache/mod.rs

@@ -4,10 +4,14 @@ use std::{collections::HashSet, sync::Arc};
 pub use data::Data;
 
 use ruma::{
+    api::federation::{self, query::get_profile_information::v1::ProfileField},
     events::{
         direct::DirectEvent,
         ignored_user_list::IgnoredUserListEvent,
-        room::{create::RoomCreateEventContent, member::MembershipState},
+        room::{
+            create::RoomCreateEventContent,
+            member::{MembershipState, RoomMemberEventContent},
+        },
         AnyStrippedStateEvent, AnySyncStateEvent, GlobalAccountDataEventType,
         RoomAccountDataEventType, StateEventType,
     },
@@ -29,15 +33,39 @@ impl Service {
         &self,
         room_id: &RoomId,
         user_id: &UserId,
-        membership: MembershipState,
+        membership_event: RoomMemberEventContent,
         sender: &UserId,
         last_state: Option<Vec<Raw<AnyStrippedStateEvent>>>,
         update_joined_count: bool,
     ) -> Result<()> {
+        let membership = membership_event.membership;
         // Keep track what remote users exist by adding them as "deactivated" users
         if user_id.server_name() != services().globals.server_name() {
             services().users.create(user_id, None)?;
-            // TODO: displayname, avatar url
+            // Try to update our local copy of the user if ours does not match
+            if ((services().users.displayname(user_id)? != membership_event.displayname)
+                || (services().users.avatar_url(user_id)? != membership_event.avatar_url)
+                || (services().users.blurhash(user_id)? != membership_event.blurhash))
+                && (membership != MembershipState::Leave)
+            {
+                let response = services()
+                    .sending
+                    .send_federation_request(
+                        user_id.server_name(),
+                        federation::query::get_profile_information::v1::Request {
+                            user_id: user_id.into(),
+                            field: Some(ProfileField::AvatarUrl),
+                        },
+                    )
+                    .await?;
+                services()
+                    .users
+                    .set_displayname(user_id, response.displayname.clone())?;
+                services()
+                    .users
+                    .set_avatar_url(user_id, response.avatar_url)?;
+                services().users.set_blurhash(user_id, response.blurhash)?;
+            };
         }
 
         match &membership {

src/service/rooms/timeline/mod.rs

@@ -18,7 +18,9 @@ use ruma::{
     events::{
         push_rules::PushRulesEvent,
         room::{
-            create::RoomCreateEventContent, encrypted::Relation, member::MembershipState,
+            create::RoomCreateEventContent,
+            encrypted::Relation,
+            member::{MembershipState, RoomMemberEventContent},
             power_levels::RoomPowerLevelsEventContent,
         },
         GlobalAccountDataEventType, StateEventType, TimelineEventType,
@@ -453,17 +455,15 @@ impl Service {
             }
             TimelineEventType::RoomMember => {
                 if let Some(state_key) = &pdu.state_key {
-                    #[derive(Deserialize)]
-                    struct ExtractMembership {
-                        membership: MembershipState,
-                    }
-
                     // if the state_key fails
                     let target_user_id = UserId::parse(state_key.clone())
                         .expect("This state_key was previously validated");
 
-                    let content = serde_json::from_str::<ExtractMembership>(pdu.content.get())
-                        .map_err(|_| Error::bad_database("Invalid content in pdu."))?;
+                    let content = serde_json::from_str::<RoomMemberEventContent>(pdu.content.get())
+                        .map_err(|e| {
+                            error!("Invalid room member event content in pdu: {e}");
+                            Error::bad_database("Invalid room member event content in pdu.")
+                        })?;
 
                     let invite_state = match content.membership {
                         MembershipState::Invite => {
@@ -481,7 +481,7 @@ impl Service {
                         .update_membership(
                             &pdu.room_id,
                             &target_user_id,
-                            content.membership,
+                            content,
                             &pdu.sender,
                             invite_state,
                             true,