refactor: remove ProtectionStatus

Author: link2xt

src/chat.rs

@@ -12,7 +12,6 @@ use std::time::Duration;
 use anyhow::{Context as _, Result, anyhow, bail, ensure};
 use chrono::TimeZone;
 use deltachat_contact_tools::{ContactAddress, sanitize_bidi_characters, sanitize_single_line};
-use deltachat_derive::{FromSql, ToSql};
 use mail_builder::mime::MimePart;
 use serde::{Deserialize, Serialize};
 use strum_macros::EnumIter;
@@ -67,41 +66,6 @@ pub enum ChatItem {
     },
 }
 
-/// Chat protection status.
-#[derive(
-    Debug,
-    Default,
-    Display,
-    Clone,
-    Copy,
-    PartialEq,
-    Eq,
-    FromPrimitive,
-    ToPrimitive,
-    FromSql,
-    ToSql,
-    IntoStaticStr,
-    Serialize,
-    Deserialize,
-)]
-#[repr(u32)]
-pub enum ProtectionStatus {
-    /// Chat is not protected.
-    #[default]
-    Unprotected = 0,
-
-    /// Chat is protected.
-    ///
-    /// All members of the chat must be verified.
-    Protected = 1,
-    // `2` was never used as a value.
-
-    // Chats don't break in Core v2 anymore. Chats with broken protection existing before the
-    // key-contacts migration are treated as `Unprotected`.
-    //
-    // ProtectionBroken = 3,
-}
-
 /// The reason why messages cannot be sent to the chat.
 ///
 /// The reason is mainly for logging and displaying in debug REPL, thus not translated.
@@ -1375,9 +1339,6 @@ pub struct Chat {
 
     /// Duration of the chat being muted.
     pub mute_duration: MuteDuration,
-
-    /// If the chat is protected (verified).
-    pub(crate) protected: ProtectionStatus,
 }
 
 impl Chat {
@@ -1387,7 +1348,7 @@ impl Chat {
             .sql
             .query_row(
                 "SELECT c.type, c.name, c.grpid, c.param, c.archived,
-                    c.blocked, c.locations_send_until, c.muted_until, c.protected
+                    c.blocked, c.locations_send_until, c.muted_until
              FROM chats c
              WHERE c.id=?;",
                 (chat_id,),
@@ -1402,7 +1363,6 @@ impl Chat {
                         blocked: row.get::<_, Option<_>>(5)?.unwrap_or_default(),
                         is_sending_locations: row.get(6)?,
                         mute_duration: row.get(7)?,
-                        protected: row.get(8)?,
                     };
                     Ok(c)
                 },
@@ -2422,27 +2382,21 @@ impl ChatIdBlocked {
             _ => (),
         }
 
-        let protected = contact_id == ContactId::SELF || contact.is_verified(context).await?;
         let smeared_time = create_smeared_timestamp(context);
 
         let chat_id = context
             .sql
             .transaction(move |transaction| {
                 transaction.execute(
                     "INSERT INTO chats
-                     (type, name, param, blocked, created_timestamp, protected)
-                     VALUES(?, ?, ?, ?, ?, ?)",
+                     (type, name, param, blocked, created_timestamp)
+                     VALUES(?, ?, ?, ?, ?)",
                     (
                         Chattype::Single,
                         chat_name,
                         params.to_string(),
                         create_blocked as u8,
                         smeared_time,
-                        if protected {
-                            ProtectionStatus::Protected
-                        } else {
-                            ProtectionStatus::Unprotected
-                        },
                     ),
                 )?;
                 let chat_id = ChatId::new(
@@ -4413,24 +4367,21 @@ pub(crate) async fn get_chat_cnt(context: &Context) -> Result<usize> {
     }
 }
 
-/// Returns a tuple of `(chatid, is_protected, blocked)`.
+/// Returns a tuple of `(chatid, blocked)`.
 pub(crate) async fn get_chat_id_by_grpid(
     context: &Context,
     grpid: &str,
-) -> Result<Option<(ChatId, bool, Blocked)>> {
+) -> Result<Option<(ChatId, Blocked)>> {
     context
         .sql
         .query_row_optional(
-            "SELECT id, blocked, protected FROM chats WHERE grpid=?;",
+            "SELECT id, blocked FROM chats WHERE grpid=?;",
             (grpid,),
             |row| {
                 let chat_id = row.get::<_, ChatId>(0)?;
 
                 let b = row.get::<_, Option<Blocked>>(1)?.unwrap_or_default();
-                let p = row
-                    .get::<_, Option<ProtectionStatus>>(2)?
-                    .unwrap_or_default();
-                Ok((chat_id, p == ProtectionStatus::Protected, b))
+                Ok((chat_id, b))
             },
         )
         .await

src/contact.rs

@@ -1778,9 +1778,7 @@ WHERE type=? AND id IN (
         // also unblock mailinglist
         // if the contact is a mailinglist address explicitly created to allow unblocking
         if !new_blocking && contact.origin == Origin::MailinglistAddress {
-            if let Some((chat_id, _, _)) =
-                chat::get_chat_id_by_grpid(context, &contact.addr).await?
-            {
+            if let Some((chat_id, ..)) = chat::get_chat_id_by_grpid(context, &contact.addr).await? {
                 chat_id.unblock_ex(context, Nosync).await?;
             }
         }

src/context.rs

@@ -14,7 +14,7 @@ use pgp::types::PublicKeyTrait;
 use ratelimit::Ratelimit;
 use tokio::sync::{Mutex, Notify, RwLock};
 
-use crate::chat::{ChatId, ProtectionStatus, get_chat_cnt};
+use crate::chat::{ChatId, get_chat_cnt};
 use crate::chatlist_events;
 use crate::config::Config;
 use crate::constants::{
@@ -1086,7 +1086,6 @@ impl Context {
     async fn get_self_report(&self) -> Result<String> {
         #[derive(Default)]
         struct ChatNumbers {
-            protected: u32,
             opportunistic_dc: u32,
             opportunistic_mua: u32,
             unencrypted_dc: u32,
@@ -1121,7 +1120,6 @@ impl Context {
         res += &format!("key_created {key_created}\n");
 
         // how many of the chats active in the last months are:
-        // - protected
         // - opportunistic-encrypted and the contact uses Delta Chat
         // - opportunistic-encrypted and the contact uses a classical MUA
         // - unencrypted and the contact uses Delta Chat
@@ -1130,7 +1128,7 @@ impl Context {
         let chats = self
             .sql
             .query_map(
-                "SELECT c.protected, m.param, m.msgrmsg
+                "SELECT m.param, m.msgrmsg
                     FROM chats c
                     JOIN msgs m
                         ON c.id=m.chat_id
@@ -1148,23 +1146,20 @@ impl Context {
                     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))
+                    Ok((message_param, is_dc_message))
                 },
                 |rows| {
                     let mut chats = ChatNumbers::default();
                     for row in rows {
-                        let (protected, message_param, is_dc_message) = row?;
+                        let (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 encrypted {
+                        if encrypted {
                             if is_dc_message {
                                 chats.opportunistic_dc += 1;
                             } else {
@@ -1180,7 +1175,6 @@ impl Context {
                 },
             )
             .await?;
-        res += &format!("chats_protected {}\n", chats.protected);
         res += &format!("chats_opportunistic_dc {}\n", chats.opportunistic_dc);
         res += &format!("chats_opportunistic_mua {}\n", chats.opportunistic_mua);
         res += &format!("chats_unencrypted_dc {}\n", chats.unencrypted_dc);

src/receive_imf.rs

@@ -246,9 +246,7 @@ async fn get_to_and_past_contact_ids(
     let chat_id = match chat_assignment {
         ChatAssignment::Trash => None,
         ChatAssignment::GroupChat { grpid } => {
-            if let Some((chat_id, _protected, _blocked)) =
-                chat::get_chat_id_by_grpid(context, grpid).await?
-            {
+            if let Some((chat_id, _blocked)) = chat::get_chat_id_by_grpid(context, grpid).await? {
                 Some(chat_id)
             } else {
                 None
@@ -1340,9 +1338,7 @@ async fn do_chat_assignment(
             }
             ChatAssignment::GroupChat { grpid } => {
                 // Try to assign to a chat based on Chat-Group-ID.
-                if let Some((id, _protected, blocked)) =
-                    chat::get_chat_id_by_grpid(context, grpid).await?
-                {
+                if let Some((id, blocked)) = chat::get_chat_id_by_grpid(context, grpid).await? {
                     chat_id = Some(id);
                     chat_id_blocked = blocked;
                 } else if allow_creation || test_normal_chat.is_some() {
@@ -1471,9 +1467,7 @@ async fn do_chat_assignment(
                 chat_id = Some(DC_CHAT_ID_TRASH);
             }
             ChatAssignment::GroupChat { grpid } => {
-                if let Some((id, _protected, blocked)) =
-                    chat::get_chat_id_by_grpid(context, grpid).await?
-                {
+                if let Some((id, blocked)) = chat::get_chat_id_by_grpid(context, grpid).await? {
                     chat_id = Some(id);
                     chat_id_blocked = blocked;
                 } else if allow_creation {
@@ -1540,7 +1534,7 @@ async fn do_chat_assignment(
             if chat_id.is_none() && allow_creation {
                 let to_contact = Contact::get_by_id(context, to_id).await?;
                 if let Some(list_id) = to_contact.param.get(Param::ListId) {
-                    if let Some((id, _, blocked)) =
+                    if let Some((id, blocked)) =
                         chat::get_chat_id_by_grpid(context, list_id).await?
                     {
                         chat_id = Some(id);
@@ -3146,7 +3140,7 @@ async fn create_or_lookup_mailinglist_or_broadcast(
 ) -> Result<Option<(ChatId, Blocked)>> {
     let listid = mailinglist_header_listid(list_id_header)?;
 
-    if let Some((chat_id, _, blocked)) = chat::get_chat_id_by_grpid(context, &listid).await? {
+    if let Some((chat_id, blocked)) = chat::get_chat_id_by_grpid(context, &listid).await? {
         return Ok(Some((chat_id, blocked)));
     }
 

src/receive_imf/receive_imf_tests.rs

@@ -1000,7 +1000,7 @@ async fn test_other_device_writes_to_mailinglist() -> Result<()> {
         chat::get_chat_id_by_grpid(&t, "delta.codespeak.net")
             .await?
             .unwrap(),
-        (first_chat.id, false, Blocked::Request)
+        (first_chat.id, Blocked::Request)
     );
 
     receive_imf(

src/securejoin/bob.rs

@@ -327,7 +327,7 @@ async fn joining_chat_id(
         QrInvite::Contact { .. } => Ok(alice_chat_id),
         QrInvite::Group { grpid, name, .. } => {
             let group_chat_id = match chat::get_chat_id_by_grpid(context, grpid).await? {
-                Some((chat_id, _protected, _blocked)) => {
+                Some((chat_id, _blocked)) => {
                     chat_id.unblock_ex(context, Nosync).await?;
                     chat_id
                 }