Move self-reporting logic into new file self_reporting.rs

Author: Hocuri

src/context.rs

@@ -26,7 +26,7 @@ use crate::debug_logging::DebugLogging;
 use crate::download::DownloadState;
 use crate::events::{Event, EventEmitter, EventType, Events};
 use crate::imap::{FolderMeaning, Imap, ServerMetadata};
-use crate::key::{load_self_public_key, load_self_secret_key, DcKey as _};
+use crate::key::{load_self_public_key, load_self_secret_key, self_fingerprint, DcKey as _};
 use crate::log::LogExt;
 use crate::log::{info, warn};
 use crate::login_param::{ConfiguredLoginParam, EnteredLoginParam};
@@ -1062,197 +1062,6 @@ impl Context {
         Ok(res)
     }
 
-    async fn get_self_report(&self) -> Result<String> {
-        #[derive(Serialize)]
-        struct Statistics {
-            core_version: String,
-            num_msgs: u32,
-            num_chats: u32,
-            db_size: u64,
-            key_created: i64,
-            chat_numbers: ChatNumbers,
-            self_reporting_id: String,
-        }
-        #[derive(Default, Serialize)]
-        struct ChatNumbers {
-            protected: u32,
-            protection_broken: u32,
-            opportunistic_dc: u32,
-            opportunistic_mua: u32,
-            unencrypted_dc: u32,
-            unencrypted_mua: u32,
-        }
-
-        let num_msgs: u32 = self
-            .sql
-            .query_get_value(
-                "SELECT COUNT(*) FROM msgs WHERE hidden=0 AND chat_id!=?",
-                (DC_CHAT_ID_TRASH,),
-            )
-            .await?
-            .unwrap_or_default();
-
-        let num_chats: u32 = self
-            .sql
-            .query_get_value("SELECT COUNT(*) FROM chats WHERE id>9 AND blocked!=1", ())
-            .await?
-            .unwrap_or_default();
-
-        let db_size = tokio::fs::metadata(&self.sql.dbfile).await?.len();
-
-        let key_created = load_self_secret_key(self)
-            .await?
-            .primary_key
-            .created_at()
-            .timestamp();
-
-        // how many of the chats active in the last months are:
-        // - protected
-        // - protection-broken
-        // - opportunistic-encrypted and the contact uses Delta Chat
-        // - opportunistic-encrypted and the contact uses a classical MUA
-        // - unencrypted and the contact uses Delta Chat
-        // - unencrypted and the contact uses a classical MUA
-        let three_months_ago = time().saturating_sub(3600 * 24 * 30 * 3);
-        let chat_numbers = self
-            .sql
-            .query_map(
-                "SELECT c.protected, m.param, m.msgrmsg
-                    FROM chats c
-                    JOIN msgs m
-                        ON c.id=m.chat_id
-                        AND m.id=(
-                                SELECT id
-                                FROM msgs
-                                WHERE chat_id=c.id
-                                AND hidden=0
-                                AND download_state=?
-                                AND to_id!=?
-                                ORDER BY timestamp DESC, id DESC LIMIT 1)
-                    WHERE c.id>9
-                    AND (c.blocked=0 OR c.blocked=2)
-                    AND IFNULL(m.timestamp,c.created_timestamp) > ?
-                    GROUP BY c.id",
-                (DownloadState::Done, ContactId::INFO, three_months_ago),
-                |row| {
-                    let protected: ProtectionStatus = row.get(0)?;
-                    let message_param: Params =
-                        row.get::<_, String>(1)?.parse().unwrap_or_default();
-                    let is_dc_message: bool = row.get(2)?;
-                    Ok((protected, message_param, is_dc_message))
-                },
-                |rows| {
-                    let mut chats = ChatNumbers::default();
-                    for row in rows {
-                        let (protected, message_param, is_dc_message) = row?;
-                        let encrypted = message_param
-                            .get_bool(Param::GuaranteeE2ee)
-                            .unwrap_or(false);
-
-                        if protected == ProtectionStatus::Protected {
-                            chats.protected += 1;
-                        } else if protected == ProtectionStatus::ProtectionBroken {
-                            chats.protection_broken += 1;
-                        } else if encrypted {
-                            if is_dc_message {
-                                chats.opportunistic_dc += 1;
-                            } else {
-                                chats.opportunistic_mua += 1;
-                            }
-                        } else if is_dc_message {
-                            chats.unencrypted_dc += 1;
-                        } else {
-                            chats.unencrypted_mua += 1;
-                        }
-                    }
-                    Ok(chats)
-                },
-            )
-            .await?;
-
-        let self_reporting_id = match self.get_config(Config::SelfReportingId).await? {
-            Some(id) => id,
-            None => {
-                let id = create_id();
-                self.set_config_internal(Config::SelfReportingId, Some(&id))
-                    .await?;
-                id
-            }
-        };
-        let statistics = Statistics {
-            core_version: get_version_str().to_string(),
-            num_msgs,
-            num_chats,
-            db_size,
-            key_created,
-            chat_numbers,
-            self_reporting_id,
-        };
-
-        Ok(serde_json::to_string_pretty(&statistics)?)
-    }
-
-    /// Drafts a message with statistics about the usage of Delta Chat.
-    /// The user can inspect the message if they want, and then hit "Send".
-    ///
-    /// On the other end, a bot will receive the message and make it available
-    /// to Delta Chat's developers.
-    pub async fn send_self_report(&self) -> Result<ChatId> {
-        info!(self, "Sending self report.");
-        // Setting `Config::LastHousekeeping` at the beginning avoids endless loops when things do not
-        // work out for whatever reason or are interrupted by the OS.
-        self.set_config_internal(Config::LastSelfReportSent, Some(&time().to_string()))
-            .await
-            .log_err(self)
-            .ok();
-
-        const SELF_REPORTING_BOT_VCARD: &str = include_str!("../assets/self-reporting-bot.vcf");
-        let contact_id: ContactId = *import_vcard(self, SELF_REPORTING_BOT_VCARD)
-            .await?
-            .first()
-            .context("Self reporting bot vCard does not contain a contact")?;
-        mark_contact_id_as_verified(self, contact_id, ContactId::SELF).await?;
-
-        let chat_id = if let Some(res) = ChatId::lookup_by_contact(self, contact_id).await? {
-            // Already exists, no need to create.
-            res
-        } else {
-            let chat_id = ChatId::get_for_contact(self, contact_id).await?;
-            chat_id
-                .set_visibility(self, ChatVisibility::Archived)
-                .await?;
-            chat::set_muted(self, chat_id, MuteDuration::Forever).await?;
-            chat_id
-        };
-
-        chat_id
-            .set_protection(self, ProtectionStatus::Protected, time(), Some(contact_id))
-            .await?;
-
-        let mut msg = Message::new(Viewtype::File);
-        msg.set_text(
-            "The attachment contains anonymous usage statistics, \
-because you enabled this in the settings. \
-This helps us improve the security of Delta Chat. \
-See TODO[blog post] for more information."
-                .to_string(),
-        );
-        msg.set_file_from_bytes(
-            self,
-            "statistics.txt",
-            self.get_self_report().await?.as_bytes(),
-            Some("text/plain"),
-        )?;
-
-        crate::chat::send_msg(self, chat_id, &mut msg)
-            .await
-            .context("Failed to send self_reporting message")
-            .log_err(self)
-            .ok();
-
-        Ok(chat_id)
-    }
-
     /// Get a list of fresh, unmuted messages in unblocked chats.
     ///
     /// The list starts with the most recent message

src/context/context_tests.rs

@@ -598,23 +598,6 @@ async fn test_get_next_msgs() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_draft_self_report() -> Result<()> {
-    let alice = TestContext::new_alice().await;
-
-    let chat_id = alice.send_self_report().await?;
-    let msg = get_chat_msg(&alice, chat_id, 0, 2).await;
-    assert_eq!(msg.get_info_type(), SystemMessage::ChatProtectionEnabled);
-
-    let chat = Chat::load_from_db(&alice, chat_id).await?;
-    assert!(chat.is_protected());
-
-    let statistics_msg = get_chat_msg(&alice, chat_id, 1, 2).await;
-    assert_eq!(statistics_msg.get_filename().unwrap(), "statistics.txt");
-
-    Ok(())
-}
-
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_cache_is_cleared_when_io_is_started() -> Result<()> {
     let alice = TestContext::new_alice().await;

src/lib.rs

@@ -98,6 +98,7 @@ pub mod html;
 pub mod net;
 pub mod plaintext;
 mod push;
+mod self_reporting;
 pub mod summary;
 
 mod debug_logging;

src/scheduler.rs

@@ -24,6 +24,7 @@ use crate::imap::{FolderMeaning, Imap, session::Session};
 use crate::location;
 use crate::log::{LogExt, error, info, warn};
 use crate::message::MsgId;
+use crate::self_reporting::maybe_send_self_report;
 use crate::smtp::{Smtp, send_smtp_messages};
 use crate::sql;
 use crate::tools::{self, duration_to_str, maybe_add_time_based_warnings, time, time_elapsed};
@@ -507,20 +508,7 @@ async fn inbox_fetch_idle(ctx: &Context, imap: &mut Imap, mut session: Session)
         }
     };
 
-    //#[cfg(target_os = "android")] TODO
-    if ctx.get_config_bool(Config::SelfReporting).await? {
-        match ctx.get_config_i64(Config::LastSelfReportSent).await {
-            Ok(last_selfreport_time) => {
-                let next_selfreport_time = last_selfreport_time.saturating_add(30); // TODO increase to 1 day or 1 week
-                if next_selfreport_time <= time() {
-                    ctx.send_self_report().await?;
-                }
-            }
-            Err(err) => {
-                warn!(ctx, "Failed to get last self_reporting time: {}", err);
-            }
-        }
-    }
+    maybe_send_self_report(ctx).await?;
     match ctx.get_config_bool(Config::FetchedExistingMsgs).await {
         Ok(fetched_existing_msgs) => {
             if !fetched_existing_msgs {