1use futures::FutureExt;
2use ruma::{
3 Int, OwnedUserId, RoomId, UserId,
4 events::{
5 StateEventType,
6 room::{
7 member::{MembershipState, RoomMemberEventContent},
8 power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent, UserPowerLevel},
9 },
10 },
11};
12use tuwunel_core::{
13 Err, Result, debug_info, debug_warn, err, error, implement,
14 result::NotFound,
15 utils::{FutureBoolExt, future::ReadyBoolExt, stream::ReadyExt},
16};
17use tuwunel_matrix::pdu::PduBuilder;
18
19use super::notices::text_markdown;
20use crate::rooms::state::RoomMutexGuard;
21
22#[implement(super::Service)]
28pub async fn make_user_admin(&self, user_id: &UserId) -> Result {
29 let is_local = self.services.globals.user_is_local(user_id);
30
31 if is_local && !self.services.users.exists(user_id).await {
32 return Err!(Request(NotFound("User {user_id} does not exist on this server.")));
33 }
34
35 let Ok(room_id) = self.get_admin_room().await else {
36 debug_warn!(
37 "make_user_admin was called without an admin room being available or created"
38 );
39 return Ok(());
40 };
41
42 let state_lock = self.services.state.mutex.lock(&room_id).await;
43
44 let is_joined = self
45 .services
46 .state_cache
47 .is_joined(user_id, &room_id)
48 .await;
49
50 let is_invited = self
51 .services
52 .state_cache
53 .is_invited(user_id, &room_id)
54 .await;
55
56 let already_member = is_joined || is_invited;
57
58 if !already_member {
59 self.invite_new_admin(user_id, &room_id, &state_lock)
60 .await?;
61 }
62
63 let server_user: &UserId = self.services.globals.server_user.as_ref();
64
65 let mut room_power_levels = self
66 .services
67 .state_accessor
68 .room_state_get_content::<RoomPowerLevelsEventContent>(
69 &room_id,
70 &StateEventType::RoomPowerLevels,
71 "",
72 )
73 .await
74 .unwrap_or_default();
75
76 let server_level = 69420.into();
77 let admin_level = 100.into();
78 let already_granted = room_power_levels.users.get(server_user) == Some(&server_level)
79 && room_power_levels.users.get(user_id) == Some(&admin_level);
80
81 if !already_granted {
82 room_power_levels
83 .users
84 .insert(server_user.into(), server_level);
85 room_power_levels
86 .users
87 .insert(user_id.into(), admin_level);
88
89 self.services
90 .timeline
91 .build_and_append_pdu(
92 PduBuilder::state(String::new(), &room_power_levels),
93 server_user,
94 &room_id,
95 &state_lock,
96 )
97 .await?;
98 }
99
100 let room_tag = self
102 .services
103 .server
104 .config
105 .admin
106 .room
107 .tag
108 .as_str();
109
110 if !already_granted
111 && !room_tag.is_empty()
112 && let Err(e) = self
113 .services
114 .account_data
115 .set_room_tag(user_id, &room_id, room_tag.into(), None)
116 .await
117 {
118 error!(?room_id, ?user_id, ?room_tag, "Failed to set tag for admin grant: {e}");
119 }
120
121 if !already_member && self.services.server.config.admin.room.notices {
122 let welcome_message = "## Thank you for trying out tuwunel!\n\nTuwunel is a continuation of conduwuit which was technically a hard fork of Conduit.\n\nHelpful links:\n> GitHub Repo: https://github.com/matrix-construct/tuwunel\n> Documentation: https://matrix-construct.github.io/tuwunel\n> Report issues: https://github.com/matrix-construct/tuwunel/issues\n\nFor a list of available commands, send the following message in this room: `!admin --help`";
123
124 self.services
126 .timeline
127 .build_and_append_pdu(
128 PduBuilder::timeline(&text_markdown(welcome_message)),
129 server_user,
130 &room_id,
131 &state_lock,
132 )
133 .await?;
134 }
135
136 Ok(())
137}
138
139#[implement(super::Service)]
147pub async fn make_room_admin(&self, room_id: &RoomId, target: &UserId) -> Result {
148 let power_levels = self
149 .services
150 .state_accessor
151 .get_power_levels(room_id)
152 .await?;
153
154 let sender = self
155 .services
156 .state_cache
157 .local_users_in_room(room_id)
158 .ready_fold(None, |best: Option<(OwnedUserId, UserPowerLevel)>, user| {
159 let level = power_levels.for_user(user);
160 match best {
161 | Some((_, best_level)) if best_level >= level => best,
162 | _ => Some((user.to_owned(), level)),
163 }
164 })
165 .await;
166
167 let Some((sender, _)) = sender else {
168 return Err!(Request(InvalidParam("Server not in room")));
169 };
170
171 grantable_level(&power_levels, &sender)?;
173
174 let is_joined = self
175 .services
176 .state_cache
177 .is_joined(target, room_id);
178
179 let is_invited = self
180 .services
181 .state_cache
182 .is_invited(target, room_id);
183
184 let is_public = self.services.metadata.is_public(room_id);
185
186 let needs_invite = is_joined
188 .is_false()
189 .and2(is_invited.is_false(), is_public.is_false());
190
191 if needs_invite.await {
192 self.services
193 .membership
194 .invite(&sender, target, room_id, None, false)
195 .await?;
196 }
197
198 let state_lock = self.services.state.mutex.lock(room_id).await;
200
201 let power_levels = self
202 .services
203 .state_accessor
204 .get_power_levels(room_id)
205 .await?;
206
207 let grant_level = grantable_level(&power_levels, &sender)?;
208
209 let mut content = self
210 .services
211 .state_accessor
212 .room_state_get_content::<RoomPowerLevelsEventContent>(
213 room_id,
214 &StateEventType::RoomPowerLevels,
215 "",
216 )
217 .await
218 .unwrap_or_default();
219
220 content.users.insert(target.into(), grant_level);
221
222 self.services
223 .timeline
224 .build_and_append_pdu(
225 PduBuilder::state(String::new(), &content),
226 &sender,
227 room_id,
228 &state_lock,
229 )
230 .await
231 .map(|_| ())
232}
233
234fn grantable_level(power_levels: &RoomPowerLevels, sender: &UserId) -> Result<Int> {
239 if !power_levels.user_can_send_state(sender, StateEventType::RoomPowerLevels) {
240 return Err!(Request(InvalidParam(
241 "No local admin in room with power to update power levels"
242 )));
243 }
244
245 match power_levels.for_user(sender) {
246 | UserPowerLevel::Infinite => Ok(100.into()),
247 | UserPowerLevel::Int(level) => Ok(level),
248 }
249}
250
251#[implement(super::Service)]
252async fn invite_new_admin(
253 &self,
254 user_id: &UserId,
255 room_id: &RoomId,
256 state_lock: &RoomMutexGuard,
257) -> Result {
258 let server_user = self.services.globals.server_user.as_ref();
259
260 if self.services.globals.user_is_local(user_id) {
263 debug_info!("Inviting local user {user_id} to admin room {room_id}");
264 self.services
265 .timeline
266 .build_and_append_pdu(
267 PduBuilder::state(
268 String::from(user_id),
269 &RoomMemberEventContent::new(MembershipState::Invite),
270 ),
271 server_user,
272 room_id,
273 state_lock,
274 )
275 .await?;
276
277 debug_info!("Force joining local user {user_id} to admin room {room_id}");
278 self.services
279 .timeline
280 .build_and_append_pdu(
281 PduBuilder::state(
282 String::from(user_id),
283 &RoomMemberEventContent::new(MembershipState::Join),
284 ),
285 user_id,
286 room_id,
287 state_lock,
288 )
289 .await?;
290 } else {
291 debug_info!("Inviting remote user {user_id} to admin room {room_id}");
292 self.services
293 .timeline
294 .build_and_append_pdu(
295 PduBuilder::state(
296 user_id.to_string(),
297 &RoomMemberEventContent::new(MembershipState::Invite),
298 ),
299 server_user,
300 room_id,
301 state_lock,
302 )
303 .await?;
304 }
305
306 Ok(())
307}
308
309#[implement(super::Service)]
317pub async fn revoke_admin(&self, user_id: &UserId) -> Result<bool> {
318 use MembershipState::{Invite, Join, Knock, Leave};
319
320 if user_id == self.services.globals.server_user {
321 return Err!(Request(InvalidParam("The server user's admin rights cannot be revoked.")));
322 }
323
324 let Some(room_id) = self.get_admin_room().await.present()? else {
325 return Ok(false);
326 };
327
328 let state_lock = self.services.state.mutex.lock(&room_id).await;
329
330 let Some(event) = self
331 .services
332 .state_accessor
333 .get_member(&room_id, user_id)
334 .await
335 .present()
336 .map_err(|e| err!(error!(?e, "Failure occurred while attempting revoke.")))?
337 .filter(|event| matches!(event.membership, Invite | Knock | Join))
338 else {
339 return Ok(false);
340 };
341
342 self.services
343 .timeline
344 .build_and_append_pdu(
345 PduBuilder::state(user_id.to_string(), &RoomMemberEventContent {
346 membership: Leave,
347 reason: Some("Admin Revoked".into()),
348 is_direct: false,
349 join_authorized_via_users_server: None,
350 third_party_invite: None,
351 ..event
352 }),
353 self.services.globals.server_user.as_ref(),
354 &room_id,
355 &state_lock,
356 )
357 .boxed() .await
359 .map(|_| true)
360}