roblox-api 0.1.1

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
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

use crate::{AssetTypeId, DateTime, Error, Paging, client::Client};
use serde::Deserialize;

pub const URL: &str = "https://inventory.roblox.com/v2";

#[derive(Clone, Debug, Deserialize)]
pub struct FromOwnerAssetOwner {
    pub id: u64,
    #[serde(rename = "type")]
    pub kind: u64,
    pub name: String,
}

#[derive(Clone, Debug, Deserialize)]
pub struct FromOwnerAssetInfo {
    pub id: u64,
    #[serde(rename = "serialNumber")]
    pub serial: u64,
    #[serde(rename = "collectibleItemInstanceId")]
    pub collectible_instance_id: Option<String>,
    pub owner: UserOwnedAssetOwner,
    pub created: DateTime,
    pub updated: DateTime,
}

#[derive(Clone, Debug, Deserialize)]
pub struct UserOwnedAssetOwner {
    #[serde(rename = "userId")]
    pub id: u64,
    #[serde(rename = "buildersClubMembershipType")]
    pub premium_membership_type: String,
    #[serde(rename = "username")]
    pub name: String,
}

#[derive(Clone, Debug, Deserialize)]
pub struct UserOwnedAssetInfo {
    #[serde(rename = "assetId")]
    pub id: u64,
    #[serde(rename = "userAssetId")]
    pub instance_id: u64,
    #[serde(rename = "assetName")]
    pub name: String,
    pub owner: UserOwnedAssetOwner,
    #[serde(rename = "collectibleItemId")]
    pub collectible_id: Option<u64>,
    #[serde(rename = "collectibleItemInstanceId")]
    pub collectible_instance_id: Option<u64>,
    #[serde(rename = "serialNumber")]
    pub serial: Option<u64>,
    pub created: DateTime,
    pub updated: DateTime,
}

#[derive(Clone, Debug, Deserialize)]
pub struct UserOwnedAssets {
    #[serde(rename = "nextPageCursor")]
    pub next_cursor: Option<String>,
    #[serde(rename = "previousPageCursor")]
    pub previous_cursor: Option<String>,
    #[serde(rename = "data")]
    pub assets: Vec<UserOwnedAssetInfo>,
}

#[derive(Clone, Debug, Deserialize)]
pub struct AssetOwners {
    #[serde(rename = "nextPageCursor")]
    pub next_cursor: String,
    #[serde(rename = "previousPageCursor")]
    pub previous_cursor: String,
    #[serde(rename = "data")]
    pub assets: Vec<FromOwnerAssetInfo>,
}

pub async fn asset_owners(
    client: &mut Client,
    id: u64,
    paging: Paging<'_>,
) -> Result<AssetOwners, Error> {
    let limit = paging.limit.unwrap_or(10);
    let sort_order = paging.order.unwrap_or_default().to_string();
    let cursor = match paging.cursor {
        Some(cursor) => format!("&cursor={cursor}"),
        None => String::new(),
    };

    let result = client
        .requestor
        .client
        .get(format!(
            "{URL}/assets/{id}/owners?limit={limit}&sortOrder={sort_order}{cursor}"
        ))
        .headers(client.requestor.default_headers.clone())
        .send()
        .await;

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

pub async fn user_owned_assets(
    client: &mut Client,
    user_id: u64,
    asset_type_id: AssetTypeId,
    paging: Paging<'_>,
) -> Result<UserOwnedAssets, Error> {
    let asset_type_id = asset_type_id as u8;

    let limit = paging.limit.unwrap_or(10);
    let sort_order = paging.order.unwrap_or_default().to_string();
    let cursor = match paging.cursor {
        Some(cursor) => format!("&cursor={cursor}"),
        None => String::new(),
    };

    let result = client
        .requestor
        .client
        .get(format!("{URL}/users/{user_id}/inventory/{asset_type_id}?limit={limit}&sortOrder={sort_order}{cursor}"))
        .headers(client.requestor.default_headers.clone())
        .send()
        .await;

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