From b964063dbb4cd90883ff50eadd255a4d9493d55d Mon Sep 17 00:00:00 2001
From: Simon Goller <neosam+github@posteo.de>
Date: Mon, 29 Apr 2024 06:29:25 +0200
Subject: [PATCH] Finalize permission service

---
 Cargo.lock             |   1 +
 rest/Cargo.toml        |   1 +
 rest/src/permission.rs | 266 ++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 263 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 55a2b25..c92621f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1112,6 +1112,7 @@ dependencies = [
  "bytes",
  "http-body",
  "serde",
+ "serde_json",
  "service",
  "tokio",
  "uuid",
diff --git a/rest/Cargo.toml b/rest/Cargo.toml
index 801ab91..bbecd2f 100644
--- a/rest/Cargo.toml
+++ b/rest/Cargo.toml
@@ -10,6 +10,7 @@ axum = "0.7.5"
 bytes = "1.6.0"
 http-body = "1.0.0"
 serde = "1.0.198"
+serde_json = "1.0.116"
 
 [dependencies.tokio]
 version = "1.37.0"
diff --git a/rest/src/permission.rs b/rest/src/permission.rs
index 3b26440..0b9d12d 100644
--- a/rest/src/permission.rs
+++ b/rest/src/permission.rs
@@ -1,19 +1,81 @@
-use axum::{body::Body, extract::State, response::Response, routing::post, Json, Router};
+use std::sync::Arc;
+
+use axum::{
+    body::Body,
+    extract::State,
+    response::Response,
+    routing::{delete, get, post},
+    Json, Router,
+};
 use serde::{Deserialize, Serialize};
-use uuid::Uuid;
 
 use crate::{error_handler, RestStateDef};
 use service::PermissionService;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct User {
-    #[serde(default)]
-    pub id: Uuid,
     pub name: String,
 }
+impl From<&service::User> for User {
+    fn from(user: &service::User) -> Self {
+        Self {
+            name: user.name.to_string(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Role {
+    pub name: String,
+}
+impl From<&service::Role> for Role {
+    fn from(role: &service::Role) -> Self {
+        Self {
+            name: role.name.to_string(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Privilege {
+    pub name: String,
+}
+impl From<&service::Privilege> for Privilege {
+    fn from(privilege: &service::Privilege) -> Self {
+        Self {
+            name: privilege.name.to_string(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct UserRole {
+    pub user: String,
+    pub role: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RolePrivilege {
+    pub role: String,
+    pub privilege: String,
+}
 
 pub fn generate_route<RestState: RestStateDef>() -> Router<RestState> {
-    Router::new().route("/user/", post(add_user::<RestState>))
+    Router::new()
+        .route("/user/", get(get_all_users::<RestState>))
+        .route("/user/", post(add_user::<RestState>))
+        .route("/user/", delete(remove_user::<RestState>))
+        .route("/role/", get(get_all_roles::<RestState>))
+        .route("/role/", post(add_role::<RestState>))
+        .route("/role/", delete(delete_role::<RestState>))
+        .route("/privilege/", get(get_all_privileges::<RestState>))
+        .route("/user-role/", post(add_user_role::<RestState>))
+        .route("/user-role/", delete(remove_user_role::<RestState>))
+        .route("/role-privilege/", post(add_role_privilege::<RestState>))
+        .route(
+            "/role-privilege/",
+            delete(remove_role_privilege::<RestState>),
+        )
 }
 
 pub async fn add_user<RestState: RestStateDef>(
@@ -27,6 +89,23 @@ pub async fn add_user<RestState: RestStateDef>(
                 .permission_service()
                 .create_user(user.name.as_str())
                 .await?;
+            Ok(Response::builder()
+                .status(201)
+                .body(Body::from(""))
+                .unwrap())
+        })
+        .await,
+    )
+}
+
+pub async fn remove_user<RestState: RestStateDef>(
+    rest_state: State<RestState>,
+    Json(user): Json<String>,
+) -> Response {
+    println!("Removing user: {:?}", user);
+    error_handler(
+        (async {
+            rest_state.permission_service().delete_user(&user).await?;
             Ok(Response::builder()
                 .status(200)
                 .body(Body::from(""))
@@ -35,3 +114,180 @@ pub async fn add_user<RestState: RestStateDef>(
         .await,
     )
 }
+
+pub async fn add_role<RestState: RestStateDef>(
+    rest_state: State<RestState>,
+    Json(role): Json<Role>,
+) -> Response {
+    error_handler(
+        (async {
+            rest_state
+                .permission_service()
+                .create_role(role.name.as_str())
+                .await?;
+            Ok(Response::builder()
+                .status(200)
+                .body(Body::from(""))
+                .unwrap())
+        })
+        .await,
+    )
+}
+
+pub async fn delete_role<RestState: RestStateDef>(
+    rest_state: State<RestState>,
+    Json(role): Json<String>,
+) -> Response {
+    error_handler(
+        (async {
+            rest_state
+                .permission_service()
+                .delete_role(role.as_str())
+                .await?;
+            Ok(Response::builder()
+                .status(200)
+                .body(Body::from(""))
+                .unwrap())
+        })
+        .await,
+    )
+}
+
+pub async fn add_user_role<RestState: RestStateDef>(
+    rest_state: State<RestState>,
+    Json(user_role): Json<UserRole>,
+) -> Response {
+    error_handler(
+        (async {
+            rest_state
+                .permission_service()
+                .add_user_role(user_role.user.as_str(), user_role.role.as_str())
+                .await?;
+            Ok(Response::builder()
+                .status(201)
+                .body(Body::from(""))
+                .unwrap())
+        })
+        .await,
+    )
+}
+
+pub async fn remove_user_role<RestState: RestStateDef>(
+    rest_state: State<RestState>,
+    Json(user_role): Json<UserRole>,
+) -> Response {
+    error_handler(
+        (async {
+            rest_state
+                .permission_service()
+                .delete_user_role(user_role.user.as_str(), user_role.role.as_str())
+                .await?;
+            Ok(Response::builder()
+                .status(200)
+                .body(Body::from(""))
+                .unwrap())
+        })
+        .await,
+    )
+}
+
+pub async fn add_role_privilege<RestState: RestStateDef>(
+    rest_state: State<RestState>,
+    Json(role_privilege): Json<RolePrivilege>,
+) -> Response {
+    error_handler(
+        (async {
+            rest_state
+                .permission_service()
+                .add_role_privilege(
+                    role_privilege.role.as_str(),
+                    role_privilege.privilege.as_str(),
+                )
+                .await?;
+            Ok(Response::builder()
+                .status(201)
+                .body(Body::from(""))
+                .unwrap())
+        })
+        .await,
+    )
+}
+
+pub async fn remove_role_privilege<RestState: RestStateDef>(
+    rest_state: State<RestState>,
+    Json(role_privilege): Json<RolePrivilege>,
+) -> Response {
+    error_handler(
+        (async {
+            rest_state
+                .permission_service()
+                .delete_role_privilege(
+                    role_privilege.role.as_str(),
+                    role_privilege.privilege.as_str(),
+                )
+                .await?;
+            Ok(Response::builder()
+                .status(200)
+                .body(Body::from(""))
+                .unwrap())
+        })
+        .await,
+    )
+}
+
+pub async fn get_all_users<RestState: RestStateDef>(rest_state: State<RestState>) -> Response {
+    error_handler(
+        (async {
+            let users: Arc<[User]> = rest_state
+                .permission_service()
+                .get_all_users()
+                .await?
+                .iter()
+                .map(|u| User::from(u))
+                .collect();
+            Ok(Response::builder()
+                .status(200)
+                .body(Body::from(serde_json::to_string(&users).unwrap()))
+                .unwrap())
+        })
+        .await,
+    )
+}
+
+pub async fn get_all_roles<RestState: RestStateDef>(rest_state: State<RestState>) -> Response {
+    error_handler(
+        (async {
+            let roles: Arc<[Role]> = rest_state
+                .permission_service()
+                .get_all_roles()
+                .await?
+                .iter()
+                .map(|u| Role::from(u))
+                .collect();
+            Ok(Response::builder()
+                .status(200)
+                .body(Body::from(serde_json::to_string(&roles).unwrap()))
+                .unwrap())
+        })
+        .await,
+    )
+}
+
+pub async fn get_all_privileges<RestState: RestStateDef>(rest_state: State<RestState>) -> Response {
+    error_handler(
+        (async {
+            let privileges: Arc<[Privilege]> = rest_state
+                .permission_service()
+                .get_all_privileges()
+                .await?
+                .iter()
+                .map(|u| Privilege::from(u))
+                .collect();
+            Ok(Response::builder()
+                .status(200)
+                .body(Body::from(serde_json::to_string(&privileges).unwrap()))
+                .unwrap())
+        })
+        .await,
+    )
+}