rnacos 0.8.3

Nacos server re-implemented in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::common::appdata::AppShareData;
use crate::common::model::{ApiResult, PageResult, UserSession};
use crate::console::model::user_model::{UpdateUserInfoParam, UserPageParams};
use crate::user::{UserManagerReq, UserManagerResult};
use actix_http::HttpMessage;
use actix_web::web::Data;
use actix_web::{web, HttpRequest, HttpResponse, Responder};
use std::sync::Arc;

use crate::console::user_api::ResetPasswordParam;
pub use crate::console::user_api::{get_user_info, get_user_web_resources};
use crate::user::model::UserDto;

pub async fn reset_password(
    req: HttpRequest,
    app: Data<Arc<AppShareData>>,
    web::Json(param): web::Json<ResetPasswordParam>,
) -> actix_web::Result<impl Responder> {
    let (msg, username) = if let Some(session) = req.extensions().get::<Arc<UserSession>>() {
        let username = Arc::new(session.username.to_string());
        (
            UserManagerReq::CheckUser {
                name: username.clone(),
                password: param.old_password,
            },
            username,
        )
    } else {
        return Ok(HttpResponse::Ok().json(ApiResult::<()>::error(
            "NOT_FOUND_USER_SESSION".to_owned(),
            None,
        )));
    };
    if let Ok(Ok(v)) = app.user_manager.send(msg).await {
        match v {
            UserManagerResult::CheckUserResult(valid, _user) => {
                if valid {
                    let msg = UserManagerReq::UpdateUser {
                        user: UserDto {
                            username,
                            password: Some(param.new_password),
                            ..Default::default()
                        },
                        namespace_privilege_param: None,
                    };
                    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)))
}

pub async fn get_user_page_list(
    app: Data<Arc<AppShareData>>,
    web::Query(param): web::Query<UserPageParams>,
) -> actix_web::Result<impl Responder> {
    let (limit, offset) = param.get_limit_info();
    let msg = UserManagerReq::QueryPageList {
        like_username: param.like_username,
        offset: Some(offset as i64),
        limit: Some(limit as i64),
        is_rev: param.is_rev.unwrap_or_default(),
    };
    match app.user_manager.send(msg).await.unwrap().unwrap() {
        UserManagerResult::UserPageResult(total_count, list) => {
            Ok(HttpResponse::Ok().json(ApiResult::success(Some(PageResult { total_count, list }))))
        }
        _ => Ok(HttpResponse::Ok().json(ApiResult::<()>::error(
            "NOT_FOUND_USER".to_owned(),
            Some("result type is error".to_owned()),
        ))),
    }
}

pub async fn add_user(
    app: Data<Arc<AppShareData>>,
    web::Json(user_param): web::Json<UpdateUserInfoParam>,
) -> actix_web::Result<impl Responder> {
    let namespace_privilege_param = user_param.namespace_privilege_param.clone();
    let user: UserDto = user_param.into();
    if user.roles.is_none() {
        return Ok(HttpResponse::Ok().json(ApiResult::<()>::error(
            "USER_ROLE_IS_EMPTY".to_string(),
            Some("user roles is empty".to_owned()),
        )));
    }
    let msg = UserManagerReq::AddUser {
        user: UserDto {
            username: user.username,
            password: Some(user.password.unwrap_or_default()),
            gmt_create: None,
            gmt_modified: None,
            ..user
        },
        namespace_privilege_param,
    };
    app.user_manager.send(msg).await.ok();
    Ok(HttpResponse::Ok().json(ApiResult::success(Some(true))))
}

pub async fn update_user(
    app: Data<Arc<AppShareData>>,
    web::Json(user_param): web::Json<UpdateUserInfoParam>,
) -> actix_web::Result<impl Responder> {
    let namespace_privilege_param = user_param.namespace_privilege_param.clone();
    let user: UserDto = user_param.into();
    let msg = UserManagerReq::UpdateUser {
        user: UserDto {
            username: user.username,
            gmt_create: None,
            ..user
        },
        namespace_privilege_param,
    };
    app.user_manager.send(msg).await.ok();
    Ok(HttpResponse::Ok().json(ApiResult::success(Some(true))))
}

pub async fn remove_user(
    app: Data<Arc<AppShareData>>,
    web::Json(user): web::Json<UpdateUserInfoParam>,
) -> actix_web::Result<impl Responder> {
    let msg = UserManagerReq::Remove {
        username: user.username,
    };
    app.user_manager.send(msg).await.ok();
    Ok(HttpResponse::Ok().json(ApiResult::success(Some(true))))
}