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   #![allow(clippy::unwrap_used)]
 111   #![allow(clippy::indexing_slicing)]
 112
 113   use crate::{
 114     source::{
 115       instance::Instance,
 116       local_user::{LocalUser, LocalUserInsertForm},
 117       password_reset_request::PasswordResetRequest,
 118       person::{Person, PersonInsertForm},
 119     },
 120     traits::Crud,
 121     utils::build_db_pool_for_tests,
 122   };
 123   use serial_test::serial;
 124
 125   #[tokio::test]
 126   #[serial]
 127   async fn test_crud() {
 128     let pool = &build_db_pool_for_tests().await;
 129     let pool = &mut pool.into();
 130
 131     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
 132       .await
 133       .unwrap();
 134
 135     let new_person = PersonInsertForm::builder()
 136       .name("thommy prw".into())
 137       .public_key("pubkey".to_string())
 138       .instance_id(inserted_instance.id)
 139       .build();
 140
 141     let inserted_person = Person::create(pool, &new_person).await.unwrap();
 142
 143     let new_local_user = LocalUserInsertForm::builder()
 144       .person_id(inserted_person.id)
 145       .password_encrypted("pass".to_string())
 146       .build();
 147
 148     let inserted_local_user = LocalUser::create(pool, &new_local_user).await.unwrap();
 149
 150     let token = "nope";
 151     let token_encrypted_ = "ca3704aa0b06f5954c79ee837faa152d84d6b2d42838f0637a15eda8337dbdce";
 152
 153     let inserted_password_reset_request =
 154       PasswordResetRequest::create_token(pool, inserted_local_user.id, token)
 155         .await
 156         .unwrap();
 157
 158     let expected_password_reset_request = PasswordResetRequest {
 159       id: inserted_password_reset_request.id,
 160       local_user_id: inserted_local_user.id,
 161       token_encrypted: token_encrypted_.to_string(),
 162       published: inserted_password_reset_request.published,
 163     };
 164
 165     let read_password_reset_request = PasswordResetRequest::read_from_token(pool, token)
 166       .await
 167       .unwrap();
 168     let num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
 169     Instance::delete(pool, inserted_instance.id).await.unwrap();
 170
 171     assert_eq!(expected_password_reset_request, read_password_reset_request);
 172     assert_eq!(
 173       expected_password_reset_request,
 174       inserted_password_reset_request
 175     );
 176     assert_eq!(1, num_deleted);
 177   }
 178 }