vrc 0.5.0

Unofficial rust types of VRChat's API
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
130
131
132
133
134
135
136
137
138
139

use racal::Queryable;
use serde::{Deserialize, Serialize};
use strum::AsRefStr;

use super::{Authentication, Order, Pagination};
use crate::model::ReleaseStatus;

/// The sorting for a world search
#[derive(
	Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize, Serialize, AsRefStr,
)]
#[serde(rename_all = "camelCase")]
#[allow(missing_docs)]
#[strum(serialize_all = "camelCase")]
pub enum WorldsSort {
	Popularity,
	Heat,
	Trust,
	Shuffle,
	Random,
	Favorites,
	ReportScore,
	ReportCount,
	PublicationDate,
	LabsPublicationDate,
	Created,
	#[strum(serialize = " _created_at")]
	#[serde(rename = " _created_at")]
	CreatedAt,
	Updated,
	#[strum(serialize = " _updated_at")]
	#[serde(rename = " _updated_at")]
	UpdatedAt,
	Order,
	Relevance,
	Magic,
	Name,
}

impl Default for WorldsSort {
	fn default() -> Self { Self::Heat }
}

#[derive(
	Default, Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize,
)]
/// Lists active worlds based on the  provided criteria
pub struct ActiveWorlds {
	/// If to filter based on featured status
	pub featured: Option<bool>,
	/// The sorting of the search
	pub sort: WorldsSort,
	/// The ordering of the search
	pub order: Order,
	/// If to filter based on a search string
	pub search: Option<String>,
	/// If to filter based on a search tag
	pub tag: Option<String>,
	/// If to exclude results based on a search tag
	pub no_tag: Option<String>,
	/// If to filter based on the release status
	pub release_status: Option<ReleaseStatus>,
	/// If to filter based on the max unity version
	pub max_unity_version: Option<String>,
	/// If to filter based on the min unity version
	pub min_unity_version: Option<String>,
	/// `standalonewindows` or `android` for example
	pub platform: Option<String>,
	/// The pagination for the query
	#[serde(flatten)]
	pub pagination: Pagination,
}

impl Queryable<Authentication, Vec<crate::model::WorldListing>>
	for ActiveWorlds
{
	fn url(&self, _: &Authentication) -> String {
		let mut query = format!(
			"{}/worlds/active?{}&sort={}&order={}",
			crate::API_BASE_URI,
			self.pagination.to_query_str(),
			&self.sort.as_ref(),
			&self.order.as_ref(),
		);

		if let Some(release_status) = &self.release_status {
			query.push_str("&releaseStatus=");
			query.push_str(release_status.as_ref());
		}

		if let Some(featured) = &self.featured {
			query.push_str("&featured=");
			query.push_str(&featured.to_string());
		}

		if let Some(search) = &self.search {
			query.push_str("&search=");
			query.push_str(search);
		}
		if let Some(tag) = &self.tag {
			query.push_str("&tag=");
			query.push_str(tag);
		}
		if let Some(no_tag) = &self.no_tag {
			query.push_str("&notag=");
			query.push_str(no_tag);
		}

		if let Some(max_unity_version) = &self.max_unity_version {
			query.push_str("&maxUnityVersion=");
			query.push_str(max_unity_version);
		}

		if let Some(min_unity_version) = &self.min_unity_version {
			query.push_str("&minUnityVersion=");
			query.push_str(min_unity_version);
		}

		if let Some(platform) = &self.platform {
			query.push_str("&platform=");
			query.push_str(platform);
		}

		query
	}
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
/// Also works as the login request
pub struct World {
	/// The ID of the world to get
	pub id: crate::id::World,
}

impl Queryable<Authentication, crate::model::World> for World {
	fn url(&self, _: &Authentication) -> String {
		format!("{}/worlds/{}", crate::API_BASE_URI, self.id.as_ref())
	}
}