broadcast channel reactions

deltachat-jsonrpc/src/api/types/reactions.rs

@@ -1,6 +1,5 @@
 use std::collections::BTreeMap;
 
-use deltachat::contact::ContactId;
 use deltachat::reaction::Reactions;
 use serde::Serialize;
 use typescript_type_def::TypeDef;
@@ -34,30 +33,24 @@ pub struct JsonrpcReactions {
 impl From<Reactions> for JsonrpcReactions {
     fn from(reactions: Reactions) -> Self {
         let reactions_by_contact: BTreeMap<u32, Vec<String>> = reactions
+            .by_contact
             .iter()
             .map(|(key, value)| (key.to_u32(), vec![value.as_str().to_string()]))
             .collect();
-        let self_reaction = reactions_by_contact.get(&ContactId::SELF.to_u32());
-
-        let mut reactions_v = Vec::new();
-        for (emoji, count) in reactions.emoji_sorted_by_frequency() {
-            let is_from_self = if let Some(self_reaction) = self_reaction {
-                self_reaction.contains(&emoji)
-            } else {
-                false
-            };
-
-            let reaction = JsonrpcReaction {
-                emoji,
-                count,
-                is_from_self,
-            };
-            reactions_v.push(reaction)
-        }
+
+        let reactions = reactions
+            .frequencies
+            .into_iter()
+            .map(|entry| JsonrpcReaction {
+                emoji: entry.reaction.as_str().to_string(),
+                count: entry.count,
+                is_from_self: entry.is_from_self,
+            })
+            .collect();
 
         JsonrpcReactions {
             reactions_by_contact,
-            reactions: reactions_v,
+            reactions,
         }
     }
 }

src/chat.rs

@@ -2685,10 +2685,11 @@ async fn prepare_send_msg(
         // from the chat.
         CantSendReason::NotAMember => msg.param.get_cmd() == SystemMessage::MemberRemovedFromGroup,
         CantSendReason::InBroadcast => {
-            matches!(
-                msg.param.get_cmd(),
-                SystemMessage::MemberRemovedFromGroup | SystemMessage::SecurejoinMessage
-            )
+            msg.param.get_int(Param::Reaction).unwrap_or_default() != 0
+                || matches!(
+                    msg.param.get_cmd(),
+                    SystemMessage::MemberRemovedFromGroup | SystemMessage::SecurejoinMessage
+                )
         }
         CantSendReason::MissingKey => msg
             .param
@@ -3677,14 +3678,15 @@ pub(crate) async fn create_out_broadcast_ex(
 
         t.execute(
             "INSERT INTO chats
-            (type, name, name_normalized, grpid, created_timestamp, param)
-            VALUES(?, ?, ?, ?, ?, ?)",
+            (type, name, name_normalized, grpid, created_timestamp, muted_until, param)
+            VALUES(?, ?, ?, ?, ?, ?, ?)",
             (
                 Chattype::OutBroadcast,
                 &chat_name,
                 normalize_text(&chat_name),
                 &grpid,
                 timestamp,
+                MuteDuration::Forever,
                 params.to_string(),
             ),
         )?;

src/chat/chat_tests.rs

@@ -3055,6 +3055,29 @@ async fn test_broadcast_change_name() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_broadcast_muted() -> Result<()> {
+    let mut tcm = TestContextManager::new();
+    let alice = &tcm.alice().await;
+    let bob = &tcm.bob().await;
+
+    // Alice's new outgoing broadcast channel is muted after creation:
+    // Channel owners can only get reaction notifications; they are usually not of much interest.
+    let alice_chat_id = create_broadcast(alice, "Channel".to_string()).await?;
+    let qr = get_securejoin_qr(alice, Some(alice_chat_id)).await?;
+    let alice_chat = Chat::load_from_db(alice, alice_chat_id).await?;
+    assert!(alice_chat.is_muted());
+
+    // Bob joins the channel, for him, it is not muted:
+    // For channel subscribers, new messages to newly subscribed channels are often interesting.
+    let bob_chat_id = tcm.exec_securejoin_qr(bob, alice, &qr).await;
+    bob_chat_id.accept(bob).await?;
+    let bob_chat = Chat::load_from_db(bob, bob_chat_id).await?;
+    assert!(!bob_chat.is_muted());
+
+    Ok(())
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_broadcast_resend_to_new_member() -> Result<()> {
     let mut tcm = TestContextManager::new();

src/config.rs

@@ -346,6 +346,9 @@ pub enum Config {
     /// Timestamp of the last time housekeeping was run
     LastHousekeeping,
 
+    /// Timestamp of the last time accumulated broadcast channel reactions were sent
+    LastReactionsBroadcast,
+
     /// Timestamp of the last `CantDecryptOutgoingMsgs` notification.
     LastCantDecryptOutgoingMsgs,
 

src/context.rs

@@ -961,6 +961,12 @@ impl Context {
                 .await?
                 .to_string(),
         );
+        res.insert(
+            "last_reactions_broadcast",
+            self.get_config_int(Config::LastReactionsBroadcast)
+                .await?
+                .to_string(),
+        );
         res.insert(
             "last_cant_decrypt_outgoing_msgs",
             self.get_config_int(Config::LastCantDecryptOutgoingMsgs)

src/events/payload.rs

@@ -92,7 +92,7 @@ pub enum EventType {
         /// ID of the message for which reactions were changed.
         msg_id: MsgId,
 
-        /// ID of the contact whose reaction set is changed.
+        /// ID of the contact whose reaction set is changed. May be 0 eg. in case of broadcasted reactions.
         contact_id: ContactId,
     },
 

src/headerdef.rs

@@ -122,6 +122,10 @@ pub enum HeaderDef {
     /// This is an unprotected header.
     ChatIsPostMessage,
 
+    /// Broadcasted reactions for this or other chat messages.
+    /// See broadcast_reactions.rs for the wire format.
+    ChatBroadcastReactions,
+
     /// [Autocrypt](https://autocrypt.org/) header.
     Autocrypt,
     AutocryptGossip,

src/mimefactory.rs

@@ -1698,6 +1698,13 @@ impl MimeFactory {
             ))
         }
 
+        if let Some(broadcast_reactions) = msg.param.get(Param::BroadcastReactions) {
+            headers.push((
+                "Chat-Broadcast-Reactions",
+                mail_builder::headers::raw::Raw::new(b_encode(broadcast_reactions)).into(),
+            ));
+        }
+
         if msg.viewtype == Viewtype::Voice
             || msg.viewtype == Viewtype::Audio
             || msg.viewtype == Viewtype::Video

src/mimeparser.rs

@@ -116,6 +116,10 @@ pub(crate) struct MimeMessage {
     pub(crate) mdn_reports: Vec<Report>,
     pub(crate) delivery_report: Option<DeliveryReport>,
 
+    /// Parsed `Chat-Broadcast-Reactions` header, if any:
+    /// accumulated reaction updates sent by a broadcast channel owner.
+    pub(crate) broadcast_reactions: Option<String>,
+
     /// Standard USENET signature, if any.
     ///
     /// `None` means no text part was received, empty string means a text part without a footer is
@@ -657,6 +661,7 @@ impl MimeMessage {
             user_avatar: None,
             group_avatar: None,
             delivery_report: None,
+            broadcast_reactions: None,
             footer: None,
             is_mime_modified: false,
             decoded_data: Vec::new(),
@@ -793,6 +798,12 @@ impl MimeMessage {
         }
     }
 
+    fn parse_broadcast_reactions_header(&mut self) {
+        self.broadcast_reactions = self
+            .get_header(HeaderDef::ChatBroadcastReactions)
+            .map(|s| s.to_string());
+    }
+
     /// Squashes mutitpart chat messages with attachment into single-part messages.
     ///
     /// Delta Chat sends attachments, such as images, in two-part messages, with the first message
@@ -874,6 +885,7 @@ impl MimeMessage {
         self.parse_system_message_headers();
         self.parse_avatar_headers(context)?;
         self.parse_videochat_headers();
+        self.parse_broadcast_reactions_header();
         if self.delivery_report.is_none() {
             self.squash_attachment_parts();
         }

src/param.rs

@@ -70,9 +70,12 @@ pub enum Param {
     /// For Messages
     WantsMdn = b'r',
 
-    /// For Messages: the message is a reaction.
+    /// For Messages: Render message as a RFC 9078 reaction.
     Reaction = b'x',
 
+    /// For Messages: Additional reactions that go to the `Chat-Broadcast-Reactions:` header
+    BroadcastReactions = b'X',
+
     /// For Chats: the timestamp of the last reaction.
     LastReactionTimestamp = b'y',