unimplement secured access

Author: DrVilepis

src/api/account.rs

@@ -2,20 +2,20 @@ use axum::{response::IntoResponse, Json};
 use http::StatusCode;
 use serde_derive::Deserialize;
 
-use crate::{api::auth::SecuredUserIdentity, database::DatabaseWrapper, error::TimeError};
+use crate::{database::DatabaseWrapper, error::TimeError, models::UserIdentity};
 
 #[derive(Deserialize)]
 pub struct Settings {
     public_profile: Option<bool>,
 }
 
 pub async fn change_settings(
-    userid: SecuredUserIdentity,
+    user: UserIdentity,
     db: DatabaseWrapper,
     settings: Json<Settings>,
 ) -> Result<impl IntoResponse, TimeError> {
     if let Some(public_profile) = settings.public_profile {
-        db.change_visibility(userid.identity.id, public_profile)
+        db.change_visibility(user.id, public_profile)
             .await?;
     };
 

src/api/activity.rs

@@ -7,10 +7,9 @@ use http::StatusCode;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    api::auth::SecuredUserIdentity,
     database::DatabaseWrapper,
     error::TimeError,
-    models::{HeartBeat, UserId},
+    models::{HeartBeat, UserId, UserIdentity},
 };
 
 pub type HeartBeatMemoryStore = DashMap<i32, (HeartBeat, chrono::NaiveDateTime, chrono::Duration)>;
@@ -142,11 +141,11 @@ pub struct ActivityDeleteRequest {
 }
 
 pub async fn delete(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     db: DatabaseWrapper,
     Json(body): Json<ActivityDeleteRequest>,
 ) -> Result<impl IntoResponse, TimeError> {
-    let deleted = db.delete_activity(user.identity.id, body.id).await?;
+    let deleted = db.delete_activity(user.id, body.id).await?;
     if deleted {
         Ok(StatusCode::OK)
     } else {

src/api/auth.rs

@@ -13,10 +13,10 @@ use lettre::{
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    auth::{secured_access::SecuredAccessTokenStorage, Authentication},
+    auth::Authentication,
     database::DatabaseWrapper,
     error::TimeError,
-    models::{SecuredAccessTokenResponse, SelfUser, UserId, UserIdentity},
+    models::{SelfUser, UserId, UserIdentity},
     utils::{generate_password_reset_token, validate_email},
     PasswordReset, PasswordResetState,
 };
@@ -78,24 +78,6 @@ impl<S: Send + Sync> FromRequestParts<S> for UserIdentity {
     }
 }
 
-pub struct SecuredUserIdentity {
-    pub identity: UserIdentity,
-}
-
-impl<S: Send + Sync> FromRequestParts<S> for SecuredUserIdentity {
-    type Rejection = TimeError;
-
-    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
-        let auth = parts.extensions.get::<Authentication>().cloned().unwrap();
-
-        if let Authentication::SecuredAccessToken(user) = auth {
-            Ok(SecuredUserIdentity { identity: user })
-        } else {
-            Err(TimeError::UnauthroizedSecuredAccess)
-        }
-    }
-}
-
 pub struct UserIdentityOptional {
     pub identity: Option<UserIdentity>,
 }
@@ -137,42 +119,6 @@ pub async fn login(
     }
 }
 
-pub async fn get_secured_access_token(
-    State(secured_access_storage): State<Arc<SecuredAccessTokenStorage>>,
-    db: DatabaseWrapper,
-    data: Json<LoginRequest>,
-) -> Result<impl IntoResponse, TimeError> {
-    if data.password.len() > 128 {
-        return Err(TimeError::InvalidLength(
-            "Password cannot be longer than 128 characters".to_string(),
-        ));
-    }
-
-    if let Ok(Some(user)) = db
-        .verify_user_password(&data.username, &data.password)
-        .await
-    {
-        Ok(Json(SecuredAccessTokenResponse {
-            token: secured_access_storage.create_token(user.id),
-        }))
-    } else {
-        Err(TimeError::InvalidCredentials)
-    }
-}
-
-pub async fn regenerate(
-    user: SecuredUserIdentity,
-    db: DatabaseWrapper,
-) -> Result<impl IntoResponse, TimeError> {
-    db.regenerate_token(user.identity.id)
-        .await
-        .inspect_err(|e| error!("{}", e))
-        .map(|token| {
-            let token = json!({ "token": token });
-            Json(token)
-        })
-}
-
 pub async fn register(
     db: DatabaseWrapper,
     Json(data): Json<RegisterRequest>,
@@ -203,7 +149,7 @@ pub async fn register(
 }
 
 pub async fn change_username(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     db: DatabaseWrapper,
     Json(data): Json<UsernameChangeRequest>,
 ) -> Result<impl IntoResponse, TimeError> {
@@ -217,7 +163,7 @@ pub async fn change_username(
         return Err(TimeError::BadUsername);
     }
 
-    let result = db.change_username(user.identity.id, &data.new).await;
+    let result = db.change_username(user.id, &data.new).await;
 
     if result.as_ref().is_err_and(|e| e.is_unique_violation()) {
         return Err(TimeError::UsernameTaken);
@@ -227,15 +173,15 @@ pub async fn change_username(
 }
 
 pub async fn change_email(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     db: DatabaseWrapper,
     Json(data): Json<EmailChangeRequest>,
 ) -> Result<impl IntoResponse, TimeError> {
     if !validate_email(&data.new) {
         return Err(TimeError::InvalidEmail);
     }
 
-    let result = db.change_email(user.identity.id, data.new).await;
+    let result = db.change_email(user.id, data.new).await;
 
     if result.as_ref().is_err_and(|e| e.is_unique_violation()) {
         return Err(TimeError::EmailTaken);

src/api/friends.rs

@@ -6,10 +6,10 @@ use http::StatusCode;
 use serde::Deserialize;
 
 use crate::{
-    api::{activity::HeartBeatMemoryStore, auth::SecuredUserIdentity},
+    api::activity::HeartBeatMemoryStore,
     database::DatabaseWrapper,
     error::TimeError,
-    models::{CurrentActivity, FriendWithTimeAndStatus, UserId},
+    models::{CurrentActivity, FriendWithTimeAndStatus, UserId, UserIdentity},
 };
 
 #[derive(Deserialize, Debug)]
@@ -93,10 +93,10 @@ pub async fn get_friends(
 }
 
 pub async fn regenerate_friend_code(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     db: DatabaseWrapper,
 ) -> Result<impl IntoResponse, TimeError> {
-    db.regenerate_friend_code(user.identity.id)
+    db.regenerate_friend_code(user.id)
         .await
         .inspect_err(|e| error!("{}", e))
         .map(|code| Json(json!({ "friend_code": code })))
@@ -108,12 +108,12 @@ pub struct RemoveFriendRequest {
 }
 
 pub async fn remove(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     db: DatabaseWrapper,
     Json(body): Json<RemoveFriendRequest>,
 ) -> Result<impl IntoResponse, TimeError> {
     let friend = db.get_user_by_name(&body.name).await?;
-    let deleted = db.remove_friend(user.identity.id, friend.id).await?;
+    let deleted = db.remove_friend(user.id, friend.id).await?;
 
     if deleted {
         Ok(StatusCode::OK)

src/api/leaderboards.rs

@@ -4,7 +4,7 @@ use http::StatusCode;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    api::auth::SecuredUserIdentity, database::DatabaseWrapper, error::TimeError, models::UserId,
+    database::DatabaseWrapper, error::TimeError, models::{UserId, UserIdentity},
 };
 
 #[derive(Deserialize, Serialize)]
@@ -69,7 +69,7 @@ pub async fn get_leaderboard(
 }
 
 pub async fn delete_leaderboard(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     Path(name): Path<String>,
     db: DatabaseWrapper,
 ) -> Result<impl IntoResponse, TimeError> {
@@ -78,7 +78,7 @@ pub async fn delete_leaderboard(
         .await
         .map_err(|_| TimeError::LeaderboardNotFound)?;
 
-    if db.is_leaderboard_admin(user.identity.id, lid).await? {
+    if db.is_leaderboard_admin(user.id, lid).await? {
         db.delete_leaderboard(&name).await?;
         Ok(StatusCode::OK)
     } else {
@@ -111,7 +111,7 @@ pub async fn join_leaderboard(
 }
 
 pub async fn leave_leaderboard(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     Path(name): Path<String>,
     db: DatabaseWrapper,
 ) -> Result<impl IntoResponse, TimeError> {
@@ -120,14 +120,14 @@ pub async fn leave_leaderboard(
         .await
         .map_err(|_| TimeError::LeaderboardNotFound)?;
 
-    if db.is_leaderboard_admin(user.identity.id, lid).await?
+    if db.is_leaderboard_admin(user.id, lid).await?
         && db.get_leaderboard_admin_count(lid).await? == 1
     {
         return Err(TimeError::LastAdmin);
     }
 
     if db
-        .remove_user_from_leaderboard(lid, user.identity.id)
+        .remove_user_from_leaderboard(lid, user.id)
         .await?
     {
         Ok(StatusCode::OK)
@@ -137,7 +137,7 @@ pub async fn leave_leaderboard(
 }
 
 pub async fn promote_member(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     Path(name): Path<String>,
     db: DatabaseWrapper,
     promotion: Json<LeaderboardUser>,
@@ -147,7 +147,7 @@ pub async fn promote_member(
         .await
         .map_err(|_| TimeError::LeaderboardNotFound)?;
 
-    if db.is_leaderboard_admin(user.identity.id, lid).await? {
+    if db.is_leaderboard_admin(user.id, lid).await? {
         let newadmin = db
             .get_user_by_name(&promotion.user)
             .await
@@ -168,7 +168,7 @@ pub async fn promote_member(
 }
 
 pub async fn demote_member(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     Path(name): Path<String>,
     db: DatabaseWrapper,
     demotion: Json<LeaderboardUser>,
@@ -178,7 +178,7 @@ pub async fn demote_member(
         .await
         .map_err(|_| TimeError::LeaderboardNotFound)?;
 
-    if db.is_leaderboard_admin(user.identity.id, lid).await? {
+    if db.is_leaderboard_admin(user.id, lid).await? {
         let oldadmin = db
             .get_user_by_name(&demotion.user)
             .await
@@ -199,7 +199,7 @@ pub async fn demote_member(
 }
 
 pub async fn kick_member(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     Path(name): Path<String>,
     db: DatabaseWrapper,
     kick: Json<LeaderboardUser>,
@@ -209,7 +209,7 @@ pub async fn kick_member(
         .await
         .map_err(|_| TimeError::LeaderboardNotFound)?;
 
-    if db.is_leaderboard_admin(user.identity.id, lid).await? {
+    if db.is_leaderboard_admin(user.id, lid).await? {
         let kmember = db
             .get_user_by_name(&kick.user)
             .await
@@ -225,7 +225,7 @@ pub async fn kick_member(
 }
 
 pub async fn regenerate_invite(
-    user: SecuredUserIdentity,
+    user: UserIdentity,
     Path(name): Path<String>,
     db: DatabaseWrapper,
 ) -> Result<impl IntoResponse, TimeError> {
@@ -234,7 +234,7 @@ pub async fn regenerate_invite(
         .await
         .map_err(|_| TimeError::LeaderboardNotFound)?;
 
-    if db.is_leaderboard_admin(user.identity.id, lid).await? {
+    if db.is_leaderboard_admin(user.id, lid).await? {
         let code = db.regenerate_leaderboard_invite(lid).await?;
         Ok(Json(json!({ "invite_code": code })))
     } else {

src/auth/mod.rs

@@ -1,8 +1,5 @@
-pub mod secured_access;
-
 use std::{
     mem,
-    sync::Arc,
     task::{Context, Poll},
 };
 
@@ -16,7 +13,6 @@ use crate::{database::DatabaseWrapper, models::UserIdentity, TestaustimeState};
 pub enum Authentication {
     NoAuth,
     AuthToken(UserIdentity),
-    SecuredAccessToken(UserIdentity),
 }
 
 #[derive(Clone)]
@@ -35,7 +31,6 @@ impl Authentication {
         match self {
             Authentication::NoAuth => None,
             Authentication::AuthToken(user_identity) => Some(user_identity),
-            Authentication::SecuredAccessToken(user_identity) => Some(user_identity),
         }
     }
 }
@@ -68,7 +63,6 @@ where
 
     fn call(&mut self, mut req: Request<B>) -> Self::Future {
         let db = DatabaseWrapper::from(&self.state.database);
-        let secured_access_storage = Arc::clone(&self.state.secured_access_storage);
         let auth = req.headers().get("Authorization").cloned();
 
         let clone = self.inner.clone();
@@ -84,14 +78,7 @@ where
                     break 'auth Authentication::NoAuth;
                 };
 
-                if let Ok(secured_access_instance) = secured_access_storage.get(token).clone() {
-                    let user = db
-                        .get_user_by_id(secured_access_instance.user_id)
-                        .await
-                        .unwrap();
-
-                    Authentication::SecuredAccessToken(user)
-                } else if let Ok(user_identity) = db.get_user_by_token(token.to_string()).await {
+                if let Ok(user_identity) = db.get_user_by_token(token.to_string()).await {
                     Authentication::AuthToken(user_identity)
                 } else {
                     Authentication::NoAuth