awc-firebase-auth 0.1.0

Simple package for handling Firebase authorization with AWC client
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

use std::fmt;
use serde::{Serialize, Deserialize};

pub enum LoginError {
    EmailNotFound,
    InvalidPassword,
    UserDisabled,
    EmailExists,
    OperationNotAllowed,
    TooManyAttempts,
    Unknown
}

pub enum RegisterError {
    EmailExists,
    OperationNotAllowed,
    TooManyAttempts,
    Unknown
}


impl fmt::Display for LoginError {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            LoginError::EmailNotFound => write!(f, "Email not found"),
            LoginError::InvalidPassword => write!(f, "Invalid password"),
            LoginError::UserDisabled => write!(f, "User disabled"),
            LoginError::EmailExists => write!(f, "Email exists"),
            LoginError::OperationNotAllowed => write!(f, "Operation not allowed"),        
            LoginError::TooManyAttempts => write!(f, "Too many attempts"),
            LoginError::Unknown => write!(f, "Unknown"),
        }
    }
}

impl fmt::Display for RegisterError {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            RegisterError::EmailExists => write!(f, "Email exists"),
            RegisterError::OperationNotAllowed => write!(f, "Operation not allowed"),
            RegisterError::TooManyAttempts => write!(f, "Too many attempts"),
            RegisterError::Unknown => write!(f, "Unknown"),
        }
    }

}

#[derive(Serialize, Deserialize)]
struct ErrorBody {
    domain: String,
    reason: String,
    message: String,
}

#[derive(Serialize, Deserialize)]
pub struct Error {
    errors: Vec<ErrorBody>,
    code: i32,
    message: String,
}

#[derive(Serialize, Deserialize)]
pub struct ErrorContainer {
    pub error: Error,
}

impl Error {
    pub fn register_error(&self) -> RegisterError {
        match self.message.as_str() {
            "EMAIL_EXISTS" => RegisterError::EmailExists,
            "OPERATION_NOT_ALLOWED" => RegisterError::OperationNotAllowed,
            "TOO_MANY_ATTEMPTS_TRY_LATER" => RegisterError::TooManyAttempts,
            _ => RegisterError::Unknown,
        }
    }

    pub fn login_error(&self) -> LoginError {
        match self.message.as_str() {
            "EMAIL_NOT_FOUND" => LoginError::EmailNotFound,
            "INVALID_PASSWORD" => LoginError::InvalidPassword,
            "USER_DISABLED" => LoginError::UserDisabled,
            "EMAIL_EXISTS" => LoginError::EmailExists,
            "OPERATION_NOT_ALLOWED" => LoginError::OperationNotAllowed,
            "TOO_MANY_ATTEMPTS_TRY_LATER" => LoginError::TooManyAttempts,
            _ => LoginError::Unknown,
        }
    }
}