roblox_api/api/inventory/
v2.rs

1use serde::{Deserialize, Serialize};
2
3use crate::{AssetTypeId, DateTime, Error, Paging, client::Client};
4
5pub const URL: &str = "https://inventory.roblox.com/v2";
6
7#[derive(Clone, Debug, Deserialize, Serialize)]
8pub struct FromOwnerAssetOwner {
9    pub id: u64,
10    #[serde(rename = "type")]
11    pub kind: u64,
12    pub name: String,
13}
14
15#[derive(Clone, Debug, Deserialize, Serialize)]
16pub struct FromOwnerAssetInfo {
17    pub id: u64,
18    #[serde(rename = "serialNumber")]
19    pub serial: u64,
20    #[serde(rename = "collectibleItemInstanceId")]
21    pub collectible_instance_id: Option<String>,
22    pub owner: UserOwnedAssetOwner,
23    pub created: DateTime,
24    pub updated: DateTime,
25}
26
27#[derive(Clone, Debug, Deserialize, Serialize)]
28pub struct UserOwnedAssetOwner {
29    #[serde(rename = "userId")]
30    pub id: u64,
31    #[serde(rename = "username")]
32    pub name: String,
33    // TODO: change this to an enum
34    #[serde(rename = "buildersClubMembershipType")]
35    pub premium_membership_type: String,
36}
37
38#[derive(Clone, Debug, Deserialize, Serialize)]
39pub struct UserOwnedAssetInfo {
40    #[serde(rename = "assetId")]
41    pub id: u64,
42    #[serde(rename = "userAssetId")]
43    pub instance_id: u64,
44    #[serde(rename = "assetName")]
45    pub name: String,
46    pub owner: UserOwnedAssetOwner,
47    #[serde(rename = "collectibleItemId")]
48    pub collectible_id: Option<String>,
49    #[serde(rename = "collectibleItemInstanceId")]
50    pub collectible_instance_id: Option<String>,
51    #[serde(rename = "serialNumber")]
52    pub serial: Option<u64>,
53    pub created: DateTime,
54    pub updated: DateTime,
55}
56
57#[derive(Clone, Debug, Deserialize, Serialize)]
58pub struct UserOwnedAssets {
59    #[serde(rename = "nextPageCursor")]
60    pub next_cursor: Option<String>,
61    #[serde(rename = "previousPageCursor")]
62    pub previous_cursor: Option<String>,
63    #[serde(rename = "data")]
64    pub assets: Vec<UserOwnedAssetInfo>,
65}
66
67#[derive(Clone, Debug, Deserialize, Serialize)]
68pub struct AssetOwners {
69    #[serde(rename = "nextPageCursor")]
70    pub next_cursor: String,
71    #[serde(rename = "previousPageCursor")]
72    pub previous_cursor: String,
73    #[serde(rename = "data")]
74    pub assets: Vec<FromOwnerAssetInfo>,
75}
76
77pub async fn asset_owners(
78    client: &mut Client,
79    id: u64,
80    paging: Paging<'_>,
81) -> Result<AssetOwners, Error> {
82    let limit = paging.limit.unwrap_or(10).to_string();
83    let sort_order = paging.order.unwrap_or_default().to_string();
84    let cursor = match paging.cursor {
85        Some(cursor) => cursor.to_string(),
86        None => String::new(),
87    };
88
89    let result = client
90        .requestor
91        .client
92        .get(format!("{URL}/assets/{id}/owners"))
93        .query(&[
94            ("limit", limit),
95            ("sortOrder", sort_order),
96            ("cursor", cursor),
97        ])
98        .headers(client.requestor.default_headers.clone())
99        .send()
100        .await;
101
102    let response = client.validate_response(result).await?;
103    client.requestor.parse_json::<AssetOwners>(response).await
104}
105
106pub async fn user_owned_assets(
107    client: &mut Client,
108    user_id: u64,
109    asset_type_id: AssetTypeId,
110    paging: Paging<'_>,
111) -> Result<UserOwnedAssets, Error> {
112    let asset_type_id = asset_type_id as u8;
113
114    let limit = paging.limit.unwrap_or(10).to_string();
115    let sort_order = paging.order.unwrap_or_default().to_string();
116    let cursor = match paging.cursor {
117        Some(cursor) => cursor.to_string(),
118        None => String::new(),
119    };
120
121    let result = client
122        .requestor
123        .client
124        .get(format!("{URL}/users/{user_id}/inventory/{asset_type_id}"))
125        .query(&[
126            ("limit", limit),
127            ("sortOrder", sort_order),
128            ("cursor", cursor),
129        ])
130        .headers(client.requestor.default_headers.clone())
131        .send()
132        .await;
133
134    let response = client.validate_response(result).await?;
135    client
136        .requestor
137        .parse_json::<UserOwnedAssets>(response)
138        .await
139}