Set can_request_admin API

crates/handlers/src/admin/model.rs

@@ -54,7 +54,7 @@ pub struct User {
     locked_at: Option<DateTime<Utc>>,
 
     /// Whether the user can request admin privileges.
-    can_request_admin: bool,
+    admin: bool,
 }
 
 impl User {
@@ -66,21 +66,21 @@ impl User {
                 username: "alice".to_owned(),
                 created_at: DateTime::default(),
                 locked_at: None,
-                can_request_admin: false,
+                admin: false,
             },
             Self {
                 id: Ulid::from_bytes([0x02; 16]),
                 username: "bob".to_owned(),
                 created_at: DateTime::default(),
                 locked_at: None,
-                can_request_admin: true,
+                admin: true,
             },
             Self {
                 id: Ulid::from_bytes([0x03; 16]),
                 username: "charlie".to_owned(),
                 created_at: DateTime::default(),
                 locked_at: Some(DateTime::default()),
-                can_request_admin: false,
+                admin: false,
             },
         ]
     }
@@ -93,7 +93,7 @@ impl From<mas_data_model::User> for User {
             username: user.username,
             created_at: user.created_at,
             locked_at: user.locked_at,
-            can_request_admin: user.can_request_admin,
+            admin: user.can_request_admin,
         }
     }
 }

crates/handlers/src/admin/v1/mod.rs

@@ -60,6 +60,10 @@ where
             "/users/by-username/:username",
             get_with(self::users::by_username, self::users::by_username_doc),
         )
+        .api_route(
+            "/users/:id/set-admin",
+            post_with(self::users::set_admin, self::users::set_admin_doc),
+        )
         .api_route(
             "/users/:id/deactivate",
             post_with(self::users::deactivate, self::users::deactivate_doc),

crates/handlers/src/admin/v1/users/list.rs

@@ -55,9 +55,9 @@ impl std::fmt::Display for UserStatus {
 #[aide(input_with = "Query<FilterParams>")]
 #[from_request(via(Query), rejection(RouteError))]
 pub struct FilterParams {
-    /// Retrieve users with (or without) the `can_request_admin` flag set
-    #[serde(rename = "filter[can_request_admin]")]
-    can_request_admin: Option<bool>,
+    /// Retrieve users with (or without) the `admin` flag set
+    #[serde(rename = "filter[admin]")]
+    admin: Option<bool>,
 
     /// Retrieve the items with the given status
     ///
@@ -74,8 +74,8 @@ impl std::fmt::Display for FilterParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut sep = '?';
 
-        if let Some(can_request_admin) = self.can_request_admin {
-            write!(f, "{sep}filter[can_request_admin]={can_request_admin}")?;
+        if let Some(admin) = self.admin {
+            write!(f, "{sep}filter[admin]={admin}")?;
             sep = '&';
         }
         if let Some(status) = self.status {
@@ -139,7 +139,7 @@ pub async fn handler(
     let base = format!("{path}{params}", path = User::PATH);
     let filter = UserFilter::default();
 
-    let filter = match params.can_request_admin {
+    let filter = match params.admin {
         Some(true) => filter.can_request_admin_only(),
         Some(false) => filter.cannot_request_admin_only(),
         None => filter,

crates/handlers/src/admin/v1/users/mod.rs

@@ -18,6 +18,7 @@ mod deactivate;
 mod get;
 mod list;
 mod lock;
+mod set_admin;
 mod set_password;
 mod unlock;
 
@@ -28,6 +29,7 @@ pub use self::{
     get::{doc as get_doc, handler as get},
     list::{doc as list_doc, handler as list},
     lock::{doc as lock_doc, handler as lock},
+    set_admin::{doc as set_admin_doc, handler as set_admin},
     set_password::{doc as set_password_doc, handler as set_password},
     unlock::{doc as unlock_doc, handler as unlock},
 };

crates/handlers/src/admin/v1/users/set_admin.rs

@@ -0,0 +1,167 @@
+// Copyright 2024 The Matrix.org Foundation C.I.C.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use aide::{transform::TransformOperation, OperationIo};
+use axum::{response::IntoResponse, Json};
+use hyper::StatusCode;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use ulid::Ulid;
+
+use crate::{
+    admin::{
+        call_context::CallContext,
+        model::{Resource, User},
+        params::UlidPathParam,
+        response::{ErrorResponse, SingleResponse},
+    },
+    impl_from_error_for_route,
+};
+
+#[derive(Debug, thiserror::Error, OperationIo)]
+#[aide(output_with = "Json<ErrorResponse>")]
+pub enum RouteError {
+    #[error(transparent)]
+    Internal(Box<dyn std::error::Error + Send + Sync + 'static>),
+
+    #[error("User ID {0} not found")]
+    NotFound(Ulid),
+}
+
+impl_from_error_for_route!(mas_storage::RepositoryError);
+
+impl IntoResponse for RouteError {
+    fn into_response(self) -> axum::response::Response {
+        let error = ErrorResponse::from_error(&self);
+        let status = match self {
+            Self::Internal(_) => StatusCode::INTERNAL_SERVER_ERROR,
+            Self::NotFound(_) => StatusCode::NOT_FOUND,
+        };
+        (status, Json(error)).into_response()
+    }
+}
+
+/// # JSON payload for the `POST /api/admin/v1/users/:id/set-admin` endpoint
+#[derive(Deserialize, JsonSchema)]
+#[serde(rename = "UserSetAdminRequest")]
+pub struct Request {
+    /// Whether the user can request admin privileges.
+    admin: bool,
+}
+
+pub fn doc(operation: TransformOperation) -> TransformOperation {
+    operation
+        .id("userSetAdmin")
+        .summary("Set whether a user can request admin")
+        .description("Calling this endpoint will not have any effect on existing sessions, meaning that their existing sessions will keep admin access if they were granted it.")
+        .tag("user")
+        .response_with::<200, Json<SingleResponse<User>>, _>(|t| {
+            // In the samples, the second user is the one which can request admin
+            let [_alice, bob, ..] = User::samples();
+            let id = bob.id();
+            let response = SingleResponse::new(bob, format!("/api/admin/v1/users/{id}/set-admin"));
+            t.description("User had admin privileges set").example(response)
+        })
+        .response_with::<404, RouteError, _>(|t| {
+            let response = ErrorResponse::from_error(&RouteError::NotFound(Ulid::nil()));
+            t.description("User ID not found").example(response)
+        })
+}
+
+#[tracing::instrument(name = "handler.admin.v1.users.set_admin", skip_all, err)]
+pub async fn handler(
+    CallContext { mut repo, .. }: CallContext,
+    id: UlidPathParam,
+    Json(params): Json<Request>,
+) -> Result<Json<SingleResponse<User>>, RouteError> {
+    let id = *id;
+    let user = repo
+        .user()
+        .lookup(id)
+        .await?
+        .ok_or(RouteError::NotFound(id))?;
+
+    let user = repo
+        .user()
+        .set_can_request_admin(user, params.admin)
+        .await?;
+
+    repo.save().await?;
+
+    Ok(Json(SingleResponse::new(
+        User::from(user),
+        format!("/api/admin/v1/users/{id}/set-admin"),
+    )))
+}
+
+#[cfg(test)]
+mod tests {
+    use hyper::{Request, StatusCode};
+    use mas_storage::{user::UserRepository, RepositoryAccess};
+    use sqlx::PgPool;
+
+    use crate::test_utils::{setup, RequestBuilderExt, ResponseExt, TestState};
+
+    #[sqlx::test(migrator = "mas_storage_pg::MIGRATOR")]
+    async fn test_change_can_request_admin(pool: PgPool) {
+        setup();
+        let mut state = TestState::from_pool(pool).await.unwrap();
+        let token = state.token_with_scope("urn:mas:admin").await;
+
+        let mut repo = state.repository().await.unwrap();
+        let user = repo
+            .user()
+            .add(&mut state.rng(), &state.clock, "alice".to_owned())
+            .await
+            .unwrap();
+        repo.save().await.unwrap();
+
+        let request = Request::post(format!("/api/admin/v1/users/{}/set-admin", user.id))
+            .bearer(&token)
+            .json(serde_json::json!({
+                "admin": true,
+            }));
+
+        let response = state.request(request).await;
+        response.assert_status(StatusCode::OK);
+        let body: serde_json::Value = response.json();
+
+        assert_eq!(body["data"]["attributes"]["admin"], true);
+
+        // Look at the state from the repository
+        let mut repo = state.repository().await.unwrap();
+        let user = repo.user().lookup(user.id).await.unwrap().unwrap();
+        assert!(user.can_request_admin);
+        repo.save().await.unwrap();
+
+        // Flip it back
+        let request = Request::post(format!("/api/admin/v1/users/{}/set-admin", user.id))
+            .bearer(&token)
+            .json(serde_json::json!({
+                "admin": false,
+            }));
+
+        let response = state.request(request).await;
+        response.assert_status(StatusCode::OK);
+        let body: serde_json::Value = response.json();
+
+        assert_eq!(body["data"]["attributes"]["admin"], false);
+
+        // Look at the state from the repository
+        let mut repo = state.repository().await.unwrap();
+        let user = repo.user().lookup(user.id).await.unwrap().unwrap();
+        assert!(!user.can_request_admin);
+        repo.save().await.unwrap();
+    }
+}