diff --git a/src/admin/user/commands.rs b/src/admin/user/commands.rs index 562bb9c74..df3938331 100644 --- a/src/admin/user/commands.rs +++ b/src/admin/user/commands.rs @@ -12,11 +12,10 @@ redaction::RoomRedactionEventContent, }, tag::{TagEvent, TagEventContent, TagInfo}, - RoomAccountDataEventType, StateEventType, TimelineEventType, + RoomAccountDataEventType, StateEventType, }, EventId, OwnedRoomId, OwnedRoomOrAliasId, OwnedUserId, RoomId, }; -use serde_json::value::to_raw_value; use crate::{ admin_command, get_room_info, @@ -461,14 +460,7 @@ pub(super) async fn force_demote( .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomPowerLevels, - content: to_raw_value(&power_levels_content).expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + PduBuilder::state(String::new(), &power_levels_content), &user_id, &room_id, &state_lock, @@ -623,16 +615,11 @@ pub(super) async fn redact_event(&self, event_id: Box) -> Result(room_id, &StateEventType::RoomMember, user_id.as_str()) @@ -1651,21 +1601,18 @@ pub async fn leave_room(services: &Services, user_id: &UserId, room_id: &RoomId, return Ok(()); }; - event.membership = MembershipState::Leave; - event.reason = reason; - services .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomMember, - content: to_raw_value(&event).expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(user_id.to_string()), - redacts: None, - timestamp: None, - }, + PduBuilder::state( + user_id.to_string(), + &RoomMemberEventContent { + membership: MembershipState::Leave, + reason, + ..event + }, + ), user_id, room_id, &state_lock, diff --git a/src/api/client/message.rs b/src/api/client/message.rs index d577e3c83..578b675b5 100644 --- a/src/api/client/message.rs +++ b/src/api/client/message.rs @@ -9,7 +9,6 @@ use futures::{FutureExt, StreamExt}; use ruma::{ api::client::{ - error::ErrorKind, filter::{RoomEventFilter, UrlFilter}, message::{get_message_events, send_message_event}, }, @@ -21,7 +20,7 @@ use crate::{ service::{pdu::PduBuilder, Services}, - utils, Error, Result, Ruma, + utils, Result, Ruma, }; /// # `PUT /_matrix/client/v3/rooms/{roomId}/send/{eventType}/{txnId}` @@ -77,27 +76,25 @@ pub(crate) async fn send_message_event_route( let mut unsigned = BTreeMap::new(); unsigned.insert("transaction_id".to_owned(), body.txn_id.to_string().into()); - let content = from_str(body.body.body.json().get()) - .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Invalid JSON body."))?; + let content = + from_str(body.body.body.json().get()).map_err(|e| err!(Request(BadJson("Invalid JSON body: {e}"))))?; let event_id = services .rooms .timeline .build_and_append_pdu( PduBuilder { - event_type: body.event_type.to_string().into(), + event_type: body.event_type.clone().into(), content, unsigned: Some(unsigned), - state_key: None, - redacts: None, timestamp: appservice_info.and(body.timestamp), + ..Default::default() }, sender_user, &body.room_id, &state_lock, ) - .await - .map(|event_id| (*event_id).to_owned())?; + .await?; services .transaction_ids @@ -106,7 +103,7 @@ pub(crate) async fn send_message_event_route( drop(state_lock); Ok(send_message_event::v3::Response { - event_id, + event_id: event_id.into(), }) } diff --git a/src/api/client/profile.rs b/src/api/client/profile.rs index cdc047f07..32f7a7236 100644 --- a/src/api/client/profile.rs +++ b/src/api/client/profile.rs @@ -13,11 +13,10 @@ }, federation, }, - events::{room::member::RoomMemberEventContent, StateEventType, TimelineEventType}, + events::{room::member::RoomMemberEventContent, StateEventType}, presence::PresenceState, OwnedMxcUri, OwnedRoomId, UserId, }; -use serde_json::value::to_raw_value; use service::Services; use crate::Ruma; @@ -310,19 +309,14 @@ pub async fn update_displayname( continue; }; - let pdu = PduBuilder { - event_type: TimelineEventType::RoomMember, - content: to_raw_value(&RoomMemberEventContent { + let pdu = PduBuilder::state( + user_id.to_string(), + &RoomMemberEventContent { displayname: displayname.clone(), join_authorized_via_users_server: None, ..content - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(user_id.to_string()), - redacts: None, - timestamp: None, - }; + }, + ); joined_rooms.push((pdu, room_id)); } @@ -360,20 +354,15 @@ pub async fn update_avatar_url( .room_state_get_content(room_id, &StateEventType::RoomMember, user_id.as_str()) .await?; - let pdu = PduBuilder { - event_type: TimelineEventType::RoomMember, - content: to_raw_value(&RoomMemberEventContent { + let pdu = PduBuilder::state( + user_id.to_string(), + &RoomMemberEventContent { avatar_url: avatar_url.clone(), blurhash: blurhash.clone(), join_authorized_via_users_server: None, ..content - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(user_id.to_string()), - redacts: None, - timestamp: None, - }; + }, + ); Ok((pdu, room_id)) }) diff --git a/src/api/client/redact.rs b/src/api/client/redact.rs index 2102f6cd5..a986dc18b 100644 --- a/src/api/client/redact.rs +++ b/src/api/client/redact.rs @@ -1,9 +1,5 @@ use axum::extract::State; -use ruma::{ - api::client::redact::redact_event, - events::{room::redaction::RoomRedactionEventContent, TimelineEventType}, -}; -use serde_json::value::to_raw_value; +use ruma::{api::client::redact::redact_event, events::room::redaction::RoomRedactionEventContent}; use crate::{service::pdu::PduBuilder, Result, Ruma}; @@ -25,16 +21,11 @@ pub(crate) async fn redact_event_route( .timeline .build_and_append_pdu( PduBuilder { - event_type: TimelineEventType::RoomRedaction, - content: to_raw_value(&RoomRedactionEventContent { + redacts: Some(body.event_id.clone().into()), + ..PduBuilder::timeline(&RoomRedactionEventContent { redacts: Some(body.event_id.clone()), reason: body.reason.clone(), }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: None, - redacts: Some(body.event_id.into()), - timestamp: None, }, sender_user, &body.room_id, @@ -44,8 +35,7 @@ pub(crate) async fn redact_event_route( drop(state_lock); - let event_id = (*event_id).to_owned(); Ok(redact_event::v3::Response { - event_id, + event_id: event_id.into(), }) } diff --git a/src/api/client/room.rs b/src/api/client/room.rs index e22ad7963..daadb7242 100644 --- a/src/api/client/room.rs +++ b/src/api/client/room.rs @@ -150,8 +150,7 @@ pub(crate) async fn create_room_route( None => services.globals.default_room_version(), }; - #[allow(clippy::single_match_else)] - let content = match &body.creation_content { + let create_content = match &body.creation_content { Some(content) => { use RoomVersionId::*; @@ -213,11 +212,9 @@ pub(crate) async fn create_room_route( .build_and_append_pdu( PduBuilder { event_type: TimelineEventType::RoomCreate, - content: to_raw_value(&content).expect("event is valid, we just created it"), - unsigned: None, + content: to_raw_value(&create_content).expect("create event content serialization"), state_key: Some(String::new()), - redacts: None, - timestamp: None, + ..Default::default() }, sender_user, &room_id, @@ -231,24 +228,16 @@ pub(crate) async fn create_room_route( .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomMember, - content: to_raw_value(&RoomMemberEventContent { - membership: MembershipState::Join, + PduBuilder::state( + sender_user.to_string(), + &RoomMemberEventContent { displayname: services.users.displayname(sender_user).await.ok(), avatar_url: services.users.avatar_url(sender_user).await.ok(), - is_direct: Some(body.is_direct), - third_party_invite: None, blurhash: services.users.blurhash(sender_user).await.ok(), - reason: None, - join_authorized_via_users_server: None, - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(sender_user.to_string()), - redacts: None, - timestamp: None, - }, + is_direct: Some(body.is_direct), + ..RoomMemberEventContent::new(MembershipState::Join) + }, + ), sender_user, &room_id, &state_lock, @@ -289,11 +278,9 @@ pub(crate) async fn create_room_route( .build_and_append_pdu( PduBuilder { event_type: TimelineEventType::RoomPowerLevels, - content: to_raw_value(&power_levels_content).expect("to_raw_value always works on serde_json::Value"), - unsigned: None, + content: to_raw_value(&power_levels_content).expect("serialized power_levels event content"), state_key: Some(String::new()), - redacts: None, - timestamp: None, + ..Default::default() }, sender_user, &room_id, @@ -308,18 +295,13 @@ pub(crate) async fn create_room_route( .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomCanonicalAlias, - content: to_raw_value(&RoomCanonicalAliasEventContent { + PduBuilder::state( + String::new(), + &RoomCanonicalAliasEventContent { alias: Some(room_alias_id.to_owned()), alt_aliases: vec![], - }) - .expect("We checked that alias earlier, it must be fine"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + }, + ), sender_user, &room_id, &state_lock, @@ -335,19 +317,14 @@ pub(crate) async fn create_room_route( .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomJoinRules, - content: to_raw_value(&RoomJoinRulesEventContent::new(match preset { + PduBuilder::state( + String::new(), + &RoomJoinRulesEventContent::new(match preset { RoomPreset::PublicChat => JoinRule::Public, // according to spec "invite" is the default _ => JoinRule::Invite, - })) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + }), + ), sender_user, &room_id, &state_lock, @@ -360,15 +337,10 @@ pub(crate) async fn create_room_route( .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomHistoryVisibility, - content: to_raw_value(&RoomHistoryVisibilityEventContent::new(HistoryVisibility::Shared)) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + PduBuilder::state( + String::new(), + &RoomHistoryVisibilityEventContent::new(HistoryVisibility::Shared), + ), sender_user, &room_id, &state_lock, @@ -381,18 +353,13 @@ pub(crate) async fn create_room_route( .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomGuestAccess, - content: to_raw_value(&RoomGuestAccessEventContent::new(match preset { + PduBuilder::state( + String::new(), + &RoomGuestAccessEventContent::new(match preset { RoomPreset::PublicChat => GuestAccess::Forbidden, _ => GuestAccess::CanJoin, - })) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + }), + ), sender_user, &room_id, &state_lock, @@ -440,15 +407,7 @@ pub(crate) async fn create_room_route( .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomName, - content: to_raw_value(&RoomNameEventContent::new(name.clone())) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + PduBuilder::state(String::new(), &RoomNameEventContent::new(name.clone())), sender_user, &room_id, &state_lock, @@ -462,17 +421,12 @@ pub(crate) async fn create_room_route( .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomTopic, - content: to_raw_value(&RoomTopicEventContent { + PduBuilder::state( + String::new(), + &RoomTopicEventContent { topic: topic.clone(), - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + }, + ), sender_user, &room_id, &state_lock, @@ -641,18 +595,13 @@ pub(crate) async fn upgrade_room_route( .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomTombstone, - content: to_raw_value(&RoomTombstoneEventContent { + PduBuilder::state( + String::new(), + &RoomTombstoneEventContent { body: "This room has been replaced".to_owned(), replacement_room: replacement_room.clone(), - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + }, + ), sender_user, &body.room_id, &state_lock, @@ -788,10 +737,8 @@ pub(crate) async fn upgrade_room_route( PduBuilder { event_type: event_type.to_string().into(), content: event_content, - unsigned: None, state_key: Some(String::new()), - redacts: None, - timestamp: None, + ..Default::default() }, sender_user, &replacement_room, @@ -821,7 +768,7 @@ pub(crate) async fn upgrade_room_route( } // Get the old room power levels - let mut power_levels_event_content: RoomPowerLevelsEventContent = services + let power_levels_event_content: RoomPowerLevelsEventContent = services .rooms .state_accessor .room_state_get_content(&body.room_id, &StateEventType::RoomPowerLevels, "") @@ -836,8 +783,6 @@ pub(crate) async fn upgrade_room_route( .checked_add(int!(1)) .ok_or_else(|| err!(Request(BadJson("users_default power levels event content is not valid"))))?, ); - power_levels_event_content.events_default = new_level; - power_levels_event_content.invite = new_level; // Modify the power levels in the old room to prevent sending of events and // inviting new users @@ -845,14 +790,14 @@ pub(crate) async fn upgrade_room_route( .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomPowerLevels, - content: to_raw_value(&power_levels_event_content).expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + PduBuilder::state( + String::new(), + &RoomPowerLevelsEventContent { + events_default: new_level, + invite: new_level, + ..power_levels_event_content + }, + ), sender_user, &body.room_id, &state_lock, diff --git a/src/api/client/state.rs b/src/api/client/state.rs index 1396ae778..5090d5575 100644 --- a/src/api/client/state.rs +++ b/src/api/client/state.rs @@ -177,10 +177,9 @@ async fn send_state_event_for_key_helper( PduBuilder { event_type: event_type.to_string().into(), content: serde_json::from_str(json.json().get())?, - unsigned: None, state_key: Some(state_key), - redacts: None, timestamp, + ..Default::default() }, sender, room_id, diff --git a/src/api/server/make_join.rs b/src/api/server/make_join.rs index ba081aade..856680382 100644 --- a/src/api/server/make_join.rs +++ b/src/api/server/make_join.rs @@ -8,7 +8,7 @@ join_rules::{AllowRule, JoinRule, RoomJoinRulesEventContent}, member::{MembershipState, RoomMemberEventContent}, }, - StateEventType, TimelineEventType, + StateEventType, }, CanonicalJsonObject, RoomId, RoomVersionId, UserId, }; @@ -125,30 +125,17 @@ pub(crate) async fn create_join_event_template_route( )); } - let content = to_raw_value(&RoomMemberEventContent { - avatar_url: None, - blurhash: None, - displayname: None, - is_direct: None, - membership: MembershipState::Join, - third_party_invite: None, - reason: None, - join_authorized_via_users_server, - }) - .expect("member event is valid value"); - let (_pdu, mut pdu_json) = services .rooms .timeline .create_hash_and_sign_event( - PduBuilder { - event_type: TimelineEventType::RoomMember, - content, - unsigned: None, - state_key: Some(body.user_id.to_string()), - redacts: None, - timestamp: None, - }, + PduBuilder::state( + body.user_id.to_string(), + &RoomMemberEventContent { + join_authorized_via_users_server, + ..RoomMemberEventContent::new(MembershipState::Join) + }, + ), &body.user_id, &body.room_id, &state_lock, diff --git a/src/api/server/make_leave.rs b/src/api/server/make_leave.rs index 41ea1c80d..81a32c865 100644 --- a/src/api/server/make_leave.rs +++ b/src/api/server/make_leave.rs @@ -2,10 +2,7 @@ use conduit::{Error, Result}; use ruma::{ api::{client::error::ErrorKind, federation::membership::prepare_leave_event}, - events::{ - room::member::{MembershipState, RoomMemberEventContent}, - TimelineEventType, - }, + events::room::member::{MembershipState, RoomMemberEventContent}, }; use serde_json::value::to_raw_value; @@ -39,30 +36,12 @@ pub(crate) async fn create_leave_event_template_route( let room_version_id = services.rooms.state.get_room_version(&body.room_id).await?; let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; - let content = to_raw_value(&RoomMemberEventContent { - avatar_url: None, - blurhash: None, - displayname: None, - is_direct: None, - membership: MembershipState::Leave, - third_party_invite: None, - reason: None, - join_authorized_via_users_server: None, - }) - .expect("member event is valid value"); let (_pdu, mut pdu_json) = services .rooms .timeline .create_hash_and_sign_event( - PduBuilder { - event_type: TimelineEventType::RoomMember, - content, - unsigned: None, - state_key: Some(body.user_id.to_string()), - redacts: None, - timestamp: None, - }, + PduBuilder::state(body.user_id.to_string(), &RoomMemberEventContent::new(MembershipState::Leave)), &body.user_id, &body.room_id, &state_lock, diff --git a/src/core/pdu/builder.rs b/src/core/pdu/builder.rs index ba4c19e57..80ff07130 100644 --- a/src/core/pdu/builder.rs +++ b/src/core/pdu/builder.rs @@ -1,20 +1,67 @@ use std::{collections::BTreeMap, sync::Arc}; -use ruma::{events::TimelineEventType, EventId, MilliSecondsSinceUnixEpoch}; +use ruma::{ + events::{EventContent, MessageLikeEventType, StateEventType, TimelineEventType}, + EventId, MilliSecondsSinceUnixEpoch, +}; use serde::Deserialize; -use serde_json::value::RawValue as RawJsonValue; +use serde_json::value::{to_raw_value, RawValue as RawJsonValue}; /// Build the start of a PDU in order to add it to the Database. #[derive(Debug, Deserialize)] -pub struct PduBuilder { +pub struct Builder { #[serde(rename = "type")] pub event_type: TimelineEventType, + pub content: Box, - pub unsigned: Option>, + + pub unsigned: Option, + pub state_key: Option, + pub redacts: Option>, - /// For timestamped messaging, should only be used for appservices - /// + + /// For timestamped messaging, should only be used for appservices. /// Will be set to current time if None pub timestamp: Option, } + +type Unsigned = BTreeMap; + +impl Builder { + pub fn state(state_key: String, content: &T) -> Self + where + T: EventContent, + { + Self { + event_type: content.event_type().into(), + content: to_raw_value(content).expect("Builder failed to serialize state event content to RawValue"), + state_key: Some(state_key), + ..Self::default() + } + } + + pub fn timeline(content: &T) -> Self + where + T: EventContent, + { + Self { + event_type: content.event_type().into(), + content: to_raw_value(content).expect("Builder failed to serialize timeline event content to RawValue"), + ..Self::default() + } + } +} + +impl Default for Builder { + fn default() -> Self { + Self { + event_type: "m.room.message".into(), + content: Box::::default(), + unsigned: None, + state_key: None, + redacts: None, + timestamp: None, + } + } +} diff --git a/src/core/pdu/mod.rs b/src/core/pdu/mod.rs index a94e2bdc6..5f50fe5b1 100644 --- a/src/core/pdu/mod.rs +++ b/src/core/pdu/mod.rs @@ -21,7 +21,10 @@ value::{to_raw_value, RawValue as RawJsonValue, Value as JsonValue}, }; -pub use self::{builder::PduBuilder, count::PduCount}; +pub use self::{ + builder::{Builder, Builder as PduBuilder}, + count::PduCount, +}; use crate::{err, is_true, warn, Error, Result}; #[derive(Deserialize)] diff --git a/src/service/admin/create.rs b/src/service/admin/create.rs index 3dd5aea35..1631f1cbb 100644 --- a/src/service/admin/create.rs +++ b/src/service/admin/create.rs @@ -2,24 +2,20 @@ use conduit::{pdu::PduBuilder, Result}; use ruma::{ - events::{ - room::{ - canonical_alias::RoomCanonicalAliasEventContent, - create::RoomCreateEventContent, - guest_access::{GuestAccess, RoomGuestAccessEventContent}, - history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent}, - join_rules::{JoinRule, RoomJoinRulesEventContent}, - member::{MembershipState, RoomMemberEventContent}, - name::RoomNameEventContent, - power_levels::RoomPowerLevelsEventContent, - preview_url::RoomPreviewUrlsEventContent, - topic::RoomTopicEventContent, - }, - TimelineEventType, + events::room::{ + canonical_alias::RoomCanonicalAliasEventContent, + create::RoomCreateEventContent, + guest_access::{GuestAccess, RoomGuestAccessEventContent}, + history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent}, + join_rules::{JoinRule, RoomJoinRulesEventContent}, + member::{MembershipState, RoomMemberEventContent}, + name::RoomNameEventContent, + power_levels::RoomPowerLevelsEventContent, + preview_url::RoomPreviewUrlsEventContent, + topic::RoomTopicEventContent, }, RoomId, RoomVersionId, }; -use serde_json::value::to_raw_value; use crate::Services; @@ -44,7 +40,7 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { let room_version = services.globals.default_room_version(); - let mut content = { + let create_content = { use RoomVersionId::*; match room_version { V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | V10 => RoomCreateEventContent::new_v1(server_user.clone()), @@ -52,23 +48,20 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { } }; - content.federate = true; - content.predecessor = None; - content.room_version = room_version; - // 1. The room create event services .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomCreate, - content: to_raw_value(&content).expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + PduBuilder::state( + String::new(), + &RoomCreateEventContent { + federate: true, + predecessor: None, + room_version, + ..create_content + }, + ), server_user, &room_id, &state_lock, @@ -80,24 +73,7 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomMember, - content: to_raw_value(&RoomMemberEventContent { - membership: MembershipState::Join, - displayname: None, - avatar_url: None, - is_direct: None, - third_party_invite: None, - blurhash: None, - reason: None, - join_authorized_via_users_server: None, - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(server_user.to_string()), - redacts: None, - timestamp: None, - }, + PduBuilder::state(server_user.to_string(), &RoomMemberEventContent::new(MembershipState::Join)), server_user, &room_id, &state_lock, @@ -111,18 +87,13 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomPowerLevels, - content: to_raw_value(&RoomPowerLevelsEventContent { + PduBuilder::state( + String::new(), + &RoomPowerLevelsEventContent { users, ..Default::default() - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + }, + ), server_user, &room_id, &state_lock, @@ -134,15 +105,7 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomJoinRules, - content: to_raw_value(&RoomJoinRulesEventContent::new(JoinRule::Invite)) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + PduBuilder::state(String::new(), &RoomJoinRulesEventContent::new(JoinRule::Invite)), server_user, &room_id, &state_lock, @@ -154,15 +117,10 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomHistoryVisibility, - content: to_raw_value(&RoomHistoryVisibilityEventContent::new(HistoryVisibility::Shared)) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + PduBuilder::state( + String::new(), + &RoomHistoryVisibilityEventContent::new(HistoryVisibility::Shared), + ), server_user, &room_id, &state_lock, @@ -174,15 +132,7 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomGuestAccess, - content: to_raw_value(&RoomGuestAccessEventContent::new(GuestAccess::Forbidden)) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + PduBuilder::state(String::new(), &RoomGuestAccessEventContent::new(GuestAccess::Forbidden)), server_user, &room_id, &state_lock, @@ -195,15 +145,7 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomName, - content: to_raw_value(&RoomNameEventContent::new(room_name)) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + PduBuilder::state(String::new(), &RoomNameEventContent::new(room_name)), server_user, &room_id, &state_lock, @@ -214,17 +156,12 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomTopic, - content: to_raw_value(&RoomTopicEventContent { + PduBuilder::state( + String::new(), + &RoomTopicEventContent { topic: format!("Manage {}", services.globals.server_name()), - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + }, + ), server_user, &room_id, &state_lock, @@ -238,18 +175,13 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomCanonicalAlias, - content: to_raw_value(&RoomCanonicalAliasEventContent { + PduBuilder::state( + String::new(), + &RoomCanonicalAliasEventContent { alias: Some(alias.clone()), alt_aliases: Vec::new(), - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + }, + ), server_user, &room_id, &state_lock, @@ -266,17 +198,12 @@ pub async fn create_admin_room(services: &Services) -> Result<()> { .rooms .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomPreviewUrls, - content: to_raw_value(&RoomPreviewUrlsEventContent { + PduBuilder::state( + String::new(), + &RoomPreviewUrlsEventContent { disabled: true, - }) - .expect("event is valid we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + }, + ), server_user, &room_id, &state_lock, diff --git a/src/service/admin/grant.rs b/src/service/admin/grant.rs index 6e266ca9b..405da982e 100644 --- a/src/service/admin/grant.rs +++ b/src/service/admin/grant.rs @@ -9,11 +9,10 @@ power_levels::RoomPowerLevelsEventContent, }, tag::{TagEvent, TagEventContent, TagInfo}, - RoomAccountDataEventType, TimelineEventType, + RoomAccountDataEventType, }, RoomId, UserId, }; -use serde_json::value::to_raw_value; use crate::pdu::PduBuilder; @@ -35,24 +34,7 @@ pub async fn make_user_admin(&self, user_id: &UserId) -> Result<()> { self.services .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomMember, - content: to_raw_value(&RoomMemberEventContent { - membership: MembershipState::Invite, - displayname: None, - avatar_url: None, - is_direct: None, - third_party_invite: None, - blurhash: None, - reason: None, - join_authorized_via_users_server: None, - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(user_id.to_string()), - redacts: None, - timestamp: None, - }, + PduBuilder::state(user_id.to_string(), &RoomMemberEventContent::new(MembershipState::Invite)), server_user, &room_id, &state_lock, @@ -61,24 +43,7 @@ pub async fn make_user_admin(&self, user_id: &UserId) -> Result<()> { self.services .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomMember, - content: to_raw_value(&RoomMemberEventContent { - membership: MembershipState::Join, - displayname: None, - avatar_url: None, - is_direct: None, - third_party_invite: None, - blurhash: None, - reason: None, - join_authorized_via_users_server: None, - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(user_id.to_string()), - redacts: None, - timestamp: None, - }, + PduBuilder::state(user_id.to_string(), &RoomMemberEventContent::new(MembershipState::Join)), user_id, &room_id, &state_lock, @@ -91,18 +56,13 @@ pub async fn make_user_admin(&self, user_id: &UserId) -> Result<()> { self.services .timeline .build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomPowerLevels, - content: to_raw_value(&RoomPowerLevelsEventContent { + PduBuilder::state( + String::new(), + &RoomPowerLevelsEventContent { users, ..Default::default() - }) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: Some(String::new()), - redacts: None, - timestamp: None, - }, + }, + ), server_user, &room_id, &state_lock, @@ -117,23 +77,18 @@ pub async fn make_user_admin(&self, user_id: &UserId) -> Result<()> { } } + let welcome_message = String::from("## Thank you for trying out conduwuit!\n\nconduwuit is a fork of upstream Conduit which is in Beta. This means you can join and participate in most Matrix rooms, but not all features are supported and you might run into bugs from time to time.\n\nHelpful links:\n> Git and Documentation: https://github.com/girlbossceo/conduwuit\n> Report issues: https://github.com/girlbossceo/conduwuit/issues\n\nFor a list of available commands, send the following message in this room: `!admin --help`\n\nHere are some rooms you can join (by typing the command):\n\nconduwuit room (Ask questions and get notified on updates):\n`/join #conduwuit:puppygock.gay`"); + // Send welcome message - self.services.timeline.build_and_append_pdu( - PduBuilder { - event_type: TimelineEventType::RoomMessage, - content: to_raw_value(&RoomMessageEventContent::text_markdown( - String::from("## Thank you for trying out conduwuit!\n\nconduwuit is a fork of upstream Conduit which is in Beta. This means you can join and participate in most Matrix rooms, but not all features are supported and you might run into bugs from time to time.\n\nHelpful links:\n> Git and Documentation: https://github.com/girlbossceo/conduwuit\n> Report issues: https://github.com/girlbossceo/conduwuit/issues\n\nFor a list of available commands, send the following message in this room: `!admin --help`\n\nHere are some rooms you can join (by typing the command):\n\nconduwuit room (Ask questions and get notified on updates):\n`/join #conduwuit:puppygock.gay`"), - )) - .expect("event is valid, we just created it"), - unsigned: None, - state_key: None, - redacts: None, - timestamp: None, - }, - server_user, - &room_id, - &state_lock, - ).await?; + self.services + .timeline + .build_and_append_pdu( + PduBuilder::timeline(&RoomMessageEventContent::text_markdown(welcome_message)), + server_user, + &room_id, + &state_lock, + ) + .await?; Ok(()) } diff --git a/src/service/admin/mod.rs b/src/service/admin/mod.rs index da7f3cf4c..58cc012c2 100644 --- a/src/service/admin/mod.rs +++ b/src/service/admin/mod.rs @@ -15,13 +15,9 @@ use futures::{FutureExt, TryFutureExt}; use loole::{Receiver, Sender}; use ruma::{ - events::{ - room::message::{Relation, RoomMessageEventContent}, - TimelineEventType, - }, + events::room::message::{Relation, RoomMessageEventContent}, OwnedEventId, OwnedRoomId, RoomId, UserId, }; -use serde_json::value::to_raw_value; use tokio::sync::{Mutex, RwLock}; use crate::{account_data, globals, rooms, rooms::state::RoomMutexGuard, Dep}; @@ -285,20 +281,12 @@ async fn respond_to_room( ) -> Result<()> { assert!(self.user_is_admin(user_id).await, "sender is not admin"); - let response_pdu = PduBuilder { - event_type: TimelineEventType::RoomMessage, - content: to_raw_value(&content).expect("event is valid, we just created it"), - unsigned: None, - state_key: None, - redacts: None, - timestamp: None, - }; - let state_lock = self.services.state.mutex.lock(room_id).await; + if let Err(e) = self .services .timeline - .build_and_append_pdu(response_pdu, user_id, room_id, &state_lock) + .build_and_append_pdu(PduBuilder::timeline(&content), user_id, room_id, &state_lock) .await { self.handle_response_error(e, room_id, user_id, &state_lock) @@ -313,23 +301,14 @@ async fn handle_response_error( &self, e: Error, room_id: &RoomId, user_id: &UserId, state_lock: &RoomMutexGuard, ) -> Result<()> { error!("Failed to build and append admin room response PDU: \"{e}\""); - let error_room_message = RoomMessageEventContent::text_plain(format!( + let content = RoomMessageEventContent::text_plain(format!( "Failed to build and append admin room PDU: \"{e}\"\n\nThe original admin command may have finished \ successfully, but we could not return the output." )); - let response_pdu = PduBuilder { - event_type: TimelineEventType::RoomMessage, - content: to_raw_value(&error_room_message).expect("event is valid, we just created it"), - unsigned: None, - state_key: None, - redacts: None, - timestamp: None, - }; - self.services .timeline - .build_and_append_pdu(response_pdu, user_id, room_id, state_lock) + .build_and_append_pdu(PduBuilder::timeline(&content), user_id, room_id, state_lock) .await?; Ok(()) diff --git a/src/service/rooms/state_accessor/mod.rs b/src/service/rooms/state_accessor/mod.rs index 3855d92a2..19f1f1413 100644 --- a/src/service/rooms/state_accessor/mod.rs +++ b/src/service/rooms/state_accessor/mod.rs @@ -37,7 +37,6 @@ ServerName, UserId, }; use serde::Deserialize; -use serde_json::value::to_raw_value; use self::data::Data; use crate::{rooms, rooms::state::RoomMutexGuard, Dep}; @@ -353,21 +352,14 @@ pub async fn get_member(&self, room_id: &RoomId, user_id: &UserId) -> Result bool { - let content = to_raw_value(&RoomMemberEventContent::new(MembershipState::Invite)) - .expect("Event content always serializes"); - - let new_event = PduBuilder { - event_type: ruma::events::TimelineEventType::RoomMember, - content, - unsigned: None, - state_key: Some(target_user.into()), - redacts: None, - timestamp: None, - }; - self.services .timeline - .create_hash_and_sign_event(new_event, sender, room_id, state_lock) + .create_hash_and_sign_event( + PduBuilder::state(target_user.into(), &RoomMemberEventContent::new(MembershipState::Invite)), + sender, + room_id, + state_lock, + ) .await .is_ok() }