[fractal] API: Remove rooms_since from BackendData

[Daniel Garcia Moreno <danigm src gnome org>]

commit 89e8fb8a742542a76ee162b0e54ab8d307984896
Author: Alejandro Domínguez <adomu net-c com>
Date:   Sat Jun 6 02:03:00 2020 +0200

    API: Remove rooms_since from BackendData

 fractal-gtk/src/app/backend_loop.rs         |  5 +-
 fractal-gtk/src/app/connect/directory.rs    |  2 +-
 fractal-gtk/src/appop/directory.rs          | 36 +++++++++----
 fractal-gtk/src/appop/mod.rs                |  2 +
 fractal-gtk/src/appop/state.rs              |  2 +-
 fractal-matrix-api/src/backend/directory.rs | 80 +++++++++--------------------
 fractal-matrix-api/src/backend/mod.rs       | 22 --------
 fractal-matrix-api/src/backend/types.rs     |  4 +-
 8 files changed, 57 insertions(+), 96 deletions(-)
---
diff --git a/fractal-gtk/src/app/backend_loop.rs b/fractal-gtk/src/app/backend_loop.rs
index 07a4b95e..e67270bb 100644
--- a/fractal-gtk/src/app/backend_loop.rs
+++ b/fractal-gtk/src/app/backend_loop.rs
@@ -59,9 +59,6 @@ pub fn backend_loop(rx: Receiver<BKResponse>) {
                     let number_tries = 0;
                     APPOP!(sync, (initial, number_tries));
                 }
-                BKResponse::DirectorySearch(Ok(rooms)) => {
-                    APPOP!(append_directory_rooms, (rooms));
-                }
 
                 BKResponse::RemoveMessage(Ok((room, msg))) => {
                     APPOP!(remove_message, (room, msg));
@@ -215,7 +212,7 @@ pub fn backend_loop(rx: Receiver<BKResponse>) {
                     let error = i18n("Error deleting message");
                     APPOP!(show_error, (error));
                 }
-                BKResponse::DirectoryProtocolsError(_) | BKResponse::DirectorySearch(Err(_)) => {
+                BKResponse::DirectoryProtocolsError(_) | BKResponse::DirectorySearchError(_) => {
                     let error = i18n("Error searching for rooms");
                     APPOP!(reset_directory_state);
                     APPOP!(show_error, (error));
diff --git a/fractal-gtk/src/app/connect/directory.rs b/fractal-gtk/src/app/connect/directory.rs
index 628eb780..c1de8f79 100644
--- a/fractal-gtk/src/app/connect/directory.rs
+++ b/fractal-gtk/src/app/connect/directory.rs
@@ -118,7 +118,7 @@ impl App {
 
         op = self.op.clone();
         q.connect_activate(move |_| {
-            op.lock().unwrap().search_rooms(false);
+            op.lock().unwrap().search_rooms(None);
         });
 
         default_matrix_server_radio.connect_toggled(clone!(directory_choice_label, 
default_matrix_server_radio, protocol_combo, other_homeserver_url_entry => move |_| {
diff --git a/fractal-gtk/src/appop/directory.rs b/fractal-gtk/src/appop/directory.rs
index 0eb9bae9..9f15b7a2 100644
--- a/fractal-gtk/src/appop/directory.rs
+++ b/fractal-gtk/src/appop/directory.rs
@@ -47,7 +47,7 @@ impl AppOp {
         }
     }
 
-    pub fn search_rooms(&mut self, more: bool) {
+    pub fn search_rooms(&mut self, rooms_since: Option<String>) {
         let login_data = unwrap_or_unit_return!(self.login_data.clone());
         let other_protocol_radio = self
             .ui
@@ -107,7 +107,7 @@ impl AppOp {
             String::new()
         };
 
-        if !more {
+        if rooms_since.is_none() {
             let directory = self
                 .ui
                 .builder
@@ -134,23 +134,39 @@ impl AppOp {
             q.set_sensitive(false);
         }
 
-        self.backend
-            .send(BKCommand::DirectorySearch(
+        let search_term = q.get_text().unwrap().to_string();
+        let tx = self.backend.clone();
+        thread::spawn(move || {
+            let query = directory::room_search(
                 login_data.server_url,
                 login_data.access_token,
                 homeserver,
-                q.get_text().unwrap().to_string(),
+                search_term,
                 protocol,
-                more,
-            ))
-            .unwrap();
+                rooms_since,
+            );
+
+            match query {
+                Ok((rooms, rooms_since)) => {
+                    APPOP!(append_directory_rooms, (rooms, rooms_since));
+                }
+                Err(err) => {
+                    tx.send(BKCommand::SendBKResponse(BKResponse::DirectorySearchError(
+                        err,
+                    )))
+                    .expect_log("Connection closed");
+                }
+            }
+        });
     }
 
     pub fn load_more_rooms(&mut self) {
-        self.search_rooms(true);
+        self.search_rooms(self.rooms_since.clone());
     }
 
-    pub fn append_directory_rooms(&mut self, rooms: Vec<Room>) {
+    pub fn append_directory_rooms(&mut self, rooms: Vec<Room>, rooms_since: Option<String>) {
+        self.rooms_since = rooms_since;
+
         let directory = self
             .ui
             .builder
diff --git a/fractal-gtk/src/appop/mod.rs b/fractal-gtk/src/appop/mod.rs
index 3d48cecf..43df8893 100644
--- a/fractal-gtk/src/appop/mod.rs
+++ b/fractal-gtk/src/appop/mod.rs
@@ -82,6 +82,7 @@ pub struct AppOp {
 
     pub media_viewer: Rc<RefCell<Option<widgets::MediaViewer>>>,
 
+    pub rooms_since: Option<String>, // This is for directory searches
     pub state: AppState,
     pub since: Option<String>,
     pub room_back_history: Rc<RefCell<Vec<AppState>>>,
@@ -120,6 +121,7 @@ impl AppOp {
             state: AppState::Login,
             room_back_history: Rc::new(RefCell::new(vec![])),
             roomlist: widgets::RoomList::new(None, None),
+            rooms_since: None,
             unread_rooms: 0,
             since: None,
             unsent_messages: HashMap::new(),
diff --git a/fractal-gtk/src/appop/state.rs b/fractal-gtk/src/appop/state.rs
index b08fb9b6..7853c18c 100644
--- a/fractal-gtk/src/appop/state.rs
+++ b/fractal-gtk/src/appop/state.rs
@@ -78,7 +78,7 @@ impl AppOp {
         }
 
         if let AppState::Directory = self.state {
-            self.search_rooms(false);
+            self.search_rooms(None);
         }
     }
 
diff --git a/fractal-matrix-api/src/backend/directory.rs b/fractal-matrix-api/src/backend/directory.rs
index b8ad698a..9c5686af 100644
--- a/fractal-matrix-api/src/backend/directory.rs
+++ b/fractal-matrix-api/src/backend/directory.rs
@@ -2,15 +2,11 @@ use url::{Host, Url};
 
 use crate::globals;
 
-use crate::backend::types::BKResponse;
-use crate::backend::types::Backend;
 use crate::error::Error;
-use std::thread;
 
 use crate::util::cache_dir_path;
 use crate::util::dw_media;
 use crate::util::ContentType;
-use crate::util::ResultExpectLog;
 use crate::util::HTTP_CLIENT;
 
 use crate::r0::directory::post_public_rooms::request as post_public_rooms;
@@ -39,18 +35,17 @@ pub fn protocols(base: Url, access_token: AccessToken) -> Result<Vec<ProtocolIns
 }
 
 pub fn room_search(
-    bk: &Backend,
     base: Url,
     access_token: AccessToken,
-    homeserver: Option<String>, // TODO: Use HostAndPort?
-    generic_search_term: Option<String>,
-    third_party: Option<String>,
-    more: bool,
-) -> Result<(), Error> {
-    let tx = bk.tx.clone();
-    let data = bk.data.clone();
+    homeserver: String, // TODO: Option<Use HostAndPort>?
+    generic_search_term: String,
+    third_party: String,
+    rooms_since: Option<String>,
+) -> Result<(Vec<Room>, Option<String>), Error> {
+    let homeserver = Some(homeserver).filter(|hs| !hs.is_empty());
+    let generic_search_term = Some(generic_search_term).filter(|q| !q.is_empty());
+    let third_party = Some(third_party).filter(|tp| !tp.is_empty());
 
-    // TODO: use transpose() when it is stabilized
     let server = homeserver
         .map(|hs| {
             Url::parse(&hs)
@@ -65,12 +60,6 @@ pub fn room_search(
         })
         .unwrap_or(Ok(None))?;
 
-    let since = if more {
-        Some(data.lock().unwrap().rooms_since.clone())
-    } else {
-        None
-    };
-
     let params = PublicRoomsParameters {
         access_token,
         server,
@@ -81,47 +70,28 @@ pub fn room_search(
         filter: Some(PublicRoomsFilter {
             generic_search_term,
         }),
-        since,
+        since: rooms_since,
         third_party_networks: third_party
             .map(ThirdPartyNetworks::Only)
             .unwrap_or_default(),
     };
 
-    thread::spawn(move || {
-        let query = post_public_rooms(base.clone(), &params, &body)
-            .map_err(Into::into)
-            .and_then(|request| {
-                HTTP_CLIENT
-                    .get_client()?
-                    .execute(request)?
-                    .json::<PublicRoomsResponse>()
-                    .map_err(Into::into)
-            })
-            .map(|response| {
-                data.lock().unwrap().rooms_since = response.next_batch.unwrap_or_default();
-
-                response
-                    .chunk
-                    .into_iter()
-                    .map(Into::into)
-                    .inspect(|r: &Room| {
-                        if let Some(avatar) = r.avatar.clone() {
-                            if let Ok(dest) = cache_dir_path(None, &r.id.to_string()) {
-                                let _ = dw_media(
-                                    base.clone(),
-                                    &avatar,
-                                    ContentType::Download,
-                                    Some(dest),
-                                );
-                            }
-                        }
-                    })
-                    .collect()
-            });
+    let request = post_public_rooms(base.clone(), &params, &body)?;
+    let response: PublicRoomsResponse = HTTP_CLIENT.get_client()?.execute(request)?.json()?;
 
-        tx.send(BKResponse::DirectorySearch(query))
-            .expect_log("Connection closed");
-    });
+    let since = response.next_batch;
+    let rooms = response
+        .chunk
+        .into_iter()
+        .map(Into::into)
+        .inspect(|r: &Room| {
+            if let Some(avatar) = r.avatar.clone() {
+                if let Ok(dest) = cache_dir_path(None, &r.id.to_string()) {
+                    let _ = dw_media(base.clone(), &avatar, ContentType::Download, Some(dest));
+                }
+            }
+        })
+        .collect();
 
-    Ok(())
+    Ok((rooms, since))
 }
diff --git a/fractal-matrix-api/src/backend/mod.rs b/fractal-matrix-api/src/backend/mod.rs
index a3c84aa7..07b9515c 100644
--- a/fractal-matrix-api/src/backend/mod.rs
+++ b/fractal-matrix-api/src/backend/mod.rs
@@ -28,7 +28,6 @@ pub use self::types::RoomType;
 impl Backend {
     pub fn new(tx: Sender<BKResponse>) -> Backend {
         let data = BackendData {
-            rooms_since: String::new(),
             m_direct: HashMap::new(),
         };
         Backend {
@@ -129,27 +128,6 @@ impl Backend {
                 ctx,
             ),
 
-            // Directory module
-            Ok(BKCommand::DirectorySearch(server, access_token, dhs, dq, dtp, more)) => {
-                let hs = match dhs {
-                    ref a if a.is_empty() => None,
-                    b => Some(b),
-                };
-
-                let q = match dq {
-                    ref a if a.is_empty() => None,
-                    b => Some(b),
-                };
-
-                let tp = match dtp {
-                    ref a if a.is_empty() => None,
-                    b => Some(b),
-                };
-
-                let r = directory::room_search(self, server, access_token, hs, q, tp, more);
-                bkerror!(r, tx, BKResponse::DirectorySearch);
-            }
-
             // Internal commands
             Ok(BKCommand::SendBKResponse(response)) => {
                 tx.send(response).expect_log("Connection closed");
diff --git a/fractal-matrix-api/src/backend/types.rs b/fractal-matrix-api/src/backend/types.rs
index 3f3993f6..fea331c6 100644
--- a/fractal-matrix-api/src/backend/types.rs
+++ b/fractal-matrix-api/src/backend/types.rs
@@ -43,7 +43,6 @@ pub enum BKCommand {
     GetUserInfoAsync(Url, UserId, Option<Sender<(String, String)>>),
     SetRoom(Url, AccessToken, RoomId),
     ShutDown,
-    DirectorySearch(Url, AccessToken, String, String, String, bool),
     AttachFile(Url, AccessToken, Message),
     DirectChat(Url, AccessToken, UserId, Member, RoomId),
     SendBKResponse(BKResponse),
@@ -63,7 +62,6 @@ pub enum BKResponse {
     RoomMessages(Result<Vec<Message>, Error>),
     RoomMessagesInit(Vec<Message>),
     SentMsg(Result<(String, Option<EventId>), Error>),
-    DirectorySearch(Result<Vec<Room>, Error>),
     RemoveMessage(Result<(RoomId, EventId), Error>),
     RoomName(RoomId, String),
     RoomTopic(RoomId, String),
@@ -105,6 +103,7 @@ pub enum BKResponse {
     MediaError(Error),
     SentMsgRedactionError(Error),
     JoinRoomError(Error),
+    DirectorySearchError(Error),
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -156,7 +155,6 @@ impl ThreadPool {
 }
 
 pub struct BackendData {
-    pub rooms_since: String,
     pub m_direct: HashMap<UserId, Vec<RoomId>>,
 }