crates/db_schema/src/impls/password_reset_request.rs

   1 use crate::{
   2   newtypes::LocalUserId,
   3   schema::password_reset_request::dsl::{local_user_id, password_reset_request, published, token},
   4   source::password_reset_request::{PasswordResetRequest, PasswordResetRequestForm},
   5   traits::Crud,
   6   utils::{get_conn, DbPool},
   7 };
   8 use diesel::{
   9   dsl::{insert_into, now, IntervalDsl},
  10   result::Error,
  11   ExpressionMethods,
  12   QueryDsl,
  13 };
  14 use diesel_async::RunQueryDsl;
  15
  16 #[async_trait]
  17 impl Crud for PasswordResetRequest {
  18   type InsertForm = PasswordResetRequestForm;
  19   type UpdateForm = PasswordResetRequestForm;
  20   type IdType = i32;
  21
  22   async fn create(pool: &mut DbPool<'_>, form: &PasswordResetRequestForm) -> Result<Self, Error> {
  23     let conn = &mut get_conn(pool).await?;
  24     insert_into(password_reset_request)
  25       .values(form)
  26       .get_result::<Self>(conn)
  27       .await
  28   }
  29   async fn update(
  30     pool: &mut DbPool<'_>,
  31     password_reset_request_id: i32,
  32     form: &PasswordResetRequestForm,
  33   ) -> Result<Self, Error> {
  34     let conn = &mut get_conn(pool).await?;
  35     diesel::update(password_reset_request.find(password_reset_request_id))
  36       .set(form)
  37       .get_result::<Self>(conn)
  38       .await
  39   }
  40 }
  41
  42 impl PasswordResetRequest {
  43   pub async fn create_token(
  44     pool: &mut DbPool<'_>,
  45     from_local_user_id: LocalUserId,
  46     token_: String,
  47   ) -> Result<PasswordResetRequest, Error> {
  48     let form = PasswordResetRequestForm {
  49       local_user_id: from_local_user_id,
  50       token: token_,
  51     };
  52
  53     Self::create(pool, &form).await
  54   }
  55   pub async fn read_from_token(
  56     pool: &mut DbPool<'_>,
  57     token_: &str,
  58   ) -> Result<PasswordResetRequest, Error> {
  59     let conn = &mut get_conn(pool).await?;
  60     password_reset_request
  61       .filter(token.eq(token_))
  62       .filter(published.gt(now - 1.days()))
  63       .first::<Self>(conn)
  64       .await
  65   }
  66
  67   pub async fn get_recent_password_resets_count(
  68     pool: &mut DbPool<'_>,
  69     user_id: LocalUserId,
  70   ) -> Result<i64, Error> {
  71     let conn = &mut get_conn(pool).await?;
  72     password_reset_request
  73       .filter(local_user_id.eq(user_id))
  74       .filter(published.gt(now - 1.days()))
  75       .count()
  76       .get_result(conn)
  77       .await
  78   }
  79 }
  80
  81 #[cfg(test)]
  82 mod tests {
  83   #![allow(clippy::unwrap_used)]
  84   #![allow(clippy::indexing_slicing)]
  85
  86   use crate::{
  87     source::{
  88       instance::Instance,
  89       local_user::{LocalUser, LocalUserInsertForm},
  90       password_reset_request::PasswordResetRequest,
  91       person::{Person, PersonInsertForm},
  92     },
  93     traits::Crud,
  94     utils::build_db_pool_for_tests,
  95   };
  96   use serial_test::serial;
  97
  98   #[tokio::test]
  99   #[serial]
 100   async fn test_crud() {
 101     let pool = &build_db_pool_for_tests().await;
 102     let pool = &mut pool.into();
 103
 104     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
 105       .await
 106       .unwrap();
 107
 108     let new_person = PersonInsertForm::builder()
 109       .name("thommy prw".into())
 110       .public_key("pubkey".to_string())
 111       .instance_id(inserted_instance.id)
 112       .build();
 113
 114     let inserted_person = Person::create(pool, &new_person).await.unwrap();
 115
 116     let new_local_user = LocalUserInsertForm::builder()
 117       .person_id(inserted_person.id)
 118       .password_encrypted("pass".to_string())
 119       .build();
 120
 121     let inserted_local_user = LocalUser::create(pool, &new_local_user).await.unwrap();
 122
 123     let token = "nope";
 124
 125     let inserted_password_reset_request =
 126       PasswordResetRequest::create_token(pool, inserted_local_user.id, token.to_string())
 127         .await
 128         .unwrap();
 129
 130     let expected_password_reset_request = PasswordResetRequest {
 131       id: inserted_password_reset_request.id,
 132       local_user_id: inserted_local_user.id,
 133       token: token.to_string(),
 134       published: inserted_password_reset_request.published,
 135     };
 136
 137     let read_password_reset_request = PasswordResetRequest::read_from_token(pool, token)
 138       .await
 139       .unwrap();
 140     let num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
 141     Instance::delete(pool, inserted_instance.id).await.unwrap();
 142
 143     assert_eq!(expected_password_reset_request, read_password_reset_request);
 144     assert_eq!(
 145       expected_password_reset_request,
 146       inserted_password_reset_request
 147     );
 148     assert_eq!(1, num_deleted);
 149   }
 150 }