Updating ui

service/src/auth/model.rs

@@ -1,14 +1,12 @@
-use std::{future::{ready, Ready}, env};
+use std::future::{ready, Ready};
 use actix_web::{FromRequest, Error as ActixError, HttpRequest, dev::Payload, http};
 use diesel::prelude::*;
-use log::error;
-use redis::Commands;
 use serde::{Serialize, Deserialize};
 use siren::ServiceError;
 
 use crate::storage::{schema::users, connection};
 
-use super::{hash, AccessToken};
+use super::{hash, Session, SESSION_COOKIE_NAME};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct RegisterUser {
@@ -58,7 +56,6 @@ impl QueryUser {
   pub fn get_by_email(email: &str) -> Result<QueryUser, ServiceError> {
     let mut conn = connection()?;
     // Check if the user exists by email, case insensitive
-
     let user = users::table
       .filter(users::email.eq(email.to_lowercase()))
       .first(&mut conn)?;
@@ -121,17 +118,17 @@ impl From<QueryUser> for ResponseUser {
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct JwtAuth {
+pub struct Auth {
   pub id: String,
   pub user: ResponseUser
 }
 
-impl FromRequest for JwtAuth {
+impl FromRequest for Auth {
   type Error = ActixError;
   type Future = Ready<Result<Self, Self::Error>>;
   fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
-    let access_token_string = match req
-      .cookie("access_token")
+    let session_id = match req
+      .cookie(SESSION_COOKIE_NAME)
       .map(|c| c.value().to_string())
       .or_else(|| {
         req.headers().get(http::header::AUTHORIZATION)
@@ -143,54 +140,17 @@ impl FromRequest for JwtAuth {
           message: "Unauthorized".to_string()
         })))
       };
-
-    let keys_dir = env::var("KEYS_DIR_PATH").expect("KEYS_DIR_PATH must be set");
-    let public_key = std::fs::read_to_string(format!("{}/public_key.pem", keys_dir)).expect("Failed to read access public key");
-
-    let access_token = match AccessToken::decode(&access_token_string, &public_key) {
-      Ok(token_details) => token_details,
-      Err(err) => {
-        error!("Failed to verify access token: {}", err);
-        return ready(Err(ActixError::from(ServiceError {
-          status: 401,
-          message: format!("Access token is invaid: {}", err)
-        })))
-      }
-    };
     
-    let mut conn = match crate::storage::redis_connection() {
-      Ok(conn) => conn,
-      Err(err) => {
-        error!("Failed to get redis connection: {}", err);
-        return ready(Err(ActixError::from(ServiceError {
-          status: 500,
-          message: format!("Failed to get redis connection: {}", err)
-        })))
-      }
-    };
-    let user_email = match conn.get::<_, String>(access_token.id.clone().to_string()) {
-      Ok(result) => serde_json::from_str::<AccessToken>(&result).unwrap().email,
-      Err(_) => {
-        return ready(Err(ActixError::from(ServiceError {
-          status: 401,
-          message: format!("Access token is invalid")
-        })))
-      }
-    };
-
-    match QueryUser::get_by_email(&user_email) {
-      Ok(user) => {
-        ready(Ok(JwtAuth { id: access_token.id, user: user.into() }))
-      }
-      Err(_) => return ready(Err(ActixError::from(ServiceError {
-        status: 401,
-        message: format!("User does not exist")
-      })))
+    let ip_address = req.peer_addr().unwrap().ip().to_string();
+    
+    match Session::verify(&session_id, &ip_address) {
+      Ok(v) => return ready(Ok(Auth { id: v.0.id, user: v.1.into() })),
+      Err(err) => return ready(Err(ActixError::from(err)))
     }
   }
 }
 
-pub fn verify_role(auth: &JwtAuth, role: &str) -> Result<(), ServiceError> {
+pub fn verify_role(auth: &Auth, role: &str) -> Result<(), ServiceError> {
   if auth.user.role == role {
     Ok(())
   } else {