bombay 0.0.2

Monstercat API Rust 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

use crate::client::{Client, Error, SignedIn, SignedOut};
use serde::{Deserialize, Serialize};
use serde_json::Value;

/// Sign-in outcome variants.
///
/// There are three ways authentication proceeds after a successful sign-in
/// first-step. Without 2FA, you get a signed in client! With email 2FA,
/// you get a function to call back to check on the email confirmation. With
/// TOTP 2FA, you get a function to call back with your code. Both of these
/// callback functions can return:
///
/// 1. `Ok(Client<SignedIn>)` - You get a signed in client!
/// 3. `Err(Error)` - Something has gone wrong.
///
pub enum SignInOutcome {
    Authenticated(Client<SignedIn>),
    Email(EmailCallback),
    TOTP(TOTPCallback),
}

/// Type for callback function provided to check on email 2FA.
pub type EmailCallback = fn(&mut Client<SignedOut>) -> Result<Client<SignedIn>, Error>;

/// Type for callback function provided to try code for TOTP 2FA.
pub type TOTPCallback = fn(&mut Client<SignedOut>, String) -> Result<Client<SignedIn>, Error>;

/// User sign-in parameters.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct SigninParameters {
    pub email: String,
    pub password: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auth: Option<AuthParameters>,
}

/// 2-factor authentication parameters.
#[derive(Clone, Debug, Deserialize, Serialize)]
pub(crate) struct AuthParameters {
    #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(rename = "TOTP", skip_serializing_if = "Option::is_none")]
    pub totp: Option<String>,
}

/// Sign-in response.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct AuthReply {
    pub auth_data: Option<AuthData>,
    pub default_auth_type: Option<Auth2FAMethod>,
    #[serde(alias = "Needs2FA")]
    pub needs_2fa: bool,
}

/// Authentication data contained in sign-in response.
#[derive(Clone, Debug, Deserialize, Serialize)]
pub(crate) struct AuthData {
    #[serde(rename = "Email")]
    pub email: Option<AuthDataEmail>,
    #[serde(rename = "TOTP")]
    pub totp: Option<Value>,
}

/// Response from resending 2-factor authentication email.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct AuthDataEmail {
    pub id: Option<String>,
    pub email: Option<String>,
}

/// Variants of 2-factor authentication.
#[derive(Copy, Clone, Debug, Deserialize, Serialize)]
pub(crate) enum Auth2FAMethod {
    #[serde(rename = "Email")]
    Email,
    #[serde(rename = "TOTP")]
    TOTP,
}

/// Saved authentication credentials for callback use.
#[derive(Debug)]
pub(crate) struct SavedAuthDetails {
    pub email: String,
    pub email_id: Option<String>,
    pub password: String,
}