server/lemmy_db/src/password_reset_request.rs

   1 use crate::{
   2   schema::{password_reset_request, password_reset_request::dsl::*},
   3   Crud,
   4 };
   5 use diesel::{dsl::*, result::Error, PgConnection, *};
   6 use sha2::{Digest, Sha256};
   7
   8 #[derive(Queryable, Identifiable, PartialEq, Debug)]
   9 #[table_name = "password_reset_request"]
  10 pub struct PasswordResetRequest {
  11   pub id: i32,
  12   pub user_id: i32,
  13   pub token_encrypted: String,
  14   pub published: chrono::NaiveDateTime,
  15 }
  16
  17 #[derive(Insertable, AsChangeset)]
  18 #[table_name = "password_reset_request"]
  19 pub struct PasswordResetRequestForm {
  20   pub user_id: i32,
  21   pub token_encrypted: String,
  22 }
  23
  24 impl Crud<PasswordResetRequestForm> for PasswordResetRequest {
  25   fn read(conn: &PgConnection, password_reset_request_id: i32) -> Result<Self, Error> {
  26     use crate::schema::password_reset_request::dsl::*;
  27     password_reset_request
  28       .find(password_reset_request_id)
  29       .first::<Self>(conn)
  30   }
  31   fn create(conn: &PgConnection, form: &PasswordResetRequestForm) -> Result<Self, Error> {
  32     insert_into(password_reset_request)
  33       .values(form)
  34       .get_result::<Self>(conn)
  35   }
  36   fn update(
  37     conn: &PgConnection,
  38     password_reset_request_id: i32,
  39     form: &PasswordResetRequestForm,
  40   ) -> Result<Self, Error> {
  41     diesel::update(password_reset_request.find(password_reset_request_id))
  42       .set(form)
  43       .get_result::<Self>(conn)
  44   }
  45 }
  46
  47 impl PasswordResetRequest {
  48   pub fn create_token(conn: &PgConnection, from_user_id: i32, token: &str) -> Result<Self, Error> {
  49     let mut hasher = Sha256::new();
  50     hasher.update(token);
  51     let token_hash: String = PasswordResetRequest::bytes_to_hex(hasher.finalize().to_vec());
  52
  53     let form = PasswordResetRequestForm {
  54       user_id: from_user_id,
  55       token_encrypted: token_hash,
  56     };
  57
  58     Self::create(&conn, &form)
  59   }
  60   pub fn read_from_token(conn: &PgConnection, token: &str) -> Result<Self, Error> {
  61     let mut hasher = Sha256::new();
  62     hasher.update(token);
  63     let token_hash: String = PasswordResetRequest::bytes_to_hex(hasher.finalize().to_vec());
  64     password_reset_request
  65       .filter(token_encrypted.eq(token_hash))
  66       .filter(published.gt(now - 1.days()))
  67       .first::<Self>(conn)
  68   }
  69
  70   fn bytes_to_hex(bytes: Vec<u8>) -> String {
  71     let mut str = String::new();
  72     for byte in bytes {
  73       str = format!("{}{:02x}", str, byte);
  74     }
  75     str
  76   }
  77 }
  78
  79 #[cfg(test)]
  80 mod tests {
  81   use super::super::user::*;
  82   use crate::{
  83     password_reset_request::PasswordResetRequest,
  84     tests::establish_unpooled_connection,
  85     Crud,
  86     ListingType,
  87     SortType,
  88   };
  89
  90   #[test]
  91   fn test_crud() {
  92     let conn = establish_unpooled_connection();
  93
  94     let new_user = UserForm {
  95       name: "thommy prw".into(),
  96       preferred_username: None,
  97       password_encrypted: "nope".into(),
  98       email: None,
  99       matrix_user_id: None,
 100       avatar: None,
 101       banner: None,
 102       admin: false,
 103       banned: false,
 104       updated: None,
 105       show_nsfw: false,
 106       theme: "darkly".into(),
 107       default_sort_type: SortType::Hot as i16,
 108       default_listing_type: ListingType::Subscribed as i16,
 109       lang: "browser".into(),
 110       show_avatars: true,
 111       send_notifications_to_email: false,
 112       actor_id: None,
 113       bio: None,
 114       local: true,
 115       private_key: None,
 116       public_key: None,
 117       last_refreshed_at: None,
 118     };
 119
 120     let inserted_user = User_::create(&conn, &new_user).unwrap();
 121
 122     let token = "nope";
 123     let token_encrypted_ = "ca3704aa0b06f5954c79ee837faa152d84d6b2d42838f0637a15eda8337dbdce";
 124
 125     let inserted_password_reset_request =
 126       PasswordResetRequest::create_token(&conn, inserted_user.id, token).unwrap();
 127
 128     let expected_password_reset_request = PasswordResetRequest {
 129       id: inserted_password_reset_request.id,
 130       user_id: inserted_user.id,
 131       token_encrypted: token_encrypted_.to_string(),
 132       published: inserted_password_reset_request.published,
 133     };
 134
 135     let read_password_reset_request = PasswordResetRequest::read_from_token(&conn, token).unwrap();
 136     let num_deleted = User_::delete(&conn, inserted_user.id).unwrap();
 137
 138     assert_eq!(expected_password_reset_request, read_password_reset_request);
 139     assert_eq!(
 140       expected_password_reset_request,
 141       inserted_password_reset_request
 142     );
 143     assert_eq!(1, num_deleted);
 144   }
 145 }