1use 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 pub fn are_members_synced(&self) -> bool {
51 self.inner.read().members_synced
52 }
53
54 #[cfg(feature = "testing")]
59 pub fn mark_members_synced(&self) {
60 self.inner.update(|info| {
61 info.members_synced = true;
62 });
63 }
64
65 pub fn mark_members_missing(&self) {
67 self.inner.update_if(|info| {
68 mem::replace(&mut info.members_synced, false)
70 })
71 }
72
73 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 pub fn active_members_count(&self) -> u64 {
122 self.inner.read().active_members_count()
123 }
124
125 pub fn invited_members_count(&self) -> u64 {
127 self.inner.read().invited_members_count()
128 }
129
130 pub fn joined_members_count(&self) -> u64 {
132 self.inner.read().joined_members_count()
133 }
134
135 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 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#[derive(Clone, Debug)]
193pub struct RoomMember {
194 pub(crate) event: Arc<MemberEvent>,
195 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 pub fn user_id(&self) -> &UserId {
236 self.event.user_id()
237 }
238
239 pub fn event(&self) -> &Arc<MemberEvent> {
241 &self.event
242 }
243
244 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 pub fn name(&self) -> &str {
258 if let Some(d) = self.display_name() { d } else { self.user_id().localpart() }
259 }
260
261 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 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 pub fn power_level(&self) -> UserPowerLevel {
293 self.power_levels.for_user(self.user_id())
294 }
295
296 pub fn can_ban(&self) -> bool {
300 self.can_do_impl(|pls| pls.user_can_ban(self.user_id()))
301 }
302
303 pub fn can_invite(&self) -> bool {
307 self.can_do_impl(|pls| pls.user_can_invite(self.user_id()))
308 }
309
310 pub fn can_kick(&self) -> bool {
314 self.can_do_impl(|pls| pls.user_can_kick(self.user_id()))
315 }
316
317 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 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 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 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 pub fn can_pin_or_unpin_event(&self) -> bool {
348 self.can_send_state(StateEventType::RoomPinnedEvents)
349 }
350
351 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 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 pub fn name_ambiguous(&self) -> bool {
375 self.display_name_ambiguous
376 }
377
378 pub fn membership(&self) -> &MembershipState {
380 self.event.membership()
381 }
382
383 pub fn is_ignored(&self) -> bool {
385 self.is_ignored
386 }
387}
388
389pub(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#[derive(Debug, Clone)]
399pub enum RoomMembersUpdate {
400 FullReload,
402 Partial(BTreeSet<OwnedUserId>),
404}
405
406bitflags! {
407 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
412 pub struct RoomMemberships: u16 {
413 const JOIN = 0b00000001;
415 const INVITE = 0b00000010;
417 const KNOCK = 0b00000100;
419 const LEAVE = 0b00001000;
421 const BAN = 0b00010000;
423
424 const ACTIVE = Self::JOIN.bits() | Self::INVITE.bits();
426 }
427}
428
429impl RoomMemberships {
430 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 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}