crates/db_schema/src/impls/password_reset_request.rs

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