[fractal] API, room: use endpoint in new_room

[Daniel Garcia Moreno <danigm src gnome org>]

commit efec765054cf79dad1a3d41348a2e6d408cd26bf
Author: Alejandro Domínguez <adomu net-c com>
Date:   Tue Mar 10 02:22:07 2020 +0100

    API, room: use endpoint in new_room

 fractal-matrix-api/src/backend/mod.rs         | 15 ++----
 fractal-matrix-api/src/backend/room.rs        | 70 ++++++++++++--------------
 fractal-matrix-api/src/r0.rs                  |  1 +
 fractal-matrix-api/src/r0/room.rs             | 10 ++++
 fractal-matrix-api/src/r0/room/create_room.rs | 72 +++++++++++++++++++++++++++
 5 files changed, 119 insertions(+), 49 deletions(-)
---
diff --git a/fractal-matrix-api/src/backend/mod.rs b/fractal-matrix-api/src/backend/mod.rs
index 5a530ca5..8d903e23 100644
--- a/fractal-matrix-api/src/backend/mod.rs
+++ b/fractal-matrix-api/src/backend/mod.rs
@@ -331,18 +331,11 @@ impl Backend {
                 bkerror2!(r, tx, BKResponse::AttachedFile);
             }
             Ok(BKCommand::NewRoom(server, access_token, name, privacy, internal_id)) => {
-                let r = room::new_room(
-                    self,
-                    server,
-                    access_token,
-                    name,
-                    privacy,
-                    internal_id.clone(),
-                );
-                if let Err(e) = r {
-                    tx.send(BKResponse::NewRoom(Err(e), 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 r =
diff --git a/fractal-matrix-api/src/backend/room.rs b/fractal-matrix-api/src/backend/room.rs
index 2af87ef6..1456e071 100644
--- a/fractal-matrix-api/src/backend/room.rs
+++ b/fractal-matrix-api/src/backend/room.rs
@@ -56,6 +56,12 @@ use crate::r0::redact::redact_event::request as redact_event;
 use crate::r0::redact::redact_event::Body as RedactEventBody;
 use crate::r0::redact::redact_event::Parameters as RedactEventParameters;
 use crate::r0::redact::redact_event::Response as RedactEventResponse;
+use crate::r0::room::create_room::request as create_room;
+use crate::r0::room::create_room::Body as CreateRoomBody;
+use crate::r0::room::create_room::Parameters as CreateRoomParameters;
+use crate::r0::room::create_room::Response as CreateRoomResponse;
+use crate::r0::room::create_room::RoomPreset;
+use crate::r0::room::Visibility;
 use crate::r0::state::create_state_events_for_key::request as create_state_events_for_key;
 use crate::r0::state::create_state_events_for_key::Parameters as CreateStateEventsForKeyParameters;
 use crate::r0::state::get_state_events_for_key::request as get_state_events_for_key;
@@ -598,50 +604,38 @@ fn upload_file(
 }
 
 pub fn new_room(
-    bk: &Backend,
     base: Url,
     access_token: AccessToken,
     name: String,
     privacy: RoomType,
-    internal_id: RoomId,
-) -> Result<(), Error> {
-    let url = bk.url(base, &access_token, "createRoom", vec![])?;
-    let attrs = json!({
-        "invite": [],
-        "invite_3pid": [],
-        "name": &name,
-        "visibility": match privacy {
-            RoomType::Public => "public",
-            RoomType::Private => "private",
-        },
-        "topic": "",
-        "preset": match privacy {
-            RoomType::Public => "public_chat",
-            RoomType::Private => "private_chat",
-        },
-    });
+) -> Result<Room, Error> {
+    let params = CreateRoomParameters { access_token };
 
-    let tx = bk.tx.clone();
-    post!(
-        url,
-        &attrs,
-        move |r: JsonValue| {
-            let room_res = RoomId::try_from(r["room_id"].as_str().unwrap_or_default())
-                .map_err(Into::into)
-                .map(|room_id| Room {
-                    name: Some(name),
-                    ..Room::new(room_id, RoomMembership::Joined(RoomTag::None))
-                });
+    let (visibility, preset) = match privacy {
+        RoomType::Public => (Visibility::Public, RoomPreset::PublicChat),
+        RoomType::Private => (Visibility::Private, RoomPreset::PrivateChat),
+    };
 
-            tx.send(BKResponse::NewRoom(room_res, internal_id))
-                .expect_log("Connection closed");
-        },
-        |err| {
-            tx.send(BKResponse::NewRoom(Err(err), internal_id))
-                .expect_log("Connection closed");
-        }
-    );
-    Ok(())
+    let body = CreateRoomBody {
+        name: Some(name.clone()),
+        visibility: Some(visibility),
+        preset: Some(preset),
+        ..Default::default()
+    };
+
+    create_room(base, &params, &body)
+        .map_err(Into::into)
+        .and_then(|request| {
+            let response = HTTP_CLIENT
+                .get_client()?
+                .execute(request)?
+                .json::<CreateRoomResponse>()?;
+
+            Ok(Room {
+                name: Some(name),
+                ..Room::new(response.room_id, RoomMembership::Joined(RoomTag::None))
+            })
+        })
 }
 
 fn update_direct_chats(url: Url, data: Arc<Mutex<BackendData>>, user_id: UserId, room_id: RoomId) {
diff --git a/fractal-matrix-api/src/r0.rs b/fractal-matrix-api/src/r0.rs
index cea5d6ea..131a5e26 100644
--- a/fractal-matrix-api/src/r0.rs
+++ b/fractal-matrix-api/src/r0.rs
@@ -9,6 +9,7 @@ pub mod message;
 pub mod profile;
 pub mod read_marker;
 pub mod redact;
+pub mod room;
 pub mod search;
 pub mod server;
 pub mod state;
diff --git a/fractal-matrix-api/src/r0/room.rs b/fractal-matrix-api/src/r0/room.rs
new file mode 100644
index 00000000..38eca8c1
--- /dev/null
+++ b/fractal-matrix-api/src/r0/room.rs
@@ -0,0 +1,10 @@
+pub mod create_room;
+
+pub use serde::Serialize;
+
+#[derive(Clone, Copy, Debug, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Visibility {
+    Public,
+    Private,
+}
diff --git a/fractal-matrix-api/src/r0/room/create_room.rs b/fractal-matrix-api/src/r0/room/create_room.rs
new file mode 100644
index 00000000..328691c6
--- /dev/null
+++ b/fractal-matrix-api/src/r0/room/create_room.rs
@@ -0,0 +1,72 @@
+use super::Visibility;
+use crate::r0::{AccessToken, HostAndPort, Medium};
+use reqwest::blocking::Client;
+use reqwest::blocking::Request;
+use reqwest::Error;
+use ruma_identifiers::{RoomId, UserId};
+use serde::{Deserialize, Serialize};
+use serde_json::Value as JsonValue;
+use std::ops::Not;
+use url::Url;
+
+#[derive(Clone, Debug, Serialize)]
+pub struct Parameters {
+    pub access_token: AccessToken,
+}
+
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct Body {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub visibility: Option<Visibility>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub room_alias_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub topic: Option<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub invite: Vec<UserId>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub invite3pid: Vec<InviteThreePID>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub room_version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub creation_content: Option<JsonValue>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub initial_state: Vec<JsonValue>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub preset: Option<RoomPreset>,
+    #[serde(skip_serializing_if = "Not::not")]
+    pub is_direct: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub power_level_content_override: Option<JsonValue>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct InviteThreePID {
+    pub id_server: HostAndPort<String>,
+    pub id_access_token: AccessToken,
+    pub medium: Medium, // TODO: Use enum
+    pub address: String,
+}
+
+#[derive(Clone, Copy, Debug, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum RoomPreset {
+    PrivateChat,
+    PublicChat,
+    TrustedPrivateChat,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct Response {
+    pub room_id: RoomId,
+}
+
+pub fn request(base: Url, params: &Parameters, body: &Body) -> Result<Request, Error> {
+    let url = base
+        .join("/_matrix/client/r0/createRoom")
+        .expect("Malformed URL in create_room");
+
+    Client::new().post(url).query(params).json(body).build()
+}