StuffHEADmain

3 files changed, 216 insertions, 216 deletions

diff --git a/src/models/client.rs b/src/models/client.rs
index 38be37f..6d0c909 100644
--- a/src/models/client.rs
+++ b/src/models/client.rs
@@ -1,165 +1,165 @@
-use std::{hash::Hash, marker::PhantomData};
-
-use actix_web::{http::StatusCode, ResponseError};
-use exun::{Expect, RawUnexpected};
-use raise::yeet;
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-use url::Url;
-use uuid::Uuid;
-
-use crate::services::crypto::PasswordHash;
-
-/// There are two types of clients, based on their ability to maintain the
-/// security of their client credentials.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, sqlx::Type)]
-#[sqlx(rename_all = "lowercase")]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-pub enum ClientType {
-	/// A client that is capable of maintaining the confidentiality of their
-	/// credentials, or capable of secure client authentication using other
-	/// means. An example would be a secure server with restricted access to
-	/// the client credentials.
-	Confidential,
-	/// A client that is incapable of maintaining the confidentiality of their
-	/// credentials and cannot authenticate securely by any other means, such
-	/// as an installed application, or a web-browser based application.
-	Public,
-}
-
-#[derive(Debug, Clone)]
-pub struct Client {
-	id: Uuid,
-	ty: ClientType,
-	alias: Box<str>,
-	secret: Option<PasswordHash>,
-	allowed_scopes: Box<[Box<str>]>,
-	default_scopes: Option<Box<[Box<str>]>>,
-	redirect_uris: Box<[Url]>,
-	trusted: bool,
-}
-
-impl PartialEq for Client {
-	fn eq(&self, other: &Self) -> bool {
-		self.id == other.id
-	}
-}
-
-impl Eq for Client {}
-
-impl Hash for Client {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		state.write_u128(self.id.as_u128())
-	}
-}
-
-#[derive(Debug, Clone, Copy, Error)]
-#[error("Confidential clients must have a secret, but it was not provided")]
-pub enum CreateClientError {
-	#[error("Confidential clients must have a secret, but it was not provided")]
-	NoSecret,
-	#[error("Only confidential clients may be trusted")]
-	TrustedError,
-	#[error("Redirect URIs must not include a fragment component")]
-	UriFragment,
-	#[error("Redirect URIs must use HTTPS")]
-	NonHttpsUri,
-}
-
-impl ResponseError for CreateClientError {
-	fn status_code(&self) -> StatusCode {
-		StatusCode::BAD_REQUEST
-	}
-}
-
-impl Client {
-	pub fn new(
-		id: Uuid,
-		alias: &str,
-		ty: ClientType,
-		secret: Option<&str>,
-		allowed_scopes: Box<[Box<str>]>,
-		default_scopes: Option<Box<[Box<str>]>>,
-		redirect_uris: &[Url],
-		trusted: bool,
-	) -> Result<Self, Expect<CreateClientError>> {
-		let secret = if let Some(secret) = secret {
-			Some(PasswordHash::new(secret)?)
-		} else {
-			None
-		};
-
-		if ty == ClientType::Confidential && secret.is_none() {
-			yeet!(CreateClientError::NoSecret.into());
-		}
-
-		if ty == ClientType::Public && trusted {
-			yeet!(CreateClientError::TrustedError.into());
-		}
-
-		for redirect_uri in redirect_uris {
-			if redirect_uri.scheme() != "https" {
-				yeet!(CreateClientError::NonHttpsUri.into())
-			}
-
-			if redirect_uri.fragment().is_some() {
-				yeet!(CreateClientError::UriFragment.into())
-			}
-		}
-
-		Ok(Self {
-			id,
-			alias: Box::from(alias),
-			ty,
-			secret,
-			allowed_scopes,
-			default_scopes,
-			redirect_uris: redirect_uris.into_iter().cloned().collect(),
-			trusted,
-		})
-	}
-
-	pub fn id(&self) -> Uuid {
-		self.id
-	}
-
-	pub fn alias(&self) -> &str {
-		&self.alias
-	}
-
-	pub fn client_type(&self) -> ClientType {
-		self.ty
-	}
-
-	pub fn redirect_uris(&self) -> &[Url] {
-		&self.redirect_uris
-	}
-
-	pub fn secret_hash(&self) -> Option<&[u8]> {
-		self.secret.as_ref().map(|s| s.hash())
-	}
-
-	pub fn secret_salt(&self) -> Option<&[u8]> {
-		self.secret.as_ref().map(|s| s.salt())
-	}
-
-	pub fn secret_version(&self) -> Option<u8> {
-		self.secret.as_ref().map(|s| s.version())
-	}
-
-	pub fn allowed_scopes(&self) -> String {
-		self.allowed_scopes.join(" ")
-	}
-
-	pub fn default_scopes(&self) -> Option<String> {
-		self.default_scopes.clone().map(|s| s.join(" "))
-	}
-
-	pub fn is_trusted(&self) -> bool {
-		self.trusted
-	}
-
-	pub fn check_secret(&self, secret: &str) -> Option<Result<bool, RawUnexpected>> {
-		self.secret.as_ref().map(|s| s.check_password(secret))
-	}
-}
+use std::{hash::Hash, marker::PhantomData};

+

+use actix_web::{http::StatusCode, ResponseError};

+use exun::{Expect, RawUnexpected};

+use raise::yeet;

+use serde::{Deserialize, Serialize};

+use thiserror::Error;

+use url::Url;

+use uuid::Uuid;

+

+use crate::services::crypto::PasswordHash;

+

+/// There are two types of clients, based on their ability to maintain the

+/// security of their client credentials.

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, sqlx::Type)]

+#[sqlx(rename_all = "lowercase")]

+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]

+pub enum ClientType {

+	/// A client that is capable of maintaining the confidentiality of their

+	/// credentials, or capable of secure client authentication using other

+	/// means. An example would be a secure server with restricted access to

+	/// the client credentials.

+	Confidential,

+	/// A client that is incapable of maintaining the confidentiality of their

+	/// credentials and cannot authenticate securely by any other means, such

+	/// as an installed application, or a web-browser based application.

+	Public,

+}

+

+#[derive(Debug, Clone)]

+pub struct Client {

+	id: Uuid,

+	ty: ClientType,

+	alias: Box<str>,

+	secret: Option<PasswordHash>,

+	allowed_scopes: Box<[Box<str>]>,

+	default_scopes: Option<Box<[Box<str>]>>,

+	redirect_uris: Box<[Url]>,

+	trusted: bool,

+}

+

+impl PartialEq for Client {

+	fn eq(&self, other: &Self) -> bool {

+		self.id == other.id

+	}

+}

+

+impl Eq for Client {}

+

+impl Hash for Client {

+	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

+		state.write_u128(self.id.as_u128())

+	}

+}

+

+#[derive(Debug, Clone, Copy, Error)]

+#[error("Confidential clients must have a secret, but it was not provided")]

+pub enum CreateClientError {

+	#[error("Confidential clients must have a secret, but it was not provided")]

+	NoSecret,

+	#[error("Only confidential clients may be trusted")]

+	TrustedError,

+	#[error("Redirect URIs must not include a fragment component")]

+	UriFragment,

+	#[error("Redirect URIs must use HTTPS")]

+	NonHttpsUri,

+}

+

+impl ResponseError for CreateClientError {

+	fn status_code(&self) -> StatusCode {

+		StatusCode::BAD_REQUEST

+	}

+}

+

+impl Client {

+	pub fn new(

+		id: Uuid,

+		alias: &str,

+		ty: ClientType,

+		secret: Option<&str>,

+		allowed_scopes: Box<[Box<str>]>,

+		default_scopes: Option<Box<[Box<str>]>>,

+		redirect_uris: &[Url],

+		trusted: bool,

+	) -> Result<Self, Expect<CreateClientError>> {

+		let secret = if let Some(secret) = secret {

+			Some(PasswordHash::new(secret)?)

+		} else {

+			None

+		};

+

+		if ty == ClientType::Confidential && secret.is_none() {

+			yeet!(CreateClientError::NoSecret.into());

+		}

+

+		if ty == ClientType::Public && trusted {

+			yeet!(CreateClientError::TrustedError.into());

+		}

+

+		for redirect_uri in redirect_uris {

+			if redirect_uri.scheme() != "https" {

+				yeet!(CreateClientError::NonHttpsUri.into())

+			}

+

+			if redirect_uri.fragment().is_some() {

+				yeet!(CreateClientError::UriFragment.into())

+			}

+		}

+

+		Ok(Self {

+			id,

+			alias: Box::from(alias),

+			ty,

+			secret,

+			allowed_scopes,

+			default_scopes,

+			redirect_uris: redirect_uris.into_iter().cloned().collect(),

+			trusted,

+		})

+	}

+

+	pub fn id(&self) -> Uuid {

+		self.id

+	}

+

+	pub fn alias(&self) -> &str {

+		&self.alias

+	}

+

+	pub fn client_type(&self) -> ClientType {

+		self.ty

+	}

+

+	pub fn redirect_uris(&self) -> &[Url] {

+		&self.redirect_uris

+	}

+

+	pub fn secret_hash(&self) -> Option<&[u8]> {

+		self.secret.as_ref().map(|s| s.hash())

+	}

+

+	pub fn secret_salt(&self) -> Option<&[u8]> {

+		self.secret.as_ref().map(|s| s.salt())

+	}

+

+	pub fn secret_version(&self) -> Option<u8> {

+		self.secret.as_ref().map(|s| s.version())

+	}

+

+	pub fn allowed_scopes(&self) -> String {

+		self.allowed_scopes.join(" ")

+	}

+

+	pub fn default_scopes(&self) -> Option<String> {

+		self.default_scopes.clone().map(|s| s.join(" "))

+	}

+

+	pub fn is_trusted(&self) -> bool {

+		self.trusted

+	}

+

+	pub fn check_secret(&self, secret: &str) -> Option<Result<bool, RawUnexpected>> {

+		self.secret.as_ref().map(|s| s.check_password(secret))

+	}

+}

diff --git a/src/models/mod.rs b/src/models/mod.rs
index 633f846..1379893 100644
--- a/src/models/mod.rs
+++ b/src/models/mod.rs
@@ -1,2 +1,2 @@
-pub mod client;
-pub mod user;
+pub mod client;

+pub mod user;

diff --git a/src/models/user.rs b/src/models/user.rs
index 8555ee2..493a267 100644
--- a/src/models/user.rs
+++ b/src/models/user.rs
@@ -1,49 +1,49 @@
-use std::hash::Hash;
-
-use exun::RawUnexpected;
-use uuid::Uuid;
-
-use crate::services::crypto::PasswordHash;
-
-#[derive(Debug, Clone)]
-pub struct User {
-	pub id: Uuid,
-	pub username: Box<str>,
-	pub password: PasswordHash,
-}
-
-impl PartialEq for User {
-	fn eq(&self, other: &Self) -> bool {
-		self.id == other.id
-	}
-}
-
-impl Eq for User {}
-
-impl Hash for User {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		state.write_u128(self.id.as_u128())
-	}
-}
-
-impl User {
-	pub fn username(&self) -> &str {
-		&self.username
-	}
-
-	pub fn password_hash(&self) -> &[u8] {
-		self.password.hash()
-	}
-
-	pub fn password_salt(&self) -> &[u8] {
-		self.password.salt()
-	}
-
-	pub fn password_version(&self) -> u8 {
-		self.password.version()
-	}
-
-	pub fn check_password(&self, password: &str) -> Result<bool, RawUnexpected> {
-		self.password.check_password(password)
-	}
-}
+use std::hash::Hash;

+

+use exun::RawUnexpected;

+use uuid::Uuid;

+

+use crate::services::crypto::PasswordHash;

+

+#[derive(Debug, Clone)]

+pub struct User {

+	pub id: Uuid,

+	pub username: Box<str>,

+	pub password: PasswordHash,

+}

+

+impl PartialEq for User {

+	fn eq(&self, other: &Self) -> bool {

+		self.id == other.id

+	}

+}

+

+impl Eq for User {}

+

+impl Hash for User {

+	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

+		state.write_u128(self.id.as_u128())

+	}

+}

+

+impl User {

+	pub fn username(&self) -> &str {

+		&self.username

+	}

+

+	pub fn password_hash(&self) -> &[u8] {

+		self.password.hash()

+	}

+

+	pub fn password_salt(&self) -> &[u8] {

+		self.password.salt()

+	}

+

+	pub fn password_version(&self) -> u8 {

+		self.password.version()

+	}

+

+	pub fn check_password(&self, password: &str) -> Result<bool, RawUnexpected> {

+		self.password.check_password(password)

+	}

+}