More imap async fixes

1 files changed, 120 insertions, 84 deletions

diff --git a/src/components/mail/listing/conversations.rs b/src/components/mail/listing/conversations.rs
index f7dc2146..6c9fee75 100644
--- a/src/components/mail/listing/conversations.rs
+++ b/src/components/mail/listing/conversations.rs
@@ -21,6 +21,7 @@
 
 use super::*;
 use crate::components::utilities::PageMovement;
+use crate::jobs::{oneshot, JobId};
 use std::iter::FromIterator;
 
 /// A list of all mail (`Envelope`s) in a `Mailbox`. On `\n` it opens the `Envelope` content in a
@@ -38,6 +39,11 @@ pub struct ConversationsListing {
     /// Cache current view.
     content: CellBuffer,
 
+    search_job: Option<(
+        String,
+        oneshot::Receiver<Result<SmallVec<[EnvelopeHash; 512]>>>,
+        JobId,
+    )>,
     filter_term: String,
     filtered_selection: Vec<ThreadHash>,
     filtered_order: HashMap<ThreadHash, usize>,
@@ -693,82 +699,53 @@ impl ListingTrait for ConversationsListing {
         results: Result<SmallVec<[EnvelopeHash; 512]>>,
         context: &Context,
     ) {
-        /*
-            if filter_term.is_empty() {
-                return;
-            }
+        if filter_term.is_empty() {
+            return;
+        }
 
-            self.order.clear();
-            self.selection.clear();
-            self.length = 0;
-            self.filtered_selection.clear();
-            self.filtered_order.clear();
-            self.filter_term = filter_term.to_string();
-            self.row_updates.clear();
-            for v in self.selection.values_mut() {
-                *v = false;
-            }
+        self.order.clear();
+        self.selection.clear();
+        self.length = 0;
+        self.filtered_selection.clear();
+        self.filtered_order.clear();
+        self.filter_term = filter_term.to_string();
+        self.row_updates.clear();
+        for v in self.selection.values_mut() {
+            *v = false;
+        }
 
-            let account = &context.accounts[self.cursor_pos.0];
-            match account.search(&self.filter_term, self.sort, self.cursor_pos.1) {
-                Ok(results) => {
-                    /*
-                    let threads = &account.collection.threads[&self.cursor_pos.1];
-                    for env_hash in results {
-                        if !account.collection.contains_key(&env_hash) {
-                            continue;
-                        }
-                        let env_thread_node_hash = account.collection.get_env(env_hash).thread();
-                        if !threads.thread_nodes.contains_key(&env_thread_node_hash) {
-                            continue;
-                        }
-                        let thread =
-                            threads.find_group(threads.thread_nodes[&env_thread_node_hash].group);
-                        if self.filtered_order.contains_key(&thread) {
-                            continue;
-                        }
-                        if self.all_threads.contains(&thread) {
-                            self.filtered_selection.push(thread);
-                            self.filtered_order
-                                .insert(thread, self.filtered_selection.len() - 1);
-                        }
+        let account = &context.accounts[self.cursor_pos.0];
+        match results {
+            Ok(results) => {
+                let threads = &account.collection.threads[&self.cursor_pos.1];
+                for env_hash in results {
+                    if !account.collection.contains_key(&env_hash) {
+                        continue;
                     }
-                    if !self.filtered_selection.is_empty() {
-                        threads.group_inner_sort_by(
-                            &mut self.filtered_selection,
-                            self.sort,
-                            &context.accounts[self.cursor_pos.0].collection.envelopes,
-                        );
-                        self.new_cursor_pos.2 =
-                            std::cmp::min(self.filtered_selection.len() - 1, self.cursor_pos.2);
-                    } else {
-                        let default_cell = {
-                            let mut ret = Cell::with_char(' ');
-                            ret.set_fg(self.color_cache.theme_default.fg)
-                                .set_bg(self.color_cache.theme_default.bg)
-                                .set_attrs(self.color_cache.theme_default.attrs);
-                            ret
-                        };
-                        self.content = CellBuffer::new_with_context(0, 0, default_cell, context);
+                    let env_thread_node_hash = account.collection.get_env(env_hash).thread();
+                    if !threads.thread_nodes.contains_key(&env_thread_node_hash) {
+                        continue;
+                    }
+                    let thread =
+                        threads.find_group(threads.thread_nodes[&env_thread_node_hash].group);
+                    if self.filtered_order.contains_key(&thread) {
+                        continue;
+                    }
+                    if self.all_threads.contains(&thread) {
+                        self.filtered_selection.push(thread);
+                        self.filtered_order
+                            .insert(thread, self.filtered_selection.len() - 1);
                     }
-                    self.redraw_threads_list(
-                        context,
-                        Box::new(self.filtered_selection.clone().into_iter())
-                            as Box<dyn Iterator<Item = ThreadHash>>,
-                    );
-                    */
                 }
-                Err(e) => {
-                    self.cursor_pos.2 = 0;
-                    self.new_cursor_pos.2 = 0;
-                    let message = format!(
-                        "Encountered an error while searching for `{}`: {}.",
-                        self.filter_term, e
-                    );
-                    log(
-                        format!("Failed to search for term {}: {}", self.filter_term, e),
-                        ERROR,
+                if !self.filtered_selection.is_empty() {
+                    threads.group_inner_sort_by(
+                        &mut self.filtered_selection,
+                        self.sort,
+                        &context.accounts[self.cursor_pos.0].collection.envelopes,
                     );
+                    self.new_cursor_pos.2 =
+                        std::cmp::min(self.filtered_selection.len() - 1, self.cursor_pos.2);
+                } else {
                     let default_cell = {
                         let mut ret = Cell::with_char(' ');
                         ret.set_fg(self.color_cache.theme_default.fg)
@@ -776,20 +753,45 @@ impl ListingTrait for ConversationsListing {
                             .set_attrs(self.color_cache.theme_default.attrs);
                         ret
                     };
-                    self.content =
-                        CellBuffer::new_with_context(message.len(), 1, default_cell, context);
-                    write_string_to_grid(
-                        &message,
-                        &mut self.content,
-                        self.color_cache.theme_default.fg,
-                        self.color_cache.theme_default.bg,
-                        self.color_cache.theme_default.attrs,
-                        ((0, 0), (message.len() - 1, 0)),
-                        None,
-                    );
+                    self.content = CellBuffer::new_with_context(0, 0, default_cell, context);
                 }
+                self.redraw_threads_list(
+                    context,
+                    Box::new(self.filtered_selection.clone().into_iter())
+                        as Box<dyn Iterator<Item = ThreadHash>>,
+                );
+            }
+            Err(e) => {
+                self.cursor_pos.2 = 0;
+                self.new_cursor_pos.2 = 0;
+                let message = format!(
+                    "Encountered an error while searching for `{}`: {}.",
+                    self.filter_term, e
+                );
+                log(
+                    format!("Failed to search for term {}: {}", self.filter_term, e),
+                    ERROR,
+                );
+                let default_cell = {
+                    let mut ret = Cell::with_char(' ');
+                    ret.set_fg(self.color_cache.theme_default.fg)
+                        .set_bg(self.color_cache.theme_default.bg)
+                        .set_attrs(self.color_cache.theme_default.attrs);
+                    ret
+                };
+                self.content =
+                    CellBuffer::new_with_context(message.len(), 1, default_cell, context);
+                write_string_to_grid(
+                    &message,
+                    &mut self.content,
+                    self.color_cache.theme_default.fg,
+                    self.color_cache.theme_default.bg,
+                    self.color_cache.theme_default.attrs,
+                    ((0, 0), (message.len() - 1, 0)),
+                    None,
+                );
             }
-        */
+        }
     }
 
     fn set_movement(&mut self, mvm: PageMovement) {
@@ -815,6 +817,7 @@ impl ConversationsListing {
             subsort: (SortField::Date, SortOrder::Desc),
             order: HashMap::default(),
             all_threads: HashSet::default(),
+            search_job: None,
             filter_term: String::new(),
             filtered_selection: Vec::new(),
             filtered_order: HashMap::default(),
@@ -1345,8 +1348,29 @@ impl Component for ConversationsListing {
             }
             UIEvent::Action(ref action) => match action {
                 Action::Listing(Search(ref filter_term)) if !self.unfocused => {
-                    //self.filter(filter_term, context);
-                    self.dirty = true;
+                    match context.accounts[self.cursor_pos.0].search(
+                        filter_term,
+                        self.sort,
+                        self.cursor_pos.1,
+                    ) {
+                        Ok(job) => {
+                            let (chan, job_id) = context.accounts[self.cursor_pos.0]
+                                .job_executor
+                                .spawn_specialized(job);
+                            context.accounts[self.cursor_pos.0]
+                                .active_jobs
+                                .insert(job_id.clone(), crate::conf::accounts::JobRequest::Search);
+                            self.search_job = Some((filter_term.to_string(), chan, job_id));
+                        }
+                        Err(err) => {
+                            context.replies.push_back(UIEvent::Notification(
+                                Some("Could not perform search".to_string()),
+                                err.to_string(),
+                                Some(crate::types::NotificationType::ERROR),
+                            ));
+                        }
+                    };
+                    self.set_dirty(true);
                     return true;
                 }
                 _ => {}
@@ -1370,6 +1394,18 @@ impl Component for ConversationsListing {
                 self.set_dirty(true);
                 return true;
             }
+            UIEvent::StatusEvent(StatusEvent::JobFinished(ref job_id))
+                if self
+                    .search_job
+                    .as_ref()
+                    .map(|(_, _, j)| j == job_id)
+                    .unwrap_or(false) =>
+            {
+                let (filter_term, mut rcvr, _job_id) = self.search_job.take().unwrap();
+                let results = rcvr.try_recv().unwrap().unwrap();
+                self.filter(filter_term, results, context);
+                self.set_dirty(true);
+            }
             _ => {}
         }