feature 1.增加查询用户信息接口

2. 增加更新密码接口
3. 增加登出控制台接口
issue #29

src/console/api.rs

@@ -9,14 +9,14 @@ use crate::config::core::ConfigActor;
 
 use super::cluster_api::query_cluster_info;
 use super::config_api::query_config_list;
-use super::login_api;
 use super::{
     config_api::{download_config, import_config, query_history_config_page},
     connection_api::query_grpc_connection,
     model::{ConsoleResult, NamespaceInfo},
     naming_api::{query_grpc_client_instance_count, query_ops_instances_list},
     NamespaceUtils,
 };
+use super::{login_api, user_api};
 
 pub async fn query_namespace_list(config_addr: web::Data<Addr<ConfigActor>>) -> impl Responder {
     //HttpResponse::InternalServerError().body("system error")
@@ -120,6 +120,12 @@ pub fn app_config(config: &mut web::ServiceConfig) {
                     .route(web::get().to(query_cluster_info)),
             )
             .service(web::resource("/connections").route(web::get().to(query_grpc_connection)))
-            .service(web::resource("/login/login").route(web::post().to(login_api::login))),
+            .service(web::resource("/login/login").route(web::post().to(login_api::login)))
+            .service(web::resource("/login/logout").route(web::post().to(login_api::logout)))
+            .service(web::resource("/user/info").route(web::get().to(user_api::get_user_info)))
+            .service(
+                web::resource("/user/reset_password")
+                    .route(web::post().to(user_api::reset_password)),
+            ),
     );
 }

src/console/login_api.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use actix_web::{
     cookie::Cookie,
     web::{self, Data},
-    HttpResponse, Responder,
+    HttpRequest, HttpResponse, Responder,
 };
 
 use crate::{
@@ -28,38 +28,59 @@ pub async fn login(
         name: param.username,
         password: param.password,
     };
-    if let Ok(Ok(v)) = app.user_manager.send(msg).await {
-        match v {
-            UserManagerResult::CheckUserResult(valid, user) => {
-                if valid {
-                    //增加长度避免遍历
-                    let token = Arc::new(
-                        uuid::Uuid::new_v4().to_string().replace("-", "")
-                            + &uuid::Uuid::new_v4().to_string().replace("-", ""),
-                    );
-                    let session = Arc::new(UserSession {
-                        username: user.username,
-                        nickname: user.nickname,
-                        ..Default::default()
-                    });
-                    let cache_req = CacheManagerReq::Set {
-                        key: CacheKey::new(CacheType::UserSession, token.clone()),
-                        value: CacheValue::UserSession(session),
-                        ttl: app.sys_config.console_login_timeout,
-                    };
-                    app.cache_manager.do_send(cache_req);
-                    return Ok(HttpResponse::Ok()
-                        .cookie(
-                            Cookie::build("token", token.as_str())
-                                .path("/")
-                                .http_only(true)
-                                .finish(),
-                        )
-                        .json(ApiResult::success(Some(valid))));
-                }
-            }
-            _ => {}
-        };
+    if let Ok(Ok(UserManagerResult::CheckUserResult(valid, user))) =
+        app.user_manager.send(msg).await
+    {
+        if valid {
+            //增加长度避免遍历
+            let token = Arc::new(
+                uuid::Uuid::new_v4().to_string().replace('-', "")
+                    + &uuid::Uuid::new_v4().to_string().replace('-', ""),
+            );
+            let session = Arc::new(UserSession {
+                username: user.username,
+                nickname: user.nickname,
+                ..Default::default()
+            });
+            let cache_req = CacheManagerReq::Set {
+                key: CacheKey::new(CacheType::UserSession, token.clone()),
+                value: CacheValue::UserSession(session),
+                ttl: app.sys_config.console_login_timeout,
+            };
+            app.cache_manager.do_send(cache_req);
+            return Ok(HttpResponse::Ok()
+                .cookie(
+                    Cookie::build("token", token.as_str())
+                        .path("/")
+                        .http_only(true)
+                        .finish(),
+                )
+                .json(ApiResult::success(Some(valid))));
+        }
     }
     Ok(HttpResponse::Ok().json(ApiResult::<()>::error("SYSTEM_ERROR".to_owned(), None)))
 }
+
+pub async fn logout(
+    request: HttpRequest,
+    app: Data<Arc<AppShareData>>,
+) -> actix_web::Result<impl Responder> {
+    let token = if let Some(ck) = request.cookie("token") {
+        ck.value().to_owned()
+    } else if let Some(v) = request.headers().get("Token") {
+        v.to_str().unwrap_or_default().to_owned()
+    } else {
+        "".to_owned()
+    };
+    let token = Arc::new(token);
+    let cache_req = CacheManagerReq::Remove(CacheKey::new(CacheType::UserSession, token));
+    app.cache_manager.do_send(cache_req);
+    return Ok(HttpResponse::Ok()
+        .cookie(
+            Cookie::build("token", "")
+                .path("/")
+                .http_only(true)
+                .finish(),
+        )
+        .json(ApiResult::success(Some(true))));
+}

src/console/mod.rs

@@ -5,6 +5,7 @@ pub mod connection_api;
 pub mod login_api;
 pub mod model;
 pub mod naming_api;
+pub mod user_api;
 
 use std::sync::Arc;
 

src/console/user_api.rs

@@ -0,0 +1,75 @@
+use std::sync::Arc;
+
+use actix_http::HttpMessage;
+use actix_web::{
+    web::{self, Data},
+    HttpRequest, HttpResponse, Responder,
+};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    common::{
+        appdata::AppShareData,
+        model::{ApiResult, UserSession},
+    },
+    user::{UserManagerReq, UserManagerResult},
+};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ResetPasswordParam {
+    pub old_password: String,
+    pub new_password: String,
+}
+
+pub async fn get_user_info(req: HttpRequest) -> actix_web::Result<impl Responder> {
+    if let Some(session) = req.extensions().get::<Arc<UserSession>>() {
+        Ok(HttpResponse::Ok().json(ApiResult::success(Some(session.clone()))))
+    } else {
+        Ok(HttpResponse::Ok().json(ApiResult::<()>::error(
+            "NOT_FOUND_USER_SESSION".to_owned(),
+            None,
+        )))
+    }
+}
+
+pub async fn reset_password(
+    req: HttpRequest,
+    app: Data<Arc<AppShareData>>,
+    web::Form(param): web::Form<ResetPasswordParam>,
+) -> actix_web::Result<impl Responder> {
+    if let Some(session) = req.extensions().get::<Arc<UserSession>>() {
+        let username = Arc::new(session.username.to_string());
+        let msg = UserManagerReq::CheckUser {
+            name: username.clone(),
+            password: param.old_password,
+        };
+        if let Ok(Ok(v)) = app.user_manager.send(msg).await {
+            match v {
+                UserManagerResult::CheckUserResult(valid, _user) => {
+                    if valid {
+                        let msg = UserManagerReq::UpdateUser {
+                            name: username,
+                            nickname: None,
+                            password: Some(param.new_password),
+                        };
+                        if let Ok(Ok(_r)) = app.user_manager.send(msg).await {
+                            return Ok(HttpResponse::Ok().json(ApiResult::success(Some(true))));
+                        }
+                    }
+                }
+                _ => {
+                    return Ok(HttpResponse::Ok().json(ApiResult::<()>::error(
+                        "OLD_PASSWORD_INVALID".to_owned(),
+                        None,
+                    )))
+                }
+            }
+        }
+        Ok(HttpResponse::Ok().json(ApiResult::<()>::error("SYSTEM_ERROR".to_owned(), None)))
+    } else {
+        Ok(HttpResponse::Ok().json(ApiResult::<()>::error(
+            "NOT_FOUND_USER_SESSION".to_owned(),
+            None,
+        )))
+    }
+}

src/middle/login_middle.rs

@@ -78,12 +78,10 @@ where
         let is_page = !API_PATH.is_match(path);
         let token = if let Some(ck) = request.cookie("token") {
             ck.value().to_owned()
+        } else if let Some(v) = request.headers().get("Token") {
+            v.to_str().unwrap_or_default().to_owned()
         } else {
-            if let Some(v) = request.headers().get("Token") {
-                v.to_str().unwrap_or_default().to_owned()
-            } else {
-                "".to_owned()
-            }
+            "".to_owned()
         };
         let token = Arc::new(token);
         let cache_manager = self.app_share_data.cache_manager.clone();
@@ -98,18 +96,16 @@ where
             if is_check_path {
                 is_login = if token.is_empty() {
                     false
+                } else if let Ok(Some(session)) = get_user_session(
+                    &cache_manager,
+                    CacheManagerReq::Get(CacheKey::new(CacheType::UserSession, token.clone())),
+                )
+                .await
+                {
+                    request.extensions_mut().insert(session);
+                    true
                 } else {
-                    if let Ok(Some(session)) = get_user_session(
-                        &cache_manager,
-                        CacheManagerReq::Get(CacheKey::new(CacheType::UserSession, token.clone())),
-                    )
-                    .await
-                    {
-                        request.extensions_mut().insert(session);
-                        true
-                    } else {
-                        false
-                    }
+                    false
                 };
             }
             //log::info!("token: {}|{}|{}|{}|{}|{}",&token,is_page,is_check_path,is_login,request.path(),request.query_string());

src/user/mod.rs

@@ -56,18 +56,15 @@ impl UserManager {
                 offset: None,
                 is_rev: false,
             };
-            match table_manager.send(req).await?? {
-                TableManagerResult::PageListResult(count, _) => {
-                    if count == 0 {
-                        let user_manager_req = UserManagerReq::AddUser {
-                            name: Arc::new("admin".to_owned()),
-                            nickname: "admin".to_owned(),
-                            password: "admin".to_owned(),
-                        };
-                        self_addr.do_send(user_manager_req);
-                    }
+            if let TableManagerResult::PageListResult(count, _) = table_manager.send(req).await?? {
+                if count == 0 {
+                    let user_manager_req = UserManagerReq::AddUser {
+                        name: Arc::new("admin".to_owned()),
+                        nickname: "admin".to_owned(),
+                        password: "admin".to_owned(),
+                    };
+                    self_addr.do_send(user_manager_req);
                 }
-                _ => {}
             }
         }
         Ok(())
@@ -115,7 +112,6 @@ impl Inject for UserManager {
                         }
                     }
                 };
-                ()
             }
             .into_actor(act)
             .map(|_, _, _| {})