fistinc-auth 0.1.0

Paging types for Fist Inc bank
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

use actix_web::{HttpResponse, web};
use email_address::EmailAddress;
use fistinc_errors::{ApiError, ApiResult, CommonError};
use fistinc_paging::{Paging, QueryParamsImpl};
use phonenumber::PhoneNumber;
use serde::{Deserialize, Serialize};
use uuid::Uuid;

use crate::api::models::UserIdentity;
use crate::domain::entity::{Role, User};
use crate::domain::services::UserService;

#[derive(Serialize, Deserialize)]
pub struct CreateUserRequest {
    email: EmailAddress,
    phone: PhoneNumber,
    role: Role,
    password: String,
}

impl Into<User> for CreateUserRequest {
    fn into(self) -> User {
        User {
            id: Uuid::new_v4(),
            email: self.email,
            phone: self.phone,
            role: self.role,
            password: self.password,
        }
    }
}

pub async fn create_user(
    user_service: web::Data<dyn UserService>,
    params: web::Json<CreateUserRequest>,
    identity: UserIdentity,
) -> ApiResult<web::Json<User>> {
    if identity.role != Role::Administrator {
        return Err(ApiError::from(CommonError {
            message: "Have not permission".to_string(),
            code: 401,
        }));
    }
    let user = params.0.into();
    let created_user = user_service.create(user).await?;
    Ok(web::Json(created_user))
}

pub async fn get_users(
    user_service: web::Data<dyn UserService>,
    params: web::Data<QueryParamsImpl>,
    identity: UserIdentity,
) -> ApiResult<web::Json<Paging<User>>> {
    if identity.role != Role::Administrator {
        return Err(ApiError::from(CommonError {
            message: "Have not permission".to_string(),
            code: 401,
        }));
    }
    let users = user_service.users(params.get_ref()).await?;
    Ok(web::Json(users))
}

pub async fn get_user_by_id(
    user_service: web::Data<dyn UserService>,
    user_id: web::Path<String>,
    identity: UserIdentity,
) -> ApiResult<web::Json<Option<User>>> {
    if identity.role != Role::Administrator {
        return Err(ApiError::from(CommonError {
            message: "Have not permission".to_string(),
            code: 401,
        }));
    }
    match Uuid::parse_str(&*user_id) {
        Ok(user_id) => {
            Ok(web::Json(user_service.find_by_id(user_id).await?))
        }
        Err(e) => Err(ApiError::from(CommonError {
            message: e.to_string(),
            code: 400,
        }))
    }
}

pub async fn delete_user(
    user_service: web::Data<dyn UserService>,
    user_id: web::Path<String>,
    identity: UserIdentity,
) -> Result<web::HttpResponse, ApiError> {
    if identity.role != Role::Administrator {
        return Err(ApiError::from(CommonError {
            message: "Have not permission".to_string(),
            code: 401,
        }));
    }
    match Uuid::parse_str(&*user_id) {
        Ok(user_id) => {
            user_service.delete_by_id(user_id).await?;
            Ok(HttpResponse::NoContent().finish())
        }
        Err(e) => Err(ApiError::from(CommonError {
            message: e.to_string(),
            code: 400,
        }))
    }
}