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

matrix_sdk_base/room/
members.rs
