Add SecurejoinSourceStats, not tested yet

Author: Hocuri

deltachat-jsonrpc/src/api.rs

@@ -867,9 +867,9 @@ impl CommandApi {
     /// **returns**: The chat ID of the joined chat, the UI may redirect to the this chat.
     ///         A returned chat ID does not guarantee that the chat is protected or the belonging contact is verified.
     ///
-    async fn secure_join(&self, account_id: u32, qr: String) -> Result<u32> {
+    async fn secure_join(&self, account_id: u32, qr: String, source: Option<u32>) -> Result<u32> {
         let ctx = self.get_context(account_id).await?;
-        let chat_id = securejoin::join_securejoin(&ctx, &qr).await?;
+        let chat_id = securejoin::join_securejoin_with_source(&ctx, &qr, source).await?;
         Ok(chat_id.to_u32())
     }
 

src/securejoin.rs

@@ -5,7 +5,6 @@ use deltachat_contact_tools::ContactAddress;
 use percent_encoding::{NON_ALPHANUMERIC, utf8_percent_encode};
 
 use crate::chat::{self, Chat, ChatId, ChatIdBlocked, ProtectionStatus, get_chat_id_by_grpid};
-use crate::chatlist_events;
 use crate::config::Config;
 use crate::constants::{Blocked, Chattype, NON_ALPHANUMERIC_WITHOUT_DOT};
 use crate::contact::mark_contact_id_as_verified;
@@ -15,6 +14,7 @@ use crate::e2ee::ensure_secret_key_exists;
 use crate::events::EventType;
 use crate::headerdef::HeaderDef;
 use crate::key::{DcKey, Fingerprint, load_self_public_key};
+use crate::log::LogExt as _;
 use crate::log::{error, info, warn};
 use crate::message::{Message, Viewtype};
 use crate::mimeparser::{MimeMessage, SystemMessage};
@@ -23,6 +23,7 @@ use crate::qr::check_qr;
 use crate::securejoin::bob::JoinerProgress;
 use crate::sync::Sync::*;
 use crate::token;
+use crate::{chatlist_events, self_reporting};
 
 mod bob;
 mod qrinvite;
@@ -151,6 +152,27 @@ pub async fn join_securejoin(context: &Context, qr: &str) -> Result<ChatId> {
     })
 }
 
+/// Take a scanned QR-code and do the setup-contact/join-group/invite handshake.
+///
+/// This is the start of the process for the joiner.  See the module and ffi documentation
+/// for more details.
+///
+/// The function returns immediately and the handshake will run in background.
+pub async fn join_securejoin_with_source(
+    context: &Context,
+    qr: &str,
+    source: Option<u32>,
+) -> Result<ChatId> {
+    let res = join_securejoin(context, qr).await?;
+
+    self_reporting::count_securejoin_source(context, source)
+        .await
+        .log_err(context)
+        .ok();
+
+    Ok(res)
+}
+
 async fn securejoin(context: &Context, qr: &str) -> Result<ChatId> {
     /*========================================================
     ====             Bob - the joiner's side             =====

src/self_reporting.rs

@@ -3,6 +3,7 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use anyhow::{ensure, Context as _, Result};
+use deltachat_derive::FromSql;
 use pgp::types::PublicKeyTrait;
 use serde::Serialize;
 
@@ -32,6 +33,7 @@ struct Statistics {
     self_reporting_id: String,
     contact_stats: Vec<ContactStat>,
     message_stats: MessageStats,
+    securejoin_source_stats: SecurejoinSourceStats,
 }
 #[derive(Default, Serialize)]
 struct ChatNumbers {
@@ -430,10 +432,78 @@ async fn get_self_report(context: &Context) -> Result<String> {
         self_reporting_id,
         contact_stats: get_contact_stats(context).await?,
         message_stats: get_message_stats(context).await?,
+        securejoin_source_stats: get_securejoin_source_stats(context).await?,
     };
 
     Ok(serde_json::to_string_pretty(&statistics)?)
 }
 
+#[repr(u32)]
+#[derive(Debug, Clone, Copy, FromPrimitive, FromSql, PartialEq, Eq, PartialOrd, Ord)]
+enum SecurejoinSource {
+    Unknown = 0,
+    ExternalLink = 1,
+    InternalLink = 2,
+    Clipboard = 3,
+    ImageLoaded = 4,
+    Scan = 5,
+}
+
+#[derive(Serialize)]
+struct SecurejoinSourceStats {
+    unknown: u32,
+    external_link: u32,
+    internal_link: u32,
+    clipboard: u32,
+    image_loaded: u32,
+    scan: u32,
+}
+
+pub(crate) async fn count_securejoin_source(context: &Context, source: Option<u32>) -> Result<()> {
+    if context.get_config_bool(Config::SelfReporting).await? {
+        let source = source
+            .context("Missing securejoin source")
+            .log_err(context)
+            .unwrap_or(0);
+
+        context
+            .sql
+            .execute(
+                "INSERT INTO stats_securejoin_sources VALUES (?, 1)
+            ON CONFLICT (source) DO UPDATE SET count=count+1;",
+                (source,),
+            )
+            .await?;
+    }
+    Ok(())
+}
+
+async fn get_securejoin_source_stats(context: &Context) -> Result<SecurejoinSourceStats> {
+    let map = context
+        .sql
+        .query_map(
+            "SELECT source, count FROM stats_securejoin_sources",
+            (),
+            |row| {
+                let source: SecurejoinSource = row.get(0)?;
+                let count: u32 = row.get(1)?;
+                Ok((source, count))
+            },
+            |rows| Ok(rows.collect::<rusqlite::Result<BTreeMap<_, _>>>()?),
+        )
+        .await?;
+
+    let stats = SecurejoinSourceStats {
+        unknown: *map.get(&SecurejoinSource::Unknown).unwrap_or(&0),
+        external_link: *map.get(&SecurejoinSource::ExternalLink).unwrap_or(&0),
+        internal_link: *map.get(&SecurejoinSource::InternalLink).unwrap_or(&0),
+        clipboard: *map.get(&SecurejoinSource::Clipboard).unwrap_or(&0),
+        image_loaded: *map.get(&SecurejoinSource::ImageLoaded).unwrap_or(&0),
+        scan: *map.get(&SecurejoinSource::Scan).unwrap_or(&0),
+    };
+
+    Ok(stats)
+}
+
 #[cfg(test)]
 mod self_reporting_tests;

src/sql/migrations.rs

@@ -1247,6 +1247,18 @@ CREATE INDEX gossip_timestamp_index ON gossip_timestamp (chat_id, fingerprint);
         );
     }
 
+    inc_and_check(&mut migration_version, 133)?;
+    if dbversion < migration_version {
+        sql.execute_migration(
+            "CREATE TABLE stats_securejoin_sources(
+                source INTEGER PRIMARY KEY,
+                count INTEGER NOT NULL DEFAULT 0
+            ) STRICT",
+            133,
+        )
+        .await?;
+    }
+
     let new_version = sql
         .get_raw_config_int(VERSION_CFG)
         .await?