backups/grapevine
1
0
Fork 0
mirror of https://gitlab.computer.surgery/matrix/grapevine.git synced 2025-12-17 15:51:23 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

rename Ruma to Ar

Browse source 
This follows the pattern of the previous commit.
This commit is contained in:
Charles Hall 2024-05-18 19:01:27 -07:00
parent 7ea98dac72
commit f8961d5578
No known key found for this signature in database
GPG key ID: 7B8E0645816E07CF
37 changed files with 183 additions and 181 deletions
Download patch file Download diff file Expand all files Collapse all files

18
src/api/client_server/account.rs
View file

@ -19,7 +19,7 @@ use ruma::{
use tracing::{info, warn};
use super::{DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
use crate::{api::client_server, services, utils, Error, Ra, Result, Ruma};
use crate::{api::client_server, services, utils, Ar, Error, Ra, Result};
const RANDOM_USER_ID_LENGTH: usize = 10;
@ -35,7 +35,7 @@ const RANDOM_USER_ID_LENGTH: usize = 10;
/// Note: This will not reserve the username, so the username might become
/// invalid when trying to register
pub(crate) async fn get_register_available_route(
body: Ruma<get_username_availability::v3::Request>,
body: Ar<get_username_availability::v3::Request>,
) -> Result<Ra<get_username_availability::v3::Response>> {
// Validate user id
let user_id = UserId::parse_with_server_name(
@ -87,7 +87,7 @@ pub(crate) async fn get_register_available_route(
/// `access_token`
#[allow(clippy::too_many_lines)]
pub(crate) async fn register_route(
body: Ruma<register::v3::Request>,
body: Ar<register::v3::Request>,
) -> Result<Ra<register::v3::Response>> {
if !services().globals.allow_registration()
&& body.appservice_info.is_none()
@ -327,7 +327,7 @@ pub(crate) async fn register_route(
/// - Forgets to-device events
/// - Triggers device list updates
pub(crate) async fn change_password_route(
body: Ruma<change_password::v3::Request>,
body: Ar<change_password::v3::Request>,
) -> Result<Ra<change_password::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
@ -390,7 +390,7 @@ pub(crate) async fn change_password_route(
///
/// Note: Also works for Application Services
pub(crate) async fn whoami_route(
body: Ruma<whoami::v3::Request>,
body: Ar<whoami::v3::Request>,
) -> Result<Ra<whoami::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let device_id = body.sender_device.as_ref().cloned();
@ -415,7 +415,7 @@ pub(crate) async fn whoami_route(
/// - Triggers device list updates
/// - Removes ability to log in again
pub(crate) async fn deactivate_route(
body: Ruma<deactivate::v3::Request>,
body: Ar<deactivate::v3::Request>,
) -> Result<Ra<deactivate::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
@ -472,7 +472,7 @@ pub(crate) async fn deactivate_route(
///
/// - Currently always returns empty list
pub(crate) async fn third_party_route(
body: Ruma<get_3pids::v3::Request>,
body: Ar<get_3pids::v3::Request>,
) -> Result<Ra<get_3pids::v3::Response>> {
let _sender_user =
body.sender_user.as_ref().expect("user is authenticated");
@ -488,7 +488,7 @@ pub(crate) async fn third_party_route(
/// - 403 signals that The homeserver does not allow the third party identifier
/// as a contact option.
pub(crate) async fn request_3pid_management_token_via_email_route(
_body: Ruma<request_3pid_management_token_via_email::v3::Request>,
_body: Ar<request_3pid_management_token_via_email::v3::Request>,
) -> Result<Ra<request_3pid_management_token_via_email::v3::Response>> {
Err(Error::BadRequest(
ErrorKind::ThreepidDenied,
@ -504,7 +504,7 @@ pub(crate) async fn request_3pid_management_token_via_email_route(
/// - 403 signals that The homeserver does not allow the third party identifier
/// as a contact option.
pub(crate) async fn request_3pid_management_token_via_msisdn_route(
_body: Ruma<request_3pid_management_token_via_msisdn::v3::Request>,
_body: Ar<request_3pid_management_token_via_msisdn::v3::Request>,
) -> Result<Ra<request_3pid_management_token_via_msisdn::v3::Response>> {
Err(Error::BadRequest(
ErrorKind::ThreepidDenied,

8
src/api/client_server/alias.rs
View file

@ -11,13 +11,13 @@ use ruma::{
OwnedRoomAliasId,
};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `PUT /_matrix/client/r0/directory/room/{roomAlias}`
///
/// Creates a new room alias on this server.
pub(crate) async fn create_alias_route(
body: Ruma<create_alias::v3::Request>,
body: Ar<create_alias::v3::Request>,
) -> Result<Ra<create_alias::v3::Response>> {
if body.room_alias.server_name() != services().globals.server_name() {
return Err(Error::BadRequest(
@ -56,7 +56,7 @@ pub(crate) async fn create_alias_route(
/// - TODO: additional access control checks
/// - TODO: Update canonical alias event
pub(crate) async fn delete_alias_route(
body: Ruma<delete_alias::v3::Request>,
body: Ar<delete_alias::v3::Request>,
) -> Result<Ra<delete_alias::v3::Response>> {
if body.room_alias.server_name() != services().globals.server_name() {
return Err(Error::BadRequest(
@ -92,7 +92,7 @@ pub(crate) async fn delete_alias_route(
///
/// - TODO: Suggest more servers to join via
pub(crate) async fn get_alias_route(
body: Ruma<get_alias::v3::Request>,
body: Ar<get_alias::v3::Request>,
) -> Result<Ra<get_alias::v3::Response>> {
get_alias_helper(body.body.room_alias).await.map(Ra)
}

30
src/api/client_server/backup.rs
View file

@ -9,13 +9,13 @@ use ruma::api::client::{
error::ErrorKind,
};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `POST /_matrix/client/r0/room_keys/version`
///
/// Creates a new backup.
pub(crate) async fn create_backup_version_route(
body: Ruma<create_backup_version::v3::Request>,
body: Ar<create_backup_version::v3::Request>,
) -> Result<Ra<create_backup_version::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let version =
@ -31,7 +31,7 @@ pub(crate) async fn create_backup_version_route(
/// Update information about an existing backup. Only `auth_data` can be
/// modified.
pub(crate) async fn update_backup_version_route(
body: Ruma<update_backup_version::v3::Request>,
body: Ar<update_backup_version::v3::Request>,
) -> Result<Ra<update_backup_version::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().key_backups.update_backup(
@ -47,7 +47,7 @@ pub(crate) async fn update_backup_version_route(
///
/// Get information about the latest backup version.
pub(crate) async fn get_latest_backup_info_route(
body: Ruma<get_latest_backup_info::v3::Request>,
body: Ar<get_latest_backup_info::v3::Request>,
) -> Result<Ra<get_latest_backup_info::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -75,7 +75,7 @@ pub(crate) async fn get_latest_backup_info_route(
///
/// Get information about an existing backup.
pub(crate) async fn get_backup_info_route(
body: Ruma<get_backup_info::v3::Request>,
body: Ar<get_backup_info::v3::Request>,
) -> Result<Ra<get_backup_info::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let algorithm = services()
@ -105,7 +105,7 @@ pub(crate) async fn get_backup_info_route(
/// - Deletes both information about the backup, as well as all key data related
/// to the backup
pub(crate) async fn delete_backup_version_route(
body: Ruma<delete_backup_version::v3::Request>,
body: Ar<delete_backup_version::v3::Request>,
) -> Result<Ra<delete_backup_version::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -123,7 +123,7 @@ pub(crate) async fn delete_backup_version_route(
/// - Adds the keys to the backup
/// - Returns the new number of keys in this backup and the etag
pub(crate) async fn add_backup_keys_route(
body: Ruma<add_backup_keys::v3::Request>,
body: Ar<add_backup_keys::v3::Request>,
) -> Result<Ra<add_backup_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -171,7 +171,7 @@ pub(crate) async fn add_backup_keys_route(
/// - Adds the keys to the backup
/// - Returns the new number of keys in this backup and the etag
pub(crate) async fn add_backup_keys_for_room_route(
body: Ruma<add_backup_keys_for_room::v3::Request>,
body: Ar<add_backup_keys_for_room::v3::Request>,
) -> Result<Ra<add_backup_keys_for_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -217,7 +217,7 @@ pub(crate) async fn add_backup_keys_for_room_route(
/// - Adds the keys to the backup
/// - Returns the new number of keys in this backup and the etag
pub(crate) async fn add_backup_keys_for_session_route(
body: Ruma<add_backup_keys_for_session::v3::Request>,
body: Ar<add_backup_keys_for_session::v3::Request>,
) -> Result<Ra<add_backup_keys_for_session::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -256,7 +256,7 @@ pub(crate) async fn add_backup_keys_for_session_route(
///
/// Retrieves all keys from the backup.
pub(crate) async fn get_backup_keys_route(
body: Ruma<get_backup_keys::v3::Request>,
body: Ar<get_backup_keys::v3::Request>,
) -> Result<Ra<get_backup_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -271,7 +271,7 @@ pub(crate) async fn get_backup_keys_route(
///
/// Retrieves all keys from the backup for a given room.
pub(crate) async fn get_backup_keys_for_room_route(
body: Ruma<get_backup_keys_for_room::v3::Request>,
body: Ar<get_backup_keys_for_room::v3::Request>,
) -> Result<Ra<get_backup_keys_for_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -290,7 +290,7 @@ pub(crate) async fn get_backup_keys_for_room_route(
///
/// Retrieves a key from the backup.
pub(crate) async fn get_backup_keys_for_session_route(
body: Ruma<get_backup_keys_for_session::v3::Request>,
body: Ar<get_backup_keys_for_session::v3::Request>,
) -> Result<Ra<get_backup_keys_for_session::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -316,7 +316,7 @@ pub(crate) async fn get_backup_keys_for_session_route(
///
/// Delete the keys from the backup.
pub(crate) async fn delete_backup_keys_route(
body: Ruma<delete_backup_keys::v3::Request>,
body: Ar<delete_backup_keys::v3::Request>,
) -> Result<Ra<delete_backup_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -336,7 +336,7 @@ pub(crate) async fn delete_backup_keys_route(
///
/// Delete the keys from the backup for a given room.
pub(crate) async fn delete_backup_keys_for_room_route(
body: Ruma<delete_backup_keys_for_room::v3::Request>,
body: Ar<delete_backup_keys_for_room::v3::Request>,
) -> Result<Ra<delete_backup_keys_for_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -360,7 +360,7 @@ pub(crate) async fn delete_backup_keys_for_room_route(
///
/// Delete a key from the backup.
pub(crate) async fn delete_backup_keys_for_session_route(
body: Ruma<delete_backup_keys_for_session::v3::Request>,
body: Ar<delete_backup_keys_for_session::v3::Request>,
) -> Result<Ra<delete_backup_keys_for_session::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

4
src/api/client_server/capabilities.rs
View file

@ -4,14 +4,14 @@ use ruma::api::client::discovery::get_capabilities::{
self, Capabilities, RoomVersionStability, RoomVersionsCapability,
};
use crate::{services, Ra, Result, Ruma};
use crate::{services, Ar, Ra, Result};
/// # `GET /_matrix/client/r0/capabilities`
///
/// Get information on the supported feature set and other relevent capabilities
/// of this server.
pub(crate) async fn get_capabilities_route(
_body: Ruma<get_capabilities::v3::Request>,
_body: Ar<get_capabilities::v3::Request>,
) -> Result<Ra<get_capabilities::v3::Response>> {
let mut available = BTreeMap::new();
for room_version in &services().globals.unstable_room_versions {

10
src/api/client_server/config.rs
View file

@ -14,13 +14,13 @@ use ruma::{
use serde::Deserialize;
use serde_json::{json, value::RawValue as RawJsonValue};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `PUT /_matrix/client/r0/user/{userId}/account_data/{type}`
///
/// Sets some account data for the sender user.
pub(crate) async fn set_global_account_data_route(
body: Ruma<set_global_account_data::v3::Request>,
body: Ar<set_global_account_data::v3::Request>,
) -> Result<Ra<set_global_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -48,7 +48,7 @@ pub(crate) async fn set_global_account_data_route(
///
/// Sets some room account data for the sender user.
pub(crate) async fn set_room_account_data_route(
body: Ruma<set_room_account_data::v3::Request>,
body: Ar<set_room_account_data::v3::Request>,
) -> Result<Ra<set_room_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -76,7 +76,7 @@ pub(crate) async fn set_room_account_data_route(
///
/// Gets some account data for the sender user.
pub(crate) async fn get_global_account_data_route(
body: Ruma<get_global_account_data::v3::Request>,
body: Ar<get_global_account_data::v3::Request>,
) -> Result<Ra<get_global_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -101,7 +101,7 @@ pub(crate) async fn get_global_account_data_route(
///
/// Gets some room account data for the sender user.
pub(crate) async fn get_room_account_data_route(
body: Ruma<get_room_account_data::v3::Request>,
body: Ar<get_room_account_data::v3::Request>,
) -> Result<Ra<get_room_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

4
src/api/client_server/context.rs
View file

@ -9,7 +9,7 @@ use ruma::{
};
use tracing::error;
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `GET /_matrix/client/r0/rooms/{roomId}/context`
///
@ -20,7 +20,7 @@ use crate::{services, Error, Ra, Result, Ruma};
/// joined, depending on `history_visibility`)
#[allow(clippy::too_many_lines)]
pub(crate) async fn get_context_route(
body: Ruma<get_context::v3::Request>,
body: Ar<get_context::v3::Request>,
) -> Result<Ra<get_context::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =

12
src/api/client_server/device.rs
View file

@ -8,13 +8,13 @@ use ruma::api::client::{
};
use super::SESSION_ID_LENGTH;
use crate::{services, utils, Error, Ra, Result, Ruma};
use crate::{services, utils, Ar, Error, Ra, Result};
/// # `GET /_matrix/client/r0/devices`
///
/// Get metadata on all devices of the sender user.
pub(crate) async fn get_devices_route(
body: Ruma<get_devices::v3::Request>,
body: Ar<get_devices::v3::Request>,
) -> Result<Ra<get_devices::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -33,7 +33,7 @@ pub(crate) async fn get_devices_route(
///
/// Get metadata on a single device of the sender user.
pub(crate) async fn get_device_route(
body: Ruma<get_device::v3::Request>,
body: Ar<get_device::v3::Request>,
) -> Result<Ra<get_device::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -51,7 +51,7 @@ pub(crate) async fn get_device_route(
///
/// Updates the metadata on a given device of the sender user.
pub(crate) async fn update_device_route(
body: Ruma<update_device::v3::Request>,
body: Ar<update_device::v3::Request>,
) -> Result<Ra<update_device::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -82,7 +82,7 @@ pub(crate) async fn update_device_route(
/// - Forgets to-device events
/// - Triggers device list updates
pub(crate) async fn delete_device_route(
body: Ruma<delete_device::v3::Request>,
body: Ar<delete_device::v3::Request>,
) -> Result<Ra<delete_device::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
@ -136,7 +136,7 @@ pub(crate) async fn delete_device_route(
/// - Forgets to-device events
/// - Triggers device list updates
pub(crate) async fn delete_devices_route(
body: Ruma<delete_devices::v3::Request>,
body: Ar<delete_devices::v3::Request>,
) -> Result<Ra<delete_devices::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =

10
src/api/client_server/directory.rs
View file

@ -29,7 +29,7 @@ use ruma::{
};
use tracing::{error, info, warn};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `POST /_matrix/client/r0/publicRooms`
///
@ -37,7 +37,7 @@ use crate::{services, Error, Ra, Result, Ruma};
///
/// - Rooms are ordered by the number of joined members
pub(crate) async fn get_public_rooms_filtered_route(
body: Ruma<get_public_rooms_filtered::v3::Request>,
body: Ar<get_public_rooms_filtered::v3::Request>,
) -> Result<Ra<get_public_rooms_filtered::v3::Response>> {
get_public_rooms_filtered_helper(
body.server.as_deref(),
@ -56,7 +56,7 @@ pub(crate) async fn get_public_rooms_filtered_route(
///
/// - Rooms are ordered by the number of joined members
pub(crate) async fn get_public_rooms_route(
body: Ruma<get_public_rooms::v3::Request>,
body: Ar<get_public_rooms::v3::Request>,
) -> Result<Ra<get_public_rooms::v3::Response>> {
let response = get_public_rooms_filtered_helper(
body.server.as_deref(),
@ -81,7 +81,7 @@ pub(crate) async fn get_public_rooms_route(
///
/// - TODO: Access control checks
pub(crate) async fn set_room_visibility_route(
body: Ruma<set_room_visibility::v3::Request>,
body: Ar<set_room_visibility::v3::Request>,
) -> Result<Ra<set_room_visibility::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -113,7 +113,7 @@ pub(crate) async fn set_room_visibility_route(
///
/// Gets the visibility of a given room in the room directory.
pub(crate) async fn get_room_visibility_route(
body: Ruma<get_room_visibility::v3::Request>,
body: Ar<get_room_visibility::v3::Request>,
) -> Result<Ra<get_room_visibility::v3::Response>> {
if !services().rooms.metadata.exists(&body.room_id)? {
// Return 404 if the room doesn't exist

6
src/api/client_server/filter.rs
View file

@ -3,7 +3,7 @@ use ruma::api::client::{
filter::{create_filter, get_filter},
};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `GET /_matrix/client/r0/user/{userId}/filter/{filterId}`
///
@ -11,7 +11,7 @@ use crate::{services, Error, Ra, Result, Ruma};
///
/// - A user can only access their own filters
pub(crate) async fn get_filter_route(
body: Ruma<get_filter::v3::Request>,
body: Ar<get_filter::v3::Request>,
) -> Result<Ra<get_filter::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let Some(filter) =
@ -30,7 +30,7 @@ pub(crate) async fn get_filter_route(
///
/// Creates a new filter to be used by other endpoints.
pub(crate) async fn create_filter_route(
body: Ruma<create_filter::v3::Request>,
body: Ar<create_filter::v3::Request>,
) -> Result<Ra<create_filter::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
Ok(Ra(create_filter::v3::Response::new(

14
src/api/client_server/keys.rs
View file

@ -23,7 +23,7 @@ use serde_json::json;
use tracing::debug;
use super::SESSION_ID_LENGTH;
use crate::{services, utils, Error, Ra, Result, Ruma};
use crate::{services, utils, Ar, Error, Ra, Result};
/// # `POST /_matrix/client/r0/keys/upload`
///
@ -33,7 +33,7 @@ use crate::{services, utils, Error, Ra, Result, Ruma};
/// - If there are no device keys yet: Adds device keys (TODO: merge with
/// existing keys?)
pub(crate) async fn upload_keys_route(
body: Ruma<upload_keys::v3::Request>,
body: Ar<upload_keys::v3::Request>,
) -> Result<Ra<upload_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
@ -80,7 +80,7 @@ pub(crate) async fn upload_keys_route(
/// - The master and self-signing keys contain signatures that the user is
/// allowed to see
pub(crate) async fn get_keys_route(
body: Ruma<get_keys::v3::Request>,
body: Ar<get_keys::v3::Request>,
) -> Result<Ra<get_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -96,7 +96,7 @@ pub(crate) async fn get_keys_route(
///
/// Claims one-time keys
pub(crate) async fn claim_keys_route(
body: Ruma<claim_keys::v3::Request>,
body: Ar<claim_keys::v3::Request>,
) -> Result<Ra<claim_keys::v3::Response>> {
let response = claim_keys_helper(&body.one_time_keys).await?;
@ -109,7 +109,7 @@ pub(crate) async fn claim_keys_route(
///
/// - Requires UIAA to verify password
pub(crate) async fn upload_signing_keys_route(
body: Ruma<upload_signing_keys::v3::Request>,
body: Ar<upload_signing_keys::v3::Request>,
) -> Result<Ra<upload_signing_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
@ -163,7 +163,7 @@ pub(crate) async fn upload_signing_keys_route(
///
/// Uploads end-to-end key signatures from the sender user.
pub(crate) async fn upload_signatures_route(
body: Ruma<upload_signatures::v3::Request>,
body: Ar<upload_signatures::v3::Request>,
) -> Result<Ra<upload_signatures::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -226,7 +226,7 @@ pub(crate) async fn upload_signatures_route(
///
/// - TODO: left users
pub(crate) async fn get_key_changes_route(
body: Ruma<get_key_changes::v3::Request>,
body: Ar<get_key_changes::v3::Request>,
) -> Result<Ra<get_key_changes::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

14
src/api/client_server/media.rs
View file

@ -8,9 +8,7 @@ use ruma::api::client::{
},
};
use crate::{
service::media::FileMeta, services, utils, Error, Ra, Result, Ruma,
};
use crate::{service::media::FileMeta, services, utils, Ar, Error, Ra, Result};
const MXC_LENGTH: usize = 32;
@ -18,7 +16,7 @@ const MXC_LENGTH: usize = 32;
///
/// Returns max upload size.
pub(crate) async fn get_media_config_route(
_body: Ruma<get_media_config::v3::Request>,
_body: Ar<get_media_config::v3::Request>,
) -> Result<Ra<get_media_config::v3::Response>> {
Ok(Ra(get_media_config::v3::Response {
upload_size: services().globals.max_request_size().into(),
@ -32,7 +30,7 @@ pub(crate) async fn get_media_config_route(
/// - Some metadata will be saved in the database
/// - Media will be saved in the media/ directory
pub(crate) async fn create_content_route(
body: Ruma<create_content::v3::Request>,
body: Ar<create_content::v3::Request>,
) -> Result<Ra<create_content::v3::Response>> {
let mxc = format!(
"mxc://{}/{}",
@ -97,7 +95,7 @@ pub(crate) async fn get_remote_content(
///
/// - Only allows federation if `allow_remote` is true
pub(crate) async fn get_content_route(
body: Ruma<get_content::v3::Request>,
body: Ar<get_content::v3::Request>,
) -> Result<Ra<get_content::v3::Response>> {
let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
@ -131,7 +129,7 @@ pub(crate) async fn get_content_route(
///
/// - Only allows federation if `allow_remote` is true
pub(crate) async fn get_content_as_filename_route(
body: Ruma<get_content_as_filename::v3::Request>,
body: Ar<get_content_as_filename::v3::Request>,
) -> Result<Ra<get_content_as_filename::v3::Response>> {
let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
@ -177,7 +175,7 @@ pub(crate) async fn get_content_as_filename_route(
///
/// - Only allows federation if `allow_remote` is true
pub(crate) async fn get_content_thumbnail_route(
body: Ruma<get_content_thumbnail::v3::Request>,
body: Ar<get_content_thumbnail::v3::Request>,
) -> Result<Ra<get_content_thumbnail::v3::Response>> {
let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);

24
src/api/client_server/membership.rs
View file

@ -36,7 +36,7 @@ use tracing::{debug, error, info, warn};
use super::get_alias_helper;
use crate::{
service::pdu::{gen_event_id_canonical_json, PduBuilder},
services, utils, Error, PduEvent, Ra, Result, Ruma,
services, utils, Ar, Error, PduEvent, Ra, Result,
};
/// # `POST /_matrix/client/r0/rooms/{roomId}/join`
@ -48,7 +48,7 @@ use crate::{
/// - If the server does not know about the room: asks other servers over
/// federation
pub(crate) async fn join_room_by_id_route(
body: Ruma<join_room_by_id::v3::Request>,
body: Ar<join_room_by_id::v3::Request>,
) -> Result<Ra<join_room_by_id::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -95,7 +95,7 @@ pub(crate) async fn join_room_by_id_route(
/// - If the server does not know about the room: asks other servers over
/// federation
pub(crate) async fn join_room_by_id_or_alias_route(
body: Ruma<join_room_by_id_or_alias::v3::Request>,
body: Ar<join_room_by_id_or_alias::v3::Request>,
) -> Result<Ra<join_room_by_id_or_alias::v3::Response>> {
let sender_user =
body.sender_user.as_deref().expect("user is authenticated");
@ -159,7 +159,7 @@ pub(crate) async fn join_room_by_id_or_alias_route(
///
/// - This should always work if the user is currently joined.
pub(crate) async fn leave_room_route(
body: Ruma<leave_room::v3::Request>,
body: Ar<leave_room::v3::Request>,
) -> Result<Ra<leave_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -172,7 +172,7 @@ pub(crate) async fn leave_room_route(
///
/// Tries to send an invite event into the room.
pub(crate) async fn invite_user_route(
body: Ruma<invite_user::v3::Request>,
body: Ar<invite_user::v3::Request>,
) -> Result<Ra<invite_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -198,7 +198,7 @@ pub(crate) async fn invite_user_route(
///
/// Tries to send a kick event into the room.
pub(crate) async fn kick_user_route(
body: Ruma<kick_user::v3::Request>,
body: Ar<kick_user::v3::Request>,
) -> Result<Ra<kick_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -267,7 +267,7 @@ pub(crate) async fn kick_user_route(
///
/// Tries to send a ban event into the room.
pub(crate) async fn ban_user_route(
body: Ruma<ban_user::v3::Request>,
body: Ar<ban_user::v3::Request>,
) -> Result<Ra<ban_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -351,7 +351,7 @@ pub(crate) async fn ban_user_route(
///
/// Tries to send an unban event into the room.
pub(crate) async fn unban_user_route(
body: Ruma<unban_user::v3::Request>,
body: Ar<unban_user::v3::Request>,
) -> Result<Ra<unban_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -428,7 +428,7 @@ pub(crate) async fn unban_user_route(
/// Note: Other devices of the user have no way of knowing the room was
/// forgotten, so this has to be called from every device
pub(crate) async fn forget_room_route(
body: Ruma<forget_room::v3::Request>,
body: Ar<forget_room::v3::Request>,
) -> Result<Ra<forget_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -441,7 +441,7 @@ pub(crate) async fn forget_room_route(
///
/// Lists all rooms the user has joined.
pub(crate) async fn joined_rooms_route(
body: Ruma<joined_rooms::v3::Request>,
body: Ar<joined_rooms::v3::Request>,
) -> Result<Ra<joined_rooms::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -462,7 +462,7 @@ pub(crate) async fn joined_rooms_route(
///
/// - Only works if the user is currently joined
pub(crate) async fn get_member_events_route(
body: Ruma<get_member_events::v3::Request>,
body: Ar<get_member_events::v3::Request>,
) -> Result<Ra<get_member_events::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -497,7 +497,7 @@ pub(crate) async fn get_member_events_route(
/// - The sender user must be in the room
/// - TODO: An appservice just needs a puppet joined
pub(crate) async fn joined_members_route(
body: Ruma<joined_members::v3::Request>,
body: Ar<joined_members::v3::Request>,
) -> Result<Ra<joined_members::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

6
src/api/client_server/message.rs
View file

@ -14,7 +14,7 @@ use ruma::{
use crate::{
service::{pdu::PduBuilder, rooms::timeline::PduCount},
services, utils, Error, Ra, Result, Ruma,
services, utils, Ar, Error, Ra, Result,
};
/// # `PUT /_matrix/client/r0/rooms/{roomId}/send/{eventType}/{txnId}`
@ -27,7 +27,7 @@ use crate::{
/// - Tries to send the event into the room, auth rules will determine if it is
/// allowed
pub(crate) async fn send_message_event_route(
body: Ruma<send_message_event::v3::Request>,
body: Ar<send_message_event::v3::Request>,
) -> Result<Ra<send_message_event::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device = body.sender_device.as_deref();
@ -130,7 +130,7 @@ pub(crate) async fn send_message_event_route(
/// joined, depending on `history_visibility`)
#[allow(clippy::too_many_lines)]
pub(crate) async fn get_message_events_route(
body: Ruma<get_message_events::v3::Request>,
body: Ar<get_message_events::v3::Request>,
) -> Result<Ra<get_message_events::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =

12
src/api/client_server/profile.rs
View file

@ -18,7 +18,7 @@ use ruma::{
use serde_json::value::to_raw_value;
use tracing::warn;
use crate::{service::pdu::PduBuilder, services, Error, Ra, Result, Ruma};
use crate::{service::pdu::PduBuilder, services, Ar, Error, Ra, Result};
/// # `PUT /_matrix/client/r0/profile/{userId}/displayname`
///
@ -26,7 +26,7 @@ use crate::{service::pdu::PduBuilder, services, Error, Ra, Result, Ruma};
///
/// - Also makes sure other users receive the update using presence EDUs
pub(crate) async fn set_displayname_route(
body: Ruma<set_display_name::v3::Request>,
body: Ar<set_display_name::v3::Request>,
) -> Result<Ra<set_display_name::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -116,7 +116,7 @@ pub(crate) async fn set_displayname_route(
///
/// - If user is on another server: Fetches displayname over federation
pub(crate) async fn get_displayname_route(
body: Ruma<get_display_name::v3::Request>,
body: Ar<get_display_name::v3::Request>,
) -> Result<Ra<get_display_name::v3::Response>> {
if body.user_id.server_name() != services().globals.server_name() {
let response = services()
@ -146,7 +146,7 @@ pub(crate) async fn get_displayname_route(
///
/// - Also makes sure other users receive the update using presence EDUs
pub(crate) async fn set_avatar_url_route(
body: Ruma<set_avatar_url::v3::Request>,
body: Ar<set_avatar_url::v3::Request>,
) -> Result<Ra<set_avatar_url::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -239,7 +239,7 @@ pub(crate) async fn set_avatar_url_route(
/// - If user is on another server: Fetches `avatar_url` and `blurhash` over
/// federation
pub(crate) async fn get_avatar_url_route(
body: Ruma<get_avatar_url::v3::Request>,
body: Ar<get_avatar_url::v3::Request>,
) -> Result<Ra<get_avatar_url::v3::Response>> {
if body.user_id.server_name() != services().globals.server_name() {
let response = services()
@ -271,7 +271,7 @@ pub(crate) async fn get_avatar_url_route(
///
/// - If user is on another server: Fetches profile over federation
pub(crate) async fn get_profile_route(
body: Ruma<get_profile::v3::Request>,
body: Ar<get_profile::v3::Request>,
) -> Result<Ra<get_profile::v3::Response>> {
if body.user_id.server_name() != services().globals.server_name() {
let response = services()

22
src/api/client_server/push.rs
View file

@ -11,13 +11,13 @@ use ruma::{
push::{AnyPushRuleRef, InsertPushRuleError, RemovePushRuleError},
};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `GET /_matrix/client/r0/pushrules`
///
/// Retrieves the push rules event for this user.
pub(crate) async fn get_pushrules_all_route(
body: Ruma<get_pushrules_all::v3::Request>,
body: Ar<get_pushrules_all::v3::Request>,
) -> Result<Ra<get_pushrules_all::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -46,7 +46,7 @@ pub(crate) async fn get_pushrules_all_route(
///
/// Retrieves a single specified push rule for this user.
pub(crate) async fn get_pushrule_route(
body: Ruma<get_pushrule::v3::Request>,
body: Ar<get_pushrule::v3::Request>,
) -> Result<Ra<get_pushrule::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -84,7 +84,7 @@ pub(crate) async fn get_pushrule_route(
///
/// Creates a single specified push rule for this user.
pub(crate) async fn set_pushrule_route(
body: Ruma<set_pushrule::v3::Request>,
body: Ar<set_pushrule::v3::Request>,
) -> Result<Ra<set_pushrule::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let body = body.body;
@ -164,7 +164,7 @@ pub(crate) async fn set_pushrule_route(
///
/// Gets the actions of a single specified push rule for this user.
pub(crate) async fn get_pushrule_actions_route(
body: Ruma<get_pushrule_actions::v3::Request>,
body: Ar<get_pushrule_actions::v3::Request>,
) -> Result<Ra<get_pushrule_actions::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -209,7 +209,7 @@ pub(crate) async fn get_pushrule_actions_route(
///
/// Sets the actions of a single specified push rule for this user.
pub(crate) async fn set_pushrule_actions_route(
body: Ruma<set_pushrule_actions::v3::Request>,
body: Ar<set_pushrule_actions::v3::Request>,
) -> Result<Ra<set_pushrule_actions::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -264,7 +264,7 @@ pub(crate) async fn set_pushrule_actions_route(
///
/// Gets the enabled status of a single specified push rule for this user.
pub(crate) async fn get_pushrule_enabled_route(
body: Ruma<get_pushrule_enabled::v3::Request>,
body: Ar<get_pushrule_enabled::v3::Request>,
) -> Result<Ra<get_pushrule_enabled::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -310,7 +310,7 @@ pub(crate) async fn get_pushrule_enabled_route(
///
/// Sets the enabled status of a single specified push rule for this user.
pub(crate) async fn set_pushrule_enabled_route(
body: Ruma<set_pushrule_enabled::v3::Request>,
body: Ar<set_pushrule_enabled::v3::Request>,
) -> Result<Ra<set_pushrule_enabled::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -365,7 +365,7 @@ pub(crate) async fn set_pushrule_enabled_route(
///
/// Deletes a single specified push rule for this user.
pub(crate) async fn delete_pushrule_route(
body: Ruma<delete_pushrule::v3::Request>,
body: Ar<delete_pushrule::v3::Request>,
) -> Result<Ra<delete_pushrule::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -425,7 +425,7 @@ pub(crate) async fn delete_pushrule_route(
///
/// Gets all currently active pushers for the sender user.
pub(crate) async fn get_pushers_route(
body: Ruma<get_pushers::v3::Request>,
body: Ar<get_pushers::v3::Request>,
) -> Result<Ra<get_pushers::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -440,7 +440,7 @@ pub(crate) async fn get_pushers_route(
///
/// - TODO: Handle `append`
pub(crate) async fn set_pushers_route(
body: Ruma<set_pusher::v3::Request>,
body: Ar<set_pusher::v3::Request>,
) -> Result<Ra<set_pusher::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

6
src/api/client_server/read_marker.rs
View file

@ -12,7 +12,7 @@ use ruma::{
};
use crate::{
service::rooms::timeline::PduCount, services, Error, Ra, Result, Ruma,
service::rooms::timeline::PduCount, services, Ar, Error, Ra, Result,
};
/// # `POST /_matrix/client/r0/rooms/{roomId}/read_markers`
@ -23,7 +23,7 @@ use crate::{
/// - If `read_receipt` is set: Update private marker and public read receipt
/// EDU
pub(crate) async fn set_read_marker_route(
body: Ruma<set_read_marker::v3::Request>,
body: Ar<set_read_marker::v3::Request>,
) -> Result<Ra<set_read_marker::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -104,7 +104,7 @@ pub(crate) async fn set_read_marker_route(
///
/// Sets private read marker and public read receipt EDU.
pub(crate) async fn create_receipt_route(
body: Ruma<create_receipt::v3::Request>,
body: Ar<create_receipt::v3::Request>,
) -> Result<Ra<create_receipt::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

4
src/api/client_server/redact.rs
View file

@ -6,7 +6,7 @@ use ruma::{
};
use serde_json::value::to_raw_value;
use crate::{service::pdu::PduBuilder, services, Ra, Result, Ruma};
use crate::{service::pdu::PduBuilder, services, Ar, Ra, Result};
/// # `PUT /_matrix/client/r0/rooms/{roomId}/redact/{eventId}/{txnId}`
///
@ -14,7 +14,7 @@ use crate::{service::pdu::PduBuilder, services, Ra, Result, Ruma};
///
/// - TODO: Handle txn id
pub(crate) async fn redact_event_route(
body: Ruma<redact_event::v3::Request>,
body: Ar<redact_event::v3::Request>,
) -> Result<Ra<redact_event::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let body = body.body;

8
src/api/client_server/relations.rs
View file

@ -6,11 +6,11 @@ use ruma::{
uint,
};
use crate::{service::rooms::timeline::PduCount, services, Ra, Result, Ruma};
use crate::{service::rooms::timeline::PduCount, services, Ar, Ra, Result};
/// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}/{relType}/{eventType}`
pub(crate) async fn get_relating_events_with_rel_type_and_event_type_route(
body: Ruma<get_relating_events_with_rel_type_and_event_type::v1::Request>,
body: Ar<get_relating_events_with_rel_type_and_event_type::v1::Request>,
) -> Result<Ra<get_relating_events_with_rel_type_and_event_type::v1::Response>>
{
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -54,7 +54,7 @@ pub(crate) async fn get_relating_events_with_rel_type_and_event_type_route(
/// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}/{relType}`
pub(crate) async fn get_relating_events_with_rel_type_route(
body: Ruma<get_relating_events_with_rel_type::v1::Request>,
body: Ar<get_relating_events_with_rel_type::v1::Request>,
) -> Result<Ra<get_relating_events_with_rel_type::v1::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -97,7 +97,7 @@ pub(crate) async fn get_relating_events_with_rel_type_route(
/// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}`
pub(crate) async fn get_relating_events_route(
body: Ruma<get_relating_events::v1::Request>,
body: Ar<get_relating_events::v1::Request>,
) -> Result<Ra<get_relating_events::v1::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

4
src/api/client_server/report.rs
View file

@ -4,13 +4,13 @@ use ruma::{
int,
};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `POST /_matrix/client/r0/rooms/{roomId}/report/{eventId}`
///
/// Reports an inappropriate event to homeserver admins
pub(crate) async fn report_event_route(
body: Ruma<report_content::v3::Request>,
body: Ar<report_content::v3::Request>,
) -> Result<Ra<report_content::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

12
src/api/client_server/room.rs
View file

@ -30,8 +30,8 @@ use serde_json::{json, value::to_raw_value};
use tracing::{info, warn};
use crate::{
api::client_server::invite_helper, service::pdu::PduBuilder, services,
Error, Ra, Result, Ruma,
api::client_server::invite_helper, service::pdu::PduBuilder, services, Ar,
Error, Ra, Result,
};
/// # `POST /_matrix/client/r0/createRoom`
@ -52,7 +52,7 @@ use crate::{
/// - Send invite events
#[allow(clippy::too_many_lines)]
pub(crate) async fn create_room_route(
body: Ruma<create_room::v3::Request>,
body: Ar<create_room::v3::Request>,
) -> Result<Ra<create_room::v3::Response>> {
use create_room::v3::RoomPreset;
@ -548,7 +548,7 @@ pub(crate) async fn create_room_route(
/// - You have to currently be joined to the room (TODO: Respect history
/// visibility)
pub(crate) async fn get_room_event_route(
body: Ruma<get_room_event::v3::Request>,
body: Ar<get_room_event::v3::Request>,
) -> Result<Ra<get_room_event::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -585,7 +585,7 @@ pub(crate) async fn get_room_event_route(
/// - Only users joined to the room are allowed to call this TODO: Allow any
/// user to call it if `history_visibility` is world readable
pub(crate) async fn get_room_aliases_route(
body: Ruma<aliases::v3::Request>,
body: Ar<aliases::v3::Request>,
) -> Result<Ra<aliases::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -618,7 +618,7 @@ pub(crate) async fn get_room_aliases_route(
/// - Modifies old room power levels to prevent users from speaking
#[allow(clippy::too_many_lines)]
pub(crate) async fn upgrade_room_route(
body: Ruma<upgrade_room::v3::Request>,
body: Ar<upgrade_room::v3::Request>,
) -> Result<Ra<upgrade_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

4
src/api/client_server/search.rs
View file

@ -14,7 +14,7 @@ use ruma::{
uint,
};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `POST /_matrix/client/r0/search`
///
@ -24,7 +24,7 @@ use crate::{services, Error, Ra, Result, Ruma};
/// history visibility)
#[allow(clippy::too_many_lines)]
pub(crate) async fn search_events_route(
body: Ruma<search_events::v3::Request>,
body: Ar<search_events::v3::Request>,
) -> Result<Ra<search_events::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

10
src/api/client_server/session.rs
View file

@ -16,7 +16,7 @@ use serde::Deserialize;
use tracing::{info, warn};
use super::{DEVICE_ID_LENGTH, TOKEN_LENGTH};
use crate::{services, utils, Error, Ra, Result, Ruma};
use crate::{services, utils, Ar, Error, Ra, Result};
#[derive(Debug, Deserialize)]
struct Claims {
@ -28,7 +28,7 @@ struct Claims {
/// Get the supported login types of this server. One of these should be used as
/// the `type` field when logging in.
pub(crate) async fn get_login_types_route(
_body: Ruma<get_login_types::v3::Request>,
_body: Ar<get_login_types::v3::Request>,
) -> Result<Ra<get_login_types::v3::Response>> {
Ok(Ra(get_login_types::v3::Response::new(vec![
get_login_types::v3::LoginType::Password(PasswordLoginType::default()),
@ -53,7 +53,7 @@ pub(crate) async fn get_login_types_route(
/// see supported login types.
#[allow(clippy::too_many_lines)]
pub(crate) async fn login_route(
body: Ruma<login::v3::Request>,
body: Ar<login::v3::Request>,
) -> Result<Ra<login::v3::Response>> {
// To allow deprecated login methods
#![allow(deprecated)]
@ -277,7 +277,7 @@ pub(crate) async fn login_route(
/// - Forgets to-device events
/// - Triggers device list updates
pub(crate) async fn logout_route(
body: Ruma<logout::v3::Request>,
body: Ar<logout::v3::Request>,
) -> Result<Ra<logout::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
@ -310,7 +310,7 @@ pub(crate) async fn logout_route(
/// Note: This is equivalent to calling [`GET
/// /_matrix/client/r0/logout`](logout_route) from each device of this user.
pub(crate) async fn logout_all_route(
body: Ruma<logout_all::v3::Request>,
body: Ar<logout_all::v3::Request>,
) -> Result<Ra<logout_all::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

4
src/api/client_server/space.rs
View file

@ -1,13 +1,13 @@
use ruma::{api::client::space::get_hierarchy, uint};
use crate::{services, Ra, Result, Ruma};
use crate::{services, Ar, Ra, Result};
/// # `GET /_matrix/client/v1/rooms/{room_id}/hierarchy`
///
/// Paginates over the space tree in a depth-first manner to locate child rooms
/// of a given space.
pub(crate) async fn get_hierarchy_route(
body: Ruma<get_hierarchy::v1::Request>,
body: Ar<get_hierarchy::v1::Request>,
) -> Result<Ra<get_hierarchy::v1::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

12
src/api/client_server/state.rs
View file

@ -14,7 +14,7 @@ use ruma::{
};
use tracing::log::warn;
use crate::{service::pdu::PduBuilder, services, Error, Ra, Result, Ruma};
use crate::{service::pdu::PduBuilder, services, Ar, Error, Ra, Result};
/// # `PUT /_matrix/client/r0/rooms/{roomId}/state/{eventType}/{stateKey}`
///
@ -25,7 +25,7 @@ use crate::{service::pdu::PduBuilder, services, Error, Ra, Result, Ruma};
/// allowed
/// - If event is new `canonical_alias`: Rejects if alias is incorrect
pub(crate) async fn send_state_event_for_key_route(
body: Ruma<send_state_event::v3::Request>,
body: Ar<send_state_event::v3::Request>,
) -> Result<Ra<send_state_event::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -54,7 +54,7 @@ pub(crate) async fn send_state_event_for_key_route(
/// allowed
/// - If event is new `canonical_alias`: Rejects if alias is incorrect
pub(crate) async fn send_state_event_for_empty_key_route(
body: Ruma<send_state_event::v3::Request>,
body: Ar<send_state_event::v3::Request>,
) -> Result<Ra<send_state_event::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -91,7 +91,7 @@ pub(crate) async fn send_state_event_for_empty_key_route(
/// - If not joined: Only works if current room history visibility is world
/// readable
pub(crate) async fn get_state_events_route(
body: Ruma<get_state_events::v3::Request>,
body: Ar<get_state_events::v3::Request>,
) -> Result<Ra<get_state_events::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -125,7 +125,7 @@ pub(crate) async fn get_state_events_route(
/// - If not joined: Only works if current room history visibility is world
/// readable
pub(crate) async fn get_state_events_for_key_route(
body: Ruma<get_state_events_for_key::v3::Request>,
body: Ar<get_state_events_for_key::v3::Request>,
) -> Result<Ra<get_state_events_for_key::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -166,7 +166,7 @@ pub(crate) async fn get_state_events_for_key_route(
/// - If not joined: Only works if current room history visibility is world
/// readable
pub(crate) async fn get_state_events_for_empty_key_route(
body: Ruma<get_state_events_for_key::v3::Request>,
body: Ar<get_state_events_for_key::v3::Request>,
) -> Result<Ra<get_state_events_for_key::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

6
src/api/client_server/sync.rs
View file

@ -29,7 +29,7 @@ use tracing::{debug, error};
use crate::{
service::{pdu::EventHash, rooms::timeline::PduCount},
services, utils, Error, PduEvent, Ra, Result, Ruma,
services, utils, Ar, Error, PduEvent, Ra, Result,
};
/// # `GET /_matrix/client/r0/sync`
@ -73,7 +73,7 @@ use crate::{
/// subset of the state at the point of the leave)
#[allow(clippy::too_many_lines)]
pub(crate) async fn sync_events_route(
body: Ruma<sync_events::v3::Request>,
body: Ar<sync_events::v3::Request>,
) -> Result<Ra<sync_events::v3::Response>, Ra<UiaaResponse>> {
let sender_user = body.sender_user.expect("user is authenticated");
let sender_device = body.sender_device.expect("user is authenticated");
@ -1126,7 +1126,7 @@ fn share_encrypted_room(
#[allow(clippy::too_many_lines)]
pub(crate) async fn sync_events_v4_route(
body: Ruma<sync_events::v4::Request>,
body: Ar<sync_events::v4::Request>,
) -> Result<Ra<sync_events::v4::Response>, Ra<UiaaResponse>> {
let sender_user = body.sender_user.expect("user is authenticated");
let sender_device = body.sender_device.expect("user is authenticated");

8
src/api/client_server/tag.rs
View file

@ -8,7 +8,7 @@ use ruma::{
},
};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `PUT /_matrix/client/r0/user/{userId}/rooms/{roomId}/tags/{tag}`
///
@ -16,7 +16,7 @@ use crate::{services, Error, Ra, Result, Ruma};
///
/// - Inserts the tag into the tag event of the room account data.
pub(crate) async fn update_tag_route(
body: Ruma<create_tag::v3::Request>,
body: Ar<create_tag::v3::Request>,
) -> Result<Ra<create_tag::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -62,7 +62,7 @@ pub(crate) async fn update_tag_route(
///
/// - Removes the tag from the tag event of the room account data.
pub(crate) async fn delete_tag_route(
body: Ruma<delete_tag::v3::Request>,
body: Ar<delete_tag::v3::Request>,
) -> Result<Ra<delete_tag::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -105,7 +105,7 @@ pub(crate) async fn delete_tag_route(
///
/// - Gets the tag event of the room account data.
pub(crate) async fn get_tags_route(
body: Ruma<get_tags::v3::Request>,
body: Ar<get_tags::v3::Request>,
) -> Result<Ra<get_tags::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

4
src/api/client_server/thirdparty.rs
View file

@ -2,13 +2,13 @@ use std::collections::BTreeMap;
use ruma::api::client::thirdparty::get_protocols;
use crate::{Ra, Result, Ruma};
use crate::{Ar, Ra, Result};
/// # `GET /_matrix/client/r0/thirdparty/protocols`
///
/// TODO: Fetches all metadata about protocols supported by the homeserver.
pub(crate) async fn get_protocols_route(
_body: Ruma<get_protocols::v3::Request>,
_body: Ar<get_protocols::v3::Request>,
) -> Result<Ra<get_protocols::v3::Response>> {
// TODO
Ok(Ra(get_protocols::v3::Response {

4
src/api/client_server/threads.rs
View file

@ -1,10 +1,10 @@
use ruma::api::client::{error::ErrorKind, threads::get_threads};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `GET /_matrix/client/r0/rooms/{roomId}/threads`
pub(crate) async fn get_threads_route(
body: Ruma<get_threads::v1::Request>,
body: Ar<get_threads::v1::Request>,
) -> Result<Ra<get_threads::v1::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");

4
src/api/client_server/to_device.rs
View file

@ -8,13 +8,13 @@ use ruma::{
to_device::DeviceIdOrAllDevices,
};
use crate::{services, Error, Ra, Result, Ruma};
use crate::{services, Ar, Error, Ra, Result};
/// # `PUT /_matrix/client/r0/sendToDevice/{eventType}/{txnId}`
///
/// Send a to-device event to a set of client devices.
pub(crate) async fn send_event_to_device_route(
body: Ruma<send_event_to_device::v3::Request>,
body: Ar<send_event_to_device::v3::Request>,
) -> Result<Ra<send_event_to_device::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device = body.sender_device.as_deref();

4
src/api/client_server/typing.rs
View file

@ -1,12 +1,12 @@
use ruma::api::client::{error::ErrorKind, typing::create_typing_event};
use crate::{services, utils, Error, Ra, Result, Ruma};
use crate::{services, utils, Ar, Error, Ra, Result};
/// # `PUT /_matrix/client/r0/rooms/{roomId}/typing/{userId}`
///
/// Sets the typing state of the sender user.
pub(crate) async fn create_typing_event_route(
body: Ruma<create_typing_event::v3::Request>,
body: Ar<create_typing_event::v3::Request>,
) -> Result<Ra<create_typing_event::v3::Response>> {
use create_typing_event::v3::Typing;

4
src/api/client_server/unversioned.rs
View file

@ -2,7 +2,7 @@ use std::{collections::BTreeMap, iter::FromIterator};
use ruma::api::client::discovery::get_supported_versions;
use crate::{Ra, Result, Ruma};
use crate::{Ar, Ra, Result};
/// # `GET /_matrix/client/versions`
///
@ -17,7 +17,7 @@ use crate::{Ra, Result, Ruma};
/// Note: Unstable features are used while developing new features. Clients
/// should avoid using unstable features in their stable releases
pub(crate) async fn get_supported_versions_route(
_body: Ruma<get_supported_versions::Request>,
_body: Ar<get_supported_versions::Request>,
) -> Result<Ra<get_supported_versions::Response>> {
let resp = get_supported_versions::Response {
versions: vec![

4
src/api/client_server/user_directory.rs
View file

@ -6,7 +6,7 @@ use ruma::{
},
};
use crate::{services, Ra, Result, Ruma};
use crate::{services, Ar, Ra, Result};
/// # `POST /_matrix/client/r0/user_directory/search`
///
@ -16,7 +16,7 @@ use crate::{services, Ra, Result, Ruma};
/// have the join rule set to public)
/// and don't share a room with the sender
pub(crate) async fn search_users_route(
body: Ruma<search_users::v3::Request>,
body: Ar<search_users::v3::Request>,
) -> Result<Ra<search_users::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let limit = body.limit.try_into().unwrap_or(usize::MAX);

4
src/api/client_server/voip.rs
View file

@ -5,7 +5,7 @@ use hmac::{Hmac, Mac};
use ruma::{api::client::voip::get_turn_server_info, SecondsSinceUnixEpoch};
use sha1::Sha1;
use crate::{services, Ra, Result, Ruma};
use crate::{services, Ar, Ra, Result};
type HmacSha1 = Hmac<Sha1>;
@ -13,7 +13,7 @@ type HmacSha1 = Hmac<Sha1>;
///
/// TODO: Returns information about the recommended turn server.
pub(crate) async fn turn_server_route(
body: Ruma<get_turn_server_info::v3::Request>,
body: Ar<get_turn_server_info::v3::Request>,
) -> Result<Ra<get_turn_server_info::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");