char
/
matrix-rust-sdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'messages'

master
Damir Jelić 2020-05-07 10:17:14 +02:00
parent 6cbdbdcd2f 9939efe0e8
commit b97e67c404
6 changed files with 408 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
matrix_sdk/Cargo.toml
View File

@ -12,6 +12,7 @@ version = "0.1.0"
[features]
default = ["encryption", "sqlite-cryptostore"]
messages = []
encryption = ["matrix-sdk-crypto"]
sqlite-cryptostore = ["matrix-sdk-crypto/sqlite-cryptostore"]

325
matrix_sdk/src/models/message.rs Normal file
View File

@ -0,0 +1,325 @@
//! A queue that holds at most ten of the most recent messages.
//!
//! The `Room` struct optionally holds a `MessageQueue` if the "messages"
//! feature is enabled.
use std::cmp::Ordering;
use std::ops::Deref;
use std::vec::IntoIter;
use crate::events::room::message::MessageEvent;
use crate::events::EventJson;
use serde::{de, ser, Serialize};
/// A queue that holds the 10 most recent messages received from the server.
#[derive(Clone, Debug, Default)]
pub struct MessageQueue {
msgs: Vec<MessageWrapper>,
}
#[derive(Clone, Debug, Serialize)]
pub struct MessageWrapper(MessageEvent);
impl Deref for MessageWrapper {
type Target = MessageEvent;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl PartialEq for MessageWrapper {
fn eq(&self, other: &MessageWrapper) -> bool {
self.0.event_id == other.0.event_id
}
}
impl Eq for MessageWrapper {}
impl PartialOrd for MessageWrapper {
fn partial_cmp(&self, other: &MessageWrapper) -> Option<Ordering> {
Some(self.0.origin_server_ts.cmp(&other.0.origin_server_ts))
}
}
impl Ord for MessageWrapper {
fn cmp(&self, other: &MessageWrapper) -> Ordering {
self.partial_cmp(other).unwrap_or(Ordering::Equal)
}
}
impl PartialEq for MessageQueue {
fn eq(&self, other: &MessageQueue) -> bool {
self.msgs.len() == other.msgs.len()
&& self
.msgs
.iter()
.zip(other.msgs.iter())
.all(|(msg_a, msg_b)| msg_a.event_id == msg_b.event_id)
}
}
impl MessageQueue {
/// Create a new empty `MessageQueue`.
pub fn new() -> Self {
Self {
msgs: Vec::with_capacity(20),
}
}
/// Inserts a `MessageEvent` into `MessageQueue`, sorted by by `origin_server_ts`.
///
/// Removes the oldest element in the queue if there are more than 10 elements.
pub fn push(&mut self, msg: MessageEvent) -> bool {
// only push new messages into the queue
if let Some(latest) = self.msgs.last() {
if msg.origin_server_ts < latest.origin_server_ts && self.msgs.len() >= 10 {
return false;
}
}
let message = MessageWrapper(msg);
match self.msgs.binary_search_by(|m| m.cmp(&message)) {
Ok(pos) => {
if self.msgs[pos] != message {
self.msgs.insert(pos, message)
}
}
Err(pos) => self.msgs.insert(pos, message),
}
if self.msgs.len() > 10 {
self.msgs.remove(0);
}
true
}
pub fn iter(&self) -> impl Iterator<Item = &MessageWrapper> {
self.msgs.iter()
}
}
impl IntoIterator for MessageQueue {
type Item = MessageWrapper;
type IntoIter = IntoIter<Self::Item>;
fn into_iter(self) -> Self::IntoIter {
self.msgs.into_iter()
}
}
pub(crate) mod ser_deser {
use super::*;
pub fn deserialize<'de, D>(deserializer: D) -> Result<MessageQueue, D::Error>
where
D: de::Deserializer<'de>,
{
use serde::de::Error;
let messages: Vec<EventJson<MessageEvent>> = de::Deserialize::deserialize(deserializer)?;
let mut msgs = vec![];
for json in messages {
let msg = json.deserialize().map_err(D::Error::custom)?;
msgs.push(MessageWrapper(msg));
}
Ok(MessageQueue { msgs })
}
pub fn serialize<S>(msgs: &MessageQueue, serializer: S) -> Result<S::Ok, S::Error>
where
S: ser::Serializer,
{
msgs.msgs.serialize(serializer)
}
}
#[cfg(test)]
mod test {
use super::*;
use std::collections::HashMap;
use std::convert::TryFrom;
use crate::events::{collections::all::RoomEvent, EventJson};
use crate::identifiers::{RoomId, UserId};
use crate::Room;
#[test]
fn serialize() {
let id = RoomId::try_from("!roomid:example.com").unwrap();
let user = UserId::try_from("@example:example.com").unwrap();
let mut room = Room::new(&id, &user);
let json = std::fs::read_to_string("../test_data/events/message_text.json").unwrap();
let event = serde_json::from_str::<EventJson<RoomEvent>>(&json).unwrap();
let mut msgs = MessageQueue::new();
if let Ok(ev) = event.deserialize() {
if let RoomEvent::RoomMessage(msg) = ev {
msgs.push(msg);
}
}
room.messages = msgs;
let mut joined_rooms = HashMap::new();
joined_rooms.insert(id, room);
println!("{}", serde_json::to_string_pretty(&joined_rooms).unwrap());
// this is the correct JSON string changes to `ruma-events` have not been released
// that would fix the doubling of fields
// TODO uncomment when fixed
// assert_eq!(
// r#"{
// "!roomid:example.com": {
// "room_id": "!roomid:example.com",
// "room_name": {
// "name": null,
// "canonical_alias": null,
// "aliases": [],
// "heroes": [],
// "joined_member_count": null,
// "invited_member_count": null
// },
// "own_user_id": "@example:example.com",
// "creator": null,
// "members": {},
// "messages": [
// {
// "type": "m.room.message",
// "content": {
// "body": "is dancing",
// "format": "org.matrix.custom.html",
// "formatted_body": "<strong>is dancing</strong>",
// "msgtype": "m.text"
// },
// "event_id": "$152037280074GZeOm:localhost",
// "origin_server_ts": 1520372800469,
// "sender": "@example:localhost",
// "unsigned": {
// "age": 598971425
// }
// }
// ],
// "typing_users": [],
// "power_levels": null,
// "encrypted": false,
// "unread_highlight": null,
// "unread_notifications": null,
// "tombstone": null
// }
// }"#,
// serde_json::to_string_pretty(&joined_rooms).unwrap()
// );
assert_eq!(
r#"{
"!roomid:example.com": {
"room_id": "!roomid:example.com",
"room_name": {
"name": null,
"canonical_alias": null,
"aliases": [],
"heroes": [],
"joined_member_count": null,
"invited_member_count": null
},
"own_user_id": "@example:example.com",
"creator": null,
"members": {},
"messages": [
{
"content": {
"msgtype": "m.text",
"msgtype": "m.text",
"body": "is dancing",
"format": "org.matrix.custom.html",
"formatted_body": "<strong>is dancing</strong>"
},
"event_id": "$152037280074GZeOm:localhost",
"origin_server_ts": 1520372800469,
"sender": "@example:localhost",
"unsigned": {
"age": 598971425
}
}
],
"typing_users": [],
"power_levels": null,
"encrypted": false,
"unread_highlight": null,
"unread_notifications": null,
"tombstone": null
}
}"#,
serde_json::to_string_pretty(&joined_rooms).unwrap()
);
}
#[test]
fn deserialize() {
let id = RoomId::try_from("!roomid:example.com").unwrap();
let user = UserId::try_from("@example:example.com").unwrap();
let mut room = Room::new(&id, &user);
let json = std::fs::read_to_string("../test_data/events/message_text.json").unwrap();
let event = serde_json::from_str::<EventJson<RoomEvent>>(&json).unwrap();
let mut msgs = MessageQueue::new();
if let Ok(ev) = event.deserialize() {
if let RoomEvent::RoomMessage(msg) = ev {
msgs.push(msg);
}
}
room.messages = msgs;
let mut joined_rooms = HashMap::new();
joined_rooms.insert(id, room.clone());
let json = r#"{
"!roomid:example.com": {
"room_id": "!roomid:example.com",
"room_name": {
"name": null,
"canonical_alias": null,
"aliases": [],
"heroes": [],
"joined_member_count": null,
"invited_member_count": null
},
"own_user_id": "@example:example.com",
"creator": null,
"members": {},
"messages": [
{
"type": "m.room.message",
"content": {
"body": "is dancing",
"format": "org.matrix.custom.html",
"formatted_body": "<strong>is dancing</strong>",
"msgtype": "m.text"
},
"event_id": "$152037280074GZeOm:localhost",
"origin_server_ts": 1520372800469,
"sender": "@example:localhost",
"unsigned": {
"age": 598971425
}
}
],
"typing_users": [],
"power_levels": null,
"encrypted": false,
"unread_highlight": null,
"unread_notifications": null,
"tombstone": null
}
}"#;
assert_eq!(
joined_rooms,
serde_json::from_str::<HashMap<RoomId, Room>>(json).unwrap()
);
}
}

3
matrix_sdk/src/models/mod.rs
View File

@ -1,4 +1,7 @@
mod event_deser;
#[cfg(feature = "messages")]
#[cfg_attr(docsrs, doc(cfg(feature = "messages")))]
mod message;
mod room;
mod room_member;

62
matrix_sdk/src/models/room.rs
View File

@ -16,6 +16,8 @@
use std::collections::{BTreeMap, HashMap};
use std::convert::TryFrom;
#[cfg(feature = "messages")]
use super::message::MessageQueue;
use super::RoomMember;
use crate::api::r0::sync::sync_events::RoomSummary;
@ -31,11 +33,16 @@ use crate::events::room::{
tombstone::TombstoneEvent,
};
use crate::events::EventType;
#[cfg(feature = "messages")]
use crate::events::room::message::MessageEvent;
use crate::identifiers::{RoomAliasId, RoomId, UserId};
use crate::js_int::{Int, UInt};
use serde::{Deserialize, Serialize};
#[derive(Debug, Default, PartialEq, Serialize, Deserialize)]
#[cfg_attr(test, derive(Clone))]
/// `RoomName` allows the calculation of a text room name.
pub struct RoomName {
/// The displayed name of the room.
@ -58,6 +65,7 @@ pub struct RoomName {
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(test, derive(Clone))]
pub struct PowerLevels {
/// The level required to ban a user.
pub ban: Int,
@ -84,6 +92,7 @@ pub struct PowerLevels {
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(test, derive(Clone))]
pub struct Tombstone {
/// A server-defined message.
body: String,
@ -92,6 +101,7 @@ pub struct Tombstone {
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[cfg_attr(test, derive(Clone))]
/// A Matrix room.
pub struct Room {
/// The unique id of the room.
@ -104,6 +114,14 @@ pub struct Room {
pub creator: Option<UserId>,
/// The map of room members.
pub members: HashMap<UserId, RoomMember>,
/// A queue of messages, holds no more than 10 of the most recent messages.
///
/// This is helpful when using a `StateStore` to avoid multiple requests
/// to the server for messages.
#[cfg(feature = "messages")]
#[cfg_attr(docsrs, doc(cfg(feature = "messages")))]
#[serde(with = "super::message::ser_deser")]
pub messages: MessageQueue,
/// A list of users that are currently typing.
pub typing_users: Vec<UserId>,
/// The power level requirements for specific actions in this room
@ -207,6 +225,8 @@ impl Room {
own_user_id: own_user_id.clone(),
creator: None,
members: HashMap::new(),
#[cfg(feature = "messages")]
messages: MessageQueue::new(),
typing_users: Vec::new(),
power_levels: None,
encrypted: false,
@ -320,6 +340,15 @@ impl Room {
}
}
/// Handle a room.message event and update the `MessageQueue` if necessary.
///
/// Returns true if `MessageQueue` was added to.
#[cfg(feature = "messages")]
#[cfg_attr(docsrs, doc(cfg(feature = "messages")))]
pub fn handle_message(&mut self, event: &MessageEvent) -> bool {
self.messages.push(event.clone())
}
/// Handle a room.aliases event, updating the room state if necessary.
///
/// Returns true if the room name changed, false otherwise.
@ -396,15 +425,17 @@ impl Room {
pub fn receive_timeline_event(&mut self, event: &RoomEvent) -> bool {
match event {
// update to the current members of the room
RoomEvent::RoomMember(m) => self.handle_membership(m),
RoomEvent::RoomMember(member) => self.handle_membership(member),
// finds all events related to the name of the room for later use
RoomEvent::RoomName(n) => self.handle_room_name(n),
RoomEvent::RoomCanonicalAlias(ca) => self.handle_canonical(ca),
RoomEvent::RoomAliases(a) => self.handle_room_aliases(a),
RoomEvent::RoomName(name) => self.handle_room_name(name),
RoomEvent::RoomCanonicalAlias(c_alias) => self.handle_canonical(c_alias),
RoomEvent::RoomAliases(alias) => self.handle_room_aliases(alias),
// power levels of the room members
RoomEvent::RoomPowerLevels(p) => self.handle_power_level(p),
RoomEvent::RoomTombstone(t) => self.handle_tombstone(t),
RoomEvent::RoomEncryption(e) => self.handle_encryption_event(e),
RoomEvent::RoomPowerLevels(power) => self.handle_power_level(power),
RoomEvent::RoomTombstone(tomb) => self.handle_tombstone(tomb),
RoomEvent::RoomEncryption(encrypt) => self.handle_encryption_event(encrypt),
#[cfg(feature = "messages")]
RoomEvent::RoomMessage(msg) => self.handle_message(msg),
_ => false,
}
}
@ -418,13 +449,16 @@ impl Room {
/// * `event` - The event of the room.
pub fn receive_state_event(&mut self, event: &StateEvent) -> bool {
match event {
StateEvent::RoomMember(m) => self.handle_membership(m),
StateEvent::RoomName(n) => self.handle_room_name(n),
StateEvent::RoomCanonicalAlias(ca) => self.handle_canonical(ca),
StateEvent::RoomAliases(a) => self.handle_room_aliases(a),
StateEvent::RoomPowerLevels(p) => self.handle_power_level(p),
StateEvent::RoomTombstone(t) => self.handle_tombstone(t),
StateEvent::RoomEncryption(e) => self.handle_encryption_event(e),
// update to the current members of the room
StateEvent::RoomMember(member) => self.handle_membership(member),
// finds all events related to the name of the room for later use
StateEvent::RoomName(name) => self.handle_room_name(name),
StateEvent::RoomCanonicalAlias(c_alias) => self.handle_canonical(c_alias),
StateEvent::RoomAliases(alias) => self.handle_room_aliases(alias),
// power levels of the room members
StateEvent::RoomPowerLevels(power) => self.handle_power_level(power),
StateEvent::RoomTombstone(tomb) => self.handle_tombstone(tomb),
StateEvent::RoomEncryption(encrypt) => self.handle_encryption_event(encrypt),
_ => false,
}
}

1
matrix_sdk/src/models/room_member.rs
View File

@ -28,6 +28,7 @@ use serde::{Deserialize, Serialize};
// Notes: if Alice invites Bob into a room we will get an event with the sender as Alice and the state key as Bob.
#[derive(Debug, Serialize, Deserialize)]
#[cfg_attr(test, derive(Clone))]
/// A Matrix room member.
///
pub struct RoomMember {

30
matrix_sdk/src/state/mod.rs
View File

@ -106,6 +106,8 @@ mod test {
let mut joined_rooms = HashMap::new();
joined_rooms.insert(id, room);
#[cfg(not(feature = "messages"))]
assert_eq!(
r#"{
"!roomid:example.com": {
@ -128,6 +130,34 @@ mod test {
"unread_notifications": null,
"tombstone": null
}
}"#,
serde_json::to_string_pretty(&joined_rooms).unwrap()
);
#[cfg(feature = "messages")]
assert_eq!(
r#"{
"!roomid:example.com": {
"room_id": "!roomid:example.com",
"room_name": {
"name": null,
"canonical_alias": null,
"aliases": [],
"heroes": [],
"joined_member_count": null,
"invited_member_count": null
},
"own_user_id": "@example:example.com",
"creator": null,
"members": {},
"messages": [],
"typing_users": [],
"power_levels": null,
"encrypted": false,
"unread_highlight": null,
"unread_notifications": null,
"tombstone": null
}
}"#,
serde_json::to_string_pretty(&joined_rooms).unwrap()
);