ate-auth 1.9.0

Represents a standardized data model and API for authenticating an ATE chain-of-trust
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

use error_chain::error_chain;

use crate::request::*;
use ate::prelude::*;

error_chain! {
    types {
        CreateError, CreateErrorKind, ResultExt, Result;
    }
    links {
        QueryError(super::QueryError, super::QueryErrorKind);
        AteError(::ate::error::AteError, ::ate::error::AteErrorKind);
        ChainCreationError(::ate::error::ChainCreationError, ::ate::error::ChainCreationErrorKind);
        SerializationError(::ate::error::SerializationError, ::ate::error::SerializationErrorKind);
        InvokeError(::ate::error::InvokeError, ::ate::error::InvokeErrorKind);
    }
    foreign_links {
        IO(tokio::io::Error);
    }
    errors {
        OperatorBanned {
            description("create failed as the operator is currently banned")
            display("create failed as the operator is currently banned")
        }
        OperatorNotFound {
            description("create failed as the operator could not be found")
            display("create failed as the operator could not be found")
        }
        InvalidArguments {
            description("you did not provide the right type or quantity of arguments")
            display("you did not provide the right type or quantity of arguments")
        }
        AccountSuspended {
            description("create failed as the account is currently suspended")
            display("create failed as the account is currently suspended")
        }
        MissingReadKey {
            description("create failed as the session is missing a read key")
            display("create failed as the session is missing a read key")
        }
        PasswordMismatch {
            description("create failed as the passwords did not match")
            display("create failed as the passwords did not match")
        }
        AlreadyExists(msg: String) {
            description("create failed as the account or group already exists")
            display("create failed - {}", msg)
        }
        InvalidEmail {
            description("create failed as the email address is invalid")
            display("create failed as the email address is invalid")
        }
        NoMoreRoom {
            description("create failed as the account or group as there is no more room - try a different name")
            display("create failed as the account or group as there is no more room - try a different name")
        }
        InvalidName(msg: String) {
            description("create failed as the account or group name is invalid")
            display("create failed - {}", msg)
        }
        NoMasterKey {
            description("create failed as the server has not been properly initialized")
            display("create failed as the server has not been properly initialized")
        }
        ValidationError(reason: String) {
            description("create failed as there was a validation error")
            display("create failed as there was a validation error - {}", reason)
        }
        TermsAndConditions(terms: String) {
            description("create failed as the caller did not agree to the terms and conditions")
            display("create failed as the caller did not agree to the terms and conditions")
        }
        InternalError(code: u16) {
            description("create failed as the server experienced an internal error")
            display("create failed as the server experienced an internal error - code={}", code)
        }
    }
}

impl From<CreateError> for AteError {
    fn from(err: CreateError) -> AteError {
        AteErrorKind::ServiceError(err.to_string()).into()
    }
}

impl From<CreateGroupFailed> for CreateError {
    fn from(err: CreateGroupFailed) -> CreateError {
        match err {
            CreateGroupFailed::OperatorBanned => CreateErrorKind::OperatorBanned.into(),
            CreateGroupFailed::OperatorNotFound => CreateErrorKind::OperatorNotFound.into(),
            CreateGroupFailed::AccountSuspended => CreateErrorKind::AccountSuspended.into(),
            CreateGroupFailed::AlreadyExists(msg) => CreateErrorKind::AlreadyExists(msg).into(),
            CreateGroupFailed::NoMoreRoom => CreateErrorKind::NoMoreRoom.into(),
            CreateGroupFailed::NoMasterKey => CreateErrorKind::NoMasterKey.into(),
            CreateGroupFailed::InvalidGroupName(msg) => CreateErrorKind::InvalidName(msg).into(),
            CreateGroupFailed::ValidationError(reason) => {
                CreateErrorKind::ValidationError(reason).into()
            }
            CreateGroupFailed::InternalError(code) => CreateErrorKind::InternalError(code).into(),
        }
    }
}

impl From<CreateUserFailed> for CreateError {
    fn from(err: CreateUserFailed) -> CreateError {
        match err {
            CreateUserFailed::AlreadyExists(msg) => CreateErrorKind::AlreadyExists(msg).into(),
            CreateUserFailed::InvalidEmail => CreateErrorKind::InvalidEmail.into(),
            CreateUserFailed::NoMasterKey => CreateErrorKind::NoMasterKey.into(),
            CreateUserFailed::NoMoreRoom => CreateErrorKind::NoMoreRoom.into(),
            CreateUserFailed::InternalError(code) => CreateErrorKind::InternalError(code).into(),
            CreateUserFailed::TermsAndConditions(terms) => {
                CreateErrorKind::TermsAndConditions(terms).into()
            }
        }
    }
}