ruma_client_api/delayed_events/
delayed_state_event.rs1pub mod msc4140 {
15 use ruma_common::{
20 OwnedRoomId,
21 api::{auth_scheme::AccessToken, request, response},
22 metadata,
23 serde::Raw,
24 };
25 use ruma_events::{AnyStateEventContent, StateEventContent, StateEventType};
26 use serde_json::value::to_raw_value as to_raw_json_value;
27
28 use crate::delayed_events::DelayParameters;
29
30 metadata! {
31 method: PUT,
32 rate_limited: false,
33 authentication: AccessToken,
34 history: {
35 unstable => "/_matrix/client/v3/rooms/{room_id}/state/{event_type}/{state_key}",
37 }
38 }
39
40 #[request]
42 pub struct Request {
43 #[ruma_api(path)]
45 pub room_id: OwnedRoomId,
46
47 #[ruma_api(path)]
49 pub event_type: StateEventType,
50
51 #[ruma_api(path)]
53 pub state_key: String,
54
55 #[ruma_api(query_all)]
60 pub delay_parameters: DelayParameters,
61
62 #[ruma_api(body)]
64 pub body: Raw<AnyStateEventContent>,
65 }
66
67 #[response]
69 pub struct Response {
70 pub delay_id: String,
72 }
73
74 impl Request {
75 pub fn new<T>(
83 room_id: OwnedRoomId,
84 state_key: String,
85 delay_parameters: DelayParameters,
86 content: &T,
87 ) -> serde_json::Result<Self>
88 where
89 T: StateEventContent,
90 {
91 Ok(Self {
92 room_id,
93 state_key,
94 event_type: content.event_type(),
95 delay_parameters,
96 body: Raw::from_json(to_raw_json_value(content)?),
97 })
98 }
99
100 pub fn new_raw(
103 room_id: OwnedRoomId,
104 state_key: String,
105 event_type: StateEventType,
106 delay_parameters: DelayParameters,
107 body: Raw<AnyStateEventContent>,
108 ) -> Self {
109 Self { room_id, event_type, state_key, body, delay_parameters }
110 }
111 }
112
113 impl Response {
114 pub fn new(delay_id: String) -> Self {
116 Self { delay_id }
117 }
118 }
119
120 #[cfg(all(test, feature = "client"))]
121 mod tests {
122 use std::borrow::Cow;
123
124 use ruma_common::{
125 api::{
126 MatrixVersion, OutgoingRequestExt as _, SupportedVersions,
127 auth_scheme::SendAccessToken,
128 },
129 owned_room_id,
130 serde::Raw,
131 };
132 use serde_json::{Value as JsonValue, json};
133 use web_time::Duration;
134
135 use super::Request;
136 use crate::delayed_events::DelayParameters;
137
138 fn create_delayed_event_request(
139 delay_parameters: DelayParameters,
140 ) -> (http::request::Parts, Vec<u8>) {
141 let supported = SupportedVersions {
142 versions: [MatrixVersion::V1_1].into(),
143 features: Default::default(),
144 };
145
146 Request::new_raw(
147 owned_room_id!("!roomid:example.org"),
148 "@userAsStateKey:example.org".to_owned(),
149 "com.example.custom_state".into(),
150 delay_parameters,
151 Raw::new(&json!({ "key": "value" })).unwrap().cast_unchecked(),
152 )
153 .try_into_http_request(
154 "https://homeserver.tld",
155 SendAccessToken::IfRequired("auth_tok"),
156 Cow::Owned(supported),
157 )
158 .unwrap()
159 .into_parts()
160 }
161
162 #[test]
163 fn serialize_delayed_state_request() {
164 let (parts, body) = create_delayed_event_request(DelayParameters::Timeout {
165 timeout: Duration::from_millis(1_234_321),
166 });
167 assert_eq!(
168 "https://homeserver.tld/_matrix/client/v3/rooms/!roomid:example.org/state/com.example.custom_state/@userAsStateKey:example.org?org.matrix.msc4140.delay=1234321",
169 parts.uri
170 );
171 assert_eq!("PUT", parts.method);
172 assert_eq!(
173 json!({ "key": "value" }),
174 serde_json::from_slice::<JsonValue>(&body).unwrap()
175 );
176 }
177 }
178}