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