Update ruma

src/client_server/alias.rs

@@ -14,7 +14,7 @@ use rocket::{delete, get, put};
 )]
 pub fn create_alias_route(
     db: State<'_, Database>,
-    body: Ruma<create_alias::Request>,
+    body: Ruma<create_alias::IncomingRequest>,
 ) -> ConduitResult<create_alias::Response> {
     if db.rooms.id_from_alias(&body.room_alias)?.is_some() {
         return Err(Error::Conflict("Alias already exists."));
@@ -32,7 +32,7 @@ pub fn create_alias_route(
 )]
 pub fn delete_alias_route(
     db: State<'_, Database>,
-    body: Ruma<delete_alias::Request>,
+    body: Ruma<delete_alias::IncomingRequest>,
 ) -> ConduitResult<delete_alias::Response> {
     db.rooms.set_alias(&body.room_alias, None, &db.globals)?;
 
@@ -45,7 +45,7 @@ pub fn delete_alias_route(
 )]
 pub fn get_alias_route(
     db: State<'_, Database>,
-    body: Ruma<get_alias::Request>,
+    body: Ruma<get_alias::IncomingRequest>,
 ) -> ConduitResult<get_alias::Response> {
     if body.room_alias.server_name() != db.globals.server_name() {
         todo!("ask remote server");

src/client_server/directory.rs

@@ -27,7 +27,7 @@ use rocket::{get, post, put};
 )]
 pub async fn get_public_rooms_filtered_route(
     db: State<'_, Database>,
-    body: Ruma<get_public_rooms_filtered::Request>,
+    body: Ruma<get_public_rooms_filtered::IncomingRequest>,
 ) -> ConduitResult<get_public_rooms_filtered::Response> {
     let limit = body.limit.map_or(10, u64::from);
     let mut since = 0_u64;
@@ -224,11 +224,11 @@ pub async fn get_public_rooms_filtered_route(
 )]
 pub async fn get_public_rooms_route(
     db: State<'_, Database>,
-    body: Ruma<get_public_rooms::Request>,
+    body: Ruma<get_public_rooms::IncomingRequest>,
 ) -> ConduitResult<get_public_rooms::Response> {
     let Ruma {
         body:
-            get_public_rooms::Request {
+            get_public_rooms::IncomingRequest {
                 limit,
                 server,
                 since,
@@ -246,7 +246,7 @@ pub async fn get_public_rooms_route(
     } = get_public_rooms_filtered_route(
         db,
         Ruma {
-            body: get_public_rooms_filtered::Request {
+            body: get_public_rooms_filtered::IncomingRequest {
                 filter: None,
                 limit,
                 room_network: get_public_rooms_filtered::RoomNetwork::Matrix,

src/client_server/keys.rs

@@ -1,15 +1,17 @@
-use super::State;
-use super::SESSION_ID_LENGTH;
+use super::{State, SESSION_ID_LENGTH};
 use crate::{utils, ConduitResult, Database, Error, Ruma};
-use ruma::api::client::{
-    error::ErrorKind,
-    r0::{
-        keys::{
-            self, claim_keys, get_key_changes, get_keys, upload_keys, upload_signatures,
-            upload_signing_keys,
+use ruma::{
+    api::client::{
+        error::ErrorKind,
+        r0::{
+            keys::{
+                claim_keys, get_key_changes, get_keys, upload_keys, upload_signatures,
+                upload_signing_keys,
+            },
+            uiaa::{AuthFlow, UiaaInfo},
         },
-        uiaa::{AuthFlow, UiaaInfo},
     },
+    encryption::UnsignedDeviceInfo,
 };
 use std::collections::{BTreeMap, HashSet};
 
@@ -54,7 +56,7 @@ pub fn upload_keys_route(
 )]
 pub fn get_keys_route(
     db: State<'_, Database>,
-    body: Ruma<get_keys::Request>,
+    body: Ruma<get_keys::IncomingRequest>,
 ) -> ConduitResult<get_keys::Response> {
     let sender_id = body.sender_id.as_ref().expect("user is authenticated");
 
@@ -76,7 +78,7 @@ pub fn get_keys_route(
                             Error::bad_database("all_device_keys contained nonexistent device.")
                         })?;
 
-                    keys.unsigned = Some(keys::UnsignedDeviceInfo {
+                    keys.unsigned = Some(UnsignedDeviceInfo {
                         device_display_name: metadata.display_name,
                     });
 
@@ -95,7 +97,7 @@ pub fn get_keys_route(
                         ),
                     )?;
 
-                    keys.unsigned = Some(keys::UnsignedDeviceInfo {
+                    keys.unsigned = Some(UnsignedDeviceInfo {
                         device_display_name: metadata.display_name,
                     });
 
@@ -278,7 +280,7 @@ pub fn upload_signatures_route(
 )]
 pub fn get_key_changes_route(
     db: State<'_, Database>,
-    body: Ruma<get_key_changes::Request>,
+    body: Ruma<get_key_changes::IncomingRequest>,
 ) -> ConduitResult<get_key_changes::Response> {
     let sender_id = body.sender_id.as_ref().expect("user is authenticated");
 

src/client_server/membership.rs

@@ -23,7 +23,7 @@ use rocket::{get, post};
 )]
 pub fn join_room_by_id_route(
     db: State<'_, Database>,
-    body: Ruma<join_room_by_id::Request>,
+    body: Ruma<join_room_by_id::IncomingRequest>,
 ) -> ConduitResult<join_room_by_id::Response> {
     let sender_id = body.sender_id.as_ref().expect("user is authenticated");
 
@@ -76,7 +76,7 @@ pub fn join_room_by_id_or_alias_route(
         sender_id: body.sender_id.clone(),
         device_id: body.device_id.clone(),
         json_body: None,
-        body: join_room_by_id::Request {
+        body: join_room_by_id::IncomingRequest {
             room_id,
             third_party_signed: body.third_party_signed.clone(),
         },
@@ -94,7 +94,7 @@ pub fn join_room_by_id_or_alias_route(
 )]
 pub fn leave_room_route(
     db: State<'_, Database>,
-    body: Ruma<leave_room::Request>,
+    body: Ruma<leave_room::IncomingRequest>,
 ) -> ConduitResult<leave_room::Response> {
     let sender_id = body.sender_id.as_ref().expect("user is authenticated");
 

src/client_server/message.rs

@@ -2,7 +2,7 @@ use super::State;
 use crate::{pdu::PduBuilder, ConduitResult, Database, Error, Ruma};
 use ruma::api::client::{
     error::ErrorKind,
-    r0::message::{create_message_event, get_message_events},
+    r0::message::{get_message_events, send_message_event},
 };
 use std::convert::TryInto;
 
@@ -13,10 +13,10 @@ use rocket::{get, put};
     feature = "conduit_bin",
     put("/_matrix/client/r0/rooms/<_>/send/<_>/<_>", data = "<body>")
 )]
-pub fn create_message_event_route(
+pub fn send_message_event_route(
     db: State<'_, Database>,
-    body: Ruma<create_message_event::Request>,
-) -> ConduitResult<create_message_event::Response> {
+    body: Ruma<send_message_event::IncomingRequest>,
+) -> ConduitResult<send_message_event::Response> {
     let sender_id = body.sender_id.as_ref().expect("user is authenticated");
 
     let mut unsigned = serde_json::Map::new();
@@ -41,7 +41,7 @@ pub fn create_message_event_route(
         &db.account_data,
     )?;
 
-    Ok(create_message_event::Response { event_id }.into())
+    Ok(send_message_event::Response { event_id }.into())
 }
 
 #[cfg_attr(

src/client_server/state.rs

@@ -4,8 +4,8 @@ use ruma::{
     api::client::{
         error::ErrorKind,
         r0::state::{
-            create_state_event_for_empty_key, create_state_event_for_key, get_state_events,
-            get_state_events_for_empty_key, get_state_events_for_key,
+            get_state_events, get_state_events_for_empty_key, get_state_events_for_key,
+            send_state_event_for_empty_key, send_state_event_for_key,
         },
     },
     events::{room::canonical_alias, EventType},
@@ -19,10 +19,10 @@ use rocket::{get, put};
     feature = "conduit_bin",
     put("/_matrix/client/r0/rooms/<_>/state/<_>/<_>", data = "<body>")
 )]
-pub fn create_state_event_for_key_route(
+pub fn send_state_event_for_key_route(
     db: State<'_, Database>,
-    body: Ruma<create_state_event_for_key::Request>,
-) -> ConduitResult<create_state_event_for_key::Response> {
+    body: Ruma<send_state_event_for_key::IncomingRequest>,
+) -> ConduitResult<send_state_event_for_key::Response> {
     let sender_id = body.sender_id.as_ref().expect("user is authenticated");
 
     let content = serde_json::from_str::<serde_json::Value>(
@@ -78,21 +78,21 @@ pub fn create_state_event_for_key_route(
         &db.account_data,
     )?;
 
-    Ok(create_state_event_for_key::Response { event_id }.into())
+    Ok(send_state_event_for_key::Response { event_id }.into())
 }
 
 #[cfg_attr(
     feature = "conduit_bin",
     put("/_matrix/client/r0/rooms/<_>/state/<_>", data = "<body>")
 )]
-pub fn create_state_event_for_empty_key_route(
+pub fn send_state_event_for_empty_key_route(
     db: State<'_, Database>,
-    body: Ruma<create_state_event_for_empty_key::Request>,
-) -> ConduitResult<create_state_event_for_empty_key::Response> {
-    // This just calls create_state_event_for_key_route
+    body: Ruma<send_state_event_for_empty_key::IncomingRequest>,
+) -> ConduitResult<send_state_event_for_empty_key::Response> {
+    // This just calls send_state_event_for_key_route
     let Ruma {
         body:
-            create_state_event_for_empty_key::Request {
+            send_state_event_for_empty_key::IncomingRequest {
                 room_id,
                 event_type,
                 data,
@@ -102,11 +102,11 @@ pub fn create_state_event_for_empty_key_route(
         json_body,
     } = body;
 
-    Ok(create_state_event_for_empty_key::Response {
-        event_id: create_state_event_for_key_route(
+    Ok(send_state_event_for_empty_key::Response {
+        event_id: send_state_event_for_key_route(
             db,
             Ruma {
-                body: create_state_event_for_key::Request {
+                body: send_state_event_for_key::IncomingRequest {
                     room_id,
                     event_type,
                     data,

src/client_server/to_device.rs

@@ -14,7 +14,7 @@ use rocket::put;
 )]
 pub fn send_event_to_device_route(
     db: State<'_, Database>,
-    body: Ruma<send_event_to_device::Request>,
+    body: Ruma<send_event_to_device::IncomingRequest>,
 ) -> ConduitResult<send_event_to_device::Response> {
     let sender_id = body.sender_id.as_ref().expect("user is authenticated");
 

src/client_server/user_directory.rs

@@ -11,13 +11,9 @@ use rocket::post;
 )]
 pub fn search_users_route(
     db: State<'_, Database>,
-    body: Ruma<search_users::Request>,
+    body: Ruma<search_users::IncomingRequest>,
 ) -> ConduitResult<search_users::Response> {
-    let limit = if let Some(limit) = body.limit {
-        u64::from(limit)
-    } else {
-        10
-    } as usize;
+    let limit = u64::from(body.limit) as usize;
 
     let mut users = db.users.iter().filter_map(|user_id| {
         // Filter out buggy users (they should not exist, but you never know...)

src/client_server/voip.rs

@@ -1,11 +1,11 @@
 use crate::{ConduitResult, Error};
-use ruma::api::client::{error::ErrorKind, r0::message::create_message_event};
+use ruma::api::client::{error::ErrorKind, r0::message::send_message_event};
 
 #[cfg(feature = "conduit_bin")]
 use rocket::get;
 
 #[cfg_attr(feature = "conduit_bin", get("/_matrix/client/r0/voip/turnServer"))]
-pub fn turn_server_route() -> ConduitResult<create_message_event::Response> {
+pub fn turn_server_route() -> ConduitResult<send_message_event::Response> {
     Err(Error::BadRequest(
         ErrorKind::NotFound,
         "There is no turn server yet.",