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, user_id))
 170       .do_update()
 171       .set(comment_like_form)
 172       .get_result::<Self>(conn)
 173   }
 174   fn remove(conn: &PgConnection, user_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::user_id.eq(user_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.user_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     user::{UserForm, User_},
 214   };
 215
 216   #[test]
 217   fn test_crud() {
 218     let conn = establish_unpooled_connection();
 219
 220     let new_user = UserForm {
 221       name: "terry".into(),
 222       preferred_username: None,
 223       password_encrypted: "nope".into(),
 224       email: None,
 225       matrix_user_id: None,
 226       avatar: None,
 227       banner: None,
 228       admin: false,
 229       banned: Some(false),
 230       published: None,
 231       updated: None,
 232       show_nsfw: false,
 233       theme: "browser".into(),
 234       default_sort_type: SortType::Hot as i16,
 235       default_listing_type: ListingType::Subscribed as i16,
 236       lang: "browser".into(),
 237       show_avatars: true,
 238       send_notifications_to_email: false,
 239       actor_id: None,
 240       bio: None,
 241       local: true,
 242       private_key: None,
 243       public_key: None,
 244       last_refreshed_at: None,
 245       inbox_url: None,
 246       shared_inbox_url: None,
 247     };
 248
 249     let inserted_user = User_::create(&conn, &new_user).unwrap();
 250
 251     let new_community = CommunityForm {
 252       name: "test community".to_string(),
 253       title: "nada".to_owned(),
 254       description: None,
 255       creator_id: inserted_user.id,
 256       removed: None,
 257       deleted: None,
 258       updated: None,
 259       nsfw: false,
 260       actor_id: None,
 261       local: true,
 262       private_key: None,
 263       public_key: None,
 264       last_refreshed_at: None,
 265       published: None,
 266       banner: None,
 267       icon: None,
 268       inbox_url: None,
 269       shared_inbox_url: None,
 270       followers_url: None,
 271     };
 272
 273     let inserted_community = Community::create(&conn, &new_community).unwrap();
 274
 275     let new_post = PostForm {
 276       name: "A test post".into(),
 277       creator_id: inserted_user.id,
 278       url: None,
 279       body: None,
 280       community_id: inserted_community.id,
 281       removed: None,
 282       deleted: None,
 283       locked: None,
 284       stickied: None,
 285       updated: None,
 286       nsfw: false,
 287       embed_title: None,
 288       embed_description: None,
 289       embed_html: None,
 290       thumbnail_url: None,
 291       ap_id: None,
 292       local: true,
 293       published: None,
 294     };
 295
 296     let inserted_post = Post::create(&conn, &new_post).unwrap();
 297
 298     let comment_form = CommentForm {
 299       content: "A test comment".into(),
 300       creator_id: inserted_user.id,
 301       post_id: inserted_post.id,
 302       removed: None,
 303       deleted: None,
 304       read: None,
 305       parent_id: None,
 306       published: None,
 307       updated: None,
 308       ap_id: None,
 309       local: true,
 310     };
 311
 312     let inserted_comment = Comment::create(&conn, &comment_form).unwrap();
 313
 314     let expected_comment = Comment {
 315       id: inserted_comment.id,
 316       content: "A test comment".into(),
 317       creator_id: inserted_user.id,
 318       post_id: inserted_post.id,
 319       removed: false,
 320       deleted: false,
 321       read: false,
 322       parent_id: None,
 323       published: inserted_comment.published,
 324       updated: None,
 325       ap_id: inserted_comment.ap_id.to_owned(),
 326       local: true,
 327     };
 328
 329     let child_comment_form = CommentForm {
 330       content: "A child comment".into(),
 331       creator_id: inserted_user.id,
 332       post_id: inserted_post.id,
 333       parent_id: Some(inserted_comment.id),
 334       removed: None,
 335       deleted: None,
 336       read: None,
 337       published: None,
 338       updated: None,
 339       ap_id: None,
 340       local: true,
 341     };
 342
 343     let inserted_child_comment = Comment::create(&conn, &child_comment_form).unwrap();
 344
 345     // Comment Like
 346     let comment_like_form = CommentLikeForm {
 347       comment_id: inserted_comment.id,
 348       post_id: inserted_post.id,
 349       user_id: inserted_user.id,
 350       score: 1,
 351     };
 352
 353     let inserted_comment_like = CommentLike::like(&conn, &comment_like_form).unwrap();
 354
 355     let expected_comment_like = CommentLike {
 356       id: inserted_comment_like.id,
 357       comment_id: inserted_comment.id,
 358       post_id: inserted_post.id,
 359       user_id: inserted_user.id,
 360       published: inserted_comment_like.published,
 361       score: 1,
 362     };
 363
 364     // Comment Saved
 365     let comment_saved_form = CommentSavedForm {
 366       comment_id: inserted_comment.id,
 367       user_id: inserted_user.id,
 368     };
 369
 370     let inserted_comment_saved = CommentSaved::save(&conn, &comment_saved_form).unwrap();
 371
 372     let expected_comment_saved = CommentSaved {
 373       id: inserted_comment_saved.id,
 374       comment_id: inserted_comment.id,
 375       user_id: inserted_user.id,
 376       published: inserted_comment_saved.published,
 377     };
 378
 379     let read_comment = Comment::read(&conn, inserted_comment.id).unwrap();
 380     let updated_comment = Comment::update(&conn, inserted_comment.id, &comment_form).unwrap();
 381     let like_removed = CommentLike::remove(&conn, inserted_user.id, inserted_comment.id).unwrap();
 382     let saved_removed = CommentSaved::unsave(&conn, &comment_saved_form).unwrap();
 383     let num_deleted = Comment::delete(&conn, inserted_comment.id).unwrap();
 384     Comment::delete(&conn, inserted_child_comment.id).unwrap();
 385     Post::delete(&conn, inserted_post.id).unwrap();
 386     Community::delete(&conn, inserted_community.id).unwrap();
 387     User_::delete(&conn, inserted_user.id).unwrap();
 388
 389     assert_eq!(expected_comment, read_comment);
 390     assert_eq!(expected_comment, inserted_comment);
 391     assert_eq!(expected_comment, updated_comment);
 392     assert_eq!(expected_comment_like, inserted_comment_like);
 393     assert_eq!(expected_comment_saved, inserted_comment_saved);
 394     assert_eq!(
 395       expected_comment.id,
 396       inserted_child_comment.parent_id.unwrap()
 397     );
 398     assert_eq!(1, like_removed);
 399     assert_eq!(1, saved_removed);
 400     assert_eq!(1, num_deleted);
 401   }
 402 }