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

don't automatically wrap in RumaResponse

Browse source 
This allows us to use the `ruma_route` convenience function even when we
need to add our own hacks into the responses, thus making us less
reliant on Ruma.
This commit is contained in:
Charles Hall 2024-05-18 18:31:36 -07:00
parent 87ac0e2a38
commit 230ebd3884
No known key found for this signature in database
GPG key ID: 7B8E0645816E07CF
35 changed files with 438 additions and 405 deletions
Download patch file Download diff file Expand all files Collapse all files

59
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, Result, Ruma,
services, utils, Error, PduEvent, Result, Ruma, RumaResponse,
};
/// # `POST /_matrix/client/r0/rooms/{roomId}/join`
@ -49,7 +49,7 @@ use crate::{
/// federation
pub(crate) async fn join_room_by_id_route(
body: Ruma<join_room_by_id::v3::Request>,
) -> Result<join_room_by_id::v3::Response> {
) -> Result<RumaResponse<join_room_by_id::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
// There is no body.server_name for /roomId/join
@ -83,6 +83,7 @@ pub(crate) async fn join_room_by_id_route(
body.third_party_signed.as_ref(),
)
.await
.map(RumaResponse)
}
/// # `POST /_matrix/client/r0/join/{roomIdOrAlias}`
@ -95,7 +96,7 @@ pub(crate) async fn join_room_by_id_route(
/// federation
pub(crate) async fn join_room_by_id_or_alias_route(
body: Ruma<join_room_by_id_or_alias::v3::Request>,
) -> Result<join_room_by_id_or_alias::v3::Response> {
) -> Result<RumaResponse<join_room_by_id_or_alias::v3::Response>> {
let sender_user =
body.sender_user.as_deref().expect("user is authenticated");
let body = body.body;
@ -147,9 +148,9 @@ pub(crate) async fn join_room_by_id_or_alias_route(
)
.await?;
Ok(join_room_by_id_or_alias::v3::Response {
Ok(RumaResponse(join_room_by_id_or_alias::v3::Response {
room_id: join_room_response.room_id,
})
}))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/leave`
@ -159,12 +160,12 @@ 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>,
) -> Result<leave_room::v3::Response> {
) -> Result<RumaResponse<leave_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
leave_room(sender_user, &body.room_id, body.reason.clone()).await?;
Ok(leave_room::v3::Response::new())
Ok(RumaResponse(leave_room::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/invite`
@ -172,7 +173,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>,
) -> Result<invite_user::v3::Response> {
) -> Result<RumaResponse<invite_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let invite_user::v3::InvitationRecipient::UserId {
@ -187,7 +188,7 @@ pub(crate) async fn invite_user_route(
false,
)
.await?;
Ok(invite_user::v3::Response {})
Ok(RumaResponse(invite_user::v3::Response {}))
} else {
Err(Error::BadRequest(ErrorKind::NotFound, "User not found."))
}
@ -198,13 +199,13 @@ 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>,
) -> Result<kick_user::v3::Response> {
) -> Result<RumaResponse<kick_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let Ok(true) =
services().rooms.state_cache.is_left(sender_user, &body.room_id)
{
return Ok(kick_user::v3::Response {});
return Ok(RumaResponse(kick_user::v3::Response {}));
}
let mut event: RoomMemberEventContent = serde_json::from_str(
@ -259,7 +260,7 @@ pub(crate) async fn kick_user_route(
drop(state_lock);
Ok(kick_user::v3::Response::new())
Ok(RumaResponse(kick_user::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/ban`
@ -267,14 +268,14 @@ 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>,
) -> Result<ban_user::v3::Response> {
) -> Result<RumaResponse<ban_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let Ok(Some(membership_event)) =
services().rooms.state_accessor.get_member(&body.room_id, sender_user)
{
if membership_event.membership == MembershipState::Ban {
return Ok(ban_user::v3::Response {});
return Ok(RumaResponse(ban_user::v3::Response {}));
}
}
@ -343,7 +344,7 @@ pub(crate) async fn ban_user_route(
drop(state_lock);
Ok(ban_user::v3::Response::new())
Ok(RumaResponse(ban_user::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/unban`
@ -351,14 +352,14 @@ 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>,
) -> Result<unban_user::v3::Response> {
) -> Result<RumaResponse<unban_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let Ok(Some(membership_event)) =
services().rooms.state_accessor.get_member(&body.room_id, sender_user)
{
if membership_event.membership != MembershipState::Ban {
return Ok(unban_user::v3::Response {});
return Ok(RumaResponse(unban_user::v3::Response {}));
}
}
@ -414,7 +415,7 @@ pub(crate) async fn unban_user_route(
drop(state_lock);
Ok(unban_user::v3::Response::new())
Ok(RumaResponse(unban_user::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/forget`
@ -428,12 +429,12 @@ pub(crate) async fn unban_user_route(
/// forgotten, so this has to be called from every device
pub(crate) async fn forget_room_route(
body: Ruma<forget_room::v3::Request>,
) -> Result<forget_room::v3::Response> {
) -> Result<RumaResponse<forget_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().rooms.state_cache.forget(&body.room_id, sender_user)?;
Ok(forget_room::v3::Response::new())
Ok(RumaResponse(forget_room::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/joined_rooms`
@ -441,17 +442,17 @@ 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>,
) -> Result<joined_rooms::v3::Response> {
) -> Result<RumaResponse<joined_rooms::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
Ok(joined_rooms::v3::Response {
Ok(RumaResponse(joined_rooms::v3::Response {
joined_rooms: services()
.rooms
.state_cache
.rooms_joined(sender_user)
.filter_map(Result::ok)
.collect(),
})
}))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/members`
@ -462,7 +463,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>,
) -> Result<get_member_events::v3::Response> {
) -> Result<RumaResponse<get_member_events::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !services()
@ -476,7 +477,7 @@ pub(crate) async fn get_member_events_route(
));
}
Ok(get_member_events::v3::Response {
Ok(RumaResponse(get_member_events::v3::Response {
chunk: services()
.rooms
.state_accessor
@ -486,7 +487,7 @@ pub(crate) async fn get_member_events_route(
.filter(|(key, _)| key.0 == StateEventType::RoomMember)
.map(|(_, pdu)| pdu.to_member_event())
.collect(),
})
}))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/joined_members`
@ -497,7 +498,7 @@ pub(crate) async fn get_member_events_route(
/// - TODO: An appservice just needs a puppet joined
pub(crate) async fn joined_members_route(
body: Ruma<joined_members::v3::Request>,
) -> Result<joined_members::v3::Response> {
) -> Result<RumaResponse<joined_members::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !services()
@ -530,9 +531,9 @@ pub(crate) async fn joined_members_route(
);
}
Ok(joined_members::v3::Response {
Ok(RumaResponse(joined_members::v3::Response {
joined,
})
}))
}
#[allow(clippy::too_many_lines)]