1use ruma_common::{
6 OwnedEventId, OwnedRoomId, OwnedUserId, RoomVersionId, room::RoomType,
7 room_version_rules::RedactionRules,
8};
9use ruma_macros::EventContent;
10use serde::{Deserialize, Serialize};
11
12use crate::{EmptyStateKey, RedactContent, RedactedStateEventContent, StateEventType};
13
14#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
20#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
21#[ruma_event(type = "m.room.create", kind = State, state_key_type = EmptyStateKey, custom_redacted)]
22pub struct RoomCreateEventContent {
23 #[serde(skip_serializing_if = "Option::is_none")]
30 #[deprecated = "Since Matrix 1.8. This field was removed in Room version 11, clients should use the event's sender instead"]
31 pub creator: Option<OwnedUserId>,
32
33 #[serde(
35 rename = "m.federate",
36 default = "ruma_common::serde::default_true",
37 skip_serializing_if = "ruma_common::serde::is_true"
38 )]
39 pub federate: bool,
40
41 #[serde(default = "default_room_version_id")]
45 pub room_version: RoomVersionId,
46
47 #[serde(skip_serializing_if = "Option::is_none")]
52 #[cfg_attr(
53 feature = "compat-lax-room-create-deser",
54 serde(default, deserialize_with = "ruma_common::serde::default_on_error")
55 )]
56 pub predecessor: Option<PreviousRoom>,
57
58 #[serde(skip_serializing_if = "Option::is_none", rename = "type")]
60 pub room_type: Option<RoomType>,
61
62 #[serde(skip_serializing_if = "Vec::is_empty", default)]
65 pub additional_creators: Vec<OwnedUserId>,
66}
67
68impl RoomCreateEventContent {
69 pub fn new_v1(creator: OwnedUserId) -> Self {
72 #[allow(deprecated)]
73 Self {
74 creator: Some(creator),
75 federate: true,
76 room_version: default_room_version_id(),
77 predecessor: None,
78 room_type: None,
79 additional_creators: Vec::new(),
80 }
81 }
82
83 pub fn new_v11() -> Self {
88 #[allow(deprecated)]
89 Self {
90 creator: None,
91 federate: true,
92 room_version: RoomVersionId::V11,
93 predecessor: None,
94 room_type: None,
95 additional_creators: Vec::new(),
96 }
97 }
98}
99
100impl RedactContent for RoomCreateEventContent {
101 type Redacted = RedactedRoomCreateEventContent;
102
103 fn redact(self, rules: &RedactionRules) -> Self::Redacted {
104 #[allow(deprecated)]
105 if rules.keep_room_create_content {
106 self
107 } else {
108 Self {
109 room_version: default_room_version_id(),
110 creator: self.creator,
111 ..Self::new_v11()
112 }
113 }
114 }
115}
116
117#[derive(Clone, Debug, Deserialize, Serialize)]
119#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
120pub struct PreviousRoom {
121 pub room_id: OwnedRoomId,
123
124 #[deprecated = "\
126 This field should be sent by servers when possible for backwards compatibility \
127 but clients should not rely on it."]
128 #[serde(skip_serializing_if = "Option::is_none")]
129 pub event_id: Option<OwnedEventId>,
130}
131
132impl PreviousRoom {
133 pub fn new(room_id: OwnedRoomId) -> Self {
135 #[allow(deprecated)]
136 Self { room_id, event_id: None }
137 }
138}
139
140fn default_room_version_id() -> RoomVersionId {
142 RoomVersionId::V1
143}
144
145pub type RedactedRoomCreateEventContent = RoomCreateEventContent;
154
155impl RedactedStateEventContent for RedactedRoomCreateEventContent {
156 type StateKey = EmptyStateKey;
157
158 fn event_type(&self) -> StateEventType {
159 StateEventType::RoomCreate
160 }
161}
162
163#[cfg(test)]
164mod tests {
165 use assert_matches::assert_matches;
166 use ruma_common::{RoomVersionId, canonical_json::assert_to_canonical_json_eq, owned_user_id};
167 use serde_json::{from_value as from_json_value, json};
168
169 use super::{RoomCreateEventContent, RoomType};
170
171 #[test]
172 fn serialization() {
173 #[allow(deprecated)]
174 let content = RoomCreateEventContent {
175 creator: Some(owned_user_id!("@carl:example.com")),
176 federate: false,
177 room_version: RoomVersionId::V4,
178 predecessor: None,
179 room_type: None,
180 additional_creators: Vec::new(),
181 };
182
183 assert_to_canonical_json_eq!(
184 content,
185 json!({
186 "creator": "@carl:example.com",
187 "m.federate": false,
188 "room_version": "4",
189 }),
190 );
191 }
192
193 #[test]
194 fn policy_serialization() {
195 #[allow(deprecated)]
196 let content = RoomCreateEventContent {
197 creator: Some(owned_user_id!("@carl:example.com")),
198 federate: false,
199 room_version: RoomVersionId::V4,
200 predecessor: None,
201 room_type: Some(RoomType::Policy),
202 additional_creators: Vec::new(),
203 };
204
205 assert_to_canonical_json_eq!(
206 content,
207 json!({
208 "creator": "@carl:example.com",
209 "m.federate": false,
210 "room_version": "4",
211 "type": "m.policy",
212 }),
213 );
214 }
215
216 #[test]
217 fn space_serialization() {
218 #[allow(deprecated)]
219 let content = RoomCreateEventContent {
220 creator: Some(owned_user_id!("@carl:example.com")),
221 federate: false,
222 room_version: RoomVersionId::V4,
223 predecessor: None,
224 room_type: Some(RoomType::Space),
225 additional_creators: Vec::new(),
226 };
227
228 assert_to_canonical_json_eq!(
229 content,
230 json!({
231 "creator": "@carl:example.com",
232 "m.federate": false,
233 "room_version": "4",
234 "type": "m.space",
235 }),
236 );
237 }
238
239 #[test]
240 #[cfg(feature = "unstable-msc3417")]
241 fn call_serialization() {
242 #[allow(deprecated)]
243 let content = RoomCreateEventContent {
244 creator: Some(owned_user_id!("@carl:example.com")),
245 federate: false,
246 room_version: RoomVersionId::V4,
247 predecessor: None,
248 room_type: Some(RoomType::Call),
249 additional_creators: Vec::new(),
250 };
251
252 assert_to_canonical_json_eq!(
253 content,
254 json!({
255 "creator": "@carl:example.com",
256 "m.federate": false,
257 "room_version": "4",
258 "type": "org.matrix.msc3417.call",
259 }),
260 );
261 }
262
263 #[test]
264 #[allow(deprecated)]
265 fn deserialization() {
266 let json = json!({
267 "creator": "@carl:example.com",
268 "m.federate": true,
269 "room_version": "4"
270 });
271
272 let content = from_json_value::<RoomCreateEventContent>(json).unwrap();
273 assert_eq!(content.creator.unwrap(), "@carl:example.com");
274 assert!(content.federate);
275 assert_eq!(content.room_version, RoomVersionId::V4);
276 assert_matches!(content.predecessor, None);
277 assert_eq!(content.room_type, None);
278 }
279
280 #[test]
281 #[allow(deprecated)]
282 fn policy_deserialization() {
283 let json = json!({
284 "creator": "@carl:example.com",
285 "m.federate": true,
286 "room_version": "4",
287 "type": "m.policy"
288 });
289
290 let content = from_json_value::<RoomCreateEventContent>(json).unwrap();
291 assert_eq!(content.creator.unwrap(), "@carl:example.com");
292 assert!(content.federate);
293 assert_eq!(content.room_version, RoomVersionId::V4);
294 assert_matches!(content.predecessor, None);
295 assert_eq!(content.room_type, Some(RoomType::Policy));
296 }
297
298 #[test]
299 #[allow(deprecated)]
300 fn space_deserialization() {
301 let json = json!({
302 "creator": "@carl:example.com",
303 "m.federate": true,
304 "room_version": "4",
305 "type": "m.space"
306 });
307
308 let content = from_json_value::<RoomCreateEventContent>(json).unwrap();
309 assert_eq!(content.creator.unwrap(), "@carl:example.com");
310 assert!(content.federate);
311 assert_eq!(content.room_version, RoomVersionId::V4);
312 assert_matches!(content.predecessor, None);
313 assert_eq!(content.room_type, Some(RoomType::Space));
314 }
315
316 #[test]
317 #[cfg(feature = "unstable-msc3417")]
318 #[allow(deprecated)]
319 fn call_deserialization() {
320 let json = json!({
321 "creator": "@carl:example.com",
322 "m.federate": true,
323 "room_version": "4",
324 "type": "org.matrix.msc3417.call"
325 });
326
327 let content = from_json_value::<RoomCreateEventContent>(json).unwrap();
328 assert_eq!(content.creator.unwrap(), "@carl:example.com");
329 assert!(content.federate);
330 assert_eq!(content.room_version, RoomVersionId::V4);
331 assert_matches!(content.predecessor, None);
332 assert_eq!(content.room_type, Some(RoomType::Call));
333 }
334
335 #[test]
336 fn deserialize_valid_predecessor() {
337 let json = json!({
338 "m.federate": true,
339 "room_version": "11",
340 "predecessor": {
341 "room_id": "!room:localhost",
342 "event_id": "$eokpnkpn",
343 },
344 });
345
346 let content = from_json_value::<RoomCreateEventContent>(json).unwrap();
347 assert!(content.federate);
348 assert_eq!(content.room_version, RoomVersionId::V11);
349 assert_matches!(content.predecessor, Some(_));
350 assert_eq!(content.room_type, None);
351
352 let content = serde_json::from_str::<RoomCreateEventContent>(
353 r#"{"m.federate":true,"room_version":"11","predecessor":{"room_id":"!room:localhost","event_id":"$eokpnkpn"}}"#,
354 )
355 .unwrap();
356 assert!(content.federate);
357 assert_eq!(content.room_version, RoomVersionId::V11);
358 assert_matches!(content.predecessor, Some(_));
359 assert_eq!(content.room_type, None);
360 }
361
362 #[test]
363 #[cfg(feature = "compat-lax-room-create-deser")]
364 fn deserialize_invalid_predecessor() {
365 let json = json!({
366 "m.federate": true,
367 "room_version": "11",
368 "predecessor": "!room:localhost",
369 });
370
371 let content = from_json_value::<RoomCreateEventContent>(json).unwrap();
372 assert!(content.federate);
373 assert_eq!(content.room_version, RoomVersionId::V11);
374 assert_matches!(content.predecessor, None);
375 assert_eq!(content.room_type, None);
376
377 let content = serde_json::from_str::<RoomCreateEventContent>(
378 r#"{"m.federate":true,"room_version":"11","predecessor":"!room:localhost"}"#,
379 )
380 .unwrap();
381 assert!(content.federate);
382 assert_eq!(content.room_version, RoomVersionId::V11);
383 assert_matches!(content.predecessor, None);
384 assert_eq!(content.room_type, None);
385 }
386}