[fractal] Get room messages through matrix-sdk
- From: Alexandre Franke <afranke src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [fractal] Get room messages through matrix-sdk
- Date: Tue, 1 Dec 2020 20:21:59 +0000 (UTC)
commit 0f959afbaa591311ce541741a41a977111ddbff0
Author: Alejandro DomÃnguez <adomu net-c com>
Date: Wed Aug 19 22:48:31 2020 +0200
Get room messages through matrix-sdk
fractal-gtk/src/actions/message.rs | 32 +++----
fractal-gtk/src/backend/media.rs | 103 +++++++++------------
fractal-gtk/src/backend/mod.rs | 32 +++----
fractal-gtk/src/backend/room.rs | 60 ++++++------
fractal-gtk/src/backend/sync.rs | 6 +-
fractal-gtk/src/globals.rs | 2 +-
fractal-gtk/src/model/message.rs | 16 ++--
fractal-gtk/src/model/room.rs | 2 +-
fractal-gtk/src/widgets/media_viewer.rs | 42 +++------
fractal-matrix-api/src/meson.build | 3 -
fractal-matrix-api/src/r0.rs | 1 -
fractal-matrix-api/src/r0/context.rs | 1 -
fractal-matrix-api/src/r0/context/get_context.rs | 51 ----------
fractal-matrix-api/src/r0/filter.rs | 12 ---
fractal-matrix-api/src/r0/message.rs | 1 -
.../src/r0/message/get_message_events.rs | 51 ----------
16 files changed, 121 insertions(+), 294 deletions(-)
---
diff --git a/fractal-gtk/src/actions/message.rs b/fractal-gtk/src/actions/message.rs
index 05d80621..f135c77c 100644
--- a/fractal-gtk/src/actions/message.rs
+++ b/fractal-gtk/src/actions/message.rs
@@ -17,7 +17,6 @@ use crate::model::message::Message;
use crate::uibuilder::UI;
use crate::util::i18n::i18n;
use crate::App;
-use fractal_api::url::Url;
use gio::ActionGroupExt;
use gio::ActionMapExt;
use gio::SimpleAction;
@@ -224,13 +223,10 @@ pub fn new(
}
}));
- load_more_messages.connect_activate(clone!(
- @strong server_url,
- @strong access_token
- => move |_, data| {
+ load_more_messages.connect_activate(move |_, data| {
let id = get_room_id(data);
- request_more_messages(server_url.clone(), access_token.clone(), id);
- }));
+ request_more_messages(session_client.clone(), id);
+ });
actions
}
@@ -239,18 +235,14 @@ fn get_message(id: Option<&glib::Variant>) -> Option<Message> {
get_event_id(id).as_ref().and_then(get_message_by_id)
}
-fn request_more_messages(
- server_url: Url,
- access_token: AccessToken,
- id: Option<RoomId>,
-) -> Option<()> {
+fn request_more_messages(session_client: MatrixClient, id: Option<RoomId>) -> Option<()> {
let op = App::get_op()?;
let op = op.lock().unwrap();
let id = id?;
let r = op.rooms.get(&id)?;
if let Some(prev_batch) = r.prev_batch.clone() {
- thread::spawn(move || {
- match room::get_room_messages(server_url, access_token, id, prev_batch) {
+ RUNTIME.spawn(async move {
+ match room::get_room_messages(session_client, id, &prev_batch).await {
Ok((msgs, room, prev_batch)) => {
APPOP!(show_room_messages_top, (msgs, room, prev_batch));
}
@@ -261,8 +253,8 @@ fn request_more_messages(
});
} else if let Some(msg) = r.messages.iter().next().cloned() {
// no prev_batch so we use the last message to calculate that in the backend
- thread::spawn(move || {
- match room::get_room_messages_from_msg(server_url, access_token, id, msg) {
+ RUNTIME.spawn(async move {
+ match room::get_room_messages_from_msg(session_client, id, msg).await {
Ok((msgs, room, prev_batch)) => {
APPOP!(show_room_messages_top, (msgs, room, prev_batch));
}
@@ -273,16 +265,16 @@ fn request_more_messages(
});
} else if let Some(from) = op.since.clone() {
// no messages and no prev_batch so we use the last since
- thread::spawn(
- move || match room::get_room_messages(server_url, access_token, id, from) {
+ RUNTIME.spawn(async move {
+ match room::get_room_messages(session_client, id, &from).await {
Ok((msgs, room, prev_batch)) => {
APPOP!(show_room_messages_top, (msgs, room, prev_batch));
}
Err(err) => {
err.handle_error();
}
- },
- );
+ }
+ });
}
None
}
diff --git a/fractal-gtk/src/backend/media.rs b/fractal-gtk/src/backend/media.rs
index b3f464ee..3176624d 100644
--- a/fractal-gtk/src/backend/media.rs
+++ b/fractal-gtk/src/backend/media.rs
@@ -1,24 +1,16 @@
use super::MediaError;
use crate::globals;
use fractal_api::identifiers::{Error as IdError, EventId, RoomId};
-use fractal_api::reqwest::Error as ReqwestError;
use fractal_api::url::Url;
-use fractal_api::Client as MatrixClient;
+use fractal_api::{Client as MatrixClient, Error as MatrixError};
use std::path::PathBuf;
-use std::sync::mpsc::Sender;
-
-use crate::backend::HTTP_CLIENT;
-use crate::util::ResultExpectLog;
-use fractal_api::r0::AccessToken;
use crate::model::message::Message;
-use fractal_api::r0::filter::RoomEventFilter;
-use fractal_api::r0::message::get_message_events::request as get_messages_events_req;
-use fractal_api::r0::message::get_message_events::Direction as GetMessagesEventsDirection;
-use fractal_api::r0::message::get_message_events::Parameters as GetMessagesEventsParams;
-use fractal_api::r0::message::get_message_events::Response as GetMessagesEventsResponse;
+use fractal_api::api::r0::filter::{RoomEventFilter, UrlFilter};
+use fractal_api::api::r0::message::get_message_events::Request as GetMessagesEventsRequest;
+use fractal_api::assign;
-use super::{dw_media, get_prev_batch_from, ContentType, ThreadPool};
+use super::{dw_media, get_prev_batch_from, ContentType};
pub type MediaResult = Result<PathBuf, MediaError>;
pub type MediaList = (Vec<Message>, String);
@@ -37,70 +29,63 @@ pub async fn get_media(session_client: MatrixClient, media: &Url) -> MediaResult
dw_media(session_client, media, ContentType::Download, None).await
}
-pub fn get_media_list_async(
- thread_pool: ThreadPool,
- baseu: Url,
- access_token: AccessToken,
+pub async fn get_media_list(
+ session_client: MatrixClient,
room_id: RoomId,
first_media_id: EventId,
prev_batch: Option<String>,
- tx: Sender<MediaList>,
-) {
- thread_pool.run(move || {
- let media_list = prev_batch
- // FIXME: This should never be an empty token
- .or_else(|| get_prev_batch_from(baseu.clone(), access_token.clone(), &room_id,
&first_media_id).ok())
- .and_then(|from| {
- get_room_media_list(
- baseu,
- access_token,
- &room_id,
- globals::PAGE_LIMIT as u64,
- from,
- ).ok()
- })
- .unwrap_or_default();
- tx.send(media_list).expect_log("Connection closed");
- });
+) -> Option<MediaList> {
+ // FIXME: This should never be an empty token
+ let from = match prev_batch {
+ Some(prev_batch) => prev_batch,
+ None => get_prev_batch_from(session_client.clone(), &room_id, &first_media_id)
+ .await
+ .ok()?,
+ };
+
+ get_room_media_list(session_client, &room_id, globals::PAGE_LIMIT, &from)
+ .await
+ .ok()
}
enum GetRoomMediaListError {
- Reqwest(ReqwestError),
+ Matrix(MatrixError),
EventsDeserialization(IdError),
}
-impl From<ReqwestError> for GetRoomMediaListError {
- fn from(err: ReqwestError) -> Self {
- Self::Reqwest(err)
+impl From<MatrixError> for GetRoomMediaListError {
+ fn from(err: MatrixError) -> Self {
+ Self::Matrix(err)
}
}
-fn get_room_media_list(
- baseu: Url,
- access_token: AccessToken,
+async fn get_room_media_list(
+ session_client: MatrixClient,
room_id: &RoomId,
- limit: u64,
- prev_batch: String,
+ limit: u32,
+ from: &str,
) -> Result<MediaList, GetRoomMediaListError> {
- let params = GetMessagesEventsParams {
- access_token,
- from: prev_batch,
+ let not_types = &["m.sticker".into()];
+
+ let request = assign!(GetMessagesEventsRequest::backward(room_id, from), {
to: None,
- dir: GetMessagesEventsDirection::Backward,
- limit,
- filter: RoomEventFilter {
- contains_url: true,
- not_types: vec!["m.sticker"],
- ..Default::default()
- },
- };
+ limit: limit.into(),
+ filter: Some(assign!(RoomEventFilter::empty(), {
+ url_filter: Some(UrlFilter::EventsWithUrl),
+ not_types,
+ })),
+ });
- let request = get_messages_events_req(baseu, ¶ms, room_id)?;
- let response: GetMessagesEventsResponse = HTTP_CLIENT.get_client().execute(request)?.json()?;
+ let response = session_client.room_messages(request).await?;
let prev_batch = response.end.unwrap_or_default();
- let evs = response.chunk.iter().rev();
- let media_list = Message::from_json_events_iter(room_id, evs)
+ // Deserialization to JsonValue should not fail
+ let evs = response
+ .chunk
+ .iter()
+ .rev()
+ .map(|ev| serde_json::to_value(ev.json().get()).unwrap());
+ let media_list = Message::from_json_events(room_id, evs)
.map_err(GetRoomMediaListError::EventsDeserialization)?;
Ok((media_list, prev_batch))
diff --git a/fractal-gtk/src/backend/mod.rs b/fractal-gtk/src/backend/mod.rs
index 2eeb4bf4..fba8bc4e 100644
--- a/fractal-gtk/src/backend/mod.rs
+++ b/fractal-gtk/src/backend/mod.rs
@@ -1,5 +1,4 @@
use fractal_api::identifiers::{EventId, RoomId, ServerName};
-use fractal_api::reqwest::Error as ReqwestError;
use fractal_api::url::Url;
use fractal_api::{Client as MatrixClient, Error as MatrixError};
use lazy_static::lazy_static;
@@ -14,14 +13,11 @@ use std::thread;
use crate::client::ClientBlocking;
use crate::util::cache_dir_path;
+use fractal_api::api::r0::context::get_context::Request as GetContextRequest;
use fractal_api::api::r0::media::get_content::Request as GetContentRequest;
use fractal_api::api::r0::media::get_content_thumbnail::Method;
use fractal_api::api::r0::media::get_content_thumbnail::Request as GetContentThumbnailRequest;
use fractal_api::assign;
-use fractal_api::r0::context::get_context::request as get_context;
-use fractal_api::r0::context::get_context::Parameters as GetContextParameters;
-use fractal_api::r0::context::get_context::Response as GetContextResponse;
-use fractal_api::r0::AccessToken;
pub mod directory;
pub mod media;
@@ -95,22 +91,20 @@ impl ContentType {
}
}
-pub fn get_prev_batch_from(
- base: Url,
- access_token: AccessToken,
+pub async fn get_prev_batch_from(
+ session_client: MatrixClient,
room_id: &RoomId,
event_id: &EventId,
-) -> Result<String, ReqwestError> {
- let params = GetContextParameters {
- access_token,
- limit: 0,
- filter: Default::default(),
- };
-
- let request = get_context(base, ¶ms, room_id, event_id)?;
- let response: GetContextResponse = HTTP_CLIENT.get_client().execute(request)?.json()?;
- let prev_batch = response.start.unwrap_or_default();
-
+) -> Result<String, MatrixError> {
+ let request = assign!(GetContextRequest::new(room_id, event_id), {
+ limit: 0_u32.into(),
+ });
+
+ let prev_batch = session_client
+ .send(request)
+ .await?
+ .start
+ .unwrap_or_default();
Ok(prev_batch)
}
diff --git a/fractal-gtk/src/backend/room.rs b/fractal-gtk/src/backend/room.rs
index 68945831..ee7adc36 100644
--- a/fractal-gtk/src/backend/room.rs
+++ b/fractal-gtk/src/backend/room.rs
@@ -29,6 +29,8 @@ use crate::model::{
};
use fractal_api::api::r0::config::get_global_account_data::Request as GetGlobalAccountDataRequest;
use fractal_api::api::r0::config::set_global_account_data::Request as SetGlobalAccountDataRequest;
+use fractal_api::api::r0::filter::RoomEventFilter;
+use fractal_api::api::r0::message::get_message_events::Request as GetMessagesEventsRequest;
use fractal_api::api::r0::room::create_room::Request as CreateRoomRequest;
use fractal_api::api::r0::room::create_room::RoomPreset;
use fractal_api::api::r0::room::Visibility;
@@ -41,17 +43,12 @@ use fractal_api::events::EventType;
use fractal_api::events::InitialStateEvent;
use fractal_api::r0::config::set_room_account_data::request as set_room_account_data;
use fractal_api::r0::config::set_room_account_data::Parameters as SetRoomAccountDataParameters;
-use fractal_api::r0::filter::RoomEventFilter;
use fractal_api::r0::media::create_content::request as create_content;
use fractal_api::r0::media::create_content::Parameters as CreateContentParameters;
use fractal_api::r0::media::create_content::Response as CreateContentResponse;
use fractal_api::r0::message::create_message_event::request as create_message_event;
use fractal_api::r0::message::create_message_event::Parameters as CreateMessageEventParameters;
use fractal_api::r0::message::create_message_event::Response as CreateMessageEventResponse;
-use fractal_api::r0::message::get_message_events::request as get_messages_events;
-use fractal_api::r0::message::get_message_events::Direction as GetMessagesEventsDirection;
-use fractal_api::r0::message::get_message_events::Parameters as GetMessagesEventsParams;
-use fractal_api::r0::message::get_message_events::Response as GetMessagesEventsResponse;
use fractal_api::r0::pushrules::delete_room_rules::request as delete_room_rules;
use fractal_api::r0::pushrules::delete_room_rules::Parameters as DelRoomRulesParams;
use fractal_api::r0::pushrules::get_room_rules::request as get_room_rules;
@@ -212,13 +209,13 @@ pub fn get_room_members(
#[derive(Debug)]
pub enum RoomMessagesToError {
MessageNotSent,
- Reqwest(ReqwestError),
+ Matrix(MatrixError),
EventsDeserialization(IdError),
}
-impl From<ReqwestError> for RoomMessagesToError {
- fn from(err: ReqwestError) -> Self {
- Self::Reqwest(err)
+impl<T: Into<MatrixError>> From<T> for RoomMessagesToError {
+ fn from(err: T) -> Self {
+ Self::Matrix(err.into())
}
}
@@ -227,38 +224,37 @@ impl HandleError for RoomMessagesToError {}
/* Load older messages starting by prev_batch
* https://matrix.org/docs/spec/client_server/latest.html#get-matrix-client-r0-rooms-roomid-messages
*/
-pub fn get_room_messages(
- base: Url,
- access_token: AccessToken,
+pub async fn get_room_messages(
+ session_client: MatrixClient,
room_id: RoomId,
- from: String,
+ from: &str,
) -> Result<(Vec<Message>, RoomId, Option<String>), RoomMessagesToError> {
- let params = GetMessagesEventsParams {
- access_token,
- from,
+ let types = &["m.room.message".into(), "m.sticker".into()];
+
+ let request = assign!(GetMessagesEventsRequest::backward(&room_id, from), {
to: None,
- dir: GetMessagesEventsDirection::Backward,
- limit: globals::PAGE_LIMIT as u64,
- filter: RoomEventFilter {
- types: Some(vec!["m.room.message", "m.sticker"]),
- ..Default::default()
- },
- };
+ limit: globals::PAGE_LIMIT.into(),
+ filter: Some(assign!(RoomEventFilter::empty(), {
+ types: Some(types),
+ })),
+ });
- let request = get_messages_events(base, ¶ms, &room_id)?;
- let response: GetMessagesEventsResponse = HTTP_CLIENT.get_client().execute(request)?.json()?;
+ let response = session_client.room_messages(request).await?;
let prev_batch = response.end;
- let evs = response.chunk.iter().rev();
- let list = Message::from_json_events_iter(&room_id, evs)
+ let evs = response
+ .chunk
+ .into_iter()
+ .rev()
+ .map(|ev| serde_json::to_value(ev.json().get()).unwrap());
+ let list = Message::from_json_events(&room_id, evs)
.map_err(RoomMessagesToError::EventsDeserialization)?;
Ok((list, room_id, prev_batch))
}
-pub fn get_room_messages_from_msg(
- base: Url,
- access_token: AccessToken,
+pub async fn get_room_messages_from_msg(
+ session_client: MatrixClient,
room_id: RoomId,
msg: Message,
) -> Result<(Vec<Message>, RoomId, Option<String>), RoomMessagesToError> {
@@ -266,9 +262,9 @@ pub fn get_room_messages_from_msg(
// first of all, we calculate the from param using the context api, then we call the
// normal get_room_messages
- let from = get_prev_batch_from(base.clone(), access_token.clone(), &room_id, event_id)?;
+ let from = get_prev_batch_from(session_client.clone(), &room_id, event_id).await?;
- get_room_messages(base, access_token, room_id, from)
+ get_room_messages(session_client, room_id, &from).await
}
#[derive(Debug)]
diff --git a/fractal-gtk/src/backend/sync.rs b/fractal-gtk/src/backend/sync.rs
index 091d2f39..bb49c703 100644
--- a/fractal-gtk/src/backend/sync.rs
+++ b/fractal-gtk/src/backend/sync.rs
@@ -140,7 +140,7 @@ pub fn sync(
timeline: Some(RoomEventFilter {
types: Some(vec!["m.room.message", "m.sticker"]),
not_types: vec!["m.call.*"],
- limit: Some(globals::PAGE_LIMIT),
+ limit: Some(globals::PAGE_LIMIT as i32),
..Default::default()
}),
ephemeral: Some(RoomEventFilter {
@@ -220,8 +220,8 @@ pub fn sync(
let room_messages = join
.iter()
.try_fold(Vec::new(), |mut acum, (k, room)| {
- let events = room.timeline.events.iter();
- Message::from_json_events_iter(&k, events).map(|msgs| {
+ let events = room.timeline.events.clone();
+ Message::from_json_events(&k, events).map(|msgs| {
acum.extend(msgs);
acum
})
diff --git a/fractal-gtk/src/globals.rs b/fractal-gtk/src/globals.rs
index 4a26bf50..3712abd8 100644
--- a/fractal-gtk/src/globals.rs
+++ b/fractal-gtk/src/globals.rs
@@ -5,7 +5,7 @@ use regex::Regex;
use std::{path::PathBuf, time::Duration};
pub const TIMEOUT: Duration = Duration::from_secs(80);
-pub const PAGE_LIMIT: i32 = 40;
+pub const PAGE_LIMIT: u32 = 40;
pub const ROOM_DIRECTORY_LIMIT: u32 = 20;
pub const DEVICE_NAME: &str = "Fractal";
diff --git a/fractal-gtk/src/model/message.rs b/fractal-gtk/src/model/message.rs
index 56158e8e..22cc9a5a 100644
--- a/fractal-gtk/src/model/message.rs
+++ b/fractal-gtk/src/model/message.rs
@@ -65,7 +65,7 @@ impl Message {
/// List all supported types. By default a message map a m.room.message event, but there's
/// other events that we want to show in the message history so we map other event types to our
/// Message struct, like stickers
- pub const TYPES: [&'static str; 2] = ["m.room.message", "m.sticker"];
+ const SUPPORTED_EVENTS: [&'static str; 2] = ["m.room.message", "m.sticker"];
pub fn new(
room: RoomId,
@@ -110,10 +110,10 @@ impl Message {
/// Helper function to use in iterator filter of a matrix.org json response to filter supported
/// events
- pub fn supported_event(ev: &&JsonValue) -> bool {
+ fn supported_event(ev: &JsonValue) -> bool {
let type_ = ev["type"].as_str().unwrap_or_default();
- Self::TYPES.contains(&type_)
+ Self::SUPPORTED_EVENTS.contains(&type_)
}
/// Parses a matrix.org event and return a Message object
@@ -223,16 +223,14 @@ impl Message {
///
/// * `roomid` - The messages room id
/// * `events` - An iterator to the json events
- pub fn from_json_events_iter<'a, I>(
- room_id: &RoomId,
- events: I,
- ) -> Result<Vec<Message>, IdError>
+ pub fn from_json_events<I>(room_id: &RoomId, events: I) -> Result<Vec<Message>, IdError>
where
- I: Iterator<Item = &'a JsonValue>,
+ I: IntoIterator<Item = JsonValue>,
{
events
+ .into_iter()
.filter(Message::supported_event)
- .map(|msg| Message::parse_room_message(&room_id, msg))
+ .map(|msg| Message::parse_room_message(&room_id, &msg))
.collect()
}
diff --git a/fractal-gtk/src/model/room.rs b/fractal-gtk/src/model/room.rs
index 3521114c..89eee099 100644
--- a/fractal-gtk/src/model/room.rs
+++ b/fractal-gtk/src/model/room.rs
@@ -174,7 +174,7 @@ impl Room {
notifications: room.unread_notifications.notification_count,
highlight: room.unread_notifications.highlight_count,
prev_batch: timeline.prev_batch.clone(),
- messages: Message::from_json_events_iter(&k, timeline.events.iter())?,
+ messages: Message::from_json_events(&k, timeline.events.clone())?,
admins: get_admins(stevents)?,
default_power_level: get_default_power_level(stevents),
members: stevents
diff --git a/fractal-gtk/src/widgets/media_viewer.rs b/fractal-gtk/src/widgets/media_viewer.rs
index 292a448a..92bcd6bf 100644
--- a/fractal-gtk/src/widgets/media_viewer.rs
+++ b/fractal-gtk/src/widgets/media_viewer.rs
@@ -1,3 +1,4 @@
+use crate::app::RUNTIME;
use crate::backend::media;
use crate::backend::ThreadPool;
use fractal_api::r0::AccessToken;
@@ -29,9 +30,6 @@ use crate::widgets::ErrorDialog;
use crate::widgets::PlayerExt;
use crate::widgets::{MediaPlayer, VideoPlayerWidget};
use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::mpsc::channel;
-use std::sync::mpsc::TryRecvError;
-use std::sync::mpsc::{Receiver, Sender};
use std::sync::Arc;
use std::sync::Mutex;
@@ -1035,38 +1033,24 @@ fn load_more_media(
let roomid = msg.room.clone();
let first_media_id = unwrap_or_unit_return!(msg.id);
let prev_batch = data.borrow().prev_batch.clone();
- let server_url = data.borrow().server_url.clone();
- let access_token = data.borrow().access_token.clone();
-
- let (tx, rx): (Sender<media::MediaList>, Receiver<media::MediaList>) = channel();
- media::get_media_list_async(
- thread_pool.clone(),
- server_url,
- access_token,
+
+ let media_list = RUNTIME.spawn(media::get_media_list(
+ session_client.clone(),
roomid,
first_media_id,
prev_batch,
- tx,
- );
-
- let ui = builder.clone();
- glib::timeout_add_local(
- 50,
- clone!(
- @weak data
- => @default-return Continue(false), move || match rx.try_recv() {
- Err(TryRecvError::Empty) => Continue(true),
- Err(TryRecvError::Disconnected) => {
+ ));
+
+ glib::MainContext::default().spawn_local(async move {
+ match media_list.await.map(Option::unwrap_or_default) {
+ Err(_) => {
data.borrow_mut().loading_error = true;
let err = i18n("Error while loading previous media");
ErrorDialog::new(false, &err);
-
- Continue(false)
}
Ok((msgs, prev_batch)) => {
if msgs.is_empty() {
data.borrow_mut().no_more_media = true;
- return Continue(false);
}
let thread_pool = thread_pool.clone();
@@ -1085,11 +1069,9 @@ fn load_more_media(
} else {
data.borrow_mut().current_media_index += img_msgs_count;
data.borrow_mut().previous_media(session_client.clone());
- data.borrow_mut().loading_more_media = loading_state(&ui, false);
+ data.borrow_mut().loading_more_media = loading_state(&builder, false);
}
-
- Continue(false)
}
- }),
- );
+ }
+ });
}
diff --git a/fractal-matrix-api/src/meson.build b/fractal-matrix-api/src/meson.build
index 3afeee5d..bd555ab6 100644
--- a/fractal-matrix-api/src/meson.build
+++ b/fractal-matrix-api/src/meson.build
@@ -14,10 +14,8 @@ api_sources = files(
'r0/contact/get_identifiers.rs',
'r0/contact/request_verification_token_email.rs',
'r0/contact/request_verification_token_msisdn.rs',
- 'r0/context/get_context.rs',
'r0/media/create_content.rs',
'r0/message/create_message_event.rs',
- 'r0/message/get_message_events.rs',
'r0/profile/get_display_name.rs',
'r0/profile/get_profile.rs',
'r0/profile/set_avatar_url.rs',
@@ -36,7 +34,6 @@ api_sources = files(
'r0/account.rs',
'r0/config.rs',
'r0/contact.rs',
- 'r0/context.rs',
'r0/filter.rs',
'r0/media.rs',
'r0/message.rs',
diff --git a/fractal-matrix-api/src/r0.rs b/fractal-matrix-api/src/r0.rs
index e7088cb0..e9437ab7 100644
--- a/fractal-matrix-api/src/r0.rs
+++ b/fractal-matrix-api/src/r0.rs
@@ -1,7 +1,6 @@
pub mod account;
pub mod config;
pub mod contact;
-pub mod context;
pub mod filter;
pub mod media;
pub mod message;
diff --git a/fractal-matrix-api/src/r0/filter.rs b/fractal-matrix-api/src/r0/filter.rs
index 3571fb6a..ccb248a5 100644
--- a/fractal-matrix-api/src/r0/filter.rs
+++ b/fractal-matrix-api/src/r0/filter.rs
@@ -102,15 +102,3 @@ where
ser.serialize_str(&filter_str)
}
-
-pub(crate) fn serialize_room_event_filter_as_str<S>(
- filter: &RoomEventFilter,
- ser: S,
-) -> Result<S::Ok, S::Error>
-where
- S: Serializer,
-{
- let filter_str = serde_json::to_string(filter).expect("Malformed filter");
-
- ser.serialize_str(&filter_str)
-}
diff --git a/fractal-matrix-api/src/r0/message.rs b/fractal-matrix-api/src/r0/message.rs
index 9abe4770..a6fdcc30 100644
--- a/fractal-matrix-api/src/r0/message.rs
+++ b/fractal-matrix-api/src/r0/message.rs
@@ -1,2 +1 @@
pub mod create_message_event;
-pub mod get_message_events;
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
