authy 0.9.8

Bindings for the Authy two factor web service.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

//! Bindings to the [Phone Verification](https://www.twilio.com/docs/api/authy/authy-phone-verification-api) and [Phone Intelligence](https://www.twilio.com/docs/api/authy/authy-phone-intelligence-api) apis.
//!
//! Much of the documentation for this module comes from the Authy TOTP service
//! documentation.
use std::fmt::{self, Display};

use serde_json;

use error::AuthyError;
use client::{Client, Status};

const PREFIX: &'static str = "protected";

/// Returned when requesting info on a phone number
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct PhoneInfo {
    /// Phone number type. It can be voip, landline, cellphone, unknown.
    #[serde(rename = "type")]
    pub phone_type: String,

    /// Name of the service provider.
    pub provider: Option<String>,

    /// Whether the phone number was ported or not.
    pub ported: bool,
}

/// Returned when initiating verification of a phone number.
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct PhoneStart {
    pub carrier: String,
    pub is_cellphone: bool,
    pub message: String,
    pub seconds_to_expire: u16,
    pub uuid: Option<String>,
    pub success: bool,
}

/// The contact type used when verifying a phone number
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum ContactType {
    SMS,
    Call,
}

impl Display for ContactType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ContactType::SMS => write!(f, "sms"),
            ContactType::Call => write!(f, "call")
        } 
    }
}

/// Request information on a phone number.
///
/// The Authy Phone Intelligence API provides information about a phone number.
/// We return 3 key pieces of information.
///
/// * type of phone number [cell phone | landline | voip]
/// * provider of the number, e.g. "AT&T Wireless"
/// * If the number has been ported from a previous provider.
///
/// Please see the Authy documentation for more details:
/// https://www.twilio.com/docs/api/authy/authy-phone-intelligence-api
pub fn info(client: &Client, country_code: u16, phone: &str, user_ip: Option<&str>) -> Result<(Status, PhoneInfo), AuthyError> {
    let mut params: Vec<(String, String)> = vec![];
    params.push(("country_code".into(), country_code.to_string()));
    params.push(("phone_number".into(), phone.into()));
    if let Some(user_ip) = user_ip {
        params.push(("user_ip".into(), user_ip.into()));
    };

    let (status, res) = client.get(PREFIX, "phones/info", Some(params))?;

    let phone_info = serde_json::from_value(res)?;

    Ok((status, phone_info))
}

/// Initiate a phone verification check.
///
/// The Authy Phone Verification API allows you to verify that the user has the
/// device in their possession. The Authy Phone Verification API lets you
/// request a verification code to be sent to the user and also verify that the
/// code received by the user is valid.
///
/// When you want to verify a user's phone you start by requesting a
/// verification code for that user's phone number. The verification code is
/// valid for 10 minutes. Subsequent calls to the API within the expiration
/// time will send the same verification code.
///
/// Please see the Authy documentation for more details:
/// https://www.twilio.com/docs/api/authy/authy-phone-verification-api#requesting-and-verifying-the-verification-code
pub fn start(client: &Client, via: ContactType, country_code: u16, phone: &str, code_length: Option<u8>, locale: Option<&str>) -> Result<(Status, PhoneStart), AuthyError> {
    let mut params: Vec<(String, String)> = vec![];
    params.push(("via".into(), via.to_string()));
    params.push(("country_code".into(), country_code.to_string()));
    params.push(("phone_number".into(), phone.into()));
    if let Some(code_length) = code_length {
        params.push(("code_length".into(), code_length.to_string()));
    };
    if let Some(locale) = locale {
        params.push(("locale".into(), locale.into()));
    };

    let (status, res) = client.post(PREFIX, "phones/verification/start", None, Some(params))?;
    let phone_verification = serde_json::from_value(res)?;

    Ok((status, phone_verification))
}

/// Verify phone verification code sent to user.
///
/// Please see the Authy documentation for more details:
/// https://www.twilio.com/docs/api/authy/authy-phone-verification-api#verifying-code-sent-to-the-user
pub fn check(client: &Client, country_code: u16, phone: &str, code: &str) -> Result<Status, AuthyError> {
    let mut params: Vec<(String, String)> = vec![];
    params.push(("country_code".into(), country_code.to_string()));
    params.push(("phone_number".into(), phone.into()));
    params.push(("verification_code".into(), code.into()));

    let (status, _) = client.get(PREFIX, "phones/verification/check", Some(params))?;

    Ok(status)
}