[fractal] BKResponse, room: remove error variants and compose over Result instead
- From: Alexandre Franke <afranke src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [fractal] BKResponse, room: remove error variants and compose over Result instead
- Date: Wed, 25 Sep 2019 20:01:00 +0000 (UTC)
commit a37d3a2ca75cd979df0b9086869a90d65829b139
Author: Alejandro Domínguez <adomu net-c com>
Date: Mon Aug 26 04:30:47 2019 +0200
BKResponse, room: remove error variants and compose over Result instead
fractal-gtk/src/app/backend_loop.rs | 38 +++++++-------
fractal-matrix-api/src/backend/mod.rs | 38 +++++++-------
fractal-matrix-api/src/backend/room.rs | 82 +++++++++++++++---------------
fractal-matrix-api/src/backend/stickers.rs | 4 +-
fractal-matrix-api/src/backend/types.rs | 48 ++++++-----------
5 files changed, 96 insertions(+), 114 deletions(-)
---
diff --git a/fractal-gtk/src/app/backend_loop.rs b/fractal-gtk/src/app/backend_loop.rs
index 6ade48f4..3dd65486 100644
--- a/fractal-gtk/src/app/backend_loop.rs
+++ b/fractal-gtk/src/app/backend_loop.rs
@@ -105,23 +105,23 @@ pub fn backend_loop(rx: Receiver<BKResponse>) {
let clear_room_list = false;
APPOP!(set_rooms, (rooms, clear_room_list));
}
- Ok(BKResponse::RoomDetail(room, key, value)) => {
+ Ok(BKResponse::RoomDetail(Ok((room, key, value)))) => {
let v = Some(value);
APPOP!(set_room_detail, (room, key, v));
}
- Ok(BKResponse::RoomAvatar(room, avatar)) => {
+ Ok(BKResponse::RoomAvatar(Ok((room, avatar)))) => {
APPOP!(set_room_avatar, (room, avatar));
}
- Ok(BKResponse::RoomMembers(room, members)) => {
+ Ok(BKResponse::RoomMembers(Ok((room, members)))) => {
APPOP!(set_room_members, (room, members));
}
Ok(BKResponse::RoomMessages(msgs)) => {
APPOP!(show_room_messages, (msgs));
}
- Ok(BKResponse::RoomMessagesTo(msgs, room, prev_batch)) => {
+ Ok(BKResponse::RoomMessagesTo(Ok((msgs, room, prev_batch)))) => {
APPOP!(show_room_messages_top, (msgs, room, prev_batch));
}
- Ok(BKResponse::SentMsg(txid, evid)) => {
+ Ok(BKResponse::SentMsg(Ok((txid, evid)))) => {
APPOP!(msg_sent, (txid, evid));
let initial = false;
APPOP!(sync, (initial));
@@ -133,20 +133,20 @@ pub fn backend_loop(rx: Receiver<BKResponse>) {
APPOP!(append_directory_rooms, (rooms));
}
- Ok(BKResponse::JoinRoom) => {
+ Ok(BKResponse::JoinRoom(Ok(_))) => {
APPOP!(reload_rooms);
}
- Ok(BKResponse::LeaveRoom) => {}
- Ok(BKResponse::SetRoomName) => {
+ Ok(BKResponse::LeaveRoom(Ok(_))) => {}
+ Ok(BKResponse::SetRoomName(Ok(_))) => {
APPOP!(show_new_room_name);
}
- Ok(BKResponse::SetRoomTopic) => {
+ Ok(BKResponse::SetRoomTopic(Ok(_))) => {
APPOP!(show_new_room_topic);
}
- Ok(BKResponse::SetRoomAvatar) => {
+ Ok(BKResponse::SetRoomAvatar(Ok(_))) => {
APPOP!(show_new_room_avatar);
}
- Ok(BKResponse::MarkedAsRead(r, _)) => {
+ Ok(BKResponse::MarkedAsRead(Ok((r, _)))) => {
APPOP!(clear_room_notifications, (r));
}
Ok(BKResponse::RoomNotifications(r, n, h)) => {
@@ -173,14 +173,14 @@ pub fn backend_loop(rx: Receiver<BKResponse>) {
.spawn()
.expect("failed to execute process");
}
- Ok(BKResponse::AttachedFile(msg)) => {
+ Ok(BKResponse::AttachedFile(Ok(msg))) => {
APPOP!(attached_file, (msg));
}
- Ok(BKResponse::NewRoom(r, internal_id)) => {
+ Ok(BKResponse::NewRoom(Ok(r), internal_id)) => {
let id = Some(internal_id);
APPOP!(new_room, (r, id));
}
- Ok(BKResponse::AddedToFav(r, tofav)) => {
+ Ok(BKResponse::AddedToFav(Ok((r, tofav)))) => {
APPOP!(added_to_fav, (r, tofav));
}
Ok(BKResponse::UserSearch(users)) => {
@@ -208,7 +208,7 @@ pub fn backend_loop(rx: Receiver<BKResponse>) {
error!("{:?}", err);
APPOP!(show_three_pid_error_dialog, (error));
}
- Ok(BKResponse::NewRoomError(err, internal_id)) => {
+ Ok(BKResponse::NewRoom(Err(err), internal_id)) => {
error!("{:?}", err);
let error = i18n("Can’t create the room, try again");
@@ -217,7 +217,7 @@ pub fn backend_loop(rx: Receiver<BKResponse>) {
APPOP!(show_error, (error));
APPOP!(set_state, (state));
}
- Ok(BKResponse::JoinRoomError(err)) => {
+ Ok(BKResponse::JoinRoom(Err(err))) => {
error!("{:?}", err);
let error = format!("{}", i18n("Can’t join the room, try again."));
let state = AppState::NoRoom;
@@ -231,11 +231,11 @@ pub fn backend_loop(rx: Receiver<BKResponse>) {
APPOP!(logout);
APPOP!(set_state, (st));
}
- Ok(BKResponse::AttachFileError(err)) => {
+ Ok(BKResponse::AttachedFile(Err(err))) => {
error!("attaching {:?}: retrying send", err);
APPOP!(retry_send);
}
- Ok(BKResponse::SendMsgError(err)) => match err {
+ Ok(BKResponse::SentMsg(Err(err))) => match err {
Error::SendMsgError(txid) => {
error!("sending {}: retrying send", txid);
APPOP!(retry_send);
@@ -245,7 +245,7 @@ pub fn backend_loop(rx: Receiver<BKResponse>) {
APPOP!(show_error, (error));
}
},
- Ok(BKResponse::SendMsgRedactionError(_)) => {
+ Ok(BKResponse::SentMsgRedaction(Err(_))) => {
let error = i18n("Error deleting message");
APPOP!(show_error, (error));
}
diff --git a/fractal-matrix-api/src/backend/mod.rs b/fractal-matrix-api/src/backend/mod.rs
index c98f2bee..c1a08e58 100644
--- a/fractal-matrix-api/src/backend/mod.rs
+++ b/fractal-matrix-api/src/backend/mod.rs
@@ -148,27 +148,27 @@ impl Backend {
// Room module
Ok(BKCommand::GetRoomMembers(room)) => {
let r = room::get_room_members(self, room);
- bkerror!(r, tx, BKResponse::RoomMembersError);
+ bkerror2!(r, tx, BKResponse::RoomMembers);
}
Ok(BKCommand::GetRoomMessages(room, from)) => {
let r = room::get_room_messages(self, room, from);
- bkerror!(r, tx, BKResponse::RoomMessagesError);
+ bkerror2!(r, tx, BKResponse::RoomMessagesTo);
}
Ok(BKCommand::GetRoomMessagesFromMsg(room, from)) => {
let r = room::get_room_messages_from_msg(self, room, from);
- bkerror!(r, tx, BKResponse::RoomMessagesError);
+ bkerror2!(r, tx, BKResponse::RoomMessagesTo);
}
Ok(BKCommand::GetMessageContext(message)) => {
let r = room::get_message_context(self, message);
- bkerror!(r, tx, BKResponse::RoomMessagesError);
+ bkerror2!(r, tx, BKResponse::RoomMessagesTo);
}
Ok(BKCommand::SendMsg(msg)) => {
let r = room::send_msg(self, msg);
- bkerror!(r, tx, BKResponse::SendMsgError);
+ bkerror2!(r, tx, BKResponse::SentMsg);
}
Ok(BKCommand::SendMsgRedaction(msg)) => {
let r = room::redact_msg(self, &msg);
- bkerror!(r, tx, BKResponse::SendMsgRedactionError);
+ bkerror2!(r, tx, BKResponse::SentMsgRedaction);
}
Ok(BKCommand::SendTyping(room)) => {
let r = room::send_typing(self, room);
@@ -180,61 +180,61 @@ impl Backend {
}
Ok(BKCommand::GetRoomAvatar(room)) => {
let r = room::get_room_avatar(self, room);
- bkerror!(r, tx, BKResponse::GetRoomAvatarError);
+ bkerror2!(r, tx, BKResponse::RoomAvatar);
}
Ok(BKCommand::JoinRoom(roomid)) => {
let r = room::join_room(self, roomid);
- bkerror!(r, tx, BKResponse::JoinRoomError);
+ bkerror2!(r, tx, BKResponse::JoinRoom);
}
Ok(BKCommand::LeaveRoom(roomid)) => {
let r = room::leave_room(self, &roomid);
- bkerror!(r, tx, BKResponse::LeaveRoomError);
+ bkerror2!(r, tx, BKResponse::LeaveRoom);
}
Ok(BKCommand::MarkAsRead(roomid, evid)) => {
let r = room::mark_as_read(self, &roomid, &evid);
- bkerror!(r, tx, BKResponse::MarkAsReadError);
+ bkerror2!(r, tx, BKResponse::MarkedAsRead);
}
Ok(BKCommand::SetRoomName(roomid, name)) => {
let r = room::set_room_name(self, &roomid, &name);
- bkerror!(r, tx, BKResponse::SetRoomNameError);
+ bkerror2!(r, tx, BKResponse::SetRoomName);
}
Ok(BKCommand::SetRoomTopic(roomid, topic)) => {
let r = room::set_room_topic(self, &roomid, &topic);
- bkerror!(r, tx, BKResponse::SetRoomTopicError);
+ bkerror2!(r, tx, BKResponse::SetRoomTopic);
}
Ok(BKCommand::SetRoomAvatar(roomid, fname)) => {
let r = room::set_room_avatar(self, &roomid, &fname);
- bkerror!(r, tx, BKResponse::SetRoomAvatarError);
+ bkerror2!(r, tx, BKResponse::SetRoomAvatar);
}
Ok(BKCommand::AttachFile(msg)) => {
let r = room::attach_file(self, msg);
- bkerror!(r, tx, BKResponse::AttachFileError);
+ bkerror2!(r, tx, BKResponse::AttachedFile);
}
Ok(BKCommand::NewRoom(name, privacy, internalid)) => {
let r = room::new_room(self, &name, privacy, internalid.clone());
if let Err(e) = r {
- tx.send(BKResponse::NewRoomError(e, internalid))
+ tx.send(BKResponse::NewRoom(Err(e), internalid))
.expect_log("Connection closed");
}
}
Ok(BKCommand::DirectChat(user, internalid)) => {
let r = room::direct_chat(self, &user, internalid.clone());
if let Err(e) = r {
- tx.send(BKResponse::NewRoomError(e, internalid))
+ tx.send(BKResponse::NewRoom(Err(e), internalid))
.expect_log("Connection closed");
}
}
Ok(BKCommand::AddToFav(roomid, tofav)) => {
let r = room::add_to_fav(self, roomid, tofav);
- bkerror!(r, tx, BKResponse::AddToFavError);
+ bkerror2!(r, tx, BKResponse::AddedToFav);
}
Ok(BKCommand::AcceptInv(roomid)) => {
let r = room::join_room(self, roomid);
- bkerror!(r, tx, BKResponse::AcceptInvError);
+ bkerror2!(r, tx, BKResponse::JoinRoom);
}
Ok(BKCommand::RejectInv(roomid)) => {
let r = room::leave_room(self, &roomid);
- bkerror!(r, tx, BKResponse::RejectInvError);
+ bkerror2!(r, tx, BKResponse::LeaveRoom);
}
Ok(BKCommand::Invite(room, userid)) => {
let r = room::invite(self, &room, &userid);
diff --git a/fractal-matrix-api/src/backend/room.rs b/fractal-matrix-api/src/backend/room.rs
index babf5725..768c606f 100644
--- a/fractal-matrix-api/src/backend/room.rs
+++ b/fractal-matrix-api/src/backend/room.rs
@@ -58,11 +58,11 @@ pub fn get_room_detail(bk: &Backend, roomid: String, key: String) -> Result<(),
let k = keys.split('.').last().unwrap();
let value = String::from(r[&k].as_str().unwrap_or_default());
- tx.send(BKResponse::RoomDetail(roomid, key, value))
+ tx.send(BKResponse::RoomDetail(Ok((roomid, key, value))))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::RoomDetailError(err))
+ tx.send(BKResponse::RoomDetail(Err(err)))
.expect_log("Connection closed");
}
);
@@ -87,18 +87,18 @@ pub fn get_room_avatar(bk: &Backend, roomid: String) -> Result<(), Error> {
dest.as_ref().map(String::as_str),
);
}
- tx.send(BKResponse::RoomAvatar(roomid, avatar))
+ tx.send(BKResponse::RoomAvatar(Ok((roomid, avatar))))
.expect_log("Connection closed");
},
|err: Error| match err {
Error::MatrixError(ref js)
if js["errcode"].as_str().unwrap_or_default() == "M_NOT_FOUND" =>
{
- tx.send(BKResponse::RoomAvatar(roomid, None))
+ tx.send(BKResponse::RoomAvatar(Ok((roomid, None))))
.expect_log("Connection closed");
}
_ => {
- tx.send(BKResponse::RoomAvatarError(err))
+ tx.send(BKResponse::RoomAvatar(Err(err)))
.expect_log("Connection closed");
}
}
@@ -123,11 +123,11 @@ pub fn get_room_members(bk: &Backend, roomid: String) -> Result<(), Error> {
member
})
.collect();
- tx.send(BKResponse::RoomMembers(roomid, ms))
+ tx.send(BKResponse::RoomMembers(Ok((roomid, ms))))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::RoomMembersError(err))
+ tx.send(BKResponse::RoomMembers(Err(err)))
.expect_log("Connection closed");
}
);
@@ -161,11 +161,11 @@ pub fn get_room_messages(bk: &Backend, roomid: String, from: String) -> Result<(
let evs = array.unwrap().iter().rev();
let list = Message::from_json_events_iter(&roomid, evs);
let prev_batch = r["end"].as_str().map(String::from);
- tx.send(BKResponse::RoomMessagesTo(list, roomid, prev_batch))
+ tx.send(BKResponse::RoomMessagesTo(Ok((list, roomid, prev_batch))))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::RoomMembersError(err))
+ tx.send(BKResponse::RoomMessagesTo(Err(err)))
.expect_log("Connection closed");
}
);
@@ -178,11 +178,11 @@ pub fn get_room_messages_from_msg(bk: &Backend, roomid: String, msg: Message) ->
// normal get_room_messages
let baseu = bk.get_base_url();
let tk = bk.data.lock().unwrap().access_token.clone();
- let tx = bk.internal_tx.clone();
+ let itx = bk.internal_tx.clone();
thread::spawn(move || {
if let Ok(from) = get_prev_batch_from(&baseu, &tk, &roomid, &msg.id) {
- if let Some(t) = tx {
+ if let Some(t) = itx {
t.send(BKCommand::GetRoomMessages(roomid, from))
.expect_log("Connection closed");
}
@@ -234,16 +234,16 @@ fn parse_context(
if let Err(err) =
parse_context(tx.clone(), tk, baseu, roomid, &id.unwrap(), limit * 2)
{
- tx.send(BKResponse::RoomMessagesError(err))
+ tx.send(BKResponse::RoomMessagesTo(Err(err)))
.expect_log("Connection closed");
}
} else {
- tx.send(BKResponse::RoomMessagesTo(ms, roomid, None))
+ tx.send(BKResponse::RoomMessagesTo(Ok((ms, roomid, None))))
.expect_log("Connection closed");
}
},
|err| {
- tx.send(BKResponse::RoomMessagesError(err))
+ tx.send(BKResponse::RoomMessagesTo(Err(err)))
.expect_log("Connection closed");
}
);
@@ -299,11 +299,11 @@ pub fn send_msg(bk: &Backend, msg: Message) -> Result<(), Error> {
&attrs,
move |js: JsonValue| {
let evid = js["event_id"].as_str().unwrap_or_default();
- tx.send(BKResponse::SentMsg(msg.id, evid.to_string()))
+ tx.send(BKResponse::SentMsg(Ok((msg.id, evid.to_string()))))
.expect_log("Connection closed");
},
|_| {
- tx.send(BKResponse::SendMsgError(Error::SendMsgError(msg.id)))
+ tx.send(BKResponse::SentMsg(Err(Error::SendMsgError(msg.id))))
.expect_log("Connection closed");
}
);
@@ -350,13 +350,13 @@ pub fn redact_msg(bk: &Backend, msg: &Message) -> Result<(), Error> {
&attrs,
move |js: JsonValue| {
let evid = js["event_id"].as_str().unwrap_or_default();
- tx.send(BKResponse::SentMsgRedaction(msgid, evid.to_string()))
+ tx.send(BKResponse::SentMsgRedaction(Ok((msgid, evid.to_string()))))
.expect_log("Connection closed");
},
|_| {
- tx.send(BKResponse::SendMsgRedactionError(
+ tx.send(BKResponse::SentMsgRedaction(Err(
Error::SendMsgRedactionError(msgid),
- ))
+ )))
.expect_log("Connection closed");
}
);
@@ -373,11 +373,11 @@ pub fn join_room(bk: &Backend, roomid: String) -> Result<(), Error> {
&url,
move |_: JsonValue| {
data.lock().unwrap().join_to_room = roomid.clone();
- tx.send(BKResponse::JoinRoom)
+ tx.send(BKResponse::JoinRoom(Ok(())))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::JoinRoomError(err))
+ tx.send(BKResponse::JoinRoom(Err(err)))
.expect_log("Connection closed");
}
);
@@ -392,11 +392,11 @@ pub fn leave_room(bk: &Backend, roomid: &str) -> Result<(), Error> {
post!(
&url,
move |_: JsonValue| {
- tx.send(BKResponse::LeaveRoom)
+ tx.send(BKResponse::LeaveRoom(Ok(())))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::LeaveRoomError(err))
+ tx.send(BKResponse::LeaveRoom(Err(err)))
.expect_log("Connection closed");
}
);
@@ -416,11 +416,11 @@ pub fn mark_as_read(bk: &Backend, roomid: &str, eventid: &str) -> Result<(), Err
post!(
&url,
move |_: JsonValue| {
- tx.send(BKResponse::MarkedAsRead(r, e))
+ tx.send(BKResponse::MarkedAsRead(Ok((r, e))))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::MarkAsReadError(err))
+ tx.send(BKResponse::MarkedAsRead(Err(err)))
.expect_log("Connection closed");
}
);
@@ -452,11 +452,11 @@ pub fn set_room_name(bk: &Backend, roomid: &str, name: &str) -> Result<(), Error
&url,
&attrs,
|_| {
- tx.send(BKResponse::SetRoomName)
+ tx.send(BKResponse::SetRoomName(Ok(())))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::SetRoomNameError(err))
+ tx.send(BKResponse::SetRoomName(Err(err)))
.expect_log("Connection closed");
}
);
@@ -477,11 +477,11 @@ pub fn set_room_topic(bk: &Backend, roomid: &str, topic: &str) -> Result<(), Err
&url,
&attrs,
|_| {
- tx.send(BKResponse::SetRoomTopic)
+ tx.send(BKResponse::SetRoomTopic(Ok(())))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::SetRoomTopicError(err))
+ tx.send(BKResponse::SetRoomTopic(Err(err)))
.expect_log("Connection closed");
}
);
@@ -504,7 +504,7 @@ pub fn set_room_avatar(bk: &Backend, roomid: &str, avatar: &str) -> Result<(), E
thread::spawn(move || {
match put_media(mediaurl.as_str(), contents) {
Err(err) => {
- tx.send(BKResponse::SetRoomAvatarError(err))
+ tx.send(BKResponse::SetRoomAvatar(Err(err)))
.expect_log("Connection closed");
}
Ok(js) => {
@@ -514,11 +514,11 @@ pub fn set_room_avatar(bk: &Backend, roomid: &str, avatar: &str) -> Result<(), E
&roomurl,
&attrs,
|_| {
- tx.send(BKResponse::SetRoomAvatar)
+ tx.send(BKResponse::SetRoomAvatar(Ok(())))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::SetRoomAvatarError(err))
+ tx.send(BKResponse::SetRoomAvatar(Err(err)))
.expect_log("Connection closed");
}
);
@@ -548,7 +548,7 @@ pub fn attach_file(bk: &Backend, mut msg: Message) -> Result<(), Error> {
if thumb != "" {
match upload_file(&tk, &baseu, &thumb) {
Err(err) => {
- tx.send(BKResponse::AttachFileError(err))
+ tx.send(BKResponse::AttachedFile(Err(err)))
.expect_log("Connection closed");
}
Ok(thumb_uri) => {
@@ -564,7 +564,7 @@ pub fn attach_file(bk: &Backend, mut msg: Message) -> Result<(), Error> {
match upload_file(&tk, &baseu, &fname) {
Err(err) => {
- tx.send(BKResponse::AttachFileError(err))
+ tx.send(BKResponse::AttachedFile(Err(err)))
.expect_log("Connection closed");
}
Ok(uri) => {
@@ -573,7 +573,7 @@ pub fn attach_file(bk: &Backend, mut msg: Message) -> Result<(), Error> {
t.send(BKCommand::SendMsg(msg.clone()))
.expect_log("Connection closed");
}
- tx.send(BKResponse::AttachedFile(msg))
+ tx.send(BKResponse::AttachedFile(Ok(msg)))
.expect_log("Connection closed");
}
};
@@ -627,11 +627,11 @@ pub fn new_room(
let id = String::from(r["room_id"].as_str().unwrap_or_default());
let mut r = Room::new(id, RoomMembership::Joined(RoomTag::None));
r.name = Some(n);
- tx.send(BKResponse::NewRoom(r, internal_id))
+ tx.send(BKResponse::NewRoom(Ok(r), internal_id))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::NewRoomError(err, internal_id))
+ tx.send(BKResponse::NewRoom(Err(err), internal_id))
.expect_log("Connection closed");
}
);
@@ -703,13 +703,13 @@ pub fn direct_chat(bk: &Backend, user: &Member, internal_id: String) -> Result<(
let mut r = Room::new(id.clone(), RoomMembership::Joined(RoomTag::None));
r.name = m.alias.clone();
r.direct = true;
- tx.send(BKResponse::NewRoom(r, internal_id))
+ tx.send(BKResponse::NewRoom(Ok(r), internal_id))
.expect_log("Connection closed");
update_direct_chats(direct_url, data, m.uid.clone(), id);
},
|err| {
- tx.send(BKResponse::NewRoomError(err, internal_id))
+ tx.send(BKResponse::NewRoom(Err(err), internal_id))
.expect_log("Connection closed");
}
);
@@ -735,11 +735,11 @@ pub fn add_to_fav(bk: &Backend, roomid: String, tofav: bool) -> Result<(), Error
&url,
&attrs,
|_| {
- tx.send(BKResponse::AddedToFav(roomid.clone(), tofav))
+ tx.send(BKResponse::AddedToFav(Ok((roomid.clone(), tofav))))
.expect_log("Connection closed");
},
|err| {
- tx.send(BKResponse::AddToFavError(err))
+ tx.send(BKResponse::AddedToFav(Err(err)))
.expect_log("Connection closed");
}
);
diff --git a/fractal-matrix-api/src/backend/stickers.rs b/fractal-matrix-api/src/backend/stickers.rs
index 8cab3085..b8a126e4 100644
--- a/fractal-matrix-api/src/backend/stickers.rs
+++ b/fractal-matrix-api/src/backend/stickers.rs
@@ -129,11 +129,11 @@ pub fn send(bk: &Backend, roomid: &str, sticker: &Sticker) -> Result<(), Error>
&attrs,
move |js: JsonValue| {
let evid = js["event_id"].as_str().unwrap_or_default();
- tx.send(BKResponse::SentMsg(id, evid.to_string()))
+ tx.send(BKResponse::SentMsg(Ok((id, evid.to_string()))))
.expect_log("Connection closed");
},
|_| {
- tx.send(BKResponse::SendMsgError(Error::SendMsgError(id)))
+ tx.send(BKResponse::SentMsg(Err(Error::SendMsgError(id))))
.expect_log("Connection closed");
}
);
diff --git a/fractal-matrix-api/src/backend/types.rs b/fractal-matrix-api/src/backend/types.rs
index e7c7c451..eeb3c0e4 100644
--- a/fractal-matrix-api/src/backend/types.rs
+++ b/fractal-matrix-api/src/backend/types.rs
@@ -107,31 +107,31 @@ pub enum BKResponse {
Sync(String),
Rooms(Vec<Room>, Option<Room>),
UpdateRooms(Vec<Room>),
- RoomDetail(String, String, String),
- RoomAvatar(String, Option<Url>),
+ RoomDetail(Result<(String, String, String), Error>),
+ RoomAvatar(Result<(String, Option<Url>), Error>),
NewRoomAvatar(String),
RoomMemberEvent(Event),
RoomMessages(Vec<Message>),
RoomMessagesInit(Vec<Message>),
- RoomMessagesTo(Vec<Message>, String, Option<String>),
- RoomMembers(String, Vec<Member>),
- SentMsg(String, String),
- SentMsgRedaction(String, String),
+ RoomMessagesTo(Result<(Vec<Message>, String, Option<String>), Error>),
+ RoomMembers(Result<(String, Vec<Member>), Error>),
+ SentMsg(Result<(String, String), Error>),
+ SentMsgRedaction(Result<(String, String), Error>),
DirectoryProtocols(Result<Vec<ProtocolInstance>, Error>),
DirectorySearch(Result<Vec<Room>, Error>),
- JoinRoom,
- LeaveRoom,
- MarkedAsRead(String, String),
- SetRoomName,
- SetRoomTopic,
- SetRoomAvatar,
+ JoinRoom(Result<(), Error>),
+ LeaveRoom(Result<(), Error>),
+ MarkedAsRead(Result<(String, String), Error>),
+ SetRoomName(Result<(), Error>),
+ SetRoomTopic(Result<(), Error>),
+ SetRoomAvatar(Result<(), Error>),
RoomName(String, String),
RoomTopic(String, String),
Media(Result<String, Error>),
MediaUrl(Url),
- AttachedFile(Message),
- NewRoom(Room, String),
- AddedToFav(String, bool),
+ AttachedFile(Result<Message, Error>),
+ NewRoom(Result<Room, Error>, String),
+ AddedToFav(Result<(String, bool), Error>),
RoomNotifications(String, i32, i32),
UserSearch(Vec<Member>),
Stickers(Vec<StickerGroup>),
@@ -152,28 +152,10 @@ pub enum BKResponse {
LoginError(Error),
GuestLoginError(Error),
SyncError(Error),
- RoomDetailError(Error),
- RoomAvatarError(Error),
- RoomMessagesError(Error),
- RoomMembersError(Error),
- SendMsgError(Error),
- SendMsgRedactionError(Error),
SendTypingError(Error),
SetRoomError(Error),
CommandError(Error),
GetFileAsyncError(Error),
- JoinRoomError(Error),
- MarkAsReadError(Error),
- LeaveRoomError(Error),
- SetRoomNameError(Error),
- SetRoomTopicError(Error),
- SetRoomAvatarError(Error),
- GetRoomAvatarError(Error),
- AttachFileError(Error),
- NewRoomError(Error, String),
- AddToFavError(Error),
- AcceptInvError(Error),
- RejectInvError(Error),
InviteError(Error),
StickersError(Error),
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
