Merge branch 'DES-1255-implement-related-event-match-push-rule' into 'master'

DES-1255 Implement related event match push rule

See merge request beeper/synapse!16

Author: bradtgmurray

synapse/push/baserules.py

@@ -527,17 +527,25 @@ def make_base_prepend_rules(
     {
         "rule_id": "global/override/com.beeper.reaction",
         "conditions": [
+            {
+                "kind": "event_match",
+                "key": "type",
+                "pattern": "m.reaction",
+                "_id": "_reaction",
+            },
+            # Only send reaction notifications for smaller rooms (under 20 members)
             {
                 "kind": "room_member_count",
                 "is": "<20",
                 "_id": "_member_count",
             },
+            # Only send notification if the reaction is to your message
             {
-                "kind": "event_match",
-                "key": "type",
-                "pattern": "m.reaction",
-                "_id": "_reaction",
-            }
+                "kind": "related_event_match",
+                "key": "sender",
+                "pattern_type": "user_id",
+                "_id": "_sender",
+            },
         ],
         "actions": ["notify", {"set_tweak": "highlight", "value": False}],
     },

synapse/push/bulk_push_rule_evaluator.py

@@ -37,7 +37,6 @@
 
 logger = logging.getLogger(__name__)
 
-
 push_rules_invalidation_counter = Counter(
     "synapse_push_bulk_push_rule_evaluator_push_rules_invalidation_counter", ""
 )
@@ -187,8 +186,13 @@ async def action_for_event_by_user(
             sender_power_level,
         ) = await self._get_power_levels_and_sender_level(event, context)
 
+        related_event_id = event.content.get("m.relates_to", {}).get("event_id")
+        related_event = (
+            (await self.store.get_event(related_event_id)) if related_event_id else None
+        )
+
         evaluator = PushRuleEvaluatorForEvent(
-            event, len(room_members), sender_power_level, power_levels
+            event, len(room_members), sender_power_level, power_levels, related_event
         )
 
         condition_cache: Dict[str, bool] = {}

synapse/push/push_rule_evaluator.py

@@ -119,6 +119,7 @@ def __init__(
         room_member_count: int,
         sender_power_level: int,
         power_levels: Dict[str, Union[int, Dict[str, int]]],
+        related_event: Optional[EventBase],
     ):
         self._event = event
         self._room_member_count = room_member_count
@@ -128,11 +129,22 @@ def __init__(
         # Maps strings of e.g. 'content.body' -> event["content"]["body"]
         self._value_cache = _flatten_dict(event)
 
+        self._related_event = related_event
+        self._related_event_value_cache = (
+            _flatten_dict(related_event) if related_event else None
+        )
+
     def matches(
         self, condition: Dict[str, Any], user_id: str, display_name: Optional[str]
     ) -> bool:
         if condition["kind"] == "event_match":
-            return self._event_match(condition, user_id)
+            return self._event_match(condition, user_id, self._event, self._value_cache)
+        elif condition["kind"] == "related_event_match":
+            if not self._related_event:
+                return False
+            return self._event_match(
+                condition, user_id, self._related_event, self._related_event_value_cache
+            )
         elif condition["kind"] == "contains_display_name":
             return self._contains_display_name(display_name)
         elif condition["kind"] == "room_member_count":
@@ -144,7 +156,13 @@ def matches(
         else:
             return True
 
-    def _event_match(self, condition: dict, user_id: str) -> bool:
+    def _event_match(
+        self,
+        condition: dict,
+        user_id: str,
+        event: EventBase,
+        event_value_cache: Dict[str, str],
+    ) -> bool:
         pattern = condition.get("pattern", None)
 
         if not pattern:
@@ -160,13 +178,13 @@ def _event_match(self, condition: dict, user_id: str) -> bool:
 
         # XXX: optimisation: cache our pattern regexps
         if condition["key"] == "content.body":
-            body = self._event.content.get("body", None)
+            body = event.content.get("body", None)
             if not body or not isinstance(body, str):
                 return False
 
             return _glob_matches(pattern, body, word_boundary=True)
         else:
-            haystack = self._get_value(condition["key"])
+            haystack = event_value_cache.get(condition["key"], None)
             if haystack is None:
                 return False
 
@@ -190,9 +208,6 @@ def _contains_display_name(self, display_name: Optional[str]) -> bool:
 
         return bool(r.search(body))
 
-    def _get_value(self, dotted_key: str) -> Optional[str]:
-        return self._value_cache.get(dotted_key, None)
-
 
 # Caches (string, is_glob, word_boundary) -> regex for push. See _glob_matches
 regex_cache: LruCache[Tuple[str, bool, bool], Pattern] = LruCache(

tests/push/test_push_rule_evaluator.py

@@ -23,7 +23,7 @@
 
 
 class PushRuleEvaluatorTestCase(unittest.TestCase):
-    def _get_evaluator(self, content):
+    def _get_evaluator(self, content, related_event=None):
         event = FrozenEvent(
             {
                 "event_id": "$event_id",
@@ -39,7 +39,7 @@ def _get_evaluator(self, content):
         sender_power_level = 0
         power_levels = {}
         return PushRuleEvaluatorForEvent(
-            event, room_member_count, sender_power_level, power_levels
+            event, room_member_count, sender_power_level, power_levels, related_event
         )
 
     def test_display_name(self):
@@ -266,3 +266,63 @@ def test_tweaks_for_actions(self):
             push_rule_evaluator.tweaks_for_actions(actions),
             {"sound": "default", "highlight": True},
         )
+
+    def test_related_event_match(self):
+        evaluator = self._get_evaluator(
+            {
+                "m.relates_to": {
+                    "event_id": "$parent_event_id",
+                    "key": "\ud83d\udc4d\ufe0f",
+                    "rel_type": "m.annotation",
+                }
+            },
+            FrozenEvent(
+                {
+                    "event_id": "$parent.event_id",
+                    "type": "m.room.message",
+                    "sender": "@other_user:test",
+                    "state_key": "",
+                    "room_id": "#room:test",
+                    "content": {"msgtype": "m.text", "body": "Original message"},
+                },
+                RoomVersions.V1,
+            ),
+        )
+        self.assertFalse(
+            evaluator.matches(
+                {
+                    "kind": "related_event_match",
+                    "key": "sender",
+                    "pattern_type": "user_id",
+                },
+                "@user:test",
+                "display_name",
+            )
+        )
+        self.assertTrue(
+            evaluator.matches(
+                {
+                    "kind": "related_event_match",
+                    "key": "sender",
+                    "pattern_type": "user_id",
+                },
+                "@other_user:test",
+                "display_name",
+            )
+        )
+
+    def test_related_event_match_no_related_event(self):
+        evaluator = self._get_evaluator(
+            {"msgtype": "m.text", "body": "Message without related event"}
+        )
+        self.assertFalse(
+            evaluator.matches(
+                {
+                    "kind": "related_event_match",
+                    "key": "sender",
+                    "pattern_type": "user_id",
+                },
+                "@user:test",
+                "display_name",
+            )
+        )