//! `PUT /_matrix/client/*/rooms/{roomId}/state/{eventType}/{stateKey}` //! //! Send a state event to a room associated with a given state key. pub mod v3 { //! `/v3/` ([spec]) //! //! [spec]: https://spec.matrix.org/v1.4/client-server-api/#put_matrixclientv3roomsroomidstateeventtypestatekey use std::borrow::Borrow; use ruma_common::{ api::{response, Metadata}, events::{AnyStateEventContent, StateEventContent, StateEventType}, metadata, serde::Raw, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, }; use serde_json::value::to_raw_value as to_raw_json_value; const METADATA: Metadata = metadata! { method: PUT, rate_limited: false, authentication: AccessToken, history: { 1.0 => "/_matrix/client/r0/rooms/:room_id/state/:event_type/:state_key", 1.1 => "/_matrix/client/v3/rooms/:room_id/state/:event_type/:state_key", } }; /// Request type for the `send_state_event` endpoint. #[derive(Clone, Debug)] #[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)] pub struct Request { /// The room to set the state in. pub room_id: OwnedRoomId, /// The type of event to send. pub event_type: StateEventType, /// The state_key for the state to send. pub state_key: String, /// The event content to send. pub body: Raw, /// Timestamp to use for the `origin_server_ts` of the event. /// /// This is called [timestamp massaging] and can only be used by Appservices. /// /// Note that this does not change the position of the event in the timeline. /// /// [timestamp massaging]: https://spec.matrix.org/v1.4/application-service-api/#timestamp-massaging pub timestamp: Option, } impl Request { /// Creates a new `Request` with the given room id, state key and event content. /// /// # Errors /// /// Since `Request` stores the request body in serialized form, this function can fail if /// `T`s [`Serialize`][serde::Serialize] implementation can fail. pub fn new( room_id: OwnedRoomId, state_key: &K, content: &T, ) -> serde_json::Result where T: StateEventContent, T::StateKey: Borrow, K: AsRef + ?Sized, { Ok(Self { room_id, state_key: state_key.as_ref().to_owned(), event_type: content.event_type(), body: Raw::from_json(to_raw_json_value(content)?), timestamp: None, }) } /// Creates a new `Request` with the given room id, event type, state key and raw event /// content. pub fn new_raw( room_id: OwnedRoomId, event_type: StateEventType, state_key: String, body: Raw, ) -> Self { Self { room_id, event_type, state_key, body, timestamp: None } } } /// Response type for the `send_state_event` endpoint. #[response(error = crate::Error)] pub struct Response { /// A unique identifier for the event. pub event_id: OwnedEventId, } impl Response { /// Creates a new `Response` with the given event id. pub fn new(event_id: OwnedEventId) -> Self { Self { event_id } } } #[cfg(feature = "client")] impl ruma_common::api::OutgoingRequest for Request { type EndpointError = crate::Error; type IncomingResponse = Response; const METADATA: Metadata = METADATA; fn try_into_http_request( self, base_url: &str, access_token: ruma_common::api::SendAccessToken<'_>, considering_versions: &'_ [ruma_common::api::MatrixVersion], ) -> Result, ruma_common::api::error::IntoHttpError> { use http::header::{self, HeaderValue}; let query_string = serde_html_form::to_string(RequestQuery { timestamp: self.timestamp })?; let http_request = http::Request::builder() .method(http::Method::PUT) .uri(METADATA.make_endpoint_url( considering_versions, base_url, &[&self.room_id, &self.event_type, &self.state_key], &query_string, )?) .header(header::CONTENT_TYPE, "application/json") .header( header::AUTHORIZATION, HeaderValue::from_str(&format!( "Bearer {}", access_token .get_required_for_endpoint() .ok_or(ruma_common::api::error::IntoHttpError::NeedsAuthentication)? ))?, ) .body(ruma_common::serde::json_to_buf(&self.body)?)?; Ok(http_request) } } #[cfg(feature = "server")] impl ruma_common::api::IncomingRequest for Request { type EndpointError = crate::Error; type OutgoingResponse = Response; const METADATA: Metadata = METADATA; fn try_from_http_request( request: http::Request, path_args: &[S], ) -> Result where B: AsRef<[u8]>, S: AsRef, { // FIXME: find a way to make this if-else collapse with serde recognizing trailing // Option let (room_id, event_type, state_key): (OwnedRoomId, StateEventType, String) = if path_args.len() == 3 { serde::Deserialize::deserialize(serde::de::value::SeqDeserializer::< _, serde::de::value::Error, >::new( path_args.iter().map(::std::convert::AsRef::as_ref), ))? } else { let (a, b) = serde::Deserialize::deserialize(serde::de::value::SeqDeserializer::< _, serde::de::value::Error, >::new( path_args.iter().map(::std::convert::AsRef::as_ref), ))?; (a, b, "".into()) }; let request_query: RequestQuery = serde_html_form::from_str(request.uri().query().unwrap_or(""))?; let body = serde_json::from_slice(request.body().as_ref())?; Ok(Self { room_id, event_type, state_key, body, timestamp: request_query.timestamp }) } } /// Data in the request's query string. #[derive(Debug)] #[cfg_attr(feature = "client", derive(serde::Serialize))] #[cfg_attr(feature = "server", derive(serde::Deserialize))] struct RequestQuery { /// Timestamp to use for the `origin_server_ts` of the event. #[serde(rename = "ts", skip_serializing_if = "Option::is_none")] pub timestamp: Option, } #[cfg(feature = "client")] #[test] fn serialize() { use ruma_common::{ api::{MatrixVersion, OutgoingRequest as _, SendAccessToken}, events::{room::name::RoomNameEventContent, EmptyStateKey}, room_id, }; // This used to panic in make_endpoint_url because of a mismatch in the path parameter count let req = Request::new( room_id!("!room:server.tld").to_owned(), &EmptyStateKey, &RoomNameEventContent::new(Some("Test room".to_owned())), ) .unwrap() .try_into_http_request::>( "https://server.tld", SendAccessToken::IfRequired("access_token"), &[MatrixVersion::V1_1], ) .unwrap(); assert_eq!( req.uri(), "https://server.tld/_matrix/client/v3/rooms/%21room%3Aserver%2Etld/state/m%2Eroom%2Ename/" ); } }