crates/db_queries/src/source/comment.rs

   1 use crate::{ApubObject, Crud, Likeable, Saveable};
   2 use diesel::{dsl::*, result::Error, *};
   3 use lemmy_db_schema::{
   4   naive_now,
   5   source::comment::{
   6     Comment,
   7     CommentForm,
   8     CommentLike,
   9     CommentLikeForm,
  10     CommentSaved,
  11     CommentSavedForm,
  12   },
  13   Url,
  14 };
  15
  16 pub trait Comment_ {
  17   fn update_ap_id(conn: &PgConnection, comment_id: i32, apub_id: Url) -> Result<Comment, Error>;
  18   fn permadelete_for_creator(
  19     conn: &PgConnection,
  20     for_creator_id: i32,
  21   ) -> Result<Vec<Comment>, Error>;
  22   fn update_deleted(
  23     conn: &PgConnection,
  24     comment_id: i32,
  25     new_deleted: bool,
  26   ) -> Result<Comment, Error>;
  27   fn update_removed(
  28     conn: &PgConnection,
  29     comment_id: i32,
  30     new_removed: bool,
  31   ) -> Result<Comment, Error>;
  32   fn update_removed_for_creator(
  33     conn: &PgConnection,
  34     for_creator_id: i32,
  35     new_removed: bool,
  36   ) -> Result<Vec<Comment>, Error>;
  37   fn update_read(conn: &PgConnection, comment_id: i32, new_read: bool) -> Result<Comment, Error>;
  38   fn update_content(
  39     conn: &PgConnection,
  40     comment_id: i32,
  41     new_content: &str,
  42   ) -> Result<Comment, Error>;
  43 }
  44
  45 impl Comment_ for Comment {
  46   fn update_ap_id(conn: &PgConnection, comment_id: i32, apub_id: Url) -> Result<Self, Error> {
  47     use lemmy_db_schema::schema::comment::dsl::*;
  48
  49     diesel::update(comment.find(comment_id))
  50       .set(ap_id.eq(apub_id))
  51       .get_result::<Self>(conn)
  52   }
  53
  54   fn permadelete_for_creator(conn: &PgConnection, for_creator_id: i32) -> Result<Vec<Self>, Error> {
  55     use lemmy_db_schema::schema::comment::dsl::*;
  56     diesel::update(comment.filter(creator_id.eq(for_creator_id)))
  57       .set((
  58         content.eq("*Permananently Deleted*"),
  59         deleted.eq(true),
  60         updated.eq(naive_now()),
  61       ))
  62       .get_results::<Self>(conn)
  63   }
  64
  65   fn update_deleted(
  66     conn: &PgConnection,
  67     comment_id: i32,
  68     new_deleted: bool,
  69   ) -> Result<Self, Error> {
  70     use lemmy_db_schema::schema::comment::dsl::*;
  71     diesel::update(comment.find(comment_id))
  72       .set((deleted.eq(new_deleted), updated.eq(naive_now())))
  73       .get_result::<Self>(conn)
  74   }
  75
  76   fn update_removed(
  77     conn: &PgConnection,
  78     comment_id: i32,
  79     new_removed: bool,
  80   ) -> Result<Self, Error> {
  81     use lemmy_db_schema::schema::comment::dsl::*;
  82     diesel::update(comment.find(comment_id))
  83       .set((removed.eq(new_removed), updated.eq(naive_now())))
  84       .get_result::<Self>(conn)
  85   }
  86
  87   fn update_removed_for_creator(
  88     conn: &PgConnection,
  89     for_creator_id: i32,
  90     new_removed: bool,
  91   ) -> Result<Vec<Self>, Error> {
  92     use lemmy_db_schema::schema::comment::dsl::*;
  93     diesel::update(comment.filter(creator_id.eq(for_creator_id)))
  94       .set((removed.eq(new_removed), updated.eq(naive_now())))
  95       .get_results::<Self>(conn)
  96   }
  97
  98   fn update_read(conn: &PgConnection, comment_id: i32, new_read: bool) -> Result<Self, Error> {
  99     use lemmy_db_schema::schema::comment::dsl::*;
 100     diesel::update(comment.find(comment_id))
 101       .set(read.eq(new_read))
 102       .get_result::<Self>(conn)
 103   }
 104
 105   fn update_content(
 106     conn: &PgConnection,
 107     comment_id: i32,
 108     new_content: &str,
 109   ) -> Result<Self, Error> {
 110     use lemmy_db_schema::schema::comment::dsl::*;
 111     diesel::update(comment.find(comment_id))
 112       .set((content.eq(new_content), updated.eq(naive_now())))
 113       .get_result::<Self>(conn)
 114   }
 115 }
 116
 117 impl Crud<CommentForm> for Comment {
 118   fn read(conn: &PgConnection, comment_id: i32) -> Result<Self, Error> {
 119     use lemmy_db_schema::schema::comment::dsl::*;
 120     comment.find(comment_id).first::<Self>(conn)
 121   }
 122
 123   fn delete(conn: &PgConnection, comment_id: i32) -> Result<usize, Error> {
 124     use lemmy_db_schema::schema::comment::dsl::*;
 125     diesel::delete(comment.find(comment_id)).execute(conn)
 126   }
 127
 128   fn create(conn: &PgConnection, comment_form: &CommentForm) -> Result<Self, Error> {
 129     use lemmy_db_schema::schema::comment::dsl::*;
 130     insert_into(comment)
 131       .values(comment_form)
 132       .get_result::<Self>(conn)
 133   }
 134
 135   fn update(
 136     conn: &PgConnection,
 137     comment_id: i32,
 138     comment_form: &CommentForm,
 139   ) -> Result<Self, Error> {
 140     use lemmy_db_schema::schema::comment::dsl::*;
 141     diesel::update(comment.find(comment_id))
 142       .set(comment_form)
 143       .get_result::<Self>(conn)
 144   }
 145 }
 146
 147 impl ApubObject<CommentForm> for Comment {
 148   fn read_from_apub_id(conn: &PgConnection, object_id: &Url) -> Result<Self, Error> {
 149     use lemmy_db_schema::schema::comment::dsl::*;
 150     comment.filter(ap_id.eq(object_id)).first::<Self>(conn)
 151   }
 152
 153   fn upsert(conn: &PgConnection, comment_form: &CommentForm) -> Result<Self, Error> {
 154     use lemmy_db_schema::schema::comment::dsl::*;
 155     insert_into(comment)
 156       .values(comment_form)
 157       .on_conflict(ap_id)
 158       .do_update()
 159       .set(comment_form)
 160       .get_result::<Self>(conn)
 161   }
 162 }
 163
 164 impl Likeable<CommentLikeForm> for CommentLike {
 165   fn like(conn: &PgConnection, comment_like_form: &CommentLikeForm) -> Result<Self, Error> {
 166     use lemmy_db_schema::schema::comment_like::dsl::*;
 167     insert_into(comment_like)
 168       .values(comment_like_form)
 169       .on_conflict((comment_id, person_id))
 170       .do_update()
 171       .set(comment_like_form)
 172       .get_result::<Self>(conn)
 173   }
 174   fn remove(conn: &PgConnection, person_id: i32, comment_id: i32) -> Result<usize, Error> {
 175     use lemmy_db_schema::schema::comment_like::dsl;
 176     diesel::delete(
 177       dsl::comment_like
 178         .filter(dsl::comment_id.eq(comment_id))
 179         .filter(dsl::person_id.eq(person_id)),
 180     )
 181     .execute(conn)
 182   }
 183 }
 184
 185 impl Saveable<CommentSavedForm> for CommentSaved {
 186   fn save(conn: &PgConnection, comment_saved_form: &CommentSavedForm) -> Result<Self, Error> {
 187     use lemmy_db_schema::schema::comment_saved::dsl::*;
 188     insert_into(comment_saved)
 189       .values(comment_saved_form)
 190       .on_conflict((comment_id, user_id))
 191       .do_update()
 192       .set(comment_saved_form)
 193       .get_result::<Self>(conn)
 194   }
 195   fn unsave(conn: &PgConnection, comment_saved_form: &CommentSavedForm) -> Result<usize, Error> {
 196     use lemmy_db_schema::schema::comment_saved::dsl::*;
 197     diesel::delete(
 198       comment_saved
 199         .filter(comment_id.eq(comment_saved_form.comment_id))
 200         .filter(user_id.eq(comment_saved_form.person_id)),
 201     )
 202     .execute(conn)
 203   }
 204 }
 205
 206 #[cfg(test)]
 207 mod tests {
 208   use crate::{establish_unpooled_connection, Crud, Likeable, ListingType, Saveable, SortType};
 209   use lemmy_db_schema::source::{
 210     comment::*,
 211     community::{Community, CommunityForm},
 212     post::*,
 213     person::{PersonForm, Person},
 214   };
 215
 216   #[test]
 217   fn test_crud() {
 218     let conn = establish_unpooled_connection();
 219
 220     let new_person = PersonForm {
 221       name: "terry".into(),
 222       preferred_username: None,
 223       avatar: None,
 224       banner: None,
 225       banned: Some(false),
 226       deleted: false,
 227       published: None,
 228       updated: None,
 229       actor_id: None,
 230       bio: None,
 231       local: true,
 232       private_key: None,
 233       public_key: None,
 234       last_refreshed_at: None,
 235       inbox_url: None,
 236       shared_inbox_url: None,
 237     };
 238
 239     let inserted_persod = Person::create(&conn, &new_person).unwrap();
 240
 241     let new_community = CommunityForm {
 242       name: "test community".to_string(),
 243       title: "nada".to_owned(),
 244       description: None,
 245       creator_id: inserted_persod.id,
 246       removed: None,
 247       deleted: None,
 248       updated: None,
 249       nsfw: false,
 250       actor_id: None,
 251       local: true,
 252       private_key: None,
 253       public_key: None,
 254       last_refreshed_at: None,
 255       published: None,
 256       banner: None,
 257       icon: None,
 258       inbox_url: None,
 259       shared_inbox_url: None,
 260       followers_url: None,
 261     };
 262
 263     let inserted_community = Community::create(&conn, &new_community).unwrap();
 264
 265     let new_post = PostForm {
 266       name: "A test post".into(),
 267       creator_id: inserted_persod.id,
 268       url: None,
 269       body: None,
 270       community_id: inserted_community.id,
 271       removed: None,
 272       deleted: None,
 273       locked: None,
 274       stickied: None,
 275       updated: None,
 276       nsfw: false,
 277       embed_title: None,
 278       embed_description: None,
 279       embed_html: None,
 280       thumbnail_url: None,
 281       ap_id: None,
 282       local: true,
 283       published: None,
 284     };
 285
 286     let inserted_post = Post::create(&conn, &new_post).unwrap();
 287
 288     let comment_form = CommentForm {
 289       content: "A test comment".into(),
 290       creator_id: inserted_persod.id,
 291       post_id: inserted_post.id,
 292       removed: None,
 293       deleted: None,
 294       read: None,
 295       parent_id: None,
 296       published: None,
 297       updated: None,
 298       ap_id: None,
 299       local: true,
 300     };
 301
 302     let inserted_comment = Comment::create(&conn, &comment_form).unwrap();
 303
 304     let expected_comment = Comment {
 305       id: inserted_comment.id,
 306       content: "A test comment".into(),
 307       creator_id: inserted_persod.id,
 308       post_id: inserted_post.id,
 309       removed: false,
 310       deleted: false,
 311       read: false,
 312       parent_id: None,
 313       published: inserted_comment.published,
 314       updated: None,
 315       ap_id: inserted_comment.ap_id.to_owned(),
 316       local: true,
 317     };
 318
 319     let child_comment_form = CommentForm {
 320       content: "A child comment".into(),
 321       creator_id: inserted_persod.id,
 322       post_id: inserted_post.id,
 323       parent_id: Some(inserted_comment.id),
 324       removed: None,
 325       deleted: None,
 326       read: None,
 327       published: None,
 328       updated: None,
 329       ap_id: None,
 330       local: true,
 331     };
 332
 333     let inserted_child_comment = Comment::create(&conn, &child_comment_form).unwrap();
 334
 335     // Comment Like
 336     let comment_like_form = CommentLikeForm {
 337       comment_id: inserted_comment.id,
 338       post_id: inserted_post.id,
 339       person_id: inserted_persod.id,
 340       score: 1,
 341     };
 342
 343     let inserted_comment_like = CommentLike::like(&conn, &comment_like_form).unwrap();
 344
 345     let expected_comment_like = CommentLike {
 346       id: inserted_comment_like.id,
 347       comment_id: inserted_comment.id,
 348       post_id: inserted_post.id,
 349       person_id: inserted_persod.id,
 350       published: inserted_comment_like.published,
 351       score: 1,
 352     };
 353
 354     // Comment Saved
 355     let comment_saved_form = CommentSavedForm {
 356       comment_id: inserted_comment.id,
 357       person_id: inserted_persod.id,
 358     };
 359
 360     let inserted_comment_saved = CommentSaved::save(&conn, &comment_saved_form).unwrap();
 361
 362     let expected_comment_saved = CommentSaved {
 363       id: inserted_comment_saved.id,
 364       comment_id: inserted_comment.id,
 365       person_id: inserted_persod.id,
 366       published: inserted_comment_saved.published,
 367     };
 368
 369     let read_comment = Comment::read(&conn, inserted_comment.id).unwrap();
 370     let updated_comment = Comment::update(&conn, inserted_comment.id, &comment_form).unwrap();
 371     let like_removed = CommentLike::remove(&conn, inserted_persod.id, inserted_comment.id).unwrap();
 372     let saved_removed = CommentSaved::unsave(&conn, &comment_saved_form).unwrap();
 373     let num_deleted = Comment::delete(&conn, inserted_comment.id).unwrap();
 374     Comment::delete(&conn, inserted_child_comment.id).unwrap();
 375     Post::delete(&conn, inserted_post.id).unwrap();
 376     Community::delete(&conn, inserted_community.id).unwrap();
 377     Person::delete(&conn, inserted_persod.id).unwrap();
 378
 379     assert_eq!(expected_comment, read_comment);
 380     assert_eq!(expected_comment, inserted_comment);
 381     assert_eq!(expected_comment, updated_comment);
 382     assert_eq!(expected_comment_like, inserted_comment_like);
 383     assert_eq!(expected_comment_saved, inserted_comment_saved);
 384     assert_eq!(
 385       expected_comment.id,
 386       inserted_child_comment.parent_id.unwrap()
 387     );
 388     assert_eq!(1, like_removed);
 389     assert_eq!(1, saved_removed);
 390     assert_eq!(1, num_deleted);
 391   }
 392 }