resonite 0.4.0

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

//! Models for querying the Resonite API via the HTTP/REST API

// Everything is based on Resonite's models, so not much can be done
#![allow(clippy::struct_excessive_bools)]
// Everything is re-exported from here, and just organized to files
// for easier navigation & better development experience.
#![allow(clippy::module_name_repetitions)]

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

mod contact;
mod group;
mod message;
mod session;
mod stats;
mod testing;
mod user;
mod user_session;

pub use contact::*;
pub use group::*;
pub use message::*;
pub use session::*;
pub use stats::*;
pub use testing::*;
pub use user::*;
pub use user_session::*;

/// Data needed to actually request an user session.
///
/// Mixes headers and actual body data together, not an actual Resonite model.
#[cfg_attr(
	feature = "borsh",
	derive(borsh::BorshSerialize, borsh::BorshDeserialize)
)]
#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize)]
pub struct UserSessionQueryWithHeaders {
	/// The actual body of the request
	pub body: crate::query::UserSession,
	#[serde(flatten)]
	/// Headers & so on needed for authentication requests
	pub data: Authenticating,
}

/// [`racal::Queryable`](racal::Queryable)'s `RequiredApiState`.
///
/// Even unauthenticated requests to Resonite's API should take rate limits
/// into account, thus not using `()` for the API state.
pub struct NoAuthentication {}

impl racal::FromApiState<Self> for NoAuthentication {
	fn from_state(state: &Self) -> &Self { state }
}

impl racal::FromApiState<Authentication> for NoAuthentication {
	fn from_state(_: &Authentication) -> &Self { &Self {} }
}

/// [`racal::Queryable`](racal::Queryable)'s `RequiredApiState`.
///
/// With authentication
#[cfg_attr(
	feature = "borsh",
	derive(borsh::BorshSerialize, borsh::BorshDeserialize)
)]
#[derive(PartialEq, Eq, Hash, Clone, Deserialize, Serialize)]
pub struct Authentication {
	/// The secret authentication token
	pub token: String,
	/// The user that the authentication token is for
	pub user_id: crate::id::User,
}

impl Authentication {
	#[must_use]
	/// Turns the authentication into the header that it generates
	pub fn to_header(&self) -> (&'static str, String) {
		(
			"Authorization",
			("res ".to_owned() + self.user_id.as_ref() + ":" + &self.token),
		)
	}
}

impl From<crate::model::UserSession> for Authentication {
	fn from(value: crate::model::UserSession) -> Self {
		Self { token: value.token, user_id: value.user_id }
	}
}

impl std::fmt::Debug for Authentication {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		f.debug_struct("Authentication")
			.field("token", &"*****")
			.field("user_id", &self.user_id)
			.finish()
	}
}

impl FromApiState<Self> for Authentication {
	fn from_state(state: &Self) -> &Self { state }
}

/// [`racal::Queryable`](racal::Queryable)'s `RequiredApiState`.
///
/// Contains the data needed to actually request an user session.
/// Mixes headers and actual body data together, not an actual Resonite model.
#[cfg_attr(
	feature = "borsh",
	derive(borsh::BorshSerialize, borsh::BorshDeserialize)
)]
#[serde_with::serde_as]
#[derive(Debug, PartialEq, Eq, Hash, Clone, Deserialize, Serialize)]
pub struct Authenticating {
	/// TOTP header.
	///
	/// Usually should be composed of just a few numbers.
	/// Only needed in some cases, with first requirement being having
	/// second factor authentication even enabled for the account.
	#[serde(rename = "TOTP")]
	#[serde_as(deserialize_as = "serde_with::DefaultOnNull")]
	#[serde(default)]
	#[serde(skip_serializing_if = "Option::is_none")]
	pub second_factor: Option<String>,
	/// Unique identifier header.
	///
	/// Should be a SHA256 hash of the hardware.
	/// Could be any SHA256, but API will treat this as a different device based
	/// on the value of this.
	#[serde(rename = "UID")]
	pub unique_machine_identifier: String,
}

impl FromApiState<Self> for Authenticating {
	fn from_state(state: &Self) -> &Self { state }
}