[fractal] API, room: Call functions directly instead of using the loop
- From: Daniel Garcia Moreno <danigm src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [fractal] API, room: Call functions directly instead of using the loop
- Date: Fri, 24 Apr 2020 06:48:24 +0000 (UTC)
commit c570b2c95e6fceb2294724466b58469b317af0ef
Author: Alejandro Domínguez <adomu net-c com>
Date: Sun Apr 19 05:12:08 2020 +0200
API, room: Call functions directly instead of using the loop
fractal-gtk/src/actions/message.rs | 61 ++++++-------
fractal-gtk/src/actions/room_settings.rs | 23 +++--
fractal-gtk/src/app/connect/language.rs | 17 ++--
fractal-gtk/src/appop/invite.rs | 40 +++++----
fractal-gtk/src/appop/message.rs | 38 ++++----
fractal-gtk/src/appop/room.rs | 121 +++++++++++++++-----------
fractal-gtk/src/widgets/room_settings.rs | 51 ++++++-----
fractal-matrix-api/src/backend/mod.rs | 143 +------------------------------
fractal-matrix-api/src/backend/room.rs | 50 -----------
fractal-matrix-api/src/backend/types.rs | 18 ----
10 files changed, 206 insertions(+), 356 deletions(-)
---
diff --git a/fractal-gtk/src/actions/message.rs b/fractal-gtk/src/actions/message.rs
index 96bd4444..943e9819 100644
--- a/fractal-gtk/src/actions/message.rs
+++ b/fractal-gtk/src/actions/message.rs
@@ -1,3 +1,4 @@
+use fractal_api::backend::room;
use fractal_api::clone;
use fractal_api::identifiers::RoomId;
use fractal_api::r0::AccessToken;
@@ -221,7 +222,7 @@ pub fn new(
});
let b = backend.clone();
- let u = server_url.clone();
+ let s = server_url.clone();
let tk = access_token.clone();
let back_weak = Rc::downgrade(&back_history);
let window_weak = ui
@@ -243,14 +244,23 @@ pub fn new(
}
_ => {}
};
- if let Some(m) = get_message(data) {
- let _ = b.send(BKCommand::SendMsgRedaction(u.clone(), tk.clone(), m));
+ if let Some(msg) = get_message(data) {
+ let server = s.clone();
+ let access_token = tk.clone();
+ let tx = b.clone();
+ thread::spawn(move || {
+ let query = room::redact_msg(server, access_token, msg);
+ tx.send(BKCommand::SendBKResponse(BKResponse::SentMsgRedaction(
+ query,
+ )))
+ .expect_log("Connection closed");
+ });
}
});
load_more_messages.connect_activate(clone!(server_url, access_token => move |_, data| {
let id = get_room_id(data);
- request_more_messages(&backend, server_url.clone(), access_token.clone(), id);
+ request_more_messages(backend.clone(), server_url.clone(), access_token.clone(), id);
}));
actions
@@ -275,7 +285,7 @@ fn get_room_id(data: Option<&glib::Variant>) -> Option<RoomId> {
}
fn request_more_messages(
- backend: &Sender<BKCommand>,
+ tx: Sender<BKCommand>,
server_url: Url,
access_token: AccessToken,
id: Option<RoomId>,
@@ -285,34 +295,25 @@ fn request_more_messages(
let id = id?;
let r = op.rooms.get(&id)?;
if let Some(prev_batch) = r.prev_batch.clone() {
- backend
- .send(BKCommand::GetRoomMessages(
- server_url,
- access_token,
- id,
- prev_batch,
- ))
- .unwrap();
- } else if let Some(msg) = r.messages.iter().next() {
+ thread::spawn(move || {
+ let query = room::get_room_messages(server_url, access_token, id, prev_batch);
+ tx.send(BKCommand::SendBKResponse(BKResponse::RoomMessagesTo(query)))
+ .expect_log("Connection closed");
+ });
+ } 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
- backend
- .send(BKCommand::GetRoomMessagesFromMsg(
- server_url,
- access_token,
- id,
- msg.clone(),
- ))
- .unwrap();
+ thread::spawn(move || {
+ let query = room::get_room_messages_from_msg(server_url, access_token, id, msg);
+ tx.send(BKCommand::SendBKResponse(BKResponse::RoomMessagesTo(query)))
+ .expect_log("Connection closed");
+ });
} else if let Some(from) = op.since.clone() {
// no messages and no prev_batch so we use the last since
- backend
- .send(BKCommand::GetRoomMessages(
- server_url,
- access_token,
- id,
- from,
- ))
- .unwrap();
+ thread::spawn(move || {
+ let query = room::get_room_messages(server_url, access_token, id, from);
+ tx.send(BKCommand::SendBKResponse(BKResponse::RoomMessagesTo(query)))
+ .expect_log("Connection closed");
+ });
}
None
}
diff --git a/fractal-gtk/src/actions/room_settings.rs b/fractal-gtk/src/actions/room_settings.rs
index 4cb8065e..f539886e 100644
--- a/fractal-gtk/src/actions/room_settings.rs
+++ b/fractal-gtk/src/actions/room_settings.rs
@@ -1,6 +1,8 @@
+use fractal_api::backend::room;
use fractal_api::identifiers::RoomId;
use fractal_api::r0::AccessToken;
use fractal_api::url::Url;
+use fractal_api::util::ResultExpectLog;
use gio::prelude::*;
use gio::SimpleAction;
use gio::SimpleActionGroup;
@@ -8,8 +10,9 @@ use glib;
use gtk;
use std::convert::TryFrom;
use std::sync::mpsc::Sender;
+use std::thread;
-use crate::backend::BKCommand;
+use crate::backend::{BKCommand, BKResponse};
use crate::i18n::i18n;
use crate::widgets::ErrorDialog;
@@ -37,7 +40,7 @@ pub fn new(
let window_weak = window.downgrade();
let backend = backend.clone();
change_avatar.connect_activate(move |a, data| {
- if let Some(id) = data
+ if let Some(room_id) = data
.and_then(|x| x.get_str())
.and_then(|rid| RoomId::try_from(rid).ok())
{
@@ -46,14 +49,16 @@ pub fn new(
filter.set_name(Some(i18n("Images").as_str()));
filter.add_mime_type("image/*");
if let Some(path) = open(&window, i18n("Select a new avatar").as_str(), &[filter]) {
- if let Some(file) = path.to_str() {
+ if let Some(file) = path.to_str().map(Into::into) {
a.change_state(&ButtonState::Insensitive.into());
- let _ = backend.send(BKCommand::SetRoomAvatar(
- server_url.clone(),
- access_token.clone(),
- id,
- file.to_string(),
- ));
+ let tx = backend.clone();
+ let server = server_url.clone();
+ let access_token = access_token.clone();
+ thread::spawn(move || {
+ let query = room::set_room_avatar(server, access_token, room_id, file);
+ tx.send(BKCommand::SendBKResponse(BKResponse::SetRoomAvatar(query)))
+ .expect_log("Connection closed");
+ });
} else {
ErrorDialog::new(false, &i18n("Couldn’t open file"));
}
diff --git a/fractal-gtk/src/app/connect/language.rs b/fractal-gtk/src/app/connect/language.rs
index 9b5d91a1..877bc080 100644
--- a/fractal-gtk/src/app/connect/language.rs
+++ b/fractal-gtk/src/app/connect/language.rs
@@ -1,8 +1,11 @@
use crate::app::App;
-use crate::backend::BKCommand;
+use crate::backend::{BKCommand, BKResponse};
+use fractal_api::backend::room;
+use fractal_api::util::ResultExpectLog;
use glib::object::Cast;
use gtk::prelude::*;
+use std::thread;
// The TextBufferExt alias is necessary to avoid conflict with gtk's TextBufferExt
use gspell::{CheckerExt, TextBuffer, TextBufferExt as GspellTextBufferExt};
@@ -26,13 +29,17 @@ impl App {
due to the user switching rooms, the op mutex is locked already.
If the checker is modified by gtk due to the user switching the language, the op mutex
is unlocked. */
if let Ok(op) = op.try_lock() {
- if let (Some(active_room), Some(login_data)) = (&op.active_room, &op.login_data) {
+ if let (Some(active_room), Some(login_data)) = (op.active_room.as_ref(),
op.login_data.as_ref()) {
let server = login_data.server_url.clone();
let access_token = login_data.access_token.clone();
let uid = login_data.uid.clone();
- op.backend
- .send(BKCommand::ChangeLanguage(access_token, server, uid,
active_room.clone(), lang_code))
- .unwrap();
+ let room_id = active_room.clone();
+ let tx = op.backend.clone();
+ thread::spawn(move || {
+ let query = room::set_language(access_token, server, uid, room_id,
lang_code);
+ tx.send(BKCommand::SendBKResponse(BKResponse::ChangeLanguage(query)))
+ .expect_log("Connection closed");
+ });
}
}
}
diff --git a/fractal-gtk/src/appop/invite.rs b/fractal-gtk/src/appop/invite.rs
index 43ae39a3..92090edc 100644
--- a/fractal-gtk/src/appop/invite.rs
+++ b/fractal-gtk/src/appop/invite.rs
@@ -1,13 +1,16 @@
use crate::i18n::{i18n, i18n_k};
+use fractal_api::backend::room;
use fractal_api::identifiers::{RoomId, UserId};
+use fractal_api::util::ResultExpectLog;
use gtk;
use gtk::prelude::*;
+use std::thread;
use crate::appop::member::SearchType;
use crate::appop::AppOp;
-use crate::backend::BKCommand;
+use crate::backend::{BKCommand, BKResponse};
use crate::globals;
@@ -160,14 +163,18 @@ impl AppOp {
let login_data = unwrap_or_unit_return!(self.login_data.clone());
if let &Some(ref r) = &self.active_room {
for user in &self.invite_list {
- self.backend
- .send(BKCommand::Invite(
- login_data.server_url.clone(),
- login_data.access_token.clone(),
- r.clone(),
- user.0.uid.clone(),
- ))
- .unwrap();
+ let server = login_data.server_url.clone();
+ let access_token = login_data.access_token.clone();
+ let room_id = r.clone();
+ let user_id = user.0.uid.clone();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query = room::invite(server, access_token, room_id, user_id);
+ if let Err(err) = query {
+ tx.send(BKCommand::SendBKResponse(BKResponse::InviteError(err)))
+ .expect_log("Connection closed");
+ }
+ });
}
}
self.close_invite_dialog();
@@ -227,13 +234,14 @@ impl AppOp {
))
.unwrap();
} else {
- self.backend
- .send(BKCommand::RejectInv(
- login_data.server_url,
- login_data.access_token,
- rid.clone(),
- ))
- .unwrap();
+ let room_id = rid.clone();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query =
+ room::leave_room(login_data.server_url, login_data.access_token, room_id);
+ tx.send(BKCommand::SendBKResponse(BKResponse::LeaveRoom(query)))
+ .expect_log("Connection closed");
+ });
}
self.remove_inv(rid);
}
diff --git a/fractal-gtk/src/appop/message.rs b/fractal-gtk/src/appop/message.rs
index 7ff02ad1..b599d88e 100644
--- a/fractal-gtk/src/appop/message.rs
+++ b/fractal-gtk/src/appop/message.rs
@@ -1,5 +1,7 @@
use comrak::{markdown_to_html, ComrakOptions};
+use fractal_api::backend::room;
use fractal_api::identifiers::RoomId;
+use fractal_api::util::ResultExpectLog;
use gdk_pixbuf::Pixbuf;
use gio::prelude::FileExt;
use glib::source::Continue;
@@ -13,12 +15,13 @@ use serde_json::Value as JsonValue;
use std::env::temp_dir;
use std::fs;
use std::path::PathBuf;
+use std::thread;
use crate::appop::room::Force;
use crate::appop::AppOp;
use crate::App;
-use crate::backend::BKCommand;
+use crate::backend::{BKCommand, BKResponse};
use crate::uitypes::MessageContent;
use crate::uitypes::RowType;
use crate::widgets;
@@ -130,7 +133,7 @@ impl AppOp {
/* Move the last viewed mark to the last message */
let active_room_id = self.active_room.as_ref()?;
let room = self.rooms.get_mut(active_room_id)?;
- let uid = login_data.uid;
+ let uid = login_data.uid.clone();
room.messages.iter_mut().for_each(|msg| {
if msg.receipt.contains_key(&uid) {
msg.receipt.remove(&uid);
@@ -139,14 +142,19 @@ impl AppOp {
let last_message = room.messages.last_mut()?;
last_message.receipt.insert(uid, 0);
- self.backend
- .send(BKCommand::MarkAsRead(
+ let room_id = last_message.room.clone();
+ let event_id = last_message.id.clone();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query = room::mark_as_read(
login_data.server_url,
login_data.access_token,
- last_message.room.clone(),
- last_message.id.clone(),
- ))
- .unwrap();
+ room_id,
+ event_id,
+ );
+ tx.send(BKCommand::SendBKResponse(BKResponse::MarkedAsRead(query)))
+ .expect_log("Connection closed");
+ });
}
None
}
@@ -196,13 +204,13 @@ impl AppOp {
.unwrap();
}
_ => {
- self.backend
- .send(BKCommand::SendMsg(
- login_data.server_url,
- login_data.access_token,
- msg,
- ))
- .unwrap();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query =
+ room::send_msg(login_data.server_url, login_data.access_token, msg);
+ tx.send(BKCommand::SendBKResponse(BKResponse::SentMsg(query)))
+ .expect_log("Connection closed");
+ });
}
}
} else {
diff --git a/fractal-gtk/src/appop/room.rs b/fractal-gtk/src/appop/room.rs
index a7c7f5c8..cf796e96 100644
--- a/fractal-gtk/src/appop/room.rs
+++ b/fractal-gtk/src/appop/room.rs
@@ -1,10 +1,13 @@
use crate::i18n::{i18n, i18n_k, ni18n_f};
+use fractal_api::backend::room;
use fractal_api::identifiers::RoomId;
use fractal_api::url::Url;
+use fractal_api::util::ResultExpectLog;
use log::{error, warn};
use std::convert::TryFrom;
use std::fs::remove_file;
use std::os::unix::fs;
+use std::thread;
use gtk;
use gtk::prelude::*;
@@ -76,22 +79,26 @@ impl AppOp {
self.update_typing_notification();
} else {
// Request all joined members for each new room
- self.backend
- .send(BKCommand::GetRoomMembers(
- login_data.server_url.clone(),
- login_data.access_token.clone(),
- room.id.clone(),
- ))
- .unwrap();
+ let server = login_data.server_url.clone();
+ let access_token = login_data.access_token.clone();
+ let room_id = room.id.clone();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query = room::get_room_members(server, access_token, room_id);
+ tx.send(BKCommand::SendBKResponse(BKResponse::RoomMembers(query)))
+ .expect_log("Connection closed");
+ });
// Download the room avatar
// TODO: Use the avatar url returned by sync
- self.backend
- .send(BKCommand::GetRoomAvatar(
- login_data.server_url.clone(),
- login_data.access_token.clone(),
- room.id.clone(),
- ))
- .unwrap();
+ let server = login_data.server_url.clone();
+ let access_token = login_data.access_token.clone();
+ let room_id = room.id.clone();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query = room::get_room_avatar(server, access_token, room_id);
+ tx.send(BKCommand::SendBKResponse(BKResponse::RoomAvatar(query)))
+ .expect_log("Connection closed");
+ });
if clear_room_list {
roomlist.push(room.clone());
} else {
@@ -131,14 +138,15 @@ impl AppOp {
let bk = self.backend.clone();
self.roomlist.connect_fav(move |room, tofav| {
- bk.send(BKCommand::AddToFav(
- login_data.server_url.clone(),
- login_data.access_token.clone(),
- login_data.uid.clone(),
- room.id.clone(),
- tofav,
- ))
- .unwrap();
+ let tx = bk.clone();
+ let server = login_data.server_url.clone();
+ let access_token = login_data.access_token.clone();
+ let uid = login_data.uid.clone();
+ thread::spawn(move || {
+ let query = room::add_to_fav(server, access_token, uid, room.id, tofav);
+ tx.send(BKCommand::SendBKResponse(BKResponse::AddedToFav(query)))
+ .expect_log("Connection closed");
+ });
});
// Select active room in the sidebar
@@ -281,13 +289,13 @@ impl AppOp {
pub fn really_leave_active_room(&mut self) {
let login_data = unwrap_or_unit_return!(self.login_data.clone());
let r = unwrap_or_unit_return!(self.active_room.clone());
- self.backend
- .send(BKCommand::LeaveRoom(
- login_data.server_url,
- login_data.access_token,
- r.clone(),
- ))
- .unwrap();
+ let room_id = r.clone();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query = room::leave_room(login_data.server_url, login_data.access_token, room_id);
+ tx.send(BKCommand::SendBKResponse(BKResponse::LeaveRoom(query)))
+ .expect_log("Connection closed");
+ });
self.rooms.remove(&r);
self.active_room = None;
self.clear_tmp_msgs();
@@ -344,7 +352,7 @@ impl AppOp {
.get_text()
.map_or(String::new(), |gstr| gstr.to_string());
// Since the switcher
- let p = if private.get_active() {
+ let privacy = if private.get_active() {
backend::RoomType::Private
} else {
backend::RoomType::Public
@@ -352,15 +360,21 @@ impl AppOp {
let internal_id = RoomId::new(&login_data.server_url.to_string())
.expect("The server domain should have been validated");
- self.backend
- .send(BKCommand::NewRoom(
+ let int_id = internal_id.clone();
+ let name = n.clone();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let room_res = room::new_room(
login_data.server_url,
login_data.access_token,
- n.clone(),
- p,
- internal_id.clone(),
- ))
- .unwrap();
+ name,
+ privacy,
+ );
+ tx.send(BKCommand::SendBKResponse(BKResponse::NewRoom(
+ room_res, int_id,
+ )))
+ .expect_log("Connection closed");
+ });
let fakeroom = Room {
name: Some(n),
@@ -650,13 +664,13 @@ impl AppOp {
return;
}
- self.backend
- .send(BKCommand::GetRoomAvatar(
- login_data.server_url,
- login_data.access_token,
- room_id,
- ))
- .unwrap();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query =
+ room::get_room_avatar(login_data.server_url, login_data.access_token, room_id);
+ tx.send(BKCommand::SendBKResponse(BKResponse::RoomAvatar(query)))
+ .expect_log("Connection closed");
+ });
}
pub fn update_typing_notification(&mut self) {
@@ -689,24 +703,29 @@ impl AppOp {
pub fn send_typing(&mut self) {
let login_data = unwrap_or_unit_return!(self.login_data.clone());
- let active_room = unwrap_or_unit_return!(self.active_room.as_ref());
+ let active_room = unwrap_or_unit_return!(self.active_room.clone());
let now = Instant::now();
- if let Some(last_typing) = self.typing.get(active_room) {
+ if let Some(last_typing) = self.typing.get(&active_room) {
let time_passed = now.duration_since(*last_typing);
if time_passed.as_secs() < 3 {
return;
}
}
self.typing.insert(active_room.clone(), now);
- self.backend
- .send(BKCommand::SendTyping(
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query = room::send_typing(
login_data.server_url,
login_data.access_token,
login_data.uid,
- active_room.clone(),
- ))
- .unwrap();
+ active_room,
+ );
+ if let Err(err) = query {
+ tx.send(BKCommand::SendBKResponse(BKResponse::SendTypingError(err)))
+ .expect_log("Connection closed");
+ }
+ });
}
pub fn set_language(&self, lang_code: String) {
diff --git a/fractal-gtk/src/widgets/room_settings.rs b/fractal-gtk/src/widgets/room_settings.rs
index 44c97ce4..d33e7d35 100644
--- a/fractal-gtk/src/widgets/room_settings.rs
+++ b/fractal-gtk/src/widgets/room_settings.rs
@@ -1,9 +1,12 @@
+use fractal_api::backend::room;
use fractal_api::clone;
use fractal_api::identifiers::UserId;
use fractal_api::r0::AccessToken;
+use fractal_api::util::ResultExpectLog;
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::mpsc::Sender;
+use std::thread;
use crate::i18n::ni18n_f;
use fractal_api::url::Url;
@@ -13,7 +16,7 @@ use gtk::prelude::*;
use crate::actions;
use crate::actions::{ButtonState, StateExt};
-use crate::backend::BKCommand;
+use crate::backend::{BKCommand, BKResponse};
use crate::types::Member;
use crate::util::markup_text;
use crate::widgets;
@@ -428,11 +431,15 @@ impl RoomSettings {
}
}
- let _ = self.backend.send(BKCommand::GetRoomAvatar(
- self.server_url.clone(),
- self.access_token.clone(),
- self.room.id.clone(),
- ));
+ let server = self.server_url.clone();
+ let access_token = self.access_token.clone();
+ let room_id = self.room.id.clone();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query = room::get_room_avatar(server, access_token, room_id);
+ tx.send(BKCommand::SendBKResponse(BKResponse::RoomAvatar(query)))
+ .expect_log("Connection closed");
+ });
let image = widgets::Avatar::avatar_new(Some(100));
let _data = image.circle(
self.room.id.to_string(),
@@ -491,13 +498,15 @@ impl RoomSettings {
button.set_sensitive(false);
entry.set_editable(false);
- let command = BKCommand::SetRoomName(
- self.server_url.clone(),
- self.access_token.clone(),
- room.id.clone(),
- new_name.clone(),
- );
- self.backend.send(command).unwrap();
+ let server = self.server_url.clone();
+ let access_token = self.access_token.clone();
+ let room_id = room.id.clone();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query = room::set_room_name(server, access_token, room_id, new_name);
+ tx.send(BKCommand::SendBKResponse(BKResponse::SetRoomName(query)))
+ .expect_log("Connection closed");
+ });
None
}
@@ -543,13 +552,15 @@ impl RoomSettings {
button.set_sensitive(false);
name.set_editable(false);
- let command = BKCommand::SetRoomTopic(
- self.server_url.clone(),
- self.access_token.clone(),
- room.id.clone(),
- topic.clone(),
- );
- self.backend.send(command).unwrap();
+ let server = self.server_url.clone();
+ let access_token = self.access_token.clone();
+ let room_id = room.id.clone();
+ let tx = self.backend.clone();
+ thread::spawn(move || {
+ let query = room::set_room_topic(server, access_token, room_id, topic);
+ tx.send(BKCommand::SendBKResponse(BKResponse::SetRoomTopic(query)))
+ .expect_log("Connection closed");
+ });
None
}
diff --git a/fractal-matrix-api/src/backend/mod.rs b/fractal-matrix-api/src/backend/mod.rs
index 16fa0e99..61979f15 100644
--- a/fractal-matrix-api/src/backend/mod.rs
+++ b/fractal-matrix-api/src/backend/mod.rs
@@ -9,14 +9,12 @@ use crate::util::ResultExpectLog;
use crate::cache::CacheMap;
-use crate::globals;
-
use self::types::ThreadPool;
pub mod directory;
mod media;
pub mod register;
-mod room;
+pub mod room;
mod sync;
mod types;
pub mod user;
@@ -82,125 +80,16 @@ impl Backend {
}
// Room module
- Ok(BKCommand::GetRoomMembers(server, access_token, room_id)) => {
- thread::spawn(move || {
- let query = room::get_room_members(server, access_token, room_id);
- tx.send(BKResponse::RoomMembers(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::GetRoomMessages(server, access_token, room_id, from)) => {
- thread::spawn(move || {
- let query = room::get_room_messages(server, access_token, room_id, from);
- tx.send(BKResponse::RoomMessagesTo(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::GetRoomMessagesFromMsg(server, access_token, room_id, from)) => {
- thread::spawn(move || {
- let query =
- room::get_room_messages_from_msg(server, access_token, room_id, from);
- tx.send(BKResponse::RoomMessagesTo(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::GetMessageContext(server, access_token, message)) => {
- thread::spawn(move || {
- let room_id = message.room.clone();
- let event_id = &message.id;
- let query = room::get_message_context(
- server,
- access_token,
- room_id,
- event_id,
- globals::PAGE_LIMIT as u64,
- );
- tx.send(BKResponse::RoomMessagesTo(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::SendMsg(server, access_token, msg)) => {
- thread::spawn(move || {
- let query = room::send_msg(server, access_token, msg);
- tx.send(BKResponse::SentMsg(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::SendMsgRedaction(server, access_token, msg)) => {
- thread::spawn(move || {
- let query = room::redact_msg(server, access_token, msg);
- tx.send(BKResponse::SentMsgRedaction(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::SendTyping(server, access_token, uid, room_id)) => {
- thread::spawn(move || {
- let query = room::send_typing(server, access_token, uid, room_id);
- if let Err(err) = query {
- tx.send(BKResponse::SendTypingError(err))
- .expect_log("Connection closed");
- }
- });
- }
Ok(BKCommand::SetRoom(server, access_token, room_id)) => {
room::set_room(self, server, access_token, room_id)
}
- Ok(BKCommand::GetRoomAvatar(server, access_token, room_id)) => {
- thread::spawn(move || {
- let query = room::get_room_avatar(server, access_token, room_id);
- tx.send(BKResponse::RoomAvatar(query))
- .expect_log("Connection closed");
- });
- }
Ok(BKCommand::JoinRoom(server, access_token, room_id)) => {
room::join_room(self, server, access_token, room_id)
}
- Ok(BKCommand::LeaveRoom(server, access_token, room_id)) => {
- thread::spawn(move || {
- let query = room::leave_room(server, access_token, room_id);
- tx.send(BKResponse::LeaveRoom(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::MarkAsRead(server, access_token, room_id, evid)) => {
- thread::spawn(move || {
- let query = room::mark_as_read(server, access_token, room_id, evid);
- tx.send(BKResponse::MarkedAsRead(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::SetRoomName(server, access_token, room_id, name)) => {
- thread::spawn(move || {
- let query = room::set_room_name(server, access_token, room_id, name);
- tx.send(BKResponse::SetRoomName(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::SetRoomTopic(server, access_token, room_id, topic)) => {
- thread::spawn(move || {
- let query = room::set_room_topic(server, access_token, room_id, topic);
- tx.send(BKResponse::SetRoomTopic(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::SetRoomAvatar(server, access_token, room_id, fname)) => {
- thread::spawn(move || {
- let query = room::set_room_avatar(server, access_token, room_id, fname);
- tx.send(BKResponse::SetRoomAvatar(query))
- .expect_log("Connection closed");
- });
- }
Ok(BKCommand::AttachFile(server, access_token, msg)) => {
let r = room::attach_file(self, server, access_token, msg);
bkerror!(r, tx, BKResponse::AttachedFile);
}
- Ok(BKCommand::NewRoom(server, access_token, name, privacy, internal_id)) => {
- thread::spawn(move || {
- let room_res = room::new_room(server, access_token, name, privacy);
- tx.send(BKResponse::NewRoom(room_res, internal_id))
- .expect_log("Connection closed");
- });
- }
Ok(BKCommand::DirectChat(server, access_token, uid, user, internal_id)) => {
let data = self.data.clone();
@@ -210,39 +99,9 @@ impl Backend {
.expect_log("Connection closed");
});
}
- Ok(BKCommand::AddToFav(server, access_token, uid, room_id, tofav)) => {
- thread::spawn(move || {
- let query = room::add_to_fav(server, access_token, uid, room_id, tofav);
- tx.send(BKResponse::AddedToFav(query))
- .expect_log("Connection closed");
- });
- }
Ok(BKCommand::AcceptInv(server, access_token, room_id)) => {
room::join_room(self, server, access_token, room_id)
}
- Ok(BKCommand::RejectInv(server, access_token, room_id)) => {
- thread::spawn(move || {
- let query = room::leave_room(server, access_token, room_id);
- tx.send(BKResponse::LeaveRoom(query))
- .expect_log("Connection closed");
- });
- }
- Ok(BKCommand::Invite(server, access_token, room_id, userid)) => {
- thread::spawn(move || {
- let query = room::invite(server, access_token, room_id, userid);
- if let Err(err) = query {
- tx.send(BKResponse::InviteError(err))
- .expect_log("Connection closed");
- }
- });
- }
- Ok(BKCommand::ChangeLanguage(access_token, server, uid, room_id, lang)) => {
- thread::spawn(move || {
- let query = room::set_language(access_token, server, uid, room_id, lang);
- tx.send(BKResponse::ChangeLanguage(query))
- .expect_log("Connection closed");
- });
- }
// Media module
Ok(BKCommand::GetThumbAsync(server, media, ctx)) => {
diff --git a/fractal-matrix-api/src/backend/room.rs b/fractal-matrix-api/src/backend/room.rs
index 0f8f3473..56b02ffd 100644
--- a/fractal-matrix-api/src/backend/room.rs
+++ b/fractal-matrix-api/src/backend/room.rs
@@ -32,9 +32,6 @@ use crate::r0::config::set_global_account_data::request as set_global_account_da
use crate::r0::config::set_global_account_data::Parameters as SetGlobalAccountDataParameters;
use crate::r0::config::set_room_account_data::request as set_room_account_data;
use crate::r0::config::set_room_account_data::Parameters as SetRoomAccountDataParameters;
-use crate::r0::context::get_context::request as get_context;
-use crate::r0::context::get_context::Parameters as GetContextParameters;
-use crate::r0::context::get_context::Response as GetContextResponse;
use crate::r0::filter::RoomEventFilter;
use crate::r0::media::create_content::request as create_content;
use crate::r0::media::create_content::Parameters as CreateContentParameters;
@@ -237,53 +234,6 @@ pub fn get_room_messages_from_msg(
.and_then(|from| get_room_messages(base, access_token, room_id, from))
}
-pub fn get_message_context(
- base: Url,
- access_token: AccessToken,
- room_id: RoomId,
- eid: &str,
- limit: u64,
-) -> Result<(Vec<Message>, RoomId, Option<String>), Error> {
- let params = GetContextParameters {
- access_token: access_token.clone(),
- limit,
- filter: Default::default(),
- };
-
- get_context(base.clone(), ¶ms, &room_id, eid)
- .map_err(Into::into)
- .and_then(|request| {
- let response = HTTP_CLIENT
- .get_client()?
- .execute(request)?
- .json::<GetContextResponse>()?;
-
- let mut id: Option<String> = None;
-
- let ms: Result<Vec<Message>, _> = response
- .events_before
- .iter()
- .rev()
- .inspect(|msg| {
- if id.is_none() {
- id = Some(msg["event_id"].as_str().unwrap_or_default().to_string());
- }
- })
- .filter(|msg| Message::supported_event(&&msg))
- .map(|msg| Message::parse_room_message(&room_id, msg))
- .collect();
-
- match (ms, id) {
- (Ok(msgs), Some(ref id)) if msgs.is_empty() => {
- // there's no messages so we'll try with a bigger context
- get_message_context(base, access_token, room_id, id, limit * 2)
- }
- (Ok(msgs), _) => Ok((msgs, room_id, None)),
- (Err(err), _) => Err(err.into()),
- }
- })
-}
-
pub fn send_msg(
base: Url,
access_token: AccessToken,
diff --git a/fractal-matrix-api/src/backend/types.rs b/fractal-matrix-api/src/backend/types.rs
index 90cc2f6e..535b4452 100644
--- a/fractal-matrix-api/src/backend/types.rs
+++ b/fractal-matrix-api/src/backend/types.rs
@@ -24,11 +24,6 @@ pub enum BKCommand {
Register(String, String, Url, Url),
Guest(Url, Url),
Sync(Url, AccessToken, UserId, Option<String>, bool),
- GetRoomMembers(Url, AccessToken, RoomId),
- GetRoomMessages(Url, AccessToken, RoomId, String),
- GetRoomMessagesFromMsg(Url, AccessToken, RoomId, Message),
- GetMessageContext(Url, AccessToken, Message),
- GetRoomAvatar(Url, AccessToken, RoomId),
GetThumbAsync(Url, String, Sender<Result<String, Error>>),
GetMediaAsync(Url, String, Sender<Result<String, Error>>),
GetMediaListAsync(
@@ -41,26 +36,13 @@ pub enum BKCommand {
),
GetAvatarAsync(Url, Option<Member>, Sender<String>),
GetUserInfoAsync(Url, UserId, Option<Sender<(String, String)>>),
- SendMsg(Url, AccessToken, Message),
- SendMsgRedaction(Url, AccessToken, Message),
- SendTyping(Url, AccessToken, UserId, RoomId),
SetRoom(Url, AccessToken, RoomId),
ShutDown,
DirectorySearch(Url, AccessToken, String, String, String, bool),
JoinRoom(Url, AccessToken, RoomId),
- MarkAsRead(Url, AccessToken, RoomId, String),
- LeaveRoom(Url, AccessToken, RoomId),
- SetRoomName(Url, AccessToken, RoomId, String),
- SetRoomTopic(Url, AccessToken, RoomId, String),
- SetRoomAvatar(Url, AccessToken, RoomId, String),
AttachFile(Url, AccessToken, Message),
- NewRoom(Url, AccessToken, String, RoomType, RoomId),
DirectChat(Url, AccessToken, UserId, Member, RoomId),
- AddToFav(Url, AccessToken, UserId, RoomId, bool),
AcceptInv(Url, AccessToken, RoomId),
- RejectInv(Url, AccessToken, RoomId),
- Invite(Url, AccessToken, RoomId, UserId),
- ChangeLanguage(AccessToken, Url, UserId, RoomId, String),
SendBKResponse(BKResponse),
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
