feat(sdk): Add support for fetching custom profile fields

Signed-off-by: Kévin Commaille <[email protected]>

Author: zecakeh

crates/matrix-sdk/src/account.rs

@@ -23,7 +23,7 @@ use js_int::uint;
 #[cfg(feature = "experimental-element-recent-emojis")]
 use matrix_sdk_base::recent_emojis::RecentEmojisContent;
 use matrix_sdk_base::{
-    StateStoreDataKey, StateStoreDataValue,
+    SendOutsideWasm, StateStoreDataKey, StateStoreDataValue, SyncOutsideWasm,
     media::{MediaFormat, MediaRequestParameters},
     store::StateStoreExt,
 };
@@ -40,7 +40,8 @@ use ruma::{
         config::{get_global_account_data, set_global_account_data},
         error::ErrorKind,
         profile::{
-            get_avatar_url, get_display_name, get_profile, set_avatar_url, set_display_name,
+            AvatarUrl, DisplayName, ProfileFieldName, ProfileFieldValue, StaticProfileField,
+            get_profile, get_profile_field, set_avatar_url, set_display_name,
         },
         uiaa::AuthData,
     },
@@ -107,11 +108,7 @@ impl Account {
     /// ```
     pub async fn get_display_name(&self) -> Result<Option<String>> {
         let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;
-        #[allow(deprecated)]
-        let request = get_display_name::v3::Request::new(user_id.to_owned());
-        let request_config = self.client.request_config().force_auth();
-        let response = self.client.send(request).with_request_config(request_config).await?;
-        Ok(response.displayname)
+        self.fetch_profile_field_of_static::<DisplayName>(user_id.to_owned()).await
     }
 
     /// Set the display name of the account.
@@ -163,13 +160,10 @@ impl Account {
     /// ```
     pub async fn get_avatar_url(&self) -> Result<Option<OwnedMxcUri>> {
         let user_id = self.client.user_id().ok_or(Error::AuthenticationRequired)?;
-        #[allow(deprecated)]
-        let request = get_avatar_url::v3::Request::new(user_id.to_owned());
-
-        let config = Some(RequestConfig::new().force_auth());
+        let avatar_url =
+            self.fetch_profile_field_of_static::<AvatarUrl>(user_id.to_owned()).await?;
 
-        let response = self.client.send(request).with_request_config(config).await?;
-        if let Some(url) = response.avatar_url.clone() {
+        if let Some(url) = avatar_url.clone() {
             // If an avatar is found cache it.
             let _ = self
                 .client
@@ -187,7 +181,7 @@ impl Account {
                 .remove_kv_data(StateStoreDataKey::UserAvatarUrl(user_id))
                 .await;
         }
-        Ok(response.avatar_url)
+        Ok(avatar_url)
     }
 
     /// Get the URL of the account's avatar, if is stored in cache.
@@ -328,6 +322,80 @@ impl Account {
             .await?)
     }
 
+    /// Get the given field from the given user's profile.
+    ///
+    /// # Arguments
+    ///
+    /// * `user_id` - The ID of the user to get the profile field of.
+    ///
+    /// * `field` - The name of the profile field to get.
+    ///
+    /// # Returns
+    ///
+    /// Returns an error if the request fails or if deserialization of the
+    /// response fails.
+    ///
+    /// If the field is not set, the server should respond with an error with an
+    /// [`ErrorCode::NotFound`], but it might also respond with an empty
+    /// response, which would result in `Ok(None)`. Note that this error code
+    /// might also mean that the given user ID doesn't exist.
+    ///
+    /// [`ErrorCode::NotFound`]: ruma::api::client::error::ErrorCode::NotFound
+    pub async fn fetch_profile_field_of(
+        &self,
+        user_id: OwnedUserId,
+        field: ProfileFieldName,
+    ) -> Result<Option<ProfileFieldValue>> {
+        let request = get_profile_field::v3::Request::new(user_id, field);
+        let response = self
+            .client
+            .send(request)
+            .with_request_config(RequestConfig::short_retry().force_auth())
+            .await?;
+
+        Ok(response.value)
+    }
+
+    /// Get the given statically-known field from the given user's profile.
+    ///
+    /// # Arguments
+    ///
+    /// * `user_id` - The ID of the user to get the profile field of.
+    ///
+    /// # Returns
+    ///
+    /// Returns an error if the request fails or if deserialization of the
+    /// response fails.
+    ///
+    /// If the field is not set, the server should respond with an error with an
+    /// [`ErrorCode::NotFound`], but it might also respond with an empty
+    /// response, which would result in `Ok(None)`. Note that this error code
+    /// might also mean that the given user ID doesn't exist.
+    ///
+    /// [`ErrorCode::NotFound`]: ruma::api::client::error::ErrorCode::NotFound
+    pub async fn fetch_profile_field_of_static<F>(
+        &self,
+        user_id: OwnedUserId,
+    ) -> Result<Option<F::Value>>
+    where
+        F: StaticProfileField
+            + std::fmt::Debug
+            + Clone
+            + SendOutsideWasm
+            + SyncOutsideWasm
+            + 'static,
+        F::Value: SendOutsideWasm + SyncOutsideWasm,
+    {
+        let request = get_profile_field::v3::Request::new_static::<F>(user_id);
+        let response = self
+            .client
+            .send(request)
+            .with_request_config(RequestConfig::short_retry().force_auth())
+            .await?;
+
+        Ok(response.value)
+    }
+
     /// Change the password of the account.
     ///
     /// # Arguments

crates/matrix-sdk/src/test_utils/mocks/mod.rs

@@ -35,6 +35,7 @@ use ruma::{
     DeviceId, EventId, MilliSecondsSinceUnixEpoch, MxcUri, OwnedDeviceId, OwnedEventId,
     OwnedOneTimeKeyId, OwnedRoomId, OwnedUserId, RoomId, ServerName, UserId,
     api::client::{
+        profile::ProfileFieldName,
         receipt::create_receipt::v3::ReceiptType,
         room::Visibility,
         sync::sync_events::v5,
@@ -1622,6 +1623,17 @@ impl MatrixMockServer {
             Mock::given(method("GET")).and(path_regex(r"^/_matrix/client/v1/rooms/.*/hierarchy"));
         self.mock_endpoint(mock, GetHierarchyEndpoint).expect_default_access_token()
     }
+
+    /// Create a prebuilt mock for the endpoint used to get a profile field.
+    pub fn mock_get_profile_field(
+        &self,
+        user_id: &UserId,
+        field: ProfileFieldName,
+    ) -> MockEndpoint<'_, GetProfileFieldEndpoint> {
+        let mock = Mock::given(method("GET"))
+            .and(path(format!("/_matrix/client/v3/profile/{user_id}/{field}")));
+        self.mock_endpoint(mock, GetProfileFieldEndpoint { field })
+    }
 }
 
 /// A specification for a push rule ID.
@@ -4658,3 +4670,22 @@ impl<'a> MockEndpoint<'a, SlidingSyncEndpoint> {
         let _summary = sliding_sync.sync_once().await.unwrap();
     }
 }
+
+/// A prebuilt mock for `GET /_matrix/client/*/profile/{user_id}/{key_name}`.
+pub struct GetProfileFieldEndpoint {
+    field: ProfileFieldName,
+}
+
+impl<'a> MockEndpoint<'a, GetProfileFieldEndpoint> {
+    /// Returns a successful response containing the given value, if any.
+    pub fn ok_with_value(self, value: Option<Value>) -> MatrixMock<'a> {
+        if let Some(value) = value {
+            let field = self.endpoint.field.to_string();
+            self.respond_with(ResponseTemplate::new(200).set_body_json(json!({
+                field: value,
+            })))
+        } else {
+            self.ok_empty_json()
+        }
+    }
+}

crates/matrix-sdk/tests/integration/account.rs

@@ -1,4 +1,10 @@
+use assert_matches2::assert_matches;
+use matrix_sdk::test_utils::mocks::MatrixMockServer;
 use matrix_sdk_test::async_test;
+use ruma::api::{
+    MatrixVersion,
+    client::profile::{ProfileFieldName, ProfileFieldValue, TimeZone},
+};
 use serde_json::json;
 use wiremock::{
     Mock, Request, ResponseTemplate,
@@ -57,3 +63,51 @@ async fn test_account_deactivation() {
         assert!(client.account().deactivate(None, None, true).await.is_ok());
     }
 }
+
+#[async_test]
+async fn test_fetch_profile_field() {
+    let tz = "Africa/Bujumbura";
+    let display_name = "Alice";
+
+    let server = MatrixMockServer::new().await;
+    let client = server.client_builder().server_versions(vec![MatrixVersion::V1_16]).build().await;
+    let user_id = client.user_id().unwrap();
+
+    server
+        .mock_get_profile_field(user_id, ProfileFieldName::TimeZone)
+        .ok_with_value(Some(tz.into()))
+        .expect(2)
+        .named("get m.tz profile field")
+        .mount()
+        .await;
+    server
+        .mock_get_profile_field(user_id, ProfileFieldName::DisplayName)
+        .ok_with_value(Some(display_name.into()))
+        .mock_once()
+        .named("get displayname profile field")
+        .mount()
+        .await;
+    server
+        .mock_get_profile_field(user_id, ProfileFieldName::AvatarUrl)
+        .ok_with_value(None)
+        .mock_once()
+        .named("get avatar_url profile field")
+        .mount()
+        .await;
+
+    let account = client.account();
+
+    let res_avatar_url = account.get_avatar_url().await.unwrap();
+    assert_eq!(res_avatar_url, None);
+    let res_display_name = account.get_display_name().await.unwrap();
+    assert_eq!(res_display_name.as_deref(), Some(display_name));
+    let res_value = account
+        .fetch_profile_field_of(user_id.to_owned(), ProfileFieldName::TimeZone)
+        .await
+        .unwrap();
+    assert_matches!(res_value, Some(ProfileFieldValue::TimeZone(res_tz)));
+    assert_eq!(res_tz, tz);
+    let res_tz =
+        account.fetch_profile_field_of_static::<TimeZone>(user_id.to_owned()).await.unwrap();
+    assert_eq!(res_tz.as_deref(), Some(tz));
+}