[fractal] Get room detail through matrix-sdk

[Alexandre Franke <afranke src gnome org>]

commit ba03bac442ba3917771b2b2bedce293ab49dfb6e
Author: Alejandro Domínguez <adomu net-c com>
Date:   Mon Sep 7 04:09:29 2020 +0200

    Get room detail through matrix-sdk

 fractal-gtk/src/appop/room.rs   | 30 ++++++++++-----------
 fractal-gtk/src/backend/room.rs | 58 +++++++++++++++++++++++++++++------------
 2 files changed, 56 insertions(+), 32 deletions(-)
---
diff --git a/fractal-gtk/src/appop/room.rs b/fractal-gtk/src/appop/room.rs
index b05adda9..a0034eb2 100644
--- a/fractal-gtk/src/appop/room.rs
+++ b/fractal-gtk/src/appop/room.rs
@@ -1,5 +1,6 @@
 use crate::backend::room;
 use crate::util::i18n::{i18n, i18n_k, ni18n_f};
+use fractal_api::events::EventType;
 use fractal_api::identifiers::RoomId;
 use fractal_api::url::Url;
 use log::{error, warn};
@@ -259,11 +260,10 @@ impl AppOp {
             },
         );
 
-        let server_url = login_data.session_client.homeserver().clone();
-        let access_token = login_data.access_token.clone();
+        let session_client = login_data.session_client.clone();
         let a_room = active_room.clone();
-        thread::spawn(move || {
-            match room::get_room_detail(server_url, access_token, a_room, "m.room.topic".into()) {
+        RUNTIME.spawn(async move {
+            match room::get_room_detail(session_client, a_room, EventType::RoomTopic).await {
                 Ok((room, key, value)) => {
                     let v = Some(value);
                     APPOP!(set_room_detail, (room, key, v));
@@ -287,8 +287,8 @@ impl AppOp {
                 }
             }
 
-            self.set_current_room_detail(String::from("m.room.name"), room.name.clone());
-            self.set_current_room_detail(String::from("m.room.topic"), room.topic.clone());
+            self.set_current_room_detail(EventType::RoomName, room.name.clone());
+            self.set_current_room_detail(EventType::RoomTopic, room.topic.clone());
         }
 
         self.append_tmp_msgs();
@@ -422,14 +422,13 @@ impl AppOp {
         };
     }
 
-    pub fn set_room_detail(&mut self, room_id: RoomId, key: String, value: Option<String>) {
+    pub fn set_room_detail(&mut self, room_id: RoomId, key: EventType, value: Option<String>) {
         if let Some(r) = self.rooms.get_mut(&room_id) {
-            let k: &str = &key;
-            match k {
-                "m.room.name" => {
+            match key {
+                EventType::RoomName => {
                     r.name = value.clone();
                 }
-                "m.room.topic" => {
+                EventType::RoomTopic => {
                     r.topic = value.clone();
                 }
                 _ => {}
@@ -472,11 +471,10 @@ impl AppOp {
         }
     }
 
-    pub fn set_current_room_detail(&self, key: String, value: Option<String>) {
+    pub fn set_current_room_detail(&self, key: EventType, value: Option<String>) {
         let value = value.unwrap_or_default();
-        let k: &str = &key;
-        match k {
-            "m.room.name" => {
+        match key {
+            EventType::RoomName => {
                 let name_label = self
                     .ui
                     .builder
@@ -485,7 +483,7 @@ impl AppOp {
 
                 name_label.set_text(&value);
             }
-            "m.room.topic" => {
+            EventType::RoomTopic => {
                 self.set_room_topic_label(Some(value));
             }
             _ => warn!("no key {}", key),
diff --git a/fractal-gtk/src/backend/room.rs b/fractal-gtk/src/backend/room.rs
index 37ba7494..ff0ae865 100644
--- a/fractal-gtk/src/backend/room.rs
+++ b/fractal-gtk/src/backend/room.rs
@@ -2,6 +2,7 @@ use log::error;
 use serde_json::json;
 
 use fractal_api::{
+    api::{error::ErrorKind as RumaErrorKind, Error as RumaClientError},
     identifiers::{Error as IdError, EventId, RoomId, RoomIdOrAliasId, UserId},
     reqwest::Error as ReqwestError,
     url::{ParseError as UrlError, Url},
@@ -38,6 +39,7 @@ use fractal_api::api::r0::redact::redact_event::Request as RedactEventRequest;
 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;
+use fractal_api::api::r0::state::get_state_events_for_key::Request as GetStateEventForKeyRequest;
 use fractal_api::api::r0::state::send_state_event_for_key::Request as SendStateEventForKeyRequest;
 use fractal_api::api::r0::tag::create_tag::Request as CreateTagRequest;
 use fractal_api::api::r0::tag::delete_tag::Request as DeleteTagRequest;
@@ -85,32 +87,56 @@ use crate::APPOP;
 #[derive(Debug)]
 pub enum RoomDetailError {
     MalformedKey,
-    Reqwest(ReqwestError),
+    Matrix(MatrixError),
 }
 
-impl From<ReqwestError> for RoomDetailError {
-    fn from(err: ReqwestError) -> Self {
-        Self::Reqwest(err)
+impl From<MatrixError> for RoomDetailError {
+    fn from(err: MatrixError) -> Self {
+        Self::Matrix(err)
+    }
+}
+
+impl From<ParseJsonError> for RoomDetailError {
+    fn from(err: ParseJsonError) -> Self {
+        Self::Matrix(err.into())
     }
 }
 
 impl HandleError for RoomDetailError {}
 
-pub fn get_room_detail(
-    base: Url,
-    access_token: AccessToken,
+pub async fn get_room_detail(
+    session_client: MatrixClient,
     room_id: RoomId,
-    key: String,
-) -> Result<(RoomId, String, String), RoomDetailError> {
-    let k = key.split('.').last().ok_or(RoomDetailError::MalformedKey)?;
-    let params = GetStateEventsForKeyParameters { access_token };
-
-    let request = get_state_events_for_key(base, &params, &room_id, &key)?;
-    let response: JsonValue = HTTP_CLIENT.get_client().execute(request)?.json()?;
+    event_type: EventType,
+) -> Result<(RoomId, EventType, String), RoomDetailError> {
+    let key = event_type
+        .as_ref()
+        .split('.')
+        .last()
+        .ok_or(RoomDetailError::MalformedKey)?;
+
+    let request = GetStateEventForKeyRequest::new(&room_id, event_type.clone(), "");
+
+    let response = match session_client.send(request).await {
+        Ok(response) => Some(response),
+        Err(MatrixError::RumaResponse(RumaResponseError::Http(ServerError::Known(
+            RumaClientError {
+                kind: RumaErrorKind::NotFound,
+                ..
+            },
+        )))) => None,
+        Err(err) => return Err(err.into()),
+    };
 
-    let value = response[&k].as_str().map(Into::into).unwrap_or_default();
+    let value = if let Some(res) = response {
+        serde_json::to_value(&res.content)?[&key]
+            .as_str()
+            .map(Into::into)
+    } else {
+        None
+    };
 
-    Ok((room_id, key, value))
+    Ok((room_id, event_type, value.unwrap_or_default()))
 }
 
 #[derive(Debug)]