Files
continuwuity/src/api/client/profile.rs
T

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

327 lines
8.6 KiB
Rust
Raw Normal View History

use std::collections::BTreeMap;
2024-07-16 08:05:25 +00:00
use axum::extract::State;
use futures::{
2025-08-25 19:12:27 +05:00
StreamExt,
future::{join, join4},
};
2020-07-30 18:14:47 +02:00
use ruma::{
2025-08-25 19:12:27 +05:00
OwnedRoomId,
api::{
client::profile::{
get_avatar_url, get_display_name, get_profile, set_avatar_url, set_display_name,
},
federation,
2020-07-30 18:14:47 +02:00
},
presence::PresenceState,
2020-07-30 18:14:47 +02:00
};
2025-08-25 19:12:27 +05:00
use tuwunel_core::{Err, Result, utils::future::TryExtExt};
2024-07-22 07:43:51 +00:00
use crate::Ruma;
2020-07-30 18:14:47 +02:00
2021-08-31 19:14:37 +02:00
/// # `PUT /_matrix/client/r0/profile/{userId}/displayname`
///
/// Updates the displayname.
///
/// - Also makes sure other users receive the update using presence EDUs
2024-04-22 23:48:57 -04:00
pub(crate) async fn set_displayname_route(
State(services): State<crate::State>,
body: Ruma<set_display_name::v3::Request>,
2022-02-18 15:33:14 +01:00
) -> Result<set_display_name::v3::Response> {
let sender_user = body.sender_user();
if *sender_user != body.user_id && body.appservice_info.is_none() {
return Err!(Request(Forbidden("You cannot update the profile of another user")));
}
2024-07-16 08:05:25 +00:00
let all_joined_rooms: Vec<OwnedRoomId> = services
2022-10-05 09:34:25 +02:00
.state_cache
.rooms_joined(&body.user_id)
2024-08-08 17:18:30 +00:00
.map(ToOwned::to_owned)
.collect()
.await;
2021-08-31 21:20:03 +02:00
2025-08-25 19:12:27 +05:00
services
.users
.update_displayname(&body.user_id, body.displayname.clone(), &all_joined_rooms)
.await;
2020-07-30 18:14:47 +02:00
2025-09-09 18:12:21 +05:00
// Presence update
services
.presence
.maybe_ping_presence(&body.user_id, &PresenceState::Online)
.await?;
2022-02-18 15:33:14 +01:00
Ok(set_display_name::v3::Response {})
2020-07-30 18:14:47 +02:00
}
/// # `GET /_matrix/client/v3/profile/{userId}/displayname`
2021-08-31 19:14:37 +02:00
///
/// Returns the displayname of the user.
///
2024-06-16 00:36:49 +00:00
/// - If user is on another server and we do not have a local copy already fetch
/// displayname over federation
2024-04-22 23:48:57 -04:00
pub(crate) async fn get_displayname_route(
State(services): State<crate::State>,
body: Ruma<get_display_name::v3::Request>,
2022-02-18 15:33:14 +01:00
) -> Result<get_display_name::v3::Response> {
2024-07-22 07:43:51 +00:00
if !services.globals.user_is_local(&body.user_id) {
// Create and update our local copy of the user
2024-07-16 08:05:25 +00:00
if let Ok(response) = services
.sending
.send_federation_request(
body.user_id.server_name(),
federation::query::get_profile_information::v1::Request {
2022-12-14 13:09:10 +01:00
user_id: body.user_id.clone(),
field: None, // we want the full user's profile to update locally too
},
)
.await
{
2024-08-08 17:18:30 +00:00
if !services.users.exists(&body.user_id).await {
2025-04-19 23:34:52 +02:00
services
.users
.create(&body.user_id, None, None)
.await?;
}
2024-07-16 08:05:25 +00:00
services
2024-03-25 17:05:11 -04:00
.users
2024-08-08 17:18:30 +00:00
.set_displayname(&body.user_id, response.displayname.clone());
2024-07-16 08:05:25 +00:00
services
2024-03-25 17:05:11 -04:00
.users
2024-08-08 17:18:30 +00:00
.set_avatar_url(&body.user_id, response.avatar_url.clone());
2024-07-16 08:05:25 +00:00
services
2024-03-25 17:05:11 -04:00
.users
2024-08-08 17:18:30 +00:00
.set_blurhash(&body.user_id, response.blurhash.clone());
return Ok(get_display_name::v3::Response { displayname: response.displayname });
}
}
2024-08-08 17:18:30 +00:00
if !services.users.exists(&body.user_id).await {
// Return 404 if this user doesn't exist and we couldn't fetch it over
// federation
return Err!(Request(NotFound("Profile was not found.")));
}
2022-02-18 15:33:14 +01:00
Ok(get_display_name::v3::Response {
2025-04-22 04:42:26 +00:00
displayname: services
.users
.displayname(&body.user_id)
.await
.ok(),
2022-01-22 16:58:32 +01:00
})
2020-07-30 18:14:47 +02:00
}
/// # `PUT /_matrix/client/v3/profile/{userId}/avatar_url`
2021-08-31 19:14:37 +02:00
///
/// Updates the `avatar_url` and `blurhash`.
2021-08-31 19:14:37 +02:00
///
/// - Also makes sure other users receive the update using presence EDUs
2024-04-22 23:48:57 -04:00
pub(crate) async fn set_avatar_url_route(
State(services): State<crate::State>,
body: Ruma<set_avatar_url::v3::Request>,
2024-04-22 23:48:57 -04:00
) -> Result<set_avatar_url::v3::Response> {
let sender_user = body.sender_user();
if *sender_user != body.user_id && body.appservice_info.is_none() {
return Err!(Request(Forbidden("You cannot update the profile of another user")));
}
2024-07-16 08:05:25 +00:00
let all_joined_rooms: Vec<OwnedRoomId> = services
2022-10-05 09:34:25 +02:00
.state_cache
.rooms_joined(&body.user_id)
2024-08-08 17:18:30 +00:00
.map(ToOwned::to_owned)
.collect()
.await;
2021-08-31 21:20:03 +02:00
2025-08-25 19:12:27 +05:00
services
.users
.update_avatar_url(
&body.user_id,
body.avatar_url.clone(),
body.blurhash.clone(),
&all_joined_rooms,
)
.await;
2020-07-30 18:14:47 +02:00
2025-09-09 18:12:21 +05:00
// Presence update
services
.presence
.maybe_ping_presence(&body.user_id, &PresenceState::Online)
.await
.ok();
2022-02-18 15:33:14 +01:00
Ok(set_avatar_url::v3::Response {})
2020-07-30 18:14:47 +02:00
}
/// # `GET /_matrix/client/v3/profile/{userId}/avatar_url`
2021-08-31 19:14:37 +02:00
///
/// Returns the `avatar_url` and `blurhash` of the user.
2021-08-31 19:14:37 +02:00
///
2024-06-16 00:36:49 +00:00
/// - If user is on another server and we do not have a local copy already fetch
/// `avatar_url` and blurhash over federation
2024-04-22 23:48:57 -04:00
pub(crate) async fn get_avatar_url_route(
State(services): State<crate::State>,
body: Ruma<get_avatar_url::v3::Request>,
2024-04-22 23:48:57 -04:00
) -> Result<get_avatar_url::v3::Response> {
2024-07-22 07:43:51 +00:00
if !services.globals.user_is_local(&body.user_id) {
// Create and update our local copy of the user
2024-07-16 08:05:25 +00:00
if let Ok(response) = services
.sending
.send_federation_request(
body.user_id.server_name(),
federation::query::get_profile_information::v1::Request {
2022-12-14 13:09:10 +01:00
user_id: body.user_id.clone(),
field: None, // we want the full user's profile to update locally as well
},
)
.await
{
2024-08-08 17:18:30 +00:00
if !services.users.exists(&body.user_id).await {
2025-04-19 23:34:52 +02:00
services
.users
.create(&body.user_id, None, None)
.await?;
}
2024-07-16 08:05:25 +00:00
services
2024-03-25 17:05:11 -04:00
.users
2024-08-08 17:18:30 +00:00
.set_displayname(&body.user_id, response.displayname.clone());
2024-07-16 08:05:25 +00:00
services
2024-03-25 17:05:11 -04:00
.users
2024-08-08 17:18:30 +00:00
.set_avatar_url(&body.user_id, response.avatar_url.clone());
2024-07-16 08:05:25 +00:00
services
2024-03-25 17:05:11 -04:00
.users
2024-08-08 17:18:30 +00:00
.set_blurhash(&body.user_id, response.blurhash.clone());
return Ok(get_avatar_url::v3::Response {
avatar_url: response.avatar_url,
blurhash: response.blurhash,
});
}
}
2024-08-08 17:18:30 +00:00
if !services.users.exists(&body.user_id).await {
// Return 404 if this user doesn't exist and we couldn't fetch it over
// federation
return Err!(Request(NotFound("Profile was not found.")));
}
let (avatar_url, blurhash) = join(
services.users.avatar_url(&body.user_id).ok(),
services.users.blurhash(&body.user_id).ok(),
)
.await;
Ok(get_avatar_url::v3::Response { avatar_url, blurhash })
2020-07-30 18:14:47 +02:00
}
/// # `GET /_matrix/client/v3/profile/{userId}`
2021-08-31 19:14:37 +02:00
///
/// Returns the displayname, avatar_url, blurhash, and tz of the user.
2021-08-31 19:14:37 +02:00
///
/// - If user is on another server and we do not have a local copy already,
2024-06-16 00:36:49 +00:00
/// fetch profile over federation.
2024-07-16 08:05:25 +00:00
pub(crate) async fn get_profile_route(
State(services): State<crate::State>,
body: Ruma<get_profile::v3::Request>,
2024-07-16 08:05:25 +00:00
) -> Result<get_profile::v3::Response> {
2024-07-22 07:43:51 +00:00
if !services.globals.user_is_local(&body.user_id) {
// Create and update our local copy of the user
2024-07-16 08:05:25 +00:00
if let Ok(response) = services
.sending
.send_federation_request(
body.user_id.server_name(),
federation::query::get_profile_information::v1::Request {
2022-12-14 13:09:10 +01:00
user_id: body.user_id.clone(),
field: None,
},
)
.await
{
2024-08-08 17:18:30 +00:00
if !services.users.exists(&body.user_id).await {
2025-04-19 23:34:52 +02:00
services
.users
.create(&body.user_id, None, None)
.await?;
}
2024-07-16 08:05:25 +00:00
services
2024-03-25 17:05:11 -04:00
.users
2024-08-08 17:18:30 +00:00
.set_displayname(&body.user_id, response.displayname.clone());
2024-07-16 08:05:25 +00:00
services
2024-03-25 17:05:11 -04:00
.users
2024-08-08 17:18:30 +00:00
.set_avatar_url(&body.user_id, response.avatar_url.clone());
2024-07-16 08:05:25 +00:00
services
2024-03-25 17:05:11 -04:00
.users
2024-08-08 17:18:30 +00:00
.set_blurhash(&body.user_id, response.blurhash.clone());
services
.users
2024-08-08 17:18:30 +00:00
.set_timezone(&body.user_id, response.tz.clone());
for (profile_key, profile_key_value) in &response.custom_profile_fields {
services.users.set_profile_key(
&body.user_id,
profile_key,
Some(profile_key_value.clone()),
);
}
2025-08-26 02:41:51 +00:00
let canonical_fields = [
("avatar_url", response.avatar_url.map(Into::into)),
("blurhash", response.blurhash),
("displayname", response.displayname),
("tz", response.tz),
];
let response = canonical_fields
.into_iter()
.filter_map(|(key, val)| val.map(|val| (key, val)))
.map(|(key, val)| (key.to_owned(), val.into()))
.chain(response.custom_profile_fields.into_iter());
return Ok(response.collect::<get_profile::v3::Response>());
}
}
2024-08-08 17:18:30 +00:00
if !services.users.exists(&body.user_id).await {
// Return 404 if this user doesn't exist and we couldn't fetch it over
// federation
return Err!(Request(NotFound("Profile was not found.")));
2020-07-30 18:14:47 +02:00
}
let mut custom_profile_fields: BTreeMap<String, serde_json::Value> = services
.users
.all_profile_keys(&body.user_id)
.collect()
.await;
// services.users.timezone will collect the MSC4175 timezone key if it exists
custom_profile_fields.remove("us.cloke.msc4175.tz");
custom_profile_fields.remove("m.tz");
let (avatar_url, blurhash, displayname, tz) = join4(
services.users.avatar_url(&body.user_id).ok(),
services.users.blurhash(&body.user_id).ok(),
services.users.displayname(&body.user_id).ok(),
services.users.timezone(&body.user_id).ok(),
)
.await;
2025-08-26 02:41:51 +00:00
let canonical_fields = [
("avatar_url", avatar_url.map(Into::into)),
("blurhash", blurhash),
("displayname", displayname),
("tz", tz),
];
let response = canonical_fields
.into_iter()
.filter_map(|(key, val)| val.map(|val| (key, val)))
.map(|(key, val)| (key.to_owned(), val.into()))
.chain(custom_profile_fields.into_iter());
Ok(response.collect::<get_profile::v3::Response>())
2020-07-30 18:14:47 +02:00
}