roblox-api 0.1.2

Roblox web api bindings
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

use serde::{Deserialize, Serialize};

use crate::{DateTime, Error, client::Client};

pub const URL: &str = "https://apis.roblox.com/auth-token-service/v1";

// TODO: look into `qr-code-image`, `entercode`, `validatecode`, `metadata`

#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
pub enum LoginStatus {
    Created,
    Validated,
}

#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
pub struct LoginToken {
    #[serde(rename = "code")]
    pub code: String,
    #[serde(rename = "status")]
    pub status: String,
    #[serde(rename = "privateKey")]
    pub private_key: String,
    #[serde(rename = "expirationTime")]
    pub expiration_time: DateTime,
    #[serde(rename = "imagePath")]
    pub image_path: String,
}

#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
pub struct LoginTokenStatus {
    #[serde(rename = "status")]
    pub status: LoginStatus,
    #[serde(rename = "accountName")]
    pub account_name: Option<String>,
    #[serde(rename = "accountPictureUrl")]
    pub account_picture_url: Option<String>,
    #[serde(rename = "expirationTime")]
    pub expiration_time: String,
}

pub async fn login_create(client: &mut Client) -> Result<LoginToken, Error> {
    let result = client
        .requestor
        .client
        .post(format!("{URL}/login/create"))
        .headers(client.requestor.default_headers.clone())
        .send()
        .await;

    let response = client.validate_response(result).await?;
    client.requestor.parse_json::<LoginToken>(response).await
}

pub async fn login_cancel(client: &mut Client, code: &str) -> Result<(), Error> {
    #[derive(Serialize)]
    struct Request<'a> {
        code: &'a str,
    }

    let result = client
        .requestor
        .client
        .post(format!("{URL}/login/cancel"))
        .json(&Request { code })
        .headers(client.requestor.default_headers.clone())
        .send()
        .await;

    client.validate_response(result).await?;
    Ok(())
}

pub async fn login_status(
    client: &mut Client,
    code: &str,
    key: &str,
) -> Result<LoginTokenStatus, Error> {
    #[derive(Serialize)]
    struct Request<'a> {
        code: &'a str,
        #[serde(rename = "privateKey")]
        key: &'a str,
    }

    let result = client
        .requestor
        .client
        .post(format!("{URL}/login/status"))
        .json(&Request { code, key })
        .headers(client.requestor.default_headers.clone())
        .send()
        .await;

    let response = client.validate_response(result).await?;
    client
        .requestor
        .parse_json::<LoginTokenStatus>(response)
        .await
}