user-service 0.4.1

A user management microservice.
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

use super::*;

#[derive(Deserialize, AsChangeset)]
#[diesel(table_name = schema::user)]
pub struct Request {
    pub email: Option<String>,
    pub password: Option<String>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "::serde_with::rust::double_option"
    )]
    pub first_name: Option<Option<String>>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "::serde_with::rust::double_option"
    )]
    pub last_name: Option<Option<String>>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "::serde_with::rust::double_option"
    )]
    pub birthday: Option<Option<time::Date>>,
}

#[put("")]
pub async fn route(
    db: web::Data<Database>,
    info: web::Path<Info>,
    req: web::Json<Request>,
) -> impl Responder {
    let mut req = req.into_inner();

    if !valid(&req) {
        return Err(ErrorCode::BadRequest);
    }

    if let Some(password) = req.password {
        let hashed_password = hashing::generate(&password);
        req.password = Some(hashed_password);
    }

    let response: Result<usize, diesel::result::Error> = web::block(move || {
        use diesel::dsl::*;
        use schema::user::dsl::*;
        let mut conn = db.get_conn();

        conn.transaction(|conn| {
            update(user.filter(id.eq(info.user_id)))
                .set(req)
                .execute(conn)
        })
    })
    .await
    .unwrap();

    match response {
        Err(_) => Err(ErrorCode::Conflict),
        Ok(_) => Ok(HttpResponse::Ok()),
    }
}

fn valid(req: &Request) -> bool {
    if req.email.is_some() {
        if !user_client::validate::email(req.email.as_ref().unwrap()) {
            return false;
        }
    }

    if req.password.is_some() {
        if !user_client::validate::password(req.password.as_ref().unwrap()) {
            return false;
        }
    }

    if req.first_name.is_some() {
        if req.first_name.as_ref().unwrap().is_some() {
            if !user_client::validate::first_name(
                req.first_name.as_ref().unwrap().as_ref().unwrap(),
            ) {
                return false;
            }
        }
    }

    if req.last_name.is_some() {
        if req.last_name.as_ref().unwrap().is_some() {
            if !user_client::validate::last_name(req.last_name.as_ref().unwrap().as_ref().unwrap())
            {
                return false;
            }
        }
    }

    if req.birthday.is_some() {
        if req.birthday.unwrap().is_some() {
            if !user_client::validate::birthday(&req.birthday.unwrap().unwrap()) {
                return false;
            }
        }
    }

    true
}