crates/db_schema/src/impls/comment_reply.rs

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