feat(api): add group management interfaces

Resolves: #18
stack-rs · Aug 9, 2024 · 37d26a4 · 37d26a4
1 parent f150694
commit 37d26a4
Show file tree

Hide file tree

Showing 7 changed files with 437 additions and 53 deletions.
diff --git a/netmito/src/api/group.rs b/netmito/src/api/group.rs
@@ -1,33 +1,86 @@
-use axum::{extract::State, Extension, Json};
-use sea_orm::DbErr;
+use axum::{
+    extract::{Path, State},
+    middleware,
+    routing::{post, put},
+    Extension, Json, Router,
+};
 
 use crate::{
     config::InfraPool,
     error::{ApiError, ApiResult},
     schema::*,
-    service::{self, auth::AuthUser, name_validator},
+    service::{
+        self,
+        auth::{user_auth_middleware, AuthUser},
+    },
 };
 
+pub fn group_router(st: InfraPool) -> Router<InfraPool> {
+    Router::new()
+        .route("/", post(create_group))
+        .route(
+            "/:group/users",
+            put(update_user_group).delete(remove_user_group),
+        )
+        .layer(middleware::from_fn_with_state(
+            st.clone(),
+            user_auth_middleware,
+        ))
+        .with_state(st)
+}
+
 pub async fn create_group(
     Extension(u): Extension<AuthUser>,
     State(pool): State<InfraPool>,
     Json(req): Json<CreateGroupReq>,
 ) -> ApiResult<()> {
-    if !name_validator(&req.group_name) {
-        Err(ApiError::InvalidRequest("Invalid group name".to_string()))
-    } else {
-        match service::group::create_group(&pool.db, u.id, req.group_name.clone()).await {
-            Ok(_) => Ok(()),
-            Err(e) => match e {
-                crate::error::Error::ApiError(e) => Err(e),
-                crate::error::Error::DbError(DbErr::RecordNotInserted) => {
-                    Err(ApiError::AlreadyExists(req.group_name))
-                }
-                _ => {
-                    tracing::error!("{}", e);
-                    Err(ApiError::InternalServerError)
-                }
-            },
-        }
-    }
+    service::group::create_group(&pool.db, u.id, req.group_name.clone())
+        .await
+        .map_err(|e| match e {
+            crate::error::Error::AuthError(err) => ApiError::AuthError(err),
+            crate::error::Error::ApiError(e) => e,
+            _ => {
+                tracing::error!("{}", e);
+                ApiError::InternalServerError
+            }
+        })?;
+    Ok(())
+}
+
+pub async fn update_user_group(
+    Extension(u): Extension<AuthUser>,
+    State(pool): State<InfraPool>,
+    Path(group): Path<String>,
+    Json(req): Json<UpdateUserGroupRoleReq>,
+) -> ApiResult<()> {
+    service::group::update_user_group_role(u.id, group, req.relations, &pool)
+        .await
+        .map_err(|e| match e {
+            crate::error::Error::AuthError(err) => ApiError::AuthError(err),
+            crate::error::Error::ApiError(e) => e,
+            _ => {
+                tracing::error!("{}", e);
+                ApiError::InternalServerError
+            }
+        })?;
+    Ok(())
+}
+
+pub async fn remove_user_group(
+    Extension(u): Extension<AuthUser>,
+    State(pool): State<InfraPool>,
+    Path(group): Path<String>,
+    Json(req): Json<RemoveUserGroupRoleReq>,
+) -> ApiResult<()> {
+    service::group::remove_user_group_role(u.id, group, req.users, &pool)
+        .await
+        .map_err(|e| match e {
+            crate::error::Error::AuthError(err) => ApiError::AuthError(err),
+            crate::error::Error::ApiError(e) => e,
+            _ => {
+                tracing::error!("{}", e);
+                ApiError::InternalServerError
+            }
+        })?;
+    Ok(())
 }
diff --git a/netmito/src/api/mod.rs b/netmito/src/api/mod.rs
@@ -36,13 +36,14 @@ pub fn router(st: InfraPool) -> Router {
             .route("/login", post(user::login_user))
             .nest("/user", user::user_router(st.clone()))
             .nest("/admin", admin::admin_router(st.clone()))
-            .route(
-                "/group",
-                post(group::create_group).layer(middleware::from_fn_with_state(
-                    st.clone(),
-                    user_auth_middleware,
-                )),
-            )
+            .nest("/groups", group::group_router(st.clone()))
+            // .route(
+            //     "/group",
+            //     post(group::create_group).layer(middleware::from_fn_with_state(
+            //         st.clone(),
+            //         user_auth_middleware,
+            //     )),
+            // )
             .route(
                 "/worker",
                 post(worker::register).layer(middleware::from_fn_with_state(
@@ -63,13 +64,14 @@ pub fn router(st: InfraPool) -> Router {
             .route("/login", post(user::login_user))
             .nest("/user", user::user_router(st.clone()))
             .nest("/admin", admin::admin_router(st.clone()))
-            .route(
-                "/group",
-                post(group::create_group).layer(middleware::from_fn_with_state(
-                    st.clone(),
-                    user_auth_middleware,
-                )),
-            )
+            .nest("/groups", group::group_router(st.clone()))
+            // .route(
+            //     "/group",
+            //     post(group::create_group).layer(middleware::from_fn_with_state(
+            //         st.clone(),
+            //         user_auth_middleware,
+            //     )),
+            // )
             .route(
                 "/worker",
                 post(worker::register).layer(middleware::from_fn_with_state(

diff --git a/netmito/src/client.rs b/netmito/src/client.rs
@@ -15,8 +15,8 @@ use crate::{
         client::{
             CancelWorkerArgs, ClientCommand, ClientInteractiveShell, CreateCommands,
             CreateGroupArgs, CreateUserArgs, GetArtifactArgs, GetAttachmentArgs, GetCommands,
-            GetTaskArgs, GetWorkerArgs, ManageCommands, ManageTaskCommands, ManageWorkerCommands,
-            SubmitTaskArgs, UploadAttachmentArgs,
+            GetTaskArgs, GetWorkerArgs, ManageCommands, ManageGroupCommands, ManageTaskCommands,
+            ManageWorkerCommands, SubmitTaskArgs, UploadAttachmentArgs,
         },
         ClientConfig, ClientConfigCli,
     },
@@ -25,10 +25,11 @@ use crate::{
     schema::{
         AttachmentQueryInfo, AttachmentsQueryReq, ChangeTaskReq, CreateGroupReq, CreateUserReq,
         ParsedTaskQueryInfo, RedisConnectionInfo, RemoteResource, RemoteResourceDownloadResp,
-        RemoveGroupWorkerRoleReq, ReplaceWorkerTagsReq, ResourceDownloadInfo, SubmitTaskReq,
-        SubmitTaskResp, TaskQueryInfo, TaskQueryResp, TasksQueryReq, UpdateGroupWorkerRoleReq,
-        UpdateTaskLabelsReq, UploadAttachmentReq, UploadAttachmentResp, WorkerQueryInfo,
-        WorkerQueryResp, WorkersQueryReq, WorkersQueryResp,
+        RemoveGroupWorkerRoleReq, RemoveUserGroupRoleReq, ReplaceWorkerTagsReq,
+        ResourceDownloadInfo, SubmitTaskReq, SubmitTaskResp, TaskQueryInfo, TaskQueryResp,
+        TasksQueryReq, UpdateGroupWorkerRoleReq, UpdateTaskLabelsReq, UpdateUserGroupRoleReq,
+        UploadAttachmentReq, UploadAttachmentResp, WorkerQueryInfo, WorkerQueryResp,
+        WorkersQueryReq, WorkersQueryResp,
     },
     service::{
         auth::cred::get_user_credential,
@@ -499,7 +500,7 @@ impl MitoClient {
     }
 
     pub async fn create_group(&mut self, args: CreateGroupArgs) -> crate::error::Result<()> {
-        self.url.set_path("group");
+        self.url.set_path("groups");
         let req = CreateGroupReq {
             group_name: args.name,
         };
@@ -955,6 +956,48 @@ impl MitoClient {
         }
     }
 
+    pub async fn update_user_group_roles(
+        &mut self,
+        group: String,
+        args: UpdateUserGroupRoleReq,
+    ) -> crate::error::Result<()> {
+        self.url.set_path(&format!("groups/{}/users", group));
+        let resp = self
+            .http_client
+            .put(self.url.as_str())
+            .json(&args)
+            .bearer_auth(&self.credential)
+            .send()
+            .await
+            .map_err(map_reqwest_err)?;
+        if resp.status().is_success() {
+            Ok(())
+        } else {
+            Err(get_error_from_resp(resp).await.into())
+        }
+    }
+
+    pub async fn remove_user_group_roles(
+        &mut self,
+        group: String,
+        args: RemoveUserGroupRoleReq,
+    ) -> crate::error::Result<()> {
+        self.url.set_path(&format!("groups/{}/users", group));
+        let resp = self
+            .http_client
+            .delete(self.url.as_str())
+            .json(&args)
+            .bearer_auth(&self.credential)
+            .send()
+            .await
+            .map_err(map_reqwest_err)?;
+        if resp.status().is_success() {
+            Ok(())
+        } else {
+            Err(get_error_from_resp(resp).await.into())
+        }
+    }
+
     pub async fn quit(self) {}
 
     pub async fn handle_command<T>(&mut self, cmd: T) -> bool
@@ -1210,6 +1253,31 @@ impl MitoClient {
                         }
                     }
                 }
+                ManageCommands::Group(args) => {
+                    let group = args.group;
+                    match args.command {
+                        ManageGroupCommands::Update(args) => {
+                            match self.update_user_group_roles(group, args.into()).await {
+                                Ok(_) => {
+                                    tracing::info!("User group roles updated successfully");
+                                }
+                                Err(e) => {
+                                    tracing::error!("{}", e);
+                                }
+                            }
+                        }
+                        ManageGroupCommands::Remove(args) => {
+                            match self.remove_user_group_roles(group, args.into()).await {
+                                Ok(_) => {
+                                    tracing::info!("User group roles removed successfully");
+                                }
+                                Err(e) => {
+                                    tracing::error!("{}", e);
+                                }
+                            }
+                        }
+                    }
+                }
             },
             ClientCommand::Quit => {
                 return false;