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    MxcUri, OwnedUserId, UserId,
24    events::{
25        MessageLikeEventType, StateEventType,
26        ignored_user_list::IgnoredUserListEventContent,
27        presence::PresenceEvent,
28        room::{
29            member::{MembershipState, RoomMemberEventContent},
30            power_levels::{PowerLevelAction, RoomPowerLevels, UserPowerLevel},
31        },
32    },
33};
34use tracing::debug;
35
36use super::Room;
37use crate::{
38    MinimalRoomMemberEvent,
39    deserialized_responses::{DisplayName, MemberEvent},
40    store::{Result as StoreResult, StateStoreExt, ambiguity_map::is_display_name_ambiguous},
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() { d } else { self.user_id().localpart() }
259    }
260
261    /// Get the avatar url of the member, if there is one.
262    pub fn avatar_url(&self) -> Option<&MxcUri> {
263        if let Some(p) = self.profile.as_ref() {
264            p.as_original().and_then(|e| e.content.avatar_url.as_deref())
265        } else {
266            self.event.original_content()?.avatar_url.as_deref()
267        }
268    }
269
270    /// Get the normalized power level of this member.
271    ///
272    /// The normalized power level depends on the maximum power level that can
273    /// be found in a certain room, positive values that are not `Infinite` are
274    /// always in the range of 0-100.
275    pub fn normalized_power_level(&self) -> UserPowerLevel {
276        let UserPowerLevel::Int(power_level) = self.power_level() else {
277            return UserPowerLevel::Infinite;
278        };
279
280        let mut power_level = i64::from(power_level);
281
282        if self.max_power_level > 0 {
283            power_level = (power_level * 100) / self.max_power_level;
284        }
285
286        UserPowerLevel::Int(
287            power_level.try_into().expect("normalized power level should fit in Int"),
288        )
289    }
290
291    /// Get the power level of this member.
292    pub fn power_level(&self) -> UserPowerLevel {
293        self.power_levels.for_user(self.user_id())
294    }
295
296    /// Whether this user can ban other users based on the power levels.
297    ///
298    /// Same as `member.can_do(PowerLevelAction::Ban)`.
299    pub fn can_ban(&self) -> bool {
300        self.can_do_impl(|pls| pls.user_can_ban(self.user_id()))
301    }
302
303    /// Whether this user can invite other users based on the power levels.
304    ///
305    /// Same as `member.can_do(PowerLevelAction::Invite)`.
306    pub fn can_invite(&self) -> bool {
307        self.can_do_impl(|pls| pls.user_can_invite(self.user_id()))
308    }
309
310    /// Whether this user can kick other users based on the power levels.
311    ///
312    /// Same as `member.can_do(PowerLevelAction::Kick)`.
313    pub fn can_kick(&self) -> bool {
314        self.can_do_impl(|pls| pls.user_can_kick(self.user_id()))
315    }
316
317    /// Whether this user can redact their own events based on the power levels.
318    ///
319    /// Same as `member.can_do(PowerLevelAction::RedactOwn)`.
320    pub fn can_redact_own(&self) -> bool {
321        self.can_do_impl(|pls| pls.user_can_redact_own_event(self.user_id()))
322    }
323
324    /// Whether this user can redact events of other users based on the power
325    /// levels.
326    ///
327    /// Same as `member.can_do(PowerLevelAction::RedactOther)`.
328    pub fn can_redact_other(&self) -> bool {
329        self.can_do_impl(|pls| pls.user_can_redact_event_of_other(self.user_id()))
330    }
331
332    /// Whether this user can send message events based on the power levels.
333    ///
334    /// Same as `member.can_do(PowerLevelAction::SendMessage(msg_type))`.
335    pub fn can_send_message(&self, msg_type: MessageLikeEventType) -> bool {
336        self.can_do_impl(|pls| pls.user_can_send_message(self.user_id(), msg_type))
337    }
338
339    /// Whether this user can send state events based on the power levels.
340    ///
341    /// Same as `member.can_do(PowerLevelAction::SendState(state_type))`.
342    pub fn can_send_state(&self, state_type: StateEventType) -> bool {
343        self.can_do_impl(|pls| pls.user_can_send_state(self.user_id(), state_type))
344    }
345
346    /// Whether this user can pin or unpin events based on the power levels.
347    pub fn can_pin_or_unpin_event(&self) -> bool {
348        self.can_send_state(StateEventType::RoomPinnedEvents)
349    }
350
351    /// Whether this user can notify everybody in the room by writing `@room` in
352    /// a message.
353    ///
354    /// Same as `member.
355    /// can_do(PowerLevelAction::TriggerNotification(NotificationPowerLevelType::Room))`.
356    pub fn can_trigger_room_notification(&self) -> bool {
357        self.can_do_impl(|pls| pls.user_can_trigger_room_notification(self.user_id()))
358    }
359
360    /// Whether this user can do the given action based on the power
361    /// levels.
362    pub fn can_do(&self, action: PowerLevelAction) -> bool {
363        self.can_do_impl(|pls| pls.user_can_do(self.user_id(), action))
364    }
365
366    fn can_do_impl(&self, f: impl FnOnce(&RoomPowerLevels) -> bool) -> bool {
367        f(&self.power_levels)
368    }
369
370    /// Is the name that the member uses ambiguous in the room.
371    ///
372    /// A name is considered to be ambiguous if at least one other member shares
373    /// the same name.
374    pub fn name_ambiguous(&self) -> bool {
375        self.display_name_ambiguous
376    }
377
378    /// Get the membership state of this member.
379    pub fn membership(&self) -> &MembershipState {
380        self.event.membership()
381    }
382
383    /// Is the room member ignored by the current account user
384    pub fn is_ignored(&self) -> bool {
385        self.is_ignored
386    }
387}
388
389// Information about the room a member is in.
390pub(crate) struct MemberRoomInfo<'a> {
391    pub(crate) power_levels: Arc<RoomPowerLevels>,
392    pub(crate) max_power_level: i64,
393    pub(crate) users_display_names: HashMap<&'a DisplayName, BTreeSet<OwnedUserId>>,
394    pub(crate) ignored_users: Option<BTreeSet<OwnedUserId>>,
395}
396
397/// The kind of room member updates that just happened.
398#[derive(Debug, Clone)]
399pub enum RoomMembersUpdate {
400    /// The whole list room members was reloaded.
401    FullReload,
402    /// A few members were updated, their user ids are included.
403    Partial(BTreeSet<OwnedUserId>),
404}
405
406bitflags! {
407    /// Room membership filter as a bitset.
408    ///
409    /// Note that [`RoomMemberships::empty()`] doesn't filter the results and
410    /// [`RoomMemberships::all()`] filters out unknown memberships.
411    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
412    pub struct RoomMemberships: u16 {
413        /// The member joined the room.
414        const JOIN    = 0b00000001;
415        /// The member was invited to the room.
416        const INVITE  = 0b00000010;
417        /// The member requested to join the room.
418        const KNOCK   = 0b00000100;
419        /// The member left the room.
420        const LEAVE   = 0b00001000;
421        /// The member was banned.
422        const BAN     = 0b00010000;
423
424        /// The member is active in the room (i.e. joined or invited).
425        const ACTIVE = Self::JOIN.bits() | Self::INVITE.bits();
426    }
427}
428
429impl RoomMemberships {
430    /// Whether the given membership matches this `RoomMemberships`.
431    pub fn matches(&self, membership: &MembershipState) -> bool {
432        if self.is_empty() {
433            return true;
434        }
435
436        let membership = match membership {
437            MembershipState::Ban => Self::BAN,
438            MembershipState::Invite => Self::INVITE,
439            MembershipState::Join => Self::JOIN,
440            MembershipState::Knock => Self::KNOCK,
441            MembershipState::Leave => Self::LEAVE,
442            _ => return false,
443        };
444
445        self.contains(membership)
446    }
447
448    /// Get this `RoomMemberships` as a list of matching [`MembershipState`]s.
449    pub fn as_vec(&self) -> Vec<MembershipState> {
450        let mut memberships = Vec::new();
451
452        if self.contains(Self::JOIN) {
453            memberships.push(MembershipState::Join);
454        }
455        if self.contains(Self::INVITE) {
456            memberships.push(MembershipState::Invite);
457        }
458        if self.contains(Self::KNOCK) {
459            memberships.push(MembershipState::Knock);
460        }
461        if self.contains(Self::LEAVE) {
462            memberships.push(MembershipState::Leave);
463        }
464        if self.contains(Self::BAN) {
465            memberships.push(MembershipState::Ban);
466        }
467
468        memberships
469    }
470}
matrix_sdk_base/room/members.rs

matrix_sdk_base/room/
members.rs
