ruma_common/
push.rs

1//! Common types for the [push notifications module][push].
2//!
3//! [push]: https://spec.matrix.org/latest/client-server-api/#push-notifications
4//!
5//! ## Understanding the types of this module
6//!
7//! Push rules are grouped in `RuleSet`s, and are grouped in five kinds (for
8//! more details about the different kind of rules, see the `Ruleset` documentation,
9//! or the specification). These five kinds are, by order of priority:
10//!
11//! - override rules
12//! - content rules
13//! - room rules
14//! - sender rules
15//! - underride rules
16
17use std::hash::{Hash, Hasher};
18
19use indexmap::{Equivalent, IndexSet};
20use serde::{Deserialize, Serialize};
21use thiserror::Error;
22use tracing::instrument;
23
24use crate::{
25    serde::{JsonObject, Raw, StringEnum},
26    OwnedRoomId, OwnedUserId, PrivOwnedStr,
27};
28
29mod action;
30mod condition;
31mod iter;
32mod predefined;
33
34#[cfg(feature = "unstable-msc3932")]
35pub use self::condition::RoomVersionFeature;
36pub use self::{
37    action::{Action, Tweak},
38    condition::{
39        ComparisonOperator, FlattenedJson, FlattenedJsonValue, PushCondition,
40        PushConditionPowerLevelsCtx, PushConditionRoomCtx, RoomMemberCountIs, ScalarJsonValue,
41        _CustomPushCondition,
42    },
43    iter::{AnyPushRule, AnyPushRuleRef, RulesetIntoIter, RulesetIter},
44    predefined::{
45        PredefinedContentRuleId, PredefinedOverrideRuleId, PredefinedRuleId,
46        PredefinedUnderrideRuleId,
47    },
48};
49
50/// A push ruleset scopes a set of rules according to some criteria.
51///
52/// For example, some rules may only be applied for messages from a particular sender, a particular
53/// room, or by default. The push ruleset contains the entire set of scopes and rules.
54#[derive(Clone, Debug, Default, Deserialize, Serialize)]
55#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
56pub struct Ruleset {
57    /// These rules configure behavior for (unencrypted) messages that match certain patterns.
58    #[serde(default, skip_serializing_if = "IndexSet::is_empty")]
59    pub content: IndexSet<PatternedPushRule>,
60
61    /// These user-configured rules are given the highest priority.
62    ///
63    /// This field is named `override_` instead of `override` because the latter is a reserved
64    /// keyword in Rust.
65    #[serde(rename = "override", default, skip_serializing_if = "IndexSet::is_empty")]
66    pub override_: IndexSet<ConditionalPushRule>,
67
68    /// These rules change the behavior of all messages for a given room.
69    #[serde(default, skip_serializing_if = "IndexSet::is_empty")]
70    pub room: IndexSet<SimplePushRule<OwnedRoomId>>,
71
72    /// These rules configure notification behavior for messages from a specific Matrix user ID.
73    #[serde(default, skip_serializing_if = "IndexSet::is_empty")]
74    pub sender: IndexSet<SimplePushRule<OwnedUserId>>,
75
76    /// These rules are identical to override rules, but have a lower priority than `content`,
77    /// `room` and `sender` rules.
78    #[serde(default, skip_serializing_if = "IndexSet::is_empty")]
79    pub underride: IndexSet<ConditionalPushRule>,
80}
81
82impl Ruleset {
83    /// Creates an empty `Ruleset`.
84    pub fn new() -> Self {
85        Default::default()
86    }
87
88    /// Creates a borrowing iterator over all push rules in this `Ruleset`.
89    ///
90    /// For an owning iterator, use `.into_iter()`.
91    pub fn iter(&self) -> RulesetIter<'_> {
92        self.into_iter()
93    }
94
95    /// Inserts a user-defined rule in the rule set.
96    ///
97    /// If a rule with the same kind and `rule_id` exists, it will be replaced.
98    ///
99    /// If `after` or `before` is set, the rule will be moved relative to the rule with the given
100    /// ID. If both are set, the rule will become the next-most important rule with respect to
101    /// `before`. If neither are set, and the rule is newly inserted, it will become the rule with
102    /// the highest priority of its kind.
103    ///
104    /// Returns an error if the parameters are invalid.
105    pub fn insert(
106        &mut self,
107        rule: NewPushRule,
108        after: Option<&str>,
109        before: Option<&str>,
110    ) -> Result<(), InsertPushRuleError> {
111        let rule_id = rule.rule_id();
112        if rule_id.starts_with('.') {
113            return Err(InsertPushRuleError::ServerDefaultRuleId);
114        }
115        if rule_id.contains('/') {
116            return Err(InsertPushRuleError::InvalidRuleId);
117        }
118        if rule_id.contains('\\') {
119            return Err(InsertPushRuleError::InvalidRuleId);
120        }
121        if after.is_some_and(|s| s.starts_with('.')) {
122            return Err(InsertPushRuleError::RelativeToServerDefaultRule);
123        }
124        if before.is_some_and(|s| s.starts_with('.')) {
125            return Err(InsertPushRuleError::RelativeToServerDefaultRule);
126        }
127
128        match rule {
129            NewPushRule::Override(r) => {
130                let mut rule = ConditionalPushRule::from(r);
131
132                if let Some(prev_rule) = self.override_.get(rule.rule_id.as_str()) {
133                    rule.enabled = prev_rule.enabled;
134                }
135
136                // `m.rule.master` should always be the rule with the highest priority, so we insert
137                // this one at most at the second place.
138                let default_position = 1;
139
140                insert_and_move_rule(&mut self.override_, rule, default_position, after, before)
141            }
142            NewPushRule::Underride(r) => {
143                let mut rule = ConditionalPushRule::from(r);
144
145                if let Some(prev_rule) = self.underride.get(rule.rule_id.as_str()) {
146                    rule.enabled = prev_rule.enabled;
147                }
148
149                insert_and_move_rule(&mut self.underride, rule, 0, after, before)
150            }
151            NewPushRule::Content(r) => {
152                let mut rule = PatternedPushRule::from(r);
153
154                if let Some(prev_rule) = self.content.get(rule.rule_id.as_str()) {
155                    rule.enabled = prev_rule.enabled;
156                }
157
158                insert_and_move_rule(&mut self.content, rule, 0, after, before)
159            }
160            NewPushRule::Room(r) => {
161                let mut rule = SimplePushRule::from(r);
162
163                if let Some(prev_rule) = self.room.get(rule.rule_id.as_str()) {
164                    rule.enabled = prev_rule.enabled;
165                }
166
167                insert_and_move_rule(&mut self.room, rule, 0, after, before)
168            }
169            NewPushRule::Sender(r) => {
170                let mut rule = SimplePushRule::from(r);
171
172                if let Some(prev_rule) = self.sender.get(rule.rule_id.as_str()) {
173                    rule.enabled = prev_rule.enabled;
174                }
175
176                insert_and_move_rule(&mut self.sender, rule, 0, after, before)
177            }
178        }
179    }
180
181    /// Get the rule from the given kind and with the given `rule_id` in the rule set.
182    pub fn get(&self, kind: RuleKind, rule_id: impl AsRef<str>) -> Option<AnyPushRuleRef<'_>> {
183        let rule_id = rule_id.as_ref();
184
185        match kind {
186            RuleKind::Override => self.override_.get(rule_id).map(AnyPushRuleRef::Override),
187            RuleKind::Underride => self.underride.get(rule_id).map(AnyPushRuleRef::Underride),
188            RuleKind::Sender => self.sender.get(rule_id).map(AnyPushRuleRef::Sender),
189            RuleKind::Room => self.room.get(rule_id).map(AnyPushRuleRef::Room),
190            RuleKind::Content => self.content.get(rule_id).map(AnyPushRuleRef::Content),
191            RuleKind::_Custom(_) => None,
192        }
193    }
194
195    /// Set whether the rule from the given kind and with the given `rule_id` in the rule set is
196    /// enabled.
197    ///
198    /// Returns an error if the rule can't be found.
199    pub fn set_enabled(
200        &mut self,
201        kind: RuleKind,
202        rule_id: impl AsRef<str>,
203        enabled: bool,
204    ) -> Result<(), RuleNotFoundError> {
205        let rule_id = rule_id.as_ref();
206
207        match kind {
208            RuleKind::Override => {
209                let mut rule = self.override_.get(rule_id).ok_or(RuleNotFoundError)?.clone();
210                rule.enabled = enabled;
211                self.override_.replace(rule);
212            }
213            RuleKind::Underride => {
214                let mut rule = self.underride.get(rule_id).ok_or(RuleNotFoundError)?.clone();
215                rule.enabled = enabled;
216                self.underride.replace(rule);
217            }
218            RuleKind::Sender => {
219                let mut rule = self.sender.get(rule_id).ok_or(RuleNotFoundError)?.clone();
220                rule.enabled = enabled;
221                self.sender.replace(rule);
222            }
223            RuleKind::Room => {
224                let mut rule = self.room.get(rule_id).ok_or(RuleNotFoundError)?.clone();
225                rule.enabled = enabled;
226                self.room.replace(rule);
227            }
228            RuleKind::Content => {
229                let mut rule = self.content.get(rule_id).ok_or(RuleNotFoundError)?.clone();
230                rule.enabled = enabled;
231                self.content.replace(rule);
232            }
233            RuleKind::_Custom(_) => return Err(RuleNotFoundError),
234        }
235
236        Ok(())
237    }
238
239    /// Set the actions of the rule from the given kind and with the given `rule_id` in the rule
240    /// set.
241    ///
242    /// Returns an error if the rule can't be found.
243    pub fn set_actions(
244        &mut self,
245        kind: RuleKind,
246        rule_id: impl AsRef<str>,
247        actions: Vec<Action>,
248    ) -> Result<(), RuleNotFoundError> {
249        let rule_id = rule_id.as_ref();
250
251        match kind {
252            RuleKind::Override => {
253                let mut rule = self.override_.get(rule_id).ok_or(RuleNotFoundError)?.clone();
254                rule.actions = actions;
255                self.override_.replace(rule);
256            }
257            RuleKind::Underride => {
258                let mut rule = self.underride.get(rule_id).ok_or(RuleNotFoundError)?.clone();
259                rule.actions = actions;
260                self.underride.replace(rule);
261            }
262            RuleKind::Sender => {
263                let mut rule = self.sender.get(rule_id).ok_or(RuleNotFoundError)?.clone();
264                rule.actions = actions;
265                self.sender.replace(rule);
266            }
267            RuleKind::Room => {
268                let mut rule = self.room.get(rule_id).ok_or(RuleNotFoundError)?.clone();
269                rule.actions = actions;
270                self.room.replace(rule);
271            }
272            RuleKind::Content => {
273                let mut rule = self.content.get(rule_id).ok_or(RuleNotFoundError)?.clone();
274                rule.actions = actions;
275                self.content.replace(rule);
276            }
277            RuleKind::_Custom(_) => return Err(RuleNotFoundError),
278        }
279
280        Ok(())
281    }
282
283    /// Get the first push rule that applies to this event, if any.
284    ///
285    /// # Arguments
286    ///
287    /// * `event` - The raw JSON of a room message event.
288    /// * `context` - The context of the message and room at the time of the event.
289    #[instrument(skip_all, fields(context.room_id = %context.room_id))]
290    pub fn get_match<T>(
291        &self,
292        event: &Raw<T>,
293        context: &PushConditionRoomCtx,
294    ) -> Option<AnyPushRuleRef<'_>> {
295        let event = FlattenedJson::from_raw(event);
296
297        if event.get_str("sender").is_some_and(|sender| sender == context.user_id) {
298            // no need to look at the rules if the event was by the user themselves
299            None
300        } else {
301            self.iter().find(|rule| rule.applies(&event, context))
302        }
303    }
304
305    /// Get the push actions that apply to this event.
306    ///
307    /// Returns an empty slice if no push rule applies.
308    ///
309    /// # Arguments
310    ///
311    /// * `event` - The raw JSON of a room message event.
312    /// * `context` - The context of the message and room at the time of the event.
313    #[instrument(skip_all, fields(context.room_id = %context.room_id))]
314    pub fn get_actions<T>(&self, event: &Raw<T>, context: &PushConditionRoomCtx) -> &[Action] {
315        self.get_match(event, context).map(|rule| rule.actions()).unwrap_or(&[])
316    }
317
318    /// Removes a user-defined rule in the rule set.
319    ///
320    /// Returns an error if the parameters are invalid.
321    pub fn remove(
322        &mut self,
323        kind: RuleKind,
324        rule_id: impl AsRef<str>,
325    ) -> Result<(), RemovePushRuleError> {
326        let rule_id = rule_id.as_ref();
327
328        if let Some(rule) = self.get(kind.clone(), rule_id) {
329            if rule.is_server_default() {
330                return Err(RemovePushRuleError::ServerDefault);
331            }
332        } else {
333            return Err(RemovePushRuleError::NotFound);
334        }
335
336        match kind {
337            RuleKind::Override => {
338                self.override_.shift_remove(rule_id);
339            }
340            RuleKind::Underride => {
341                self.underride.shift_remove(rule_id);
342            }
343            RuleKind::Sender => {
344                self.sender.shift_remove(rule_id);
345            }
346            RuleKind::Room => {
347                self.room.shift_remove(rule_id);
348            }
349            RuleKind::Content => {
350                self.content.shift_remove(rule_id);
351            }
352            // This has been handled in the `self.get` call earlier.
353            RuleKind::_Custom(_) => unreachable!(),
354        }
355
356        Ok(())
357    }
358}
359
360/// A push rule is a single rule that states under what conditions an event should be passed onto a
361/// push gateway and how the notification should be presented.
362///
363/// These rules are stored on the user's homeserver. They are manually configured by the user, who
364/// can create and view them via the Client/Server API.
365///
366/// To create an instance of this type, first create a `SimplePushRuleInit` and convert it via
367/// `SimplePushRule::from` / `.into()`.
368#[derive(Clone, Debug, Deserialize, Serialize)]
369#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
370pub struct SimplePushRule<T> {
371    /// Actions to determine if and how a notification is delivered for events matching this rule.
372    pub actions: Vec<Action>,
373
374    /// Whether this is a default rule, or has been set explicitly.
375    pub default: bool,
376
377    /// Whether the push rule is enabled or not.
378    pub enabled: bool,
379
380    /// The ID of this rule.
381    ///
382    /// This is generally the Matrix ID of the entity that it applies to.
383    pub rule_id: T,
384}
385
386/// Initial set of fields of `SimplePushRule`.
387///
388/// This struct will not be updated even if additional fields are added to `SimplePushRule` in a new
389/// (non-breaking) release of the Matrix specification.
390#[derive(Debug)]
391#[allow(clippy::exhaustive_structs)]
392pub struct SimplePushRuleInit<T> {
393    /// Actions to determine if and how a notification is delivered for events matching this rule.
394    pub actions: Vec<Action>,
395
396    /// Whether this is a default rule, or has been set explicitly.
397    pub default: bool,
398
399    /// Whether the push rule is enabled or not.
400    pub enabled: bool,
401
402    /// The ID of this rule.
403    ///
404    /// This is generally the Matrix ID of the entity that it applies to.
405    pub rule_id: T,
406}
407
408impl<T> From<SimplePushRuleInit<T>> for SimplePushRule<T> {
409    fn from(init: SimplePushRuleInit<T>) -> Self {
410        let SimplePushRuleInit { actions, default, enabled, rule_id } = init;
411        Self { actions, default, enabled, rule_id }
412    }
413}
414
415// The following trait are needed to be able to make
416// an IndexSet of the type
417
418impl<T> Hash for SimplePushRule<T>
419where
420    T: Hash,
421{
422    fn hash<H: Hasher>(&self, state: &mut H) {
423        self.rule_id.hash(state);
424    }
425}
426
427impl<T> PartialEq for SimplePushRule<T>
428where
429    T: PartialEq<T>,
430{
431    fn eq(&self, other: &Self) -> bool {
432        self.rule_id == other.rule_id
433    }
434}
435
436impl<T> Eq for SimplePushRule<T> where T: Eq {}
437
438impl<T> Equivalent<SimplePushRule<T>> for str
439where
440    T: AsRef<str>,
441{
442    fn equivalent(&self, key: &SimplePushRule<T>) -> bool {
443        self == key.rule_id.as_ref()
444    }
445}
446
447/// Like `SimplePushRule`, but with an additional `conditions` field.
448///
449/// Only applicable to underride and override rules.
450///
451/// To create an instance of this type, first create a `ConditionalPushRuleInit` and convert it via
452/// `ConditionalPushRule::from` / `.into()`.
453#[derive(Clone, Debug, Deserialize, Serialize)]
454#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
455pub struct ConditionalPushRule {
456    /// Actions to determine if and how a notification is delivered for events matching this rule.
457    pub actions: Vec<Action>,
458
459    /// Whether this is a default rule, or has been set explicitly.
460    pub default: bool,
461
462    /// Whether the push rule is enabled or not.
463    pub enabled: bool,
464
465    /// The ID of this rule.
466    pub rule_id: String,
467
468    /// The conditions that must hold true for an event in order for a rule to be applied to an
469    /// event.
470    ///
471    /// A rule with no conditions always matches.
472    #[serde(default)]
473    pub conditions: Vec<PushCondition>,
474}
475
476impl ConditionalPushRule {
477    /// Check if the push rule applies to the event.
478    ///
479    /// # Arguments
480    ///
481    /// * `event` - The flattened JSON representation of a room message event.
482    /// * `context` - The context of the room at the time of the event.
483    pub fn applies(&self, event: &FlattenedJson, context: &PushConditionRoomCtx) -> bool {
484        if !self.enabled {
485            return false;
486        }
487
488        #[cfg(feature = "unstable-msc3932")]
489        {
490            // These 3 rules always apply.
491            #[allow(deprecated)]
492            if self.rule_id != PredefinedOverrideRuleId::Master.as_ref()
493                && self.rule_id != PredefinedOverrideRuleId::RoomNotif.as_ref()
494                && self.rule_id != PredefinedOverrideRuleId::ContainsDisplayName.as_ref()
495            {
496                // Push rules which don't specify a `room_version_supports` condition are assumed
497                // to not support extensible events and are therefore expected to be treated as
498                // disabled when a room version does support extensible events.
499                let room_supports_ext_ev =
500                    context.supported_features.contains(&RoomVersionFeature::ExtensibleEvents);
501                let rule_has_room_version_supports = self.conditions.iter().any(|condition| {
502                    matches!(condition, PushCondition::RoomVersionSupports { .. })
503                });
504
505                if room_supports_ext_ev && !rule_has_room_version_supports {
506                    return false;
507                }
508            }
509        }
510
511        // The old mention rules are disabled when an m.mentions field is present.
512        #[allow(deprecated)]
513        if (self.rule_id == PredefinedOverrideRuleId::RoomNotif.as_ref()
514            || self.rule_id == PredefinedOverrideRuleId::ContainsDisplayName.as_ref())
515            && event.contains_mentions()
516        {
517            return false;
518        }
519
520        self.conditions.iter().all(|cond| cond.applies(event, context))
521    }
522}
523
524/// Initial set of fields of `ConditionalPushRule`.
525///
526/// This struct will not be updated even if additional fields are added to `ConditionalPushRule` in
527/// a new (non-breaking) release of the Matrix specification.
528#[derive(Debug)]
529#[allow(clippy::exhaustive_structs)]
530pub struct ConditionalPushRuleInit {
531    /// Actions to determine if and how a notification is delivered for events matching this rule.
532    pub actions: Vec<Action>,
533
534    /// Whether this is a default rule, or has been set explicitly.
535    pub default: bool,
536
537    /// Whether the push rule is enabled or not.
538    pub enabled: bool,
539
540    /// The ID of this rule.
541    pub rule_id: String,
542
543    /// The conditions that must hold true for an event in order for a rule to be applied to an
544    /// event.
545    ///
546    /// A rule with no conditions always matches.
547    pub conditions: Vec<PushCondition>,
548}
549
550impl From<ConditionalPushRuleInit> for ConditionalPushRule {
551    fn from(init: ConditionalPushRuleInit) -> Self {
552        let ConditionalPushRuleInit { actions, default, enabled, rule_id, conditions } = init;
553        Self { actions, default, enabled, rule_id, conditions }
554    }
555}
556
557// The following trait are needed to be able to make
558// an IndexSet of the type
559
560impl Hash for ConditionalPushRule {
561    fn hash<H: Hasher>(&self, state: &mut H) {
562        self.rule_id.hash(state);
563    }
564}
565
566impl PartialEq for ConditionalPushRule {
567    fn eq(&self, other: &Self) -> bool {
568        self.rule_id == other.rule_id
569    }
570}
571
572impl Eq for ConditionalPushRule {}
573
574impl Equivalent<ConditionalPushRule> for str {
575    fn equivalent(&self, key: &ConditionalPushRule) -> bool {
576        self == key.rule_id
577    }
578}
579
580/// Like `SimplePushRule`, but with an additional `pattern` field.
581///
582/// Only applicable to content rules.
583///
584/// To create an instance of this type, first create a `PatternedPushRuleInit` and convert it via
585/// `PatternedPushRule::from` / `.into()`.
586#[derive(Clone, Debug, Deserialize, Serialize)]
587#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
588pub struct PatternedPushRule {
589    /// Actions to determine if and how a notification is delivered for events matching this rule.
590    pub actions: Vec<Action>,
591
592    /// Whether this is a default rule, or has been set explicitly.
593    pub default: bool,
594
595    /// Whether the push rule is enabled or not.
596    pub enabled: bool,
597
598    /// The ID of this rule.
599    pub rule_id: String,
600
601    /// The glob-style pattern to match against.
602    pub pattern: String,
603}
604
605impl PatternedPushRule {
606    /// Check if the push rule applies to the event.
607    ///
608    /// # Arguments
609    ///
610    /// * `event` - The flattened JSON representation of a room message event.
611    /// * `context` - The context of the room at the time of the event.
612    pub fn applies_to(
613        &self,
614        key: &str,
615        event: &FlattenedJson,
616        context: &PushConditionRoomCtx,
617    ) -> bool {
618        // The old mention rules are disabled when an m.mentions field is present.
619        #[allow(deprecated)]
620        if self.rule_id == PredefinedContentRuleId::ContainsUserName.as_ref()
621            && event.contains_mentions()
622        {
623            return false;
624        }
625
626        if event.get_str("sender").is_some_and(|sender| sender == context.user_id) {
627            return false;
628        }
629
630        self.enabled && condition::check_event_match(event, key, &self.pattern, context)
631    }
632}
633
634/// Initial set of fields of `PatternedPushRule`.
635///
636/// This struct will not be updated even if additional fields are added to `PatternedPushRule` in a
637/// new (non-breaking) release of the Matrix specification.
638#[derive(Debug)]
639#[allow(clippy::exhaustive_structs)]
640pub struct PatternedPushRuleInit {
641    /// Actions to determine if and how a notification is delivered for events matching this rule.
642    pub actions: Vec<Action>,
643
644    /// Whether this is a default rule, or has been set explicitly.
645    pub default: bool,
646
647    /// Whether the push rule is enabled or not.
648    pub enabled: bool,
649
650    /// The ID of this rule.
651    pub rule_id: String,
652
653    /// The glob-style pattern to match against.
654    pub pattern: String,
655}
656
657impl From<PatternedPushRuleInit> for PatternedPushRule {
658    fn from(init: PatternedPushRuleInit) -> Self {
659        let PatternedPushRuleInit { actions, default, enabled, rule_id, pattern } = init;
660        Self { actions, default, enabled, rule_id, pattern }
661    }
662}
663
664// The following trait are needed to be able to make
665// an IndexSet of the type
666
667impl Hash for PatternedPushRule {
668    fn hash<H: Hasher>(&self, state: &mut H) {
669        self.rule_id.hash(state);
670    }
671}
672
673impl PartialEq for PatternedPushRule {
674    fn eq(&self, other: &Self) -> bool {
675        self.rule_id == other.rule_id
676    }
677}
678
679impl Eq for PatternedPushRule {}
680
681impl Equivalent<PatternedPushRule> for str {
682    fn equivalent(&self, key: &PatternedPushRule) -> bool {
683        self == key.rule_id
684    }
685}
686
687/// Information for a pusher using the Push Gateway API.
688#[derive(Clone, Debug, Serialize, Deserialize)]
689#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
690pub struct HttpPusherData {
691    /// The URL to use to send notifications to.
692    ///
693    /// Required if the pusher's kind is http.
694    pub url: String,
695
696    /// The format to use when sending notifications to the Push Gateway.
697    #[serde(skip_serializing_if = "Option::is_none")]
698    pub format: Option<PushFormat>,
699
700    /// Custom data for the pusher.
701    #[serde(flatten, default, skip_serializing_if = "JsonObject::is_empty")]
702    pub data: JsonObject,
703}
704
705impl HttpPusherData {
706    /// Creates a new `HttpPusherData` with the given URL.
707    pub fn new(url: String) -> Self {
708        Self { url, format: None, data: JsonObject::default() }
709    }
710}
711
712/// A special format that the homeserver should use when sending notifications to a Push Gateway.
713/// Currently, only `event_id_only` is supported, see the [Push Gateway API][spec].
714///
715/// [spec]: https://spec.matrix.org/latest/push-gateway-api/#homeserver-behaviour
716#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/doc/string_enum.md"))]
717#[derive(Clone, PartialEq, Eq, StringEnum)]
718#[ruma_enum(rename_all = "snake_case")]
719#[non_exhaustive]
720pub enum PushFormat {
721    /// Require the homeserver to only send a reduced set of fields in the push.
722    EventIdOnly,
723
724    #[doc(hidden)]
725    _Custom(PrivOwnedStr),
726}
727
728/// The kinds of push rules that are available.
729#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/doc/string_enum.md"))]
730#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, StringEnum)]
731#[ruma_enum(rename_all = "snake_case")]
732#[non_exhaustive]
733pub enum RuleKind {
734    /// User-configured rules that override all other kinds.
735    Override,
736
737    /// Lowest priority user-defined rules.
738    Underride,
739
740    /// Sender-specific rules.
741    Sender,
742
743    /// Room-specific rules.
744    Room,
745
746    /// Content-specific rules.
747    Content,
748
749    #[doc(hidden)]
750    _Custom(PrivOwnedStr),
751}
752
753/// A push rule to update or create.
754#[derive(Clone, Debug)]
755#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
756pub enum NewPushRule {
757    /// Rules that override all other kinds.
758    Override(NewConditionalPushRule),
759
760    /// Content-specific rules.
761    Content(NewPatternedPushRule),
762
763    /// Room-specific rules.
764    Room(NewSimplePushRule<OwnedRoomId>),
765
766    /// Sender-specific rules.
767    Sender(NewSimplePushRule<OwnedUserId>),
768
769    /// Lowest priority rules.
770    Underride(NewConditionalPushRule),
771}
772
773impl NewPushRule {
774    /// The kind of this `NewPushRule`.
775    pub fn kind(&self) -> RuleKind {
776        match self {
777            NewPushRule::Override(_) => RuleKind::Override,
778            NewPushRule::Content(_) => RuleKind::Content,
779            NewPushRule::Room(_) => RuleKind::Room,
780            NewPushRule::Sender(_) => RuleKind::Sender,
781            NewPushRule::Underride(_) => RuleKind::Underride,
782        }
783    }
784
785    /// The ID of this `NewPushRule`.
786    pub fn rule_id(&self) -> &str {
787        match self {
788            NewPushRule::Override(r) => &r.rule_id,
789            NewPushRule::Content(r) => &r.rule_id,
790            NewPushRule::Room(r) => r.rule_id.as_ref(),
791            NewPushRule::Sender(r) => r.rule_id.as_ref(),
792            NewPushRule::Underride(r) => &r.rule_id,
793        }
794    }
795}
796
797/// A simple push rule to update or create.
798#[derive(Clone, Debug, Deserialize, Serialize)]
799#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
800pub struct NewSimplePushRule<T> {
801    /// The ID of this rule.
802    ///
803    /// This is generally the Matrix ID of the entity that it applies to.
804    pub rule_id: T,
805
806    /// Actions to determine if and how a notification is delivered for events matching this
807    /// rule.
808    pub actions: Vec<Action>,
809}
810
811impl<T> NewSimplePushRule<T> {
812    /// Creates a `NewSimplePushRule` with the given ID and actions.
813    pub fn new(rule_id: T, actions: Vec<Action>) -> Self {
814        Self { rule_id, actions }
815    }
816}
817
818impl<T> From<NewSimplePushRule<T>> for SimplePushRule<T> {
819    fn from(new_rule: NewSimplePushRule<T>) -> Self {
820        let NewSimplePushRule { rule_id, actions } = new_rule;
821        Self { actions, default: false, enabled: true, rule_id }
822    }
823}
824
825/// A patterned push rule to update or create.
826#[derive(Clone, Debug, Deserialize, Serialize)]
827#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
828pub struct NewPatternedPushRule {
829    /// The ID of this rule.
830    pub rule_id: String,
831
832    /// The glob-style pattern to match against.
833    pub pattern: String,
834
835    /// Actions to determine if and how a notification is delivered for events matching this
836    /// rule.
837    pub actions: Vec<Action>,
838}
839
840impl NewPatternedPushRule {
841    /// Creates a `NewPatternedPushRule` with the given ID, pattern and actions.
842    pub fn new(rule_id: String, pattern: String, actions: Vec<Action>) -> Self {
843        Self { rule_id, pattern, actions }
844    }
845}
846
847impl From<NewPatternedPushRule> for PatternedPushRule {
848    fn from(new_rule: NewPatternedPushRule) -> Self {
849        let NewPatternedPushRule { rule_id, pattern, actions } = new_rule;
850        Self { actions, default: false, enabled: true, rule_id, pattern }
851    }
852}
853
854/// A conditional push rule to update or create.
855#[derive(Clone, Debug, Deserialize, Serialize)]
856#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
857pub struct NewConditionalPushRule {
858    /// The ID of this rule.
859    pub rule_id: String,
860
861    /// The conditions that must hold true for an event in order for a rule to be applied to an
862    /// event.
863    ///
864    /// A rule with no conditions always matches.
865    #[serde(default)]
866    pub conditions: Vec<PushCondition>,
867
868    /// Actions to determine if and how a notification is delivered for events matching this
869    /// rule.
870    pub actions: Vec<Action>,
871}
872
873impl NewConditionalPushRule {
874    /// Creates a `NewConditionalPushRule` with the given ID, conditions and actions.
875    pub fn new(rule_id: String, conditions: Vec<PushCondition>, actions: Vec<Action>) -> Self {
876        Self { rule_id, conditions, actions }
877    }
878}
879
880impl From<NewConditionalPushRule> for ConditionalPushRule {
881    fn from(new_rule: NewConditionalPushRule) -> Self {
882        let NewConditionalPushRule { rule_id, conditions, actions } = new_rule;
883        Self { actions, default: false, enabled: true, rule_id, conditions }
884    }
885}
886
887/// The error type returned when trying to insert a user-defined push rule into a `Ruleset`.
888#[derive(Debug, Error)]
889#[non_exhaustive]
890pub enum InsertPushRuleError {
891    /// The rule ID starts with a dot (`.`), which is reserved for server-default rules.
892    #[error("rule IDs starting with a dot are reserved for server-default rules")]
893    ServerDefaultRuleId,
894
895    /// The rule ID contains an invalid character.
896    #[error("invalid rule ID")]
897    InvalidRuleId,
898
899    /// The rule is being placed relative to a server-default rule, which is forbidden.
900    #[error("can't place rule relative to server-default rule")]
901    RelativeToServerDefaultRule,
902
903    /// The `before` or `after` rule could not be found.
904    #[error("The before or after rule could not be found")]
905    UnknownRuleId,
906
907    /// `before` has a higher priority than `after`.
908    #[error("before has a higher priority than after")]
909    BeforeHigherThanAfter,
910}
911
912/// The error type returned when trying modify a push rule that could not be found in a `Ruleset`.
913#[derive(Debug, Error)]
914#[non_exhaustive]
915#[error("The rule could not be found")]
916pub struct RuleNotFoundError;
917
918/// Insert the rule in the given indexset and move it to the given position.
919pub fn insert_and_move_rule<T>(
920    set: &mut IndexSet<T>,
921    rule: T,
922    default_position: usize,
923    after: Option<&str>,
924    before: Option<&str>,
925) -> Result<(), InsertPushRuleError>
926where
927    T: Hash + Eq,
928    str: Equivalent<T>,
929{
930    let (from, replaced) = set.replace_full(rule);
931
932    let mut to = default_position;
933
934    if let Some(rule_id) = after {
935        let idx = set.get_index_of(rule_id).ok_or(InsertPushRuleError::UnknownRuleId)?;
936        to = idx + 1;
937    }
938    if let Some(rule_id) = before {
939        let idx = set.get_index_of(rule_id).ok_or(InsertPushRuleError::UnknownRuleId)?;
940
941        if idx < to {
942            return Err(InsertPushRuleError::BeforeHigherThanAfter);
943        }
944
945        to = idx;
946    }
947
948    // Only move the item if it's new or if it was positioned.
949    if replaced.is_none() || after.is_some() || before.is_some() {
950        set.move_index(from, to);
951    }
952
953    Ok(())
954}
955
956/// The error type returned when trying to remove a user-defined push rule from a `Ruleset`.
957#[derive(Debug, Error)]
958#[non_exhaustive]
959pub enum RemovePushRuleError {
960    /// The rule is a server-default rules and they can't be removed.
961    #[error("server-default rules cannot be removed")]
962    ServerDefault,
963
964    /// The rule was not found.
965    #[error("rule not found")]
966    NotFound,
967}
968
969#[cfg(test)]
970mod tests {
971    use std::collections::BTreeMap;
972
973    use assert_matches2::assert_matches;
974    use js_int::{int, uint};
975    use serde_json::{
976        from_value as from_json_value, json, to_value as to_json_value,
977        value::RawValue as RawJsonValue, Value as JsonValue,
978    };
979
980    use super::{
981        action::{Action, Tweak},
982        condition::{
983            PushCondition, PushConditionPowerLevelsCtx, PushConditionRoomCtx, RoomMemberCountIs,
984        },
985        AnyPushRule, ConditionalPushRule, PatternedPushRule, Ruleset, SimplePushRule,
986    };
987    use crate::{
988        owned_room_id, owned_user_id,
989        power_levels::NotificationPowerLevels,
990        push::{PredefinedContentRuleId, PredefinedOverrideRuleId},
991        room_version_rules::{AuthorizationRules, RoomPowerLevelsRules},
992        serde::Raw,
993        user_id,
994    };
995
996    fn example_ruleset() -> Ruleset {
997        let mut set = Ruleset::new();
998
999        set.override_.insert(ConditionalPushRule {
1000            conditions: vec![PushCondition::EventMatch {
1001                key: "type".into(),
1002                pattern: "m.call.invite".into(),
1003            }],
1004            actions: vec![Action::Notify, Action::SetTweak(Tweak::Highlight(true))],
1005            rule_id: ".m.rule.call".into(),
1006            enabled: true,
1007            default: true,
1008        });
1009
1010        set
1011    }
1012
1013    fn power_levels() -> PushConditionPowerLevelsCtx {
1014        PushConditionPowerLevelsCtx {
1015            users: BTreeMap::new(),
1016            users_default: int!(50),
1017            notifications: NotificationPowerLevels { room: int!(50) },
1018            rules: RoomPowerLevelsRules::new(&AuthorizationRules::V1, None),
1019        }
1020    }
1021
1022    #[test]
1023    fn iter() {
1024        let mut set = example_ruleset();
1025
1026        let added = set.override_.insert(ConditionalPushRule {
1027            conditions: vec![PushCondition::EventMatch {
1028                key: "room_id".into(),
1029                pattern: "!roomid:matrix.org".into(),
1030            }],
1031            actions: vec![],
1032            rule_id: "!roomid:matrix.org".into(),
1033            enabled: true,
1034            default: false,
1035        });
1036        assert!(added);
1037
1038        let added = set.override_.insert(ConditionalPushRule {
1039            conditions: vec![],
1040            actions: vec![],
1041            rule_id: ".m.rule.suppress_notices".into(),
1042            enabled: false,
1043            default: true,
1044        });
1045        assert!(added);
1046
1047        let mut iter = set.into_iter();
1048
1049        let rule_opt = iter.next();
1050        assert!(rule_opt.is_some());
1051        assert_matches!(
1052            rule_opt.unwrap(),
1053            AnyPushRule::Override(ConditionalPushRule { rule_id, .. })
1054        );
1055        assert_eq!(rule_id, ".m.rule.call");
1056
1057        let rule_opt = iter.next();
1058        assert!(rule_opt.is_some());
1059        assert_matches!(
1060            rule_opt.unwrap(),
1061            AnyPushRule::Override(ConditionalPushRule { rule_id, .. })
1062        );
1063        assert_eq!(rule_id, "!roomid:matrix.org");
1064
1065        let rule_opt = iter.next();
1066        assert!(rule_opt.is_some());
1067        assert_matches!(
1068            rule_opt.unwrap(),
1069            AnyPushRule::Override(ConditionalPushRule { rule_id, .. })
1070        );
1071        assert_eq!(rule_id, ".m.rule.suppress_notices");
1072
1073        assert_matches!(iter.next(), None);
1074    }
1075
1076    #[test]
1077    fn serialize_conditional_push_rule() {
1078        let rule = ConditionalPushRule {
1079            actions: vec![Action::Notify, Action::SetTweak(Tweak::Highlight(true))],
1080            default: true,
1081            enabled: true,
1082            rule_id: ".m.rule.call".into(),
1083            conditions: vec![
1084                PushCondition::EventMatch { key: "type".into(), pattern: "m.call.invite".into() },
1085                PushCondition::ContainsDisplayName,
1086                PushCondition::RoomMemberCount { is: RoomMemberCountIs::gt(uint!(2)) },
1087                PushCondition::SenderNotificationPermission { key: "room".into() },
1088            ],
1089        };
1090
1091        let rule_value: JsonValue = to_json_value(rule).unwrap();
1092        assert_eq!(
1093            rule_value,
1094            json!({
1095                "conditions": [
1096                    {
1097                        "kind": "event_match",
1098                        "key": "type",
1099                        "pattern": "m.call.invite"
1100                    },
1101                    {
1102                        "kind": "contains_display_name"
1103                    },
1104                    {
1105                        "kind": "room_member_count",
1106                        "is": ">2"
1107                    },
1108                    {
1109                        "kind": "sender_notification_permission",
1110                        "key": "room"
1111                    }
1112                ],
1113                "actions": [
1114                    "notify",
1115                    {
1116                        "set_tweak": "highlight"
1117                    }
1118                ],
1119                "rule_id": ".m.rule.call",
1120                "default": true,
1121                "enabled": true
1122            })
1123        );
1124    }
1125
1126    #[test]
1127    fn serialize_simple_push_rule() {
1128        let rule = SimplePushRule {
1129            actions: vec![Action::Notify],
1130            default: false,
1131            enabled: false,
1132            rule_id: owned_room_id!("!roomid:server.name"),
1133        };
1134
1135        let rule_value: JsonValue = to_json_value(rule).unwrap();
1136        assert_eq!(
1137            rule_value,
1138            json!({
1139                "actions": [
1140                    "notify"
1141                ],
1142                "rule_id": "!roomid:server.name",
1143                "default": false,
1144                "enabled": false
1145            })
1146        );
1147    }
1148
1149    #[test]
1150    fn serialize_patterned_push_rule() {
1151        let rule = PatternedPushRule {
1152            actions: vec![
1153                Action::Notify,
1154                Action::SetTweak(Tweak::Sound("default".into())),
1155                Action::SetTweak(Tweak::Custom {
1156                    name: "dance".into(),
1157                    value: RawJsonValue::from_string("true".into()).unwrap(),
1158                }),
1159            ],
1160            default: true,
1161            enabled: true,
1162            pattern: "user_id".into(),
1163            rule_id: ".m.rule.contains_user_name".into(),
1164        };
1165
1166        let rule_value: JsonValue = to_json_value(rule).unwrap();
1167        assert_eq!(
1168            rule_value,
1169            json!({
1170                "actions": [
1171                    "notify",
1172                    {
1173                        "set_tweak": "sound",
1174                        "value": "default"
1175                    },
1176                    {
1177                        "set_tweak": "dance",
1178                        "value": true
1179                    }
1180                ],
1181                "pattern": "user_id",
1182                "rule_id": ".m.rule.contains_user_name",
1183                "default": true,
1184                "enabled": true
1185            })
1186        );
1187    }
1188
1189    #[test]
1190    fn serialize_ruleset() {
1191        let mut set = example_ruleset();
1192
1193        set.override_.insert(ConditionalPushRule {
1194            conditions: vec![
1195                PushCondition::RoomMemberCount { is: RoomMemberCountIs::from(uint!(2)) },
1196                PushCondition::EventMatch { key: "type".into(), pattern: "m.room.message".into() },
1197            ],
1198            actions: vec![
1199                Action::Notify,
1200                Action::SetTweak(Tweak::Sound("default".into())),
1201                Action::SetTweak(Tweak::Highlight(false)),
1202            ],
1203            rule_id: ".m.rule.room_one_to_one".into(),
1204            enabled: true,
1205            default: true,
1206        });
1207        set.content.insert(PatternedPushRule {
1208            actions: vec![
1209                Action::Notify,
1210                Action::SetTweak(Tweak::Sound("default".into())),
1211                Action::SetTweak(Tweak::Highlight(true)),
1212            ],
1213            rule_id: ".m.rule.contains_user_name".into(),
1214            pattern: "user_id".into(),
1215            enabled: true,
1216            default: true,
1217        });
1218
1219        let set_value: JsonValue = to_json_value(set).unwrap();
1220        assert_eq!(
1221            set_value,
1222            json!({
1223                "override": [
1224                    {
1225                        "actions": [
1226                            "notify",
1227                            {
1228                                "set_tweak": "highlight",
1229                            },
1230                        ],
1231                        "conditions": [
1232                            {
1233                                "kind": "event_match",
1234                                "key": "type",
1235                                "pattern": "m.call.invite"
1236                            },
1237                        ],
1238                        "rule_id": ".m.rule.call",
1239                        "default": true,
1240                        "enabled": true,
1241                    },
1242                    {
1243                        "conditions": [
1244                            {
1245                                "kind": "room_member_count",
1246                                "is": "2"
1247                            },
1248                            {
1249                                "kind": "event_match",
1250                                "key": "type",
1251                                "pattern": "m.room.message"
1252                            }
1253                        ],
1254                        "actions": [
1255                            "notify",
1256                            {
1257                                "set_tweak": "sound",
1258                                "value": "default"
1259                            },
1260                            {
1261                                "set_tweak": "highlight",
1262                                "value": false
1263                            }
1264                        ],
1265                        "rule_id": ".m.rule.room_one_to_one",
1266                        "default": true,
1267                        "enabled": true
1268                    },
1269                ],
1270                "content": [
1271                    {
1272                        "actions": [
1273                            "notify",
1274                            {
1275                                "set_tweak": "sound",
1276                                "value": "default"
1277                            },
1278                            {
1279                                "set_tweak": "highlight"
1280                            }
1281                        ],
1282                        "pattern": "user_id",
1283                        "rule_id": ".m.rule.contains_user_name",
1284                        "default": true,
1285                        "enabled": true
1286                    }
1287                ],
1288            })
1289        );
1290    }
1291
1292    #[test]
1293    fn deserialize_patterned_push_rule() {
1294        let rule = from_json_value::<PatternedPushRule>(json!({
1295            "actions": [
1296                "notify",
1297                {
1298                    "set_tweak": "sound",
1299                    "value": "default"
1300                },
1301                {
1302                    "set_tweak": "highlight",
1303                    "value": true
1304                }
1305            ],
1306            "pattern": "user_id",
1307            "rule_id": ".m.rule.contains_user_name",
1308            "default": true,
1309            "enabled": true
1310        }))
1311        .unwrap();
1312        assert!(rule.default);
1313        assert!(rule.enabled);
1314        assert_eq!(rule.pattern, "user_id");
1315        assert_eq!(rule.rule_id, ".m.rule.contains_user_name");
1316
1317        let mut iter = rule.actions.iter();
1318        assert_matches!(iter.next(), Some(Action::Notify));
1319        assert_matches!(iter.next(), Some(Action::SetTweak(Tweak::Sound(sound))));
1320        assert_eq!(sound, "default");
1321        assert_matches!(iter.next(), Some(Action::SetTweak(Tweak::Highlight(true))));
1322        assert_matches!(iter.next(), None);
1323    }
1324
1325    #[test]
1326    fn deserialize_ruleset() {
1327        let set: Ruleset = from_json_value(json!({
1328            "override": [
1329                {
1330                    "actions": [],
1331                    "conditions": [],
1332                    "rule_id": "!roomid:server.name",
1333                    "default": false,
1334                    "enabled": true
1335                },
1336                {
1337                    "actions": [],
1338                    "conditions": [],
1339                    "rule_id": ".m.rule.call",
1340                    "default": true,
1341                    "enabled": true
1342                },
1343            ],
1344            "underride": [
1345                {
1346                    "actions": [],
1347                    "conditions": [],
1348                    "rule_id": ".m.rule.room_one_to_one",
1349                    "default": true,
1350                    "enabled": true
1351                },
1352            ],
1353            "room": [
1354                {
1355                    "actions": [],
1356                    "rule_id": "!roomid:server.name",
1357                    "default": false,
1358                    "enabled": false
1359                }
1360            ],
1361            "sender": [],
1362            "content": [
1363                {
1364                    "actions": [],
1365                    "pattern": "user_id",
1366                    "rule_id": ".m.rule.contains_user_name",
1367                    "default": true,
1368                    "enabled": true
1369                },
1370                {
1371                    "actions": [],
1372                    "pattern": "ruma",
1373                    "rule_id": "ruma",
1374                    "default": false,
1375                    "enabled": true
1376                }
1377            ]
1378        }))
1379        .unwrap();
1380
1381        let mut iter = set.into_iter();
1382
1383        let rule_opt = iter.next();
1384        assert!(rule_opt.is_some());
1385        assert_matches!(
1386            rule_opt.unwrap(),
1387            AnyPushRule::Override(ConditionalPushRule { rule_id, .. })
1388        );
1389        assert_eq!(rule_id, "!roomid:server.name");
1390
1391        let rule_opt = iter.next();
1392        assert!(rule_opt.is_some());
1393        assert_matches!(
1394            rule_opt.unwrap(),
1395            AnyPushRule::Override(ConditionalPushRule { rule_id, .. })
1396        );
1397        assert_eq!(rule_id, ".m.rule.call");
1398
1399        let rule_opt = iter.next();
1400        assert!(rule_opt.is_some());
1401        assert_matches!(rule_opt.unwrap(), AnyPushRule::Content(PatternedPushRule { rule_id, .. }));
1402        assert_eq!(rule_id, ".m.rule.contains_user_name");
1403
1404        let rule_opt = iter.next();
1405        assert!(rule_opt.is_some());
1406        assert_matches!(rule_opt.unwrap(), AnyPushRule::Content(PatternedPushRule { rule_id, .. }));
1407        assert_eq!(rule_id, "ruma");
1408
1409        let rule_opt = iter.next();
1410        assert!(rule_opt.is_some());
1411        assert_matches!(rule_opt.unwrap(), AnyPushRule::Room(SimplePushRule { rule_id, .. }));
1412        assert_eq!(rule_id, "!roomid:server.name");
1413
1414        let rule_opt = iter.next();
1415        assert!(rule_opt.is_some());
1416        assert_matches!(
1417            rule_opt.unwrap(),
1418            AnyPushRule::Underride(ConditionalPushRule { rule_id, .. })
1419        );
1420        assert_eq!(rule_id, ".m.rule.room_one_to_one");
1421
1422        assert_matches!(iter.next(), None);
1423    }
1424
1425    #[test]
1426    fn default_ruleset_applies() {
1427        let set = Ruleset::server_default(user_id!("@jolly_jumper:server.name"));
1428
1429        let context_one_to_one = &PushConditionRoomCtx {
1430            room_id: owned_room_id!("!dm:server.name"),
1431            member_count: uint!(2),
1432            user_id: owned_user_id!("@jj:server.name"),
1433            user_display_name: "Jolly Jumper".into(),
1434            power_levels: Some(power_levels()),
1435            #[cfg(feature = "unstable-msc3931")]
1436            supported_features: Default::default(),
1437        };
1438
1439        let context_public_room = &PushConditionRoomCtx {
1440            room_id: owned_room_id!("!far_west:server.name"),
1441            member_count: uint!(100),
1442            user_id: owned_user_id!("@jj:server.name"),
1443            user_display_name: "Jolly Jumper".into(),
1444            power_levels: Some(power_levels()),
1445            #[cfg(feature = "unstable-msc3931")]
1446            supported_features: Default::default(),
1447        };
1448
1449        let message = serde_json::from_str::<Raw<JsonValue>>(
1450            r#"{
1451                "type": "m.room.message"
1452            }"#,
1453        )
1454        .unwrap();
1455
1456        assert_matches!(
1457            set.get_actions(&message, context_one_to_one),
1458            [
1459                Action::Notify,
1460                Action::SetTweak(Tweak::Sound(_)),
1461                Action::SetTweak(Tweak::Highlight(false))
1462            ]
1463        );
1464        assert_matches!(
1465            set.get_actions(&message, context_public_room),
1466            [Action::Notify, Action::SetTweak(Tweak::Highlight(false))]
1467        );
1468
1469        let user_name = serde_json::from_str::<Raw<JsonValue>>(
1470            r#"{
1471                "type": "m.room.message",
1472                "content": {
1473                    "body": "Hi jolly_jumper!"
1474                }
1475            }"#,
1476        )
1477        .unwrap();
1478
1479        assert_matches!(
1480            set.get_actions(&user_name, context_one_to_one),
1481            [
1482                Action::Notify,
1483                Action::SetTweak(Tweak::Sound(_)),
1484                Action::SetTweak(Tweak::Highlight(true)),
1485            ]
1486        );
1487        assert_matches!(
1488            set.get_actions(&user_name, context_public_room),
1489            [
1490                Action::Notify,
1491                Action::SetTweak(Tweak::Sound(_)),
1492                Action::SetTweak(Tweak::Highlight(true)),
1493            ]
1494        );
1495
1496        let notice = serde_json::from_str::<Raw<JsonValue>>(
1497            r#"{
1498                "type": "m.room.message",
1499                "content": {
1500                    "msgtype": "m.notice"
1501                }
1502            }"#,
1503        )
1504        .unwrap();
1505        assert_matches!(set.get_actions(&notice, context_one_to_one), []);
1506
1507        let at_room = serde_json::from_str::<Raw<JsonValue>>(
1508            r#"{
1509                "type": "m.room.message",
1510                "sender": "@rantanplan:server.name",
1511                "content": {
1512                    "body": "@room Attention please!",
1513                    "msgtype": "m.text"
1514                }
1515            }"#,
1516        )
1517        .unwrap();
1518
1519        assert_matches!(
1520            set.get_actions(&at_room, context_public_room),
1521            [Action::Notify, Action::SetTweak(Tweak::Highlight(true)),]
1522        );
1523
1524        let empty = serde_json::from_str::<Raw<JsonValue>>(r#"{}"#).unwrap();
1525        assert_matches!(set.get_actions(&empty, context_one_to_one), []);
1526    }
1527
1528    #[test]
1529    fn custom_ruleset_applies() {
1530        let context_one_to_one = &PushConditionRoomCtx {
1531            room_id: owned_room_id!("!dm:server.name"),
1532            member_count: uint!(2),
1533            user_id: owned_user_id!("@jj:server.name"),
1534            user_display_name: "Jolly Jumper".into(),
1535            power_levels: Some(power_levels()),
1536            #[cfg(feature = "unstable-msc3931")]
1537            supported_features: Default::default(),
1538        };
1539
1540        let message = serde_json::from_str::<Raw<JsonValue>>(
1541            r#"{
1542                "sender": "@rantanplan:server.name",
1543                "type": "m.room.message",
1544                "content": {
1545                    "msgtype": "m.text",
1546                    "body": "Great joke!"
1547                }
1548            }"#,
1549        )
1550        .unwrap();
1551
1552        let mut set = Ruleset::new();
1553        let disabled = ConditionalPushRule {
1554            actions: vec![Action::Notify],
1555            default: false,
1556            enabled: false,
1557            rule_id: "disabled".into(),
1558            conditions: vec![PushCondition::RoomMemberCount {
1559                is: RoomMemberCountIs::from(uint!(2)),
1560            }],
1561        };
1562        set.underride.insert(disabled);
1563
1564        let test_set = set.clone();
1565        assert_matches!(test_set.get_actions(&message, context_one_to_one), []);
1566
1567        let no_conditions = ConditionalPushRule {
1568            actions: vec![Action::SetTweak(Tweak::Highlight(true))],
1569            default: false,
1570            enabled: true,
1571            rule_id: "no.conditions".into(),
1572            conditions: vec![],
1573        };
1574        set.underride.insert(no_conditions);
1575
1576        let test_set = set.clone();
1577        assert_matches!(
1578            test_set.get_actions(&message, context_one_to_one),
1579            [Action::SetTweak(Tweak::Highlight(true))]
1580        );
1581
1582        let sender = SimplePushRule {
1583            actions: vec![Action::Notify],
1584            default: false,
1585            enabled: true,
1586            rule_id: owned_user_id!("@rantanplan:server.name"),
1587        };
1588        set.sender.insert(sender);
1589
1590        let test_set = set.clone();
1591        assert_matches!(test_set.get_actions(&message, context_one_to_one), [Action::Notify]);
1592
1593        let room = SimplePushRule {
1594            actions: vec![Action::SetTweak(Tweak::Highlight(true))],
1595            default: false,
1596            enabled: true,
1597            rule_id: owned_room_id!("!dm:server.name"),
1598        };
1599        set.room.insert(room);
1600
1601        let test_set = set.clone();
1602        assert_matches!(
1603            test_set.get_actions(&message, context_one_to_one),
1604            [Action::SetTweak(Tweak::Highlight(true))]
1605        );
1606
1607        let content = PatternedPushRule {
1608            actions: vec![Action::SetTweak(Tweak::Sound("content".into()))],
1609            default: false,
1610            enabled: true,
1611            rule_id: "content".into(),
1612            pattern: "joke".into(),
1613        };
1614        set.content.insert(content);
1615
1616        let test_set = set.clone();
1617        assert_matches!(
1618            test_set.get_actions(&message, context_one_to_one),
1619            [Action::SetTweak(Tweak::Sound(sound))]
1620        );
1621        assert_eq!(sound, "content");
1622
1623        let three_conditions = ConditionalPushRule {
1624            actions: vec![Action::SetTweak(Tweak::Sound("three".into()))],
1625            default: false,
1626            enabled: true,
1627            rule_id: "three.conditions".into(),
1628            conditions: vec![
1629                PushCondition::RoomMemberCount { is: RoomMemberCountIs::from(uint!(2)) },
1630                PushCondition::ContainsDisplayName,
1631                PushCondition::EventMatch {
1632                    key: "room_id".into(),
1633                    pattern: "!dm:server.name".into(),
1634                },
1635            ],
1636        };
1637        set.override_.insert(three_conditions);
1638
1639        assert_matches!(
1640            set.get_actions(&message, context_one_to_one),
1641            [Action::SetTweak(Tweak::Sound(sound))]
1642        );
1643        assert_eq!(sound, "content");
1644
1645        let new_message = serde_json::from_str::<Raw<JsonValue>>(
1646            r#"{
1647                "sender": "@rantanplan:server.name",
1648                "type": "m.room.message",
1649                "content": {
1650                    "msgtype": "m.text",
1651                    "body": "Tell me another one, Jolly Jumper!"
1652                }
1653            }"#,
1654        )
1655        .unwrap();
1656
1657        assert_matches!(
1658            set.get_actions(&new_message, context_one_to_one),
1659            [Action::SetTweak(Tweak::Sound(sound))]
1660        );
1661        assert_eq!(sound, "three");
1662    }
1663
1664    #[test]
1665    #[allow(deprecated)]
1666    fn old_mentions_apply() {
1667        let set = Ruleset::server_default(user_id!("@jolly_jumper:server.name"));
1668
1669        let context = &PushConditionRoomCtx {
1670            room_id: owned_room_id!("!far_west:server.name"),
1671            member_count: uint!(100),
1672            user_id: owned_user_id!("@jj:server.name"),
1673            user_display_name: "Jolly Jumper".into(),
1674            power_levels: Some(power_levels()),
1675            #[cfg(feature = "unstable-msc3931")]
1676            supported_features: Default::default(),
1677        };
1678
1679        let message = serde_json::from_str::<Raw<JsonValue>>(
1680            r#"{
1681                "content": {
1682                    "body": "jolly_jumper"
1683                },
1684                "type": "m.room.message"
1685            }"#,
1686        )
1687        .unwrap();
1688
1689        assert_eq!(
1690            set.get_match(&message, context).unwrap().rule_id(),
1691            PredefinedContentRuleId::ContainsUserName.as_ref()
1692        );
1693
1694        let message = serde_json::from_str::<Raw<JsonValue>>(
1695            r#"{
1696                "content": {
1697                    "body": "jolly_jumper",
1698                    "m.mentions": {}
1699                },
1700                "type": "m.room.message"
1701            }"#,
1702        )
1703        .unwrap();
1704
1705        assert_ne!(
1706            set.get_match(&message, context).unwrap().rule_id(),
1707            PredefinedContentRuleId::ContainsUserName.as_ref()
1708        );
1709
1710        let message = serde_json::from_str::<Raw<JsonValue>>(
1711            r#"{
1712                "content": {
1713                    "body": "Jolly Jumper"
1714                },
1715                "type": "m.room.message"
1716            }"#,
1717        )
1718        .unwrap();
1719
1720        assert_eq!(
1721            set.get_match(&message, context).unwrap().rule_id(),
1722            PredefinedOverrideRuleId::ContainsDisplayName.as_ref()
1723        );
1724
1725        let message = serde_json::from_str::<Raw<JsonValue>>(
1726            r#"{
1727                "content": {
1728                    "body": "Jolly Jumper",
1729                    "m.mentions": {}
1730                },
1731                "type": "m.room.message"
1732            }"#,
1733        )
1734        .unwrap();
1735
1736        assert_ne!(
1737            set.get_match(&message, context).unwrap().rule_id(),
1738            PredefinedOverrideRuleId::ContainsDisplayName.as_ref()
1739        );
1740
1741        let message = serde_json::from_str::<Raw<JsonValue>>(
1742            r#"{
1743                "content": {
1744                    "body": "@room"
1745                },
1746                "sender": "@admin:server.name",
1747                "type": "m.room.message"
1748            }"#,
1749        )
1750        .unwrap();
1751
1752        assert_eq!(
1753            set.get_match(&message, context).unwrap().rule_id(),
1754            PredefinedOverrideRuleId::RoomNotif.as_ref()
1755        );
1756
1757        let message = serde_json::from_str::<Raw<JsonValue>>(
1758            r#"{
1759                "content": {
1760                    "body": "@room",
1761                    "m.mentions": {}
1762                },
1763                "sender": "@admin:server.name",
1764                "type": "m.room.message"
1765            }"#,
1766        )
1767        .unwrap();
1768
1769        assert_ne!(
1770            set.get_match(&message, context).unwrap().rule_id(),
1771            PredefinedOverrideRuleId::RoomNotif.as_ref()
1772        );
1773    }
1774
1775    #[test]
1776    fn intentional_mentions_apply() {
1777        let set = Ruleset::server_default(user_id!("@jolly_jumper:server.name"));
1778
1779        let context = &PushConditionRoomCtx {
1780            room_id: owned_room_id!("!far_west:server.name"),
1781            member_count: uint!(100),
1782            user_id: owned_user_id!("@jj:server.name"),
1783            user_display_name: "Jolly Jumper".into(),
1784            power_levels: Some(power_levels()),
1785            #[cfg(feature = "unstable-msc3931")]
1786            supported_features: Default::default(),
1787        };
1788
1789        let message = serde_json::from_str::<Raw<JsonValue>>(
1790            r#"{
1791                "content": {
1792                    "body": "Hey jolly_jumper!",
1793                    "m.mentions": {
1794                        "user_ids": ["@jolly_jumper:server.name"]
1795                    }
1796                },
1797                "sender": "@admin:server.name",
1798                "type": "m.room.message"
1799            }"#,
1800        )
1801        .unwrap();
1802
1803        assert_eq!(
1804            set.get_match(&message, context).unwrap().rule_id(),
1805            PredefinedOverrideRuleId::IsUserMention.as_ref()
1806        );
1807
1808        let message = serde_json::from_str::<Raw<JsonValue>>(
1809            r#"{
1810                "content": {
1811                    "body": "Listen room!",
1812                    "m.mentions": {
1813                        "room": true
1814                    }
1815                },
1816                "sender": "@admin:server.name",
1817                "type": "m.room.message"
1818            }"#,
1819        )
1820        .unwrap();
1821
1822        assert_eq!(
1823            set.get_match(&message, context).unwrap().rule_id(),
1824            PredefinedOverrideRuleId::IsRoomMention.as_ref()
1825        );
1826    }
1827
1828    #[test]
1829    fn invite_for_me_applies() {
1830        let set = Ruleset::server_default(user_id!("@jolly_jumper:server.name"));
1831
1832        let context = &PushConditionRoomCtx {
1833            room_id: owned_room_id!("!far_west:server.name"),
1834            member_count: uint!(100),
1835            user_id: owned_user_id!("@jj:server.name"),
1836            user_display_name: "Jolly Jumper".into(),
1837            // `invite_state` usually doesn't include the power levels.
1838            power_levels: None,
1839            #[cfg(feature = "unstable-msc3931")]
1840            supported_features: Default::default(),
1841        };
1842
1843        let message = serde_json::from_str::<Raw<JsonValue>>(
1844            r#"{
1845                "content": {
1846                    "membership": "invite"
1847                },
1848                "state_key": "@jolly_jumper:server.name",
1849                "sender": "@admin:server.name",
1850                "type": "m.room.member"
1851            }"#,
1852        )
1853        .unwrap();
1854
1855        assert_eq!(
1856            set.get_match(&message, context).unwrap().rule_id(),
1857            PredefinedOverrideRuleId::InviteForMe.as_ref()
1858        );
1859    }
1860}
ruma_common/push.rs

ruma_common/
push.rs
