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