[fractal] API, room: use endpoint in send_msg

[Daniel Garcia Moreno <danigm src gnome org>]

commit 6cf477de2e9f435a36d02cbd8193ca26274d248c
Author: Alejandro Domínguez <adomu net-c com>
Date:   Thu Mar 5 14:43:14 2020 +0100

    API, room: use endpoint in send_msg

 fractal-matrix-api/src/backend/mod.rs              |  7 ++-
 fractal-matrix-api/src/backend/room.rs             | 73 +++++++++++-----------
 fractal-matrix-api/src/r0/message.rs               |  1 +
 .../src/r0/message/create_message_event.rs         | 36 +++++++++++
 4 files changed, 78 insertions(+), 39 deletions(-)
---
diff --git a/fractal-matrix-api/src/backend/mod.rs b/fractal-matrix-api/src/backend/mod.rs
index ab6bf9b5..77c431c7 100644
--- a/fractal-matrix-api/src/backend/mod.rs
+++ b/fractal-matrix-api/src/backend/mod.rs
@@ -256,8 +256,11 @@ impl Backend {
                 });
             }
             Ok(BKCommand::SendMsg(server, access_token, msg)) => {
-                let r = room::send_msg(self, server, access_token, msg);
-                bkerror2!(r, tx, BKResponse::SentMsg);
+                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)) => {
                 let r = room::redact_msg(self, server, access_token, &msg);
diff --git a/fractal-matrix-api/src/backend/room.rs b/fractal-matrix-api/src/backend/room.rs
index 2138cf7a..23713b64 100644
--- a/fractal-matrix-api/src/backend/room.rs
+++ b/fractal-matrix-api/src/backend/room.rs
@@ -42,6 +42,9 @@ use crate::r0::membership::join_room_by_id_or_alias::request as join_room_req;
 use crate::r0::membership::join_room_by_id_or_alias::Parameters as JoinRoomParameters;
 use crate::r0::membership::leave_room::request as leave_room_req;
 use crate::r0::membership::leave_room::Parameters as LeaveRoomParameters;
+use crate::r0::message::create_message_event::request as create_message_event;
+use crate::r0::message::create_message_event::Parameters as CreateMessageEventParameters;
+use crate::r0::message::create_message_event::Response as CreateMessageEventResponse;
 use crate::r0::message::get_message_events::request as get_messages_events;
 use crate::r0::message::get_message_events::Direction as GetMessagesEventsDirection;
 use crate::r0::message::get_message_events::Parameters as GetMessagesEventsParams;
@@ -277,58 +280,51 @@ pub fn get_message_context(
 }
 
 pub fn send_msg(
-    bk: &Backend,
     base: Url,
     access_token: AccessToken,
     msg: Message,
-) -> Result<(), Error> {
+) -> Result<(String, String), Error> {
     let room_id: RoomId = msg.room.clone();
 
-    let url = bk.url(
-        base,
-        &access_token,
-        &format!("rooms/{}/send/m.room.message/{}", room_id, msg.id),
-        vec![],
-    )?;
+    let params = CreateMessageEventParameters { access_token };
 
-    let mut attrs = json!({
-        "body": msg.body.clone(),
-        "msgtype": msg.mtype.clone()
+    let mut body = json!({
+        "body": msg.body,
+        "msgtype": msg.mtype,
     });
 
-    if let Some(ref u) = msg.url {
-        attrs["url"] = json!(u);
+    if let Some(u) = msg.url.as_ref() {
+        body["url"] = json!(u);
     }
 
     if let (Some(f), Some(f_b)) = (msg.format.as_ref(), msg.formatted_body.as_ref()) {
-        attrs["formatted_body"] = json!(f_b);
-        attrs["format"] = json!(f);
+        body["formatted_body"] = json!(f_b);
+        body["format"] = json!(f);
     }
 
-    if let Some(xctx) = msg.extra_content.as_ref() {
-        if let Some(xctx) = xctx.as_object() {
-            for (k, v) in xctx {
-                attrs[k] = v.clone();
-            }
-        }
+    let extra_content_map = msg
+        .extra_content
+        .as_ref()
+        .and_then(|v| v.as_object())
+        .cloned()
+        .unwrap_or_default();
+
+    for (k, v) in extra_content_map {
+        body[k] = v;
     }
 
-    let tx = bk.tx.clone();
-    put!(
-        url,
-        &attrs,
-        move |js: JsonValue| {
-            let evid = js["event_id"].as_str().unwrap_or_default();
-            tx.send(BKResponse::SentMsg(Ok((msg.id, evid.to_string()))))
-                .expect_log("Connection closed");
-        },
-        |_| {
-            tx.send(BKResponse::SentMsg(Err(Error::SendMsgError(msg.id))))
-                .expect_log("Connection closed");
-        }
-    );
+    create_message_event(base, &params, &body, &room_id, "m.room.message", &msg.id)
+        .map_err::<Error, _>(Into::into)
+        .and_then(|request| {
+            let response = HTTP_CLIENT
+                .get_client()?
+                .execute(request)?
+                .json::<CreateMessageEventResponse>()?;
 
-    Ok(())
+            let evid = response.event_id.unwrap_or_default();
+            Ok((msg.id.clone(), evid))
+        })
+        .or(Err(Error::SendMsgError(msg.id)))
 }
 
 pub fn send_typing(
@@ -611,7 +607,10 @@ pub fn attach_file(
     let itx = bk.internal_tx.clone();
 
     if fname.starts_with("mxc://") && thumb.starts_with("mxc://") {
-        return send_msg(bk, baseu, tk, msg);
+        tx.send(BKResponse::SentMsg(send_msg(baseu, tk, msg)))
+            .expect_log("Connection closed");
+
+        return Ok(());
     }
 
     thread::spawn(move || {
diff --git a/fractal-matrix-api/src/r0/message.rs b/fractal-matrix-api/src/r0/message.rs
index 7a4e2571..9abe4770 100644
--- a/fractal-matrix-api/src/r0/message.rs
+++ b/fractal-matrix-api/src/r0/message.rs
@@ -1 +1,2 @@
+pub mod create_message_event;
 pub mod get_message_events;
diff --git a/fractal-matrix-api/src/r0/message/create_message_event.rs 
b/fractal-matrix-api/src/r0/message/create_message_event.rs
new file mode 100644
index 00000000..46d5fe86
--- /dev/null
+++ b/fractal-matrix-api/src/r0/message/create_message_event.rs
@@ -0,0 +1,36 @@
+use crate::r0::AccessToken;
+use reqwest::blocking::Client;
+use reqwest::blocking::Request;
+use reqwest::Error;
+use ruma_identifiers::RoomId;
+use serde::{Deserialize, Serialize};
+use serde_json::Value as JsonValue;
+use url::Url;
+
+#[derive(Clone, Debug, Serialize)]
+pub struct Parameters {
+    pub access_token: AccessToken,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct Response {
+    pub event_id: Option<String>,
+}
+
+pub fn request(
+    base: Url,
+    params: &Parameters,
+    body: &JsonValue,
+    room_id: &RoomId,
+    event_type: &str,
+    txn_id: &str,
+) -> Result<Request, Error> {
+    let url = base
+        .join(&format!(
+            "/_matrix/client/r0/rooms/{}/send/{}/{}",
+            room_id, event_type, txn_id,
+        ))
+        .expect("Malformed URL in user_directory");
+
+    Client::new().put(url).query(params).json(body).build()
+}