refactor: Fix errors in api/server/user.rs

src/api/server/user.rs

@@ -1,14 +1,14 @@
 use std::time::Duration;
 
 use axum::extract::State;
-use conduwuit::{Error, Result};
+use conduwuit::{Err, Result};
 use futures::{FutureExt, StreamExt, TryFutureExt};
-use ruma::api::{
+use ruma::{
-	client::error::ErrorKind,
+	api::federation::{
-	federation::{
 		device::get_devices::{self, v1::UserDevice},
 		keys::{claim_keys, get_keys},
 	},
+	assign,
 };
 
 use crate::{
@@ -24,54 +24,55 @@ pub(crate) async fn get_devices_route(
 	body: Ruma<get_devices::v1::Request>,
 ) -> Result<get_devices::v1::Response> {
 	if !services.globals.user_is_local(&body.user_id) {
-		return Err(Error::BadRequest(
+		return Err!(Request(InvalidParam("Tried to access user from other server.")));
-			ErrorKind::InvalidParam,
-			"Tried to access user from other server.",
-		));
 	}
 
-	let user_id = &body.user_id;
+	let stream_id = services
-	Ok(get_devices::v1::Response {
+		.users
-		user_id: user_id.clone(),
+		.get_devicelist_version(&body.user_id)
-		stream_id: services
+		.await
-			.users
+		.unwrap_or(0)
-			.get_devicelist_version(user_id)
+		.try_into()
-			.await
+		.expect("device list version should fit into a UInt");
-			.unwrap_or(0)
-			.try_into()?,
-		devices: services
-			.users
-			.all_devices_metadata(user_id)
-			.filter_map(|metadata| async move {
-				let device_id = metadata.device_id.clone();
-				let device_id_clone = device_id.clone();
-				let device_id_string = device_id.as_str().to_owned();
-				let device_display_name = if services.globals.allow_device_name_federation() {
-					metadata.display_name.clone()
-				} else {
-					Some(device_id_string)
-				};
 
-				services
+	let devices = services
-					.users
+		.users
-					.get_device_keys(user_id, &device_id_clone)
+		.all_devices_metadata(&body.user_id)
-					.map_ok(|keys| UserDevice { device_id, keys, device_display_name })
+		.filter_map(async |metadata| {
-					.map(Result::ok)
+			let device_id = metadata.device_id.clone();
-					.await
+			let device_id_clone = device_id.clone();
-			})
+			let device_id_string = device_id.as_str().to_owned();
-			.collect()
+			let device_display_name = if services.globals.allow_device_name_federation() {
-			.await,
+				metadata.display_name.clone()
-		master_key: services
+			} else {
-			.users
+				Some(device_id_string)
-			.get_master_key(None, &body.user_id, &|u| u.server_name() == body.origin())
+			};
-			.await
+
-			.ok(),
+			services
-		self_signing_key: services
+				.users
-			.users
+				.get_device_keys(&body.user_id, &device_id_clone)
-			.get_self_signing_key(None, &body.user_id, &|u| u.server_name() == body.origin())
+				.map_ok(|keys| assign!(UserDevice::new(device_id, keys), { device_display_name }))
-			.await
+				.map(Result::ok)
-			.ok(),
+				.await
-	})
+		})
+		.collect()
+		.await;
+
+	let master_key = services
+		.users
+		.get_master_key(None, &body.user_id, &|u| u.server_name() == body.origin())
+		.await
+		.ok();
+
+	let self_signing_key = services
+		.users
+		.get_self_signing_key(None, &body.user_id, &|u| u.server_name() == body.origin())
+		.await
+		.ok();
+
+	Ok(assign!(get_devices::v1::Response::new(body.user_id.clone(), stream_id), {
+		devices, master_key, self_signing_key
+	}))
 }
 
 /// # `POST /_matrix/federation/v1/user/keys/query`
@@ -86,10 +87,7 @@ pub(crate) async fn get_keys_route(
 		.iter()
 		.any(|(u, _)| !services.globals.user_is_local(u))
 	{
-		return Err(Error::BadRequest(
+		return Err!(Request(InvalidParam("User does not belong to this server.")));
-			ErrorKind::InvalidParam,
-			"User does not belong to this server.",
-		));
 	}
 
 	let result = get_keys_helper(
@@ -102,11 +100,10 @@ pub(crate) async fn get_keys_route(
 	)
 	.await?;
 
-	Ok(get_keys::v1::Response {
+	Ok(assign!(get_keys::v1::Response::new(result.device_keys), {
-		device_keys: result.device_keys,
 		master_keys: result.master_keys,
 		self_signing_keys: result.self_signing_keys,
-	})
+	}))
 }
 
 /// # `POST /_matrix/federation/v1/user/keys/claim`
@@ -121,14 +118,11 @@ pub(crate) async fn claim_keys_route(
 		.iter()
 		.any(|(u, _)| !services.globals.user_is_local(u))
 	{
-		return Err(Error::BadRequest(
+		return Err!(Request(InvalidParam("Tried to access user from other server.")));
-			ErrorKind::InvalidParam,
-			"Tried to access user from other server.",
-		));
 	}
 
 	let result =
 		claim_keys_helper(&services, &body.one_time_keys, Duration::from_secs(0)).await?;
 
-	Ok(claim_keys::v1::Response { one_time_keys: result.one_time_keys })
+	Ok(claim_keys::v1::Response::new(result.one_time_keys))
 }