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: &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: &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: &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: &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(pool: &DbPool, token: &str) -> Result<PasswordResetRequest, Error> {
  72     let conn = &mut get_conn(pool).await?;
  73     let mut hasher = Sha256::new();
  74     hasher.update(token);
  75     let token_hash: String = bytes_to_hex(hasher.finalize().to_vec());
  76     password_reset_request
  77       .filter(token_encrypted.eq(token_hash))
  78       .filter(published.gt(now - 1.days()))
  79       .first::<Self>(conn)
  80       .await
  81   }
  82
  83   pub async fn get_recent_password_resets_count(
  84     pool: &DbPool,
  85     user_id: LocalUserId,
  86   ) -> Result<i64, Error> {
  87     let conn = &mut get_conn(pool).await?;
  88     password_reset_request
  89       .filter(local_user_id.eq(user_id))
  90       .filter(published.gt(now - 1.days()))
  91       .count()
  92       .get_result(conn)
  93       .await
  94   }
  95 }
  96
  97 fn bytes_to_hex(bytes: Vec<u8>) -> String {
  98   let mut str = String::new();
  99   for byte in bytes {
 100     str = format!("{str}{byte:02x}");
 101   }
 102   str
 103 }
 104
 105 #[cfg(test)]
 106 mod tests {
 107   use crate::{
 108     source::{
 109       instance::Instance,
 110       local_user::{LocalUser, LocalUserInsertForm},
 111       password_reset_request::PasswordResetRequest,
 112       person::{Person, PersonInsertForm},
 113     },
 114     traits::Crud,
 115     utils::build_db_pool_for_tests,
 116   };
 117   use serial_test::serial;
 118
 119   #[tokio::test]
 120   #[serial]
 121   async fn test_crud() {
 122     let pool = &build_db_pool_for_tests().await;
 123
 124     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
 125       .await
 126       .unwrap();
 127
 128     let new_person = PersonInsertForm::builder()
 129       .name("thommy prw".into())
 130       .public_key("pubkey".to_string())
 131       .instance_id(inserted_instance.id)
 132       .build();
 133
 134     let inserted_person = Person::create(pool, &new_person).await.unwrap();
 135
 136     let new_local_user = LocalUserInsertForm::builder()
 137       .person_id(inserted_person.id)
 138       .password_encrypted("pass".to_string())
 139       .build();
 140
 141     let inserted_local_user = LocalUser::create(pool, &new_local_user).await.unwrap();
 142
 143     let token = "nope";
 144     let token_encrypted_ = "ca3704aa0b06f5954c79ee837faa152d84d6b2d42838f0637a15eda8337dbdce";
 145
 146     let inserted_password_reset_request =
 147       PasswordResetRequest::create_token(pool, inserted_local_user.id, token)
 148         .await
 149         .unwrap();
 150
 151     let expected_password_reset_request = PasswordResetRequest {
 152       id: inserted_password_reset_request.id,
 153       local_user_id: inserted_local_user.id,
 154       token_encrypted: token_encrypted_.to_string(),
 155       published: inserted_password_reset_request.published,
 156     };
 157
 158     let read_password_reset_request = PasswordResetRequest::read_from_token(pool, token)
 159       .await
 160       .unwrap();
 161     let num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
 162     Instance::delete(pool, inserted_instance.id).await.unwrap();
 163
 164     assert_eq!(expected_password_reset_request, read_password_reset_request);
 165     assert_eq!(
 166       expected_password_reset_request,
 167       inserted_password_reset_request
 168     );
 169     assert_eq!(1, num_deleted);
 170   }
 171 }