crates/db_schema/src/impls/password_reset_request.rs

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