1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
//! Types for extensible file message events ([MSC3551]).
//!
//! [MSC3551]: https://github.com/matrix-org/matrix-spec-proposals/pull/3551
use js_int::UInt;
use ruma_common::OwnedMxcUri;
use ruma_macros::EventContent;
use serde::{Deserialize, Serialize};
use super::{
message::TextContentBlock,
room::{EncryptedFile, EncryptedFileHashes, EncryptedFileInfo, message::Relation},
};
/// The payload for an extensible file message.
///
/// This is the new primary type introduced in [MSC3551] and should only be sent in rooms with a
/// version that supports it. See the documentation of the [`message`] module for more information.
///
/// [MSC3551]: https://github.com/matrix-org/matrix-spec-proposals/pull/3551
/// [`message`]: super::message
#[derive(Clone, Debug, Serialize, Deserialize, EventContent)]
#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
#[ruma_event(type = "org.matrix.msc1767.file", kind = MessageLike, without_relation)]
pub struct FileEventContent {
/// The text representation of the message.
#[serde(rename = "org.matrix.msc1767.text")]
pub text: TextContentBlock,
/// The file content of the message.
#[serde(rename = "org.matrix.msc1767.file")]
pub file: FileContentBlock,
/// The caption of the message, if any.
#[serde(rename = "org.matrix.msc1767.caption", skip_serializing_if = "Option::is_none")]
pub caption: Option<CaptionContentBlock>,
/// Whether this message is automated.
#[cfg(feature = "unstable-msc3955")]
#[serde(
default,
skip_serializing_if = "ruma_common::serde::is_default",
rename = "org.matrix.msc1767.automated"
)]
pub automated: bool,
/// Information about related messages.
#[serde(
flatten,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::room::message::relation_serde::deserialize_relation"
)]
pub relates_to: Option<Relation<FileEventContentWithoutRelation>>,
}
impl FileEventContent {
/// Creates a new non-encrypted `FileEventContent` with the given fallback representation, url
/// and file info.
pub fn plain(text: TextContentBlock, url: OwnedMxcUri, name: String) -> Self {
Self {
text,
file: FileContentBlock::plain(url, name),
caption: None,
#[cfg(feature = "unstable-msc3955")]
automated: false,
relates_to: None,
}
}
/// Creates a new non-encrypted `FileEventContent` with the given plain text fallback
/// representation, url and name.
pub fn plain_with_plain_text(
plain_text: impl Into<String>,
url: OwnedMxcUri,
name: String,
) -> Self {
Self {
text: TextContentBlock::plain(plain_text),
file: FileContentBlock::plain(url, name),
caption: None,
#[cfg(feature = "unstable-msc3955")]
automated: false,
relates_to: None,
}
}
/// Creates a new encrypted `FileEventContent` with the given fallback representation, url,
/// name and encryption info.
pub fn encrypted(
text: TextContentBlock,
url: OwnedMxcUri,
name: String,
encryption_info: EncryptedContent,
) -> Self {
Self {
text,
file: FileContentBlock::encrypted(url, name, encryption_info),
caption: None,
#[cfg(feature = "unstable-msc3955")]
automated: false,
relates_to: None,
}
}
/// Creates a new encrypted `FileEventContent` with the given plain text fallback
/// representation, url, name and encryption info.
pub fn encrypted_with_plain_text(
plain_text: impl Into<String>,
url: OwnedMxcUri,
name: String,
encryption_info: EncryptedContent,
) -> Self {
Self {
text: TextContentBlock::plain(plain_text),
file: FileContentBlock::encrypted(url, name, encryption_info),
caption: None,
#[cfg(feature = "unstable-msc3955")]
automated: false,
relates_to: None,
}
}
}
/// A block for file content.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
pub struct FileContentBlock {
/// The URL to the file.
pub url: OwnedMxcUri,
/// The original filename of the uploaded file.
pub name: String,
/// The mimetype of the file, e.g. "application/msword".
#[serde(skip_serializing_if = "Option::is_none")]
pub mimetype: Option<String>,
/// The size of the file in bytes.
#[serde(skip_serializing_if = "Option::is_none")]
pub size: Option<UInt>,
/// Information on the encrypted file.
///
/// Required if the file is encrypted.
#[serde(flatten, skip_serializing_if = "Option::is_none")]
pub encryption_info: Option<Box<EncryptedContent>>,
}
impl FileContentBlock {
/// Creates a new non-encrypted `FileContentBlock` with the given url and name.
pub fn plain(url: OwnedMxcUri, name: String) -> Self {
Self { url, name, mimetype: None, size: None, encryption_info: None }
}
/// Creates a new encrypted `FileContentBlock` with the given url, name and encryption info.
pub fn encrypted(url: OwnedMxcUri, name: String, encryption_info: EncryptedContent) -> Self {
Self {
url,
name,
mimetype: None,
size: None,
encryption_info: Some(Box::new(encryption_info)),
}
}
/// Whether the file is encrypted.
pub fn is_encrypted(&self) -> bool {
self.encryption_info.is_some()
}
}
/// The encryption info of a file sent to a room with end-to-end encryption enabled.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
pub struct EncryptedContent {
/// Information about the encryption of the file.
#[serde(flatten)]
pub info: EncryptedFileInfo,
/// A map from an algorithm name to a hash of the ciphertext.
///
/// Clients should support the SHA-256 hash, which uses the key sha256.
pub hashes: EncryptedFileHashes,
}
impl EncryptedContent {
/// Construct a new `EncryptedContent` with the given encryption info and hashes.
pub fn new(info: EncryptedFileInfo, hashes: EncryptedFileHashes) -> Self {
Self { info, hashes }
}
}
impl From<&EncryptedFile> for EncryptedContent {
fn from(encrypted: &EncryptedFile) -> Self {
let EncryptedFile { info, hashes, .. } = encrypted;
Self { info: info.to_owned(), hashes: hashes.to_owned() }
}
}
/// A block for caption content.
///
/// A caption is usually a text message that should be displayed next to some media content.
///
/// To construct a `CaptionContentBlock` with a custom [`TextContentBlock`], convert it with
/// `CaptionContentBlock::from()` / `.into()`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
pub struct CaptionContentBlock {
/// The text message of the caption.
#[serde(rename = "org.matrix.msc1767.text")]
pub text: TextContentBlock,
}
impl CaptionContentBlock {
/// A convenience constructor to create a plain text caption content block.
pub fn plain(body: impl Into<String>) -> Self {
Self { text: TextContentBlock::plain(body) }
}
/// A convenience constructor to create an HTML caption content block.
pub fn html(body: impl Into<String>, html_body: impl Into<String>) -> Self {
Self { text: TextContentBlock::html(body, html_body) }
}
/// A convenience constructor to create a caption content block from Markdown.
///
/// The content includes an HTML message if some Markdown formatting was detected, otherwise
/// only a plain text message is included.
#[cfg(feature = "markdown")]
pub fn markdown(body: impl AsRef<str> + Into<String>) -> Self {
Self { text: TextContentBlock::markdown(body) }
}
}
impl From<TextContentBlock> for CaptionContentBlock {
fn from(text: TextContentBlock) -> Self {
Self { text }
}
}