initial commit

src/db.rs

@@ -0,0 +1,47 @@
+use std::fs;
+
+// mod model;
+use crate::model;
+
+pub fn get_all_users() -> Vec<model::User> {
+    let data = fs::read_to_string("users.json").expect("Unable to read file");
+    serde_json::from_str(&data).expect("Unable to parse JSON")
+}
+
+pub fn get_user_by_id(id: String) -> Option<model::User> {
+    let users = get_all_users();
+    users.into_iter().find(|user| user.id == id)
+}
+
+pub fn get_user_by_username(username: &str) -> Option<model::User> {
+    let users = get_all_users();
+    users.into_iter().find(|user| user.username == username)
+}
+
+pub fn insert_user(user: model::User) -> model::GetUserResponse {
+    let mut users = get_all_users();
+    let respuser = model::GetUserResponse {
+        id: user.id.clone(),
+        username: user.username.clone(),
+        email: user.email.clone(),
+        group: user.group.clone(),
+        is_superuser: user.is_superuser.clone(),
+    };
+    users.push(user);
+    let data = serde_json::to_string(&users).expect("Unable to serialize JSON");
+    fs::write("users.json", data).expect("Unable to write file");
+    respuser
+}
+
+pub fn delete_user(id: String) -> bool {
+    let mut users = get_all_users();
+    let user_exists = users.iter().any(|user| user.id == id);
+    if user_exists {
+        users.retain(|user| user.id != id);
+        let data = serde_json::to_string_pretty(&users).expect("Unable to serialize JSON");
+        fs::write("users.json", data).expect("Unable to write file");
+        true
+    } else {
+        false
+    }
+}

src/main.rs

@@ -0,0 +1,91 @@
+use axum::{Json, Router, routing::delete, routing::post};
+use std::net::SocketAddr;
+
+mod db;
+mod model;
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt::init();
+
+    let app = Router::new()
+        .route("/api/users", post(get_all_users_handler))
+        .route("/api/users/user", post(get_user_by_id_handler))
+        .route(
+            "/api/users/user/username",
+            post(get_user_by_username_handler),
+        )
+        .route("/api/users/add", post(add_user_handler))
+        .route("/api/users", delete(delete_user_handler));
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], 8888));
+    println!("Сервер запускается на {}", addr);
+
+    axum::serve(tokio::net::TcpListener::bind(addr).await.unwrap(), app)
+        .await
+        .unwrap();
+}
+
+async fn get_all_users_handler() -> Json<Vec<model::GetUserResponse>> {
+    let users = db::get_all_users();
+    let mapped_users = users
+        .into_iter()
+        .map(|user| model::GetUserResponse {
+            id: user.id,
+            username: user.username,
+            email: user.email,
+            group: user.group,
+            is_superuser: user.is_superuser,
+        })
+        .collect();
+    Json(mapped_users)
+}
+
+async fn get_user_by_id_handler(
+    Json(payload): Json<model::GetUserByIdRequest>,
+) -> Json<Option<model::GetUserResponse>> {
+    let user = db::get_user_by_id(payload.id);
+    let mapped_user = user.map(|user| model::GetUserResponse {
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        group: user.group,
+        is_superuser: user.is_superuser,
+    });
+    Json(mapped_user)
+}
+
+async fn get_user_by_username_handler(
+    Json(payload): Json<model::GetUserByUsernameRequest>,
+) -> Json<Option<model::GetUserResponse>> {
+    let user = db::get_user_by_username(&payload.username);
+    let mapped_user = user.map(|user| model::GetUserResponse {
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        group: user.group,
+        is_superuser: user.is_superuser,
+    });
+    Json(mapped_user)
+}
+
+async fn add_user_handler(
+    Json(payload): Json<model::AddUserRequest>,
+) -> Json<model::GetUserResponse> {
+    let user = model::User {
+        id: payload.id.clone(),
+        username: payload.username.clone(),
+        email: payload.email.clone(),
+        password: payload.password.clone(),
+        group: payload.group.clone(),
+        is_superuser: payload.is_superuser,
+    };
+    Json(db::insert_user(user))
+}
+
+async fn delete_user_handler(
+    Json(payload): Json<model::DeleteUserRequest>,
+) -> Json<model::DeleteUserResponse> {
+    let deleted: bool = db::delete_user(payload.id);
+    Json(model::DeleteUserResponse { success: deleted })
+}

src/model.rs

@@ -0,0 +1,50 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+pub struct User {
+    pub id: String,
+    pub username: String,
+    pub email: String,
+    pub password: String,
+    pub group: String,
+    pub is_superuser: bool,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GetUserByIdRequest {
+    pub id: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GetUserByUsernameRequest {
+    pub username: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct AddUserRequest {
+    pub id: String,
+    pub username: String,
+    pub email: String,
+    pub password: String,
+    pub group: String,
+    pub is_superuser: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct GetUserResponse {
+    pub id: String,
+    pub username: String,
+    pub email: String,
+    pub group: String,
+    pub is_superuser: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct DeleteUserRequest {
+    pub id: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct DeleteUserResponse {
+    pub success: bool,
+}