neos 0.6.5

NeosVR's API in rust
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
140
141
142
143
144
145
146
147

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

use super::NoAuthentication;

/// An user's ID or their username
///
/// Used in [`UserInfo`](neos::query::UserInfo).
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum UserIdOrUsername {
	/// An user's ID
	Id(crate::id::User),
	/// An user's username
	Username(String),
}

impl UserIdOrUsername {
	#[must_use]
	/// If it's an ID
	pub const fn is_id(&self) -> bool { matches!(self, Self::Id(_)) }

	#[must_use]
	/// If it's an username
	pub const fn is_username(&self) -> bool { matches!(self, Self::Username(_)) }
}

impl AsRef<str> for UserIdOrUsername {
	fn as_ref(&self) -> &str {
		match self {
			Self::Id(v) => v.as_ref(),
			Self::Username(v) => v,
		}
	}
}

/// For easier scripting, should use String otherwise.
impl From<&'static str> for UserIdOrUsername {
	fn from(v: &'static str) -> Self { Self::Username(v.to_owned()) }
}

impl From<String> for UserIdOrUsername {
	fn from(v: String) -> Self { Self::Username(v) }
}

impl From<crate::id::User> for UserIdOrUsername {
	fn from(v: crate::id::User) -> Self { Self::Id(v) }
}

/// Gets details of an user by either username or ID
///
/// # Example usage
///
/// ```no_run
/// # tokio_test::block_on(async {
/// # use neos::{api_client::{UnauthenticatedNeos, ApiClient}, query::UserSearch};
/// # let USER_AGENT = String::new();
/// # let neos_api_client = UnauthenticatedNeos::new(USER_AGENT).unwrap();
/// let neos_user_search_query = UserSearch::new("Neos");
/// let neos_bot = neos_api_client
/// 	.query(neos_user_search_query)
/// 	.await
/// 	.expect("to be able to get the Neos bot account from Neos");
/// println!(
/// 	"The Neos bot supposedly registered on {}",
/// 	&neos_bot.first().unwrap().registration_time
/// );
/// # })
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct UserInfo {
	/// The ID or username to query information about
	pub user: UserIdOrUsername,
}

impl UserInfo {
	/// Creates a new user info query based on the username or ID
	pub fn new(user: impl Into<UserIdOrUsername>) -> Self {
		Self { user: user.into() }
	}
}

impl Queryable<NoAuthentication, crate::model::User> for UserInfo {
	fn url(&self, _: &NoAuthentication) -> String {
		format!(
			"{}/users/{}?byUsername={}",
			crate::API_BASE_URI,
			self.user.as_ref(),
			&(!self.user.is_id()).to_string()
		)
	}
}

/// Gets details of an user by either username or ID
///
/// # Example usage
///
/// ```no_run
/// # tokio_test::block_on(async {
/// # use neos::{api_client::{UnauthenticatedNeos, ApiClient}, query::UserStatus};
/// # let USER_AGENT = String::new();
/// # let neos_api_client = UnauthenticatedNeos::new(USER_AGENT).unwrap();
/// let neos_user_status_query =
/// 	UserStatus::new(neos::id::User::try_from("U-neos").unwrap());
/// let neos_bot_status = neos_api_client
/// 	.query(neos_user_status_query)
/// 	.await
/// 	.expect("to be able to get the Neos bot account from Neos");
/// println!("Neos bot account is: {}", &neos_bot_status.online_status);
/// # })
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct UserStatus {
	/// The ID of the user whose status the query is for
	pub user_id: crate::id::User,
}

impl UserStatus {
	/// Creates a new user status query
	pub fn new(user_id: impl Into<crate::id::User>) -> Self {
		Self { user_id: user_id.into() }
	}
}

impl Queryable<NoAuthentication, crate::model::UserStatus> for UserStatus {
	fn url(&self, _: &NoAuthentication) -> String {
		format!("{}/users/{}/status", crate::API_BASE_URI, self.user_id.as_ref(),)
	}
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
/// Searches users by name
pub struct UserSearch {
	/// The name to search for
	pub name: String,
}

impl UserSearch {
	/// Creates a new user search query
	pub fn new(name: impl Into<String>) -> Self { Self { name: name.into() } }
}

// TODO: Deserialize skip vec errors
impl Queryable<NoAuthentication, Vec<crate::model::User>> for UserSearch {
	fn url(&self, _: &NoAuthentication) -> String {
		format!("{}/users?name={}", crate::API_BASE_URI, self.name)
	}
}