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
138
139
140
141
142
143
144
145
146
147

//! The 'high-level' bindings to the Authy TOTP API.
//!
//! Please see [api::user](../api/user/index.html) for more details.

use std::collections::HashMap;

use error::AuthyError;
use client::{Client, Status};
use api;
pub use api::user::{PhoneCall, ActivityType};

/// An Authy user as part of the 'high level' Authy interface.
///
/// Please see [api::user](../api/user/index.html) for more details.
#[derive(Debug, Clone, Default, Eq, PartialEq, Serialize, Deserialize)]
pub struct User {
    /// The authy id for the user.
    pub id: u32,

    /// true when the Authy Mobile/Desktop App was registered.
    pub registered: bool,

    /// true when the user has used a valid code before.
    pub confirmed: bool,

    /// Has the account been marked for deletion
    pub account_disabled: bool,

    /// The country code listed for the user.
    pub country_code: u16,

    /// The last 4 of the phone number registered to the account.
    pub phone_number: String,

    /// (Unknown, API documentation doesn't list)
    pub has_hard_token: bool,

    /// List of devices, options are: android, android_tablet, ios, authy_chrome, sms.
    pub devices: Vec<String>,
}

impl User {
    /// Create a new user with the Authy service. Returns a `User` populated
    /// with data from the 'status' API call. The id returned must be stored
    /// and used future interactions with Authy for the user.
    ///
    /// Please see [api::user::create](../api/user/fn.create.html)
    pub fn create(c: &Client, email: &str, country_code: u16, phone: &str, send_instructions: bool) -> Result<User, AuthyError> {
        let (status, user_new) = api::user::create(c, email, country_code, phone, send_instructions)?;
        assert!(status.success);

        Self::find(c, user_new.id)
    }

    /// Returns a `User` populated with data from the `status` API call for the
    /// given authy id.
    ///
    /// Please see [api::user::status](../api/user/fn.status.html)
    pub fn find(c: &Client, id: u32) -> Result<User, AuthyError> {
        let mut u = User { id: id, ..User::default() };
        u.update(c)?;
        Ok(u)
    }

    /// Updates the `User` with the latest data from authy's service.
    ///
    /// Please see [api::user::status](../api/user/fn.status.html)
    pub fn update(&mut self, c: &Client) -> Result<(), AuthyError> {
        let (status, u) = api::user::status(c, self.id)?;
        assert!(status.success);
         
        self.id = u.id;
        self.confirmed = u.confirmed;
        self.registered = u.registered;
        self.account_disabled = u.account_disabled;
        self.country_code = u.country_code;
        self.has_hard_token = u.has_hard_token;
        self.phone_number = u.phone_number.clone();
        self.devices = u.devices.clone();

        Ok(())
    } 

    /// Marks a user for deletion.
    ///
    /// Please see [api::user::delete](../api/user/fn.delete.html)
    pub fn delete(&mut self, c: &Client) -> Result<(), AuthyError> {
        let status = api::user::delete(c, self.id)?;
        assert!(status.success);
        self.update(c)?;
        Ok(())
    }

    /// Perform a verification request. Returns Ok(true) for a successful 
    /// verification and Ok(false) when the verification code was invalid.
    ///
    /// Please see [api::user::verify](../api/user/fn.verify.html)
    pub fn verify(&mut self, c: &Client, token: &str) -> Result<bool, AuthyError> {
        match api::user::verify(c, self.id, token) {
            Ok(status) => {
                assert!(status.success);
                self.update(c)?;
                Ok(true)
            }
            Err(AuthyError::UnauthorizedKey(Status { ref message,.. })) 
                if message == "Token is invalid" => Ok(false), 
            Err(e) => Err(e)
        }
    }

    /// Requests that the Authy service send the user a verification code over 
    /// SMS. This request will be ignored if the user is using the Authy 
    /// Mobile app unless force is set to true.
    ///
    /// Please see [api::user::sms](../api/user/fn.sms.html)
    pub fn sms(&self, c: &Client, force: bool, action: Option<&str>, action_message: Option<&str>) -> Result<PhoneCall, AuthyError> {
        let (status, phone) = api::user::sms(c, self.id, force, action, action_message)?;
        assert!(status.success);

        Ok(phone)
    }

    /// Requests that the Authy service send the user a verification code over 
    /// the phone. This request will be ignored if the user is using the Authy 
    /// Mobile app unless force is set to true.
    ///
    /// Please see [api::user::call](../api/user/fn.call.html)
    pub fn call(&self, c: &Client, force: bool, action: Option<&str>, action_message: Option<&str>) -> Result<PhoneCall, AuthyError> {
        let (status, phone) = api::user::call(c, self.id, force, action, action_message)?;
        assert!(status.success);

        Ok(phone)
    }

    /// Optionally, you can register some of the activities that your user do
    /// on your application. This helps us to identify fraudulent behaviours.
    /// For example if you register that a user reset his password and then he
    /// tries to change his phone with Authy we can know that something weird
    /// is happening.
    ///
    /// Please see [api::user::register_activity](../api/user/fn.register_activity.html)
    pub fn register_activity(&self, c: &Client, data: Option<&HashMap<&str, String>>, activity_type: ActivityType, user_ip: &str) -> Result<(), AuthyError> {
        let status = api::user::register_activity(c, self.id, data, activity_type, user_ip)?;
        assert!(status.success);
        Ok(())
    }
}