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