crates/db_schema/src/impls/person_mention.rs

   1 use crate::{
   2   newtypes::{CommentId, PersonId, PersonMentionId},
   3   source::person_mention::*,
   4   traits::Crud,
   5 };
   6 use diesel::{dsl::*, result::Error, *};
   7
   8 impl Crud for PersonMention {
   9   type InsertForm = PersonMentionInsertForm;
  10   type UpdateForm = PersonMentionUpdateForm;
  11   type IdType = PersonMentionId;
  12   fn read(conn: &mut PgConnection, person_mention_id: PersonMentionId) -> Result<Self, Error> {
  13     use crate::schema::person_mention::dsl::*;
  14     person_mention.find(person_mention_id).first::<Self>(conn)
  15   }
  16
  17   fn create(
  18     conn: &mut PgConnection,
  19     person_mention_form: &Self::InsertForm,
  20   ) -> Result<Self, Error> {
  21     use crate::schema::person_mention::dsl::*;
  22     // since the return here isnt utilized, we dont need to do an update
  23     // but get_result doesnt return the existing row here
  24     insert_into(person_mention)
  25       .values(person_mention_form)
  26       .on_conflict((recipient_id, comment_id))
  27       .do_update()
  28       .set(person_mention_form)
  29       .get_result::<Self>(conn)
  30   }
  31
  32   fn update(
  33     conn: &mut PgConnection,
  34     person_mention_id: PersonMentionId,
  35     person_mention_form: &Self::UpdateForm,
  36   ) -> Result<Self, Error> {
  37     use crate::schema::person_mention::dsl::*;
  38     diesel::update(person_mention.find(person_mention_id))
  39       .set(person_mention_form)
  40       .get_result::<Self>(conn)
  41   }
  42 }
  43
  44 impl PersonMention {
  45   pub fn mark_all_as_read(
  46     conn: &mut PgConnection,
  47     for_recipient_id: PersonId,
  48   ) -> Result<Vec<PersonMention>, Error> {
  49     use crate::schema::person_mention::dsl::*;
  50     diesel::update(
  51       person_mention
  52         .filter(recipient_id.eq(for_recipient_id))
  53         .filter(read.eq(false)),
  54     )
  55     .set(read.eq(true))
  56     .get_results::<Self>(conn)
  57   }
  58
  59   pub fn read_by_comment_and_person(
  60     conn: &mut PgConnection,
  61     for_comment_id: CommentId,
  62     for_recipient_id: PersonId,
  63   ) -> Result<Self, Error> {
  64     use crate::schema::person_mention::dsl::*;
  65     person_mention
  66       .filter(comment_id.eq(for_comment_id))
  67       .filter(recipient_id.eq(for_recipient_id))
  68       .first::<Self>(conn)
  69   }
  70 }
  71
  72 #[cfg(test)]
  73 mod tests {
  74   use crate::{
  75     source::{
  76       comment::*,
  77       community::{Community, CommunityInsertForm},
  78       instance::Instance,
  79       person::*,
  80       person_mention::*,
  81       post::*,
  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("terrylake".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 recipient_form = PersonInsertForm::builder()
 104       .name("terrylakes recipient".into())
 105       .public_key("pubkey".to_string())
 106       .instance_id(inserted_instance.id)
 107       .build();
 108
 109     let inserted_recipient = Person::create(conn, &recipient_form).unwrap();
 110
 111     let new_community = CommunityInsertForm::builder()
 112       .name("test community lake".to_string())
 113       .title("nada".to_owned())
 114       .public_key("pubkey".to_string())
 115       .instance_id(inserted_instance.id)
 116       .build();
 117
 118     let inserted_community = Community::create(conn, &new_community).unwrap();
 119
 120     let new_post = PostInsertForm::builder()
 121       .name("A test post".into())
 122       .creator_id(inserted_person.id)
 123       .community_id(inserted_community.id)
 124       .build();
 125
 126     let inserted_post = Post::create(conn, &new_post).unwrap();
 127
 128     let comment_form = CommentInsertForm::builder()
 129       .content("A test comment".into())
 130       .creator_id(inserted_person.id)
 131       .post_id(inserted_post.id)
 132       .build();
 133
 134     let inserted_comment = Comment::create(conn, &comment_form, None).unwrap();
 135
 136     let person_mention_form = PersonMentionInsertForm {
 137       recipient_id: inserted_recipient.id,
 138       comment_id: inserted_comment.id,
 139       read: None,
 140     };
 141
 142     let inserted_mention = PersonMention::create(conn, &person_mention_form).unwrap();
 143
 144     let expected_mention = PersonMention {
 145       id: inserted_mention.id,
 146       recipient_id: inserted_mention.recipient_id,
 147       comment_id: inserted_mention.comment_id,
 148       read: false,
 149       published: inserted_mention.published,
 150     };
 151
 152     let read_mention = PersonMention::read(conn, inserted_mention.id).unwrap();
 153
 154     let person_mention_update_form = PersonMentionUpdateForm { read: Some(false) };
 155     let updated_mention =
 156       PersonMention::update(conn, inserted_mention.id, &person_mention_update_form).unwrap();
 157     Comment::delete(conn, inserted_comment.id).unwrap();
 158     Post::delete(conn, inserted_post.id).unwrap();
 159     Community::delete(conn, inserted_community.id).unwrap();
 160     Person::delete(conn, inserted_person.id).unwrap();
 161     Person::delete(conn, inserted_recipient.id).unwrap();
 162     Instance::delete(conn, inserted_instance.id).unwrap();
 163
 164     assert_eq!(expected_mention, read_mention);
 165     assert_eq!(expected_mention, inserted_mention);
 166     assert_eq!(expected_mention, updated_mention);
 167   }
 168 }