crates/db_schema/src/impls/password_reset_request.rs

   1 use crate::{
   2   newtypes::LocalUserId,
   3   schema::password_reset_request::dsl::*,
   4   source::password_reset_request::*,
   5   traits::Crud,
   6   utils::{get_conn, DbPool},
   7 };
   8 use diesel::{dsl::*, result::Error, ExpressionMethods, QueryDsl};
   9 use diesel_async::RunQueryDsl;
  10 use sha2::{Digest, Sha256};
  11
  12 #[async_trait]
  13 impl Crud for PasswordResetRequest {
  14   type InsertForm = PasswordResetRequestForm;
  15   type UpdateForm = PasswordResetRequestForm;
  16   type IdType = i32;
  17   async fn read(pool: &DbPool, password_reset_request_id: i32) -> Result<Self, Error> {
  18     let conn = &mut get_conn(pool).await?;
  19     password_reset_request
  20       .find(password_reset_request_id)
  21       .first::<Self>(conn)
  22       .await
  23   }
  24   async fn create(pool: &DbPool, form: &PasswordResetRequestForm) -> Result<Self, Error> {
  25     let conn = &mut get_conn(pool).await?;
  26     insert_into(password_reset_request)
  27       .values(form)
  28       .get_result::<Self>(conn)
  29       .await
  30   }
  31   async fn update(
  32     pool: &DbPool,
  33     password_reset_request_id: i32,
  34     form: &PasswordResetRequestForm,
  35   ) -> Result<Self, Error> {
  36     let conn = &mut get_conn(pool).await?;
  37     diesel::update(password_reset_request.find(password_reset_request_id))
  38       .set(form)
  39       .get_result::<Self>(conn)
  40       .await
  41   }
  42 }
  43
  44 impl PasswordResetRequest {
  45   pub async fn create_token(
  46     pool: &DbPool,
  47     from_local_user_id: LocalUserId,
  48     token: &str,
  49   ) -> Result<PasswordResetRequest, Error> {
  50     let mut hasher = Sha256::new();
  51     hasher.update(token);
  52     let token_hash: String = bytes_to_hex(hasher.finalize().to_vec());
  53
  54     let form = PasswordResetRequestForm {
  55       local_user_id: from_local_user_id,
  56       token_encrypted: token_hash,
  57     };
  58
  59     Self::create(pool, &form).await
  60   }
  61   pub async fn read_from_token(pool: &DbPool, token: &str) -> Result<PasswordResetRequest, Error> {
  62     let conn = &mut get_conn(pool).await?;
  63     let mut hasher = Sha256::new();
  64     hasher.update(token);
  65     let token_hash: String = bytes_to_hex(hasher.finalize().to_vec());
  66     password_reset_request
  67       .filter(token_encrypted.eq(token_hash))
  68       .filter(published.gt(now - 1.days()))
  69       .first::<Self>(conn)
  70       .await
  71   }
  72 }
  73
  74 fn bytes_to_hex(bytes: Vec<u8>) -> String {
  75   let mut str = String::new();
  76   for byte in bytes {
  77     str = format!("{}{:02x}", str, byte);
  78   }
  79   str
  80 }
  81
  82 #[cfg(test)]
  83 mod tests {
  84   use crate::{
  85     source::{
  86       instance::Instance,
  87       local_user::{LocalUser, LocalUserInsertForm},
  88       password_reset_request::PasswordResetRequest,
  89       person::*,
  90     },
  91     traits::Crud,
  92     utils::build_db_pool_for_tests,
  93   };
  94   use serial_test::serial;
  95
  96   #[tokio::test]
  97   #[serial]
  98   async fn test_crud() {
  99     let pool = &build_db_pool_for_tests().await;
 100
 101     let inserted_instance = Instance::create(pool, "my_domain.tld").await.unwrap();
 102
 103     let new_person = PersonInsertForm::builder()
 104       .name("thommy prw".into())
 105       .public_key("pubkey".to_string())
 106       .instance_id(inserted_instance.id)
 107       .build();
 108
 109     let inserted_person = Person::create(pool, &new_person).await.unwrap();
 110
 111     let new_local_user = LocalUserInsertForm::builder()
 112       .person_id(inserted_person.id)
 113       .password_encrypted("pass".to_string())
 114       .build();
 115
 116     let inserted_local_user = LocalUser::create(pool, &new_local_user).await.unwrap();
 117
 118     let token = "nope";
 119     let token_encrypted_ = "ca3704aa0b06f5954c79ee837faa152d84d6b2d42838f0637a15eda8337dbdce";
 120
 121     let inserted_password_reset_request =
 122       PasswordResetRequest::create_token(pool, inserted_local_user.id, token)
 123         .await
 124         .unwrap();
 125
 126     let expected_password_reset_request = PasswordResetRequest {
 127       id: inserted_password_reset_request.id,
 128       local_user_id: inserted_local_user.id,
 129       token_encrypted: token_encrypted_.to_string(),
 130       published: inserted_password_reset_request.published,
 131     };
 132
 133     let read_password_reset_request = PasswordResetRequest::read_from_token(pool, token)
 134       .await
 135       .unwrap();
 136     let num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
 137     Instance::delete(pool, inserted_instance.id).await.unwrap();
 138
 139     assert_eq!(expected_password_reset_request, read_password_reset_request);
 140     assert_eq!(
 141       expected_password_reset_request,
 142       inserted_password_reset_request
 143     );
 144     assert_eq!(1, num_deleted);
 145   }
 146 }