matrix_sdk_base/room/
members.rs

1// Copyright 2020 The Matrix.org Foundation C.I.C.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use std::{
16    collections::{BTreeMap, BTreeSet, HashMap},
17    mem,
18    sync::Arc,
19};
20
21use bitflags::bitflags;
22use futures_util::future;
23use ruma::{
24    Int, MxcUri, OwnedUserId, UserId,
25    events::{
26        MessageLikeEventType, StateEventType,
27        ignored_user_list::IgnoredUserListEventContent,
28        presence::PresenceEvent,
29        room::{
30            member::{MembershipState, RoomMemberEventContent},
31            power_levels::{PowerLevelAction, RoomPowerLevels, UserPowerLevel},
32        },
33    },
34};
35use tracing::debug;
36
37use super::Room;
38use crate::{
39    MinimalRoomMemberEvent, StoreError,
40    deserialized_responses::{DisplayName, MemberEvent},
41    store::{Result as StoreResult, StateStoreExt, ambiguity_map::is_display_name_ambiguous},
42};
43
44impl Room {
45    /// Check if the room has its members fully synced.
46    ///
47    /// Members might be missing if lazy member loading was enabled for the
48    /// sync.
49    ///
50    /// Returns true if no members are missing, false otherwise.
51    pub fn are_members_synced(&self) -> bool {
52        self.info.read().members_synced
53    }
54
55    /// Mark this Room as holding all member information.
56    ///
57    /// Useful in tests if we want to persuade the Room not to sync when asked
58    /// about its members.
59    #[cfg(feature = "testing")]
60    pub fn mark_members_synced(&self) {
61        self.info.update(|info| {
62            info.members_synced = true;
63        });
64    }
65
66    /// Mark this Room as still missing member information.
67    pub fn mark_members_missing(&self) {
68        self.info.update_if(|info| {
69            // notify observable subscribers only if the previous value was false
70            mem::replace(&mut info.members_synced, false)
71        })
72    }
73
74    /// Get the `RoomMember`s of this room that are known to the store, with the
75    /// given memberships.
76    pub async fn members(&self, memberships: RoomMemberships) -> StoreResult<Vec<RoomMember>> {
77        let user_ids = self.store.get_user_ids(self.room_id(), memberships).await?;
78
79        if user_ids.is_empty() {
80            return Ok(Vec::new());
81        }
82
83        let member_events = self
84            .store
85            .get_state_events_for_keys_static::<RoomMemberEventContent, _, _>(
86                self.room_id(),
87                &user_ids,
88            )
89            .await?
90            .into_iter()
91            .map(|raw_event| raw_event.deserialize())
92            .collect::<Result<Vec<_>, _>>()?;
93
94        let mut profiles = self.store.get_profiles(self.room_id(), &user_ids).await?;
95
96        let mut presences = self
97            .store
98            .get_presence_events(&user_ids)
99            .await?
100            .into_iter()
101            .filter_map(|e| {
102                e.deserialize().ok().map(|presence| (presence.sender.clone(), presence))
103            })
104            .collect::<BTreeMap<_, _>>();
105
106        let display_names = member_events.iter().map(|e| e.display_name()).collect::<Vec<_>>();
107        let room_info = self.member_room_info(&display_names).await?;
108
109        let mut members = Vec::new();
110
111        for event in member_events {
112            let profile = profiles.remove(event.user_id());
113            let presence = presences.remove(event.user_id());
114            members.push(RoomMember::from_parts(event, profile, presence, &room_info))
115        }
116
117        Ok(members)
118    }
119
120    /// Returns the number of members who have joined or been invited to the
121    /// room.
122    pub fn active_members_count(&self) -> u64 {
123        self.info.read().active_members_count()
124    }
125
126    /// Returns the number of members who have been invited to the room.
127    pub fn invited_members_count(&self) -> u64 {
128        self.info.read().invited_members_count()
129    }
130
131    /// Returns the number of members who have joined the room.
132    pub fn joined_members_count(&self) -> u64 {
133        self.info.read().joined_members_count()
134    }
135
136    /// Get the `RoomMember` with the given `user_id`.
137    ///
138    /// Returns `None` if the member was never part of this room, otherwise
139    /// return a `RoomMember` that can be in a joined, RoomState::Invited, left,
140    /// banned state.
141    ///
142    /// Async because it can read from storage.
143    pub async fn get_member(&self, user_id: &UserId) -> StoreResult<Option<RoomMember>> {
144        let event = async {
145            let Some(raw_event) = self.store.get_member_event(self.room_id(), user_id).await?
146            else {
147                debug!(%user_id, "Member event not found in state store");
148                return Ok(None);
149            };
150
151            Ok(Some(raw_event.deserialize()?))
152        };
153        let presence = async {
154            let raw_event = self.store.get_presence_event(user_id).await?;
155            Ok::<Option<PresenceEvent>, StoreError>(raw_event.and_then(|e| e.deserialize().ok()))
156        };
157
158        let profile = async { self.store.get_profile(self.room_id(), user_id).await };
159
160        let (Some(event), presence, profile) = future::try_join3(event, presence, profile).await?
161        else {
162            return Ok(None);
163        };
164
165        let display_names = [event.display_name()];
166        let room_info = self.member_room_info(&display_names).await?;
167
168        Ok(Some(RoomMember::from_parts(event, profile, presence, &room_info)))
169    }
170
171    /// The current `MemberRoomInfo` for this room.
172    ///
173    /// Async because it can read from storage.
174    async fn member_room_info<'a>(
175        &self,
176        display_names: &'a [DisplayName],
177    ) -> StoreResult<MemberRoomInfo<'a>> {
178        let max_power_level = self.max_power_level();
179        let power_levels = async { Ok(self.power_levels_or_default().await) };
180
181        let users_display_names =
182            self.store.get_users_with_display_names(self.room_id(), display_names);
183
184        let ignored_users = async {
185            Ok(self
186                .store
187                .get_account_data_event_static::<IgnoredUserListEventContent>()
188                .await?
189                .map(|c| c.deserialize())
190                .transpose()?
191                .map(|e| e.content.ignored_users.into_keys().collect()))
192        };
193
194        let (power_levels, users_display_names, ignored_users) =
195            future::try_join3(power_levels, users_display_names, ignored_users).await?;
196
197        Ok(MemberRoomInfo {
198            power_levels: power_levels.into(),
199            max_power_level,
200            users_display_names,
201            ignored_users,
202        })
203    }
204}
205
206/// A member of a room.
207#[derive(Clone, Debug)]
208pub struct RoomMember {
209    pub(crate) event: Arc<MemberEvent>,
210    // The latest member event sent by the member themselves.
211    // Stored in addition to the latest member event overall to get displayname
212    // and avatar from, which should be ignored on events sent by others.
213    pub(crate) profile: Arc<Option<MinimalRoomMemberEvent>>,
214    #[allow(dead_code)]
215    pub(crate) presence: Arc<Option<PresenceEvent>>,
216    pub(crate) power_levels: Arc<RoomPowerLevels>,
217    pub(crate) max_power_level: i64,
218    pub(crate) display_name_ambiguous: bool,
219    pub(crate) is_ignored: bool,
220}
221
222impl RoomMember {
223    pub(crate) fn from_parts(
224        event: MemberEvent,
225        profile: Option<MinimalRoomMemberEvent>,
226        presence: Option<PresenceEvent>,
227        room_info: &MemberRoomInfo<'_>,
228    ) -> Self {
229        let MemberRoomInfo { power_levels, max_power_level, users_display_names, ignored_users } =
230            room_info;
231
232        let display_name = event.display_name();
233        let display_name_ambiguous = users_display_names
234            .get(&display_name)
235            .is_some_and(|s| is_display_name_ambiguous(&display_name, s));
236        let is_ignored = ignored_users.as_ref().is_some_and(|s| s.contains(event.user_id()));
237
238        Self {
239            event: event.into(),
240            profile: profile.into(),
241            presence: presence.into(),
242            power_levels: power_levels.clone(),
243            max_power_level: *max_power_level,
244            display_name_ambiguous,
245            is_ignored,
246        }
247    }
248
249    /// Get the unique user id of this member.
250    pub fn user_id(&self) -> &UserId {
251        self.event.user_id()
252    }
253
254    /// Get the original member event
255    pub fn event(&self) -> &Arc<MemberEvent> {
256        &self.event
257    }
258
259    /// Get the display name of the member if there is one.
260    pub fn display_name(&self) -> Option<&str> {
261        if let Some(p) = self.profile.as_ref() {
262            p.as_original().and_then(|e| e.content.displayname.as_deref())
263        } else {
264            self.event.original_content()?.displayname.as_deref()
265        }
266    }
267
268    /// Get the name of the member.
269    ///
270    /// This returns either the display name or the local part of the user id if
271    /// the member didn't set a display name.
272    pub fn name(&self) -> &str {
273        if let Some(d) = self.display_name() { d } else { self.user_id().localpart() }
274    }
275
276    /// Get the avatar url of the member, if there is one.
277    pub fn avatar_url(&self) -> Option<&MxcUri> {
278        if let Some(p) = self.profile.as_ref() {
279            p.as_original().and_then(|e| e.content.avatar_url.as_deref())
280        } else {
281            self.event.original_content()?.avatar_url.as_deref()
282        }
283    }
284
285    /// Get the normalized power level of this member.
286    ///
287    /// The normalized power level depends on the maximum power level that can
288    /// be found in a certain room, positive values that are not `Infinite` are
289    /// always in the range of 0-100.
290    pub fn normalized_power_level(&self) -> UserPowerLevel {
291        let UserPowerLevel::Int(power_level) = self.power_level() else {
292            return UserPowerLevel::Infinite;
293        };
294
295        let normalized_power_level = if self.max_power_level > 0 {
296            normalize_power_level(power_level, self.max_power_level)
297        } else {
298            power_level
299        };
300
301        UserPowerLevel::Int(normalized_power_level)
302    }
303
304    /// Get the power level of this member.
305    pub fn power_level(&self) -> UserPowerLevel {
306        self.power_levels.for_user(self.user_id())
307    }
308
309    /// Whether this user can ban other users based on the power levels.
310    ///
311    /// Same as `member.can_do(PowerLevelAction::Ban)`.
312    pub fn can_ban(&self) -> bool {
313        self.can_do_impl(|pls| pls.user_can_ban(self.user_id()))
314    }
315
316    /// Whether this user can invite other users based on the power levels.
317    ///
318    /// Same as `member.can_do(PowerLevelAction::Invite)`.
319    pub fn can_invite(&self) -> bool {
320        self.can_do_impl(|pls| pls.user_can_invite(self.user_id()))
321    }
322
323    /// Whether this user can kick other users based on the power levels.
324    ///
325    /// Same as `member.can_do(PowerLevelAction::Kick)`.
326    pub fn can_kick(&self) -> bool {
327        self.can_do_impl(|pls| pls.user_can_kick(self.user_id()))
328    }
329
330    /// Whether this user can redact their own events based on the power levels.
331    ///
332    /// Same as `member.can_do(PowerLevelAction::RedactOwn)`.
333    pub fn can_redact_own(&self) -> bool {
334        self.can_do_impl(|pls| pls.user_can_redact_own_event(self.user_id()))
335    }
336
337    /// Whether this user can redact events of other users based on the power
338    /// levels.
339    ///
340    /// Same as `member.can_do(PowerLevelAction::RedactOther)`.
341    pub fn can_redact_other(&self) -> bool {
342        self.can_do_impl(|pls| pls.user_can_redact_event_of_other(self.user_id()))
343    }
344
345    /// Whether this user can send message events based on the power levels.
346    ///
347    /// Same as `member.can_do(PowerLevelAction::SendMessage(msg_type))`.
348    pub fn can_send_message(&self, msg_type: MessageLikeEventType) -> bool {
349        self.can_do_impl(|pls| pls.user_can_send_message(self.user_id(), msg_type))
350    }
351
352    /// Whether this user can send state events based on the power levels.
353    ///
354    /// Same as `member.can_do(PowerLevelAction::SendState(state_type))`.
355    pub fn can_send_state(&self, state_type: StateEventType) -> bool {
356        self.can_do_impl(|pls| pls.user_can_send_state(self.user_id(), state_type))
357    }
358
359    /// Whether this user can pin or unpin events based on the power levels.
360    pub fn can_pin_or_unpin_event(&self) -> bool {
361        self.can_send_state(StateEventType::RoomPinnedEvents)
362    }
363
364    /// Whether this user can notify everybody in the room by writing `@room` in
365    /// a message.
366    ///
367    /// Same as `member.
368    /// can_do(PowerLevelAction::TriggerNotification(NotificationPowerLevelType::Room))`.
369    pub fn can_trigger_room_notification(&self) -> bool {
370        self.can_do_impl(|pls| pls.user_can_trigger_room_notification(self.user_id()))
371    }
372
373    /// Whether this user can do the given action based on the power
374    /// levels.
375    pub fn can_do(&self, action: PowerLevelAction) -> bool {
376        self.can_do_impl(|pls| pls.user_can_do(self.user_id(), action))
377    }
378
379    fn can_do_impl(&self, f: impl FnOnce(&RoomPowerLevels) -> bool) -> bool {
380        f(&self.power_levels)
381    }
382
383    /// Is the name that the member uses ambiguous in the room.
384    ///
385    /// A name is considered to be ambiguous if at least one other member shares
386    /// the same name.
387    pub fn name_ambiguous(&self) -> bool {
388        self.display_name_ambiguous
389    }
390
391    /// Get the membership state of this member.
392    pub fn membership(&self) -> &MembershipState {
393        self.event.membership()
394    }
395
396    /// Is the room member ignored by the current account user
397    pub fn is_ignored(&self) -> bool {
398        self.is_ignored
399    }
400}
401
402// Information about the room a member is in.
403pub(crate) struct MemberRoomInfo<'a> {
404    pub(crate) power_levels: Arc<RoomPowerLevels>,
405    pub(crate) max_power_level: i64,
406    pub(crate) users_display_names: HashMap<&'a DisplayName, BTreeSet<OwnedUserId>>,
407    pub(crate) ignored_users: Option<BTreeSet<OwnedUserId>>,
408}
409
410/// The kind of room member updates that just happened.
411#[derive(Debug, Clone)]
412pub enum RoomMembersUpdate {
413    /// The whole list room members was reloaded.
414    FullReload,
415    /// A few members were updated, their user ids are included.
416    Partial(BTreeSet<OwnedUserId>),
417}
418
419bitflags! {
420    /// Room membership filter as a bitset.
421    ///
422    /// Note that [`RoomMemberships::empty()`] doesn't filter the results and
423    /// [`RoomMemberships::all()`] filters out unknown memberships.
424    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
425    pub struct RoomMemberships: u16 {
426        /// The member joined the room.
427        const JOIN    = 0b00000001;
428        /// The member was invited to the room.
429        const INVITE  = 0b00000010;
430        /// The member requested to join the room.
431        const KNOCK   = 0b00000100;
432        /// The member left the room.
433        const LEAVE   = 0b00001000;
434        /// The member was banned.
435        const BAN     = 0b00010000;
436
437        /// The member is active in the room (i.e. joined or invited).
438        const ACTIVE = Self::JOIN.bits() | Self::INVITE.bits();
439    }
440}
441
442impl RoomMemberships {
443    /// Whether the given membership matches this `RoomMemberships`.
444    pub fn matches(&self, membership: &MembershipState) -> bool {
445        if self.is_empty() {
446            return true;
447        }
448
449        let membership = match membership {
450            MembershipState::Ban => Self::BAN,
451            MembershipState::Invite => Self::INVITE,
452            MembershipState::Join => Self::JOIN,
453            MembershipState::Knock => Self::KNOCK,
454            MembershipState::Leave => Self::LEAVE,
455            _ => return false,
456        };
457
458        self.contains(membership)
459    }
460
461    /// Get this `RoomMemberships` as a list of matching [`MembershipState`]s.
462    pub fn as_vec(&self) -> Vec<MembershipState> {
463        let mut memberships = Vec::new();
464
465        if self.contains(Self::JOIN) {
466            memberships.push(MembershipState::Join);
467        }
468        if self.contains(Self::INVITE) {
469            memberships.push(MembershipState::Invite);
470        }
471        if self.contains(Self::KNOCK) {
472            memberships.push(MembershipState::Knock);
473        }
474        if self.contains(Self::LEAVE) {
475            memberships.push(MembershipState::Leave);
476        }
477        if self.contains(Self::BAN) {
478            memberships.push(MembershipState::Ban);
479        }
480
481        memberships
482    }
483}
484
485/// Scale the given `power_level` to a range between 0-100.
486pub fn normalize_power_level(power_level: Int, max_power_level: i64) -> Int {
487    let mut power_level = i64::from(power_level);
488    power_level = (power_level * 100) / max_power_level;
489
490    Int::try_from(power_level.clamp(0, 100))
491        .expect("We clamped the normalized power level so they must fit into the Int")
492}
493
494#[cfg(test)]
495mod tests {
496    use proptest::prelude::*;
497
498    use super::*;
499
500    prop_compose! {
501        fn arb_int()(id in any::<i64>()) -> Int {
502            id.try_into().unwrap_or_default()
503        }
504    }
505
506    proptest! {
507        #![proptest_config(ProptestConfig::with_cases(10_000))]
508        #[test]
509        fn test_power_level_normalization_with_min_max_level(power_level in arb_int()) {
510            let normalized = normalize_power_level(power_level, 1);
511            let normalized = i64::from(normalized);
512
513            assert!(normalized >= 0);
514            assert!(normalized <= 100);
515        }
516    }
517
518    proptest! {
519        #![proptest_config(ProptestConfig::with_cases(10_000))]
520        #[test]
521        fn test_power_level_normalization(power_level in arb_int(), max_level in 1i64..) {
522            let normalized = normalize_power_level(power_level, max_level);
523            let normalized = i64::from(normalized);
524
525            assert!(normalized >= 0);
526            assert!(normalized <= 100);
527        }
528    }
529
530    #[test]
531    fn test_power_level_normalization_limits() {
532        let level = Int::MIN;
533        let normalized = normalize_power_level(level, 1);
534        let normalized = i64::from(normalized);
535        assert!(normalized >= 0);
536        assert!(normalized <= 100);
537
538        let level = Int::MAX;
539        let normalized = normalize_power_level(level, 1);
540        let normalized = i64::from(normalized);
541        assert!(normalized >= 0);
542        assert!(normalized <= 100);
543    }
544}
matrix_sdk_base/room/members.rs

matrix_sdk_base/room/
members.rs
