tuwunel_service/rooms/state_accessor/
mod.rs1mod checked;
7mod erased;
8mod room_state;
9mod server_can;
10mod state;
11mod user_can;
12
13use std::sync::Arc;
14
15use async_trait::async_trait;
16use futures::{FutureExt, TryFutureExt, future::try_join};
17use ruma::{
18 EventEncryptionAlgorithm, OwnedRoomAliasId, RoomId, UserId,
19 events::{
20 StateEventType,
21 room::{
22 avatar::RoomAvatarEventContent,
23 canonical_alias::RoomCanonicalAliasEventContent,
24 create::RoomCreateEventContent,
25 encryption::RoomEncryptionEventContent,
26 guest_access::{GuestAccess, RoomGuestAccessEventContent},
27 history_visibility::HistoryVisibility,
28 join_rules::{JoinRule, RoomJoinRulesEventContent},
29 member::RoomMemberEventContent,
30 name::RoomNameEventContent,
31 power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
32 topic::RoomTopicEventContent,
33 },
34 },
35 room::RoomType,
36};
37use tuwunel_core::{
38 Result, err, implement,
39 utils::{BoolExt, OptionExt},
40};
41use tuwunel_matrix::{
42 Event, Pdu, room::state::resolution::events::RoomCreateEvent, room_version,
43};
44
45use crate::rooms::{state_compressor::CompressedState, timeline::Mapped};
46
47pub struct Service {
52 services: Arc<crate::services::OnceServices>,
53}
54
55#[async_trait]
56impl crate::Service for Service {
57 fn build(args: &crate::Args<'_>) -> Result<Arc<Self>> {
58 Ok(Arc::new(Self { services: args.services.clone() }))
59 }
60
61 fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
62}
63
64impl Service {
65 pub async fn get_power_levels(&self, room_id: &RoomId) -> Result<RoomPowerLevels> {
70 let create = self.get_create(room_id);
71 let power_levels = self
72 .room_state_get_content(room_id, &StateEventType::RoomPowerLevels, "")
73 .map_ok(|c: RoomPowerLevelsEventContent| c)
74 .map(Result::ok)
75 .map(Ok);
76
77 let (create, power_levels) = try_join(create, power_levels).await?;
78
79 let room_version = create.room_version()?;
80 let rules = room_version::rules(&room_version)?;
81 let creators = create.creators(&rules.authorization)?;
82
83 Ok(RoomPowerLevels::new(power_levels.into(), &rules.authorization, creators))
84 }
85
86 pub async fn get_create(&self, room_id: &RoomId) -> Result<RoomCreateEvent<Pdu>> {
91 self.room_state_get(room_id, &StateEventType::RoomCreate, "")
92 .await
93 .map(RoomCreateEvent::new)
94 }
95
96 pub async fn get_name(&self, room_id: &RoomId) -> Result<String> {
100 self.room_state_get_content(room_id, &StateEventType::RoomName, "")
101 .await
102 .and_then(|c: RoomNameEventContent| {
103 c.name
104 .is_empty()
105 .is_false()
106 .then_some(c.name)
107 .ok_or_else(|| err!(Request(NotFound("Empty name found in event content."))))
108 })
109 }
110
111 pub async fn get_avatar(&self, room_id: &RoomId) -> Result<RoomAvatarEventContent> {
115 self.room_state_get_content(room_id, &StateEventType::RoomAvatar, "")
116 .await
117 }
118
119 pub async fn get_member(
124 &self,
125 room_id: &RoomId,
126 user_id: &UserId,
127 ) -> Result<RoomMemberEventContent> {
128 self.room_state_get_content(room_id, &StateEventType::RoomMember, user_id.as_str())
129 .await
130 }
131
132 pub async fn is_world_readable(&self, room_id: &RoomId) -> bool {
137 self.get_history_visibility(room_id).await == HistoryVisibility::WorldReadable
138 }
139
140 pub async fn get_history_visibility(&self, room_id: &RoomId) -> HistoryVisibility {
145 self.services
146 .state
147 .get_room_shortstatehash(room_id)
148 .await
149 .ok()
150 .map_async(|shortstatehash| self.history_visibility(shortstatehash))
151 .await
152 .unwrap_or(HistoryVisibility::Shared)
153 }
154
155 pub async fn guest_can_join(&self, room_id: &RoomId) -> bool {
160 self.room_state_get_content(room_id, &StateEventType::RoomGuestAccess, "")
161 .await
162 .map(|c: RoomGuestAccessEventContent| c.guest_access == GuestAccess::CanJoin)
163 .unwrap_or(false)
164 }
165
166 pub async fn get_canonical_alias(&self, room_id: &RoomId) -> Result<OwnedRoomAliasId> {
171 self.room_state_get_content(room_id, &StateEventType::RoomCanonicalAlias, "")
172 .await
173 .and_then(|c: RoomCanonicalAliasEventContent| {
174 c.alias
175 .ok_or_else(|| err!(Request(NotFound("No alias found in event content."))))
176 })
177 }
178
179 pub async fn get_room_topic(&self, room_id: &RoomId) -> Result<String> {
184 self.room_state_get_content(room_id, &StateEventType::RoomTopic, "")
185 .await
186 .and_then(|content: RoomTopicEventContent| {
187 plain_text_topic(content)
188 .ok_or_else(|| err!(Request(NotFound("Empty topic found in event content."))))
189 })
190 }
191
192 pub async fn get_join_rules(&self, room_id: &RoomId) -> JoinRule {
197 self.room_state_get_content(room_id, &StateEventType::RoomJoinRules, "")
198 .await
199 .map_or(JoinRule::Invite, |c: RoomJoinRulesEventContent| c.join_rule)
200 }
201
202 pub async fn get_room_type(&self, room_id: &RoomId) -> Result<RoomType> {
207 self.room_state_get_content(room_id, &StateEventType::RoomCreate, "")
208 .await
209 .and_then(|content: RoomCreateEventContent| {
210 content
211 .room_type
212 .ok_or_else(|| err!(Request(NotFound("No type found in event content"))))
213 })
214 }
215
216 pub async fn get_room_encryption(
220 &self,
221 room_id: &RoomId,
222 ) -> Result<EventEncryptionAlgorithm> {
223 self.room_state_get_content(room_id, &StateEventType::RoomEncryption, "")
224 .await
225 .map(|content: RoomEncryptionEventContent| content.algorithm)
226 }
227
228 pub async fn is_encrypted_room(&self, room_id: &RoomId) -> bool {
233 self.room_state_get(room_id, &StateEventType::RoomEncryption, "")
234 .await
235 .is_ok()
236 }
237}
238
239#[implement(Service)]
249pub(crate) async fn get_member_checked(
250 &self,
251 state: &CompressedState,
252 user_id: &UserId,
253) -> Result<Mapped<RoomMemberEventContent>> {
254 let event_id = self
255 .state_get_id_checked(state, &StateEventType::RoomMember, user_id.as_str())
256 .await?;
257
258 let Mapped::Event(event_id) = event_id else {
259 return Ok(Mapped::Damaged);
260 };
261
262 let member: Mapped<Pdu> = self
263 .services
264 .timeline
265 .get_checked(&event_id)
266 .await?;
267
268 match member {
269 | Mapped::Event(member) => member.get_content().map(Mapped::Event),
270 | Mapped::Damaged => Ok(Mapped::Damaged),
271 }
272}
273
274#[implement(Service)]
280pub async fn is_federating(&self, room_id: &RoomId) -> bool {
281 self.get_create(room_id)
282 .await
283 .and_then(|create| create.federate())
284 .unwrap_or(true)
285}
286
287pub(crate) fn plain_text_topic(content: RoomTopicEventContent) -> Option<String> {
292 let topic = content
293 .topic_block
294 .text
295 .find_plain()
296 .map(ToOwned::to_owned)
297 .unwrap_or(content.topic);
298
299 topic.is_empty().is_false().then_some(topic)
300}