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: String) -> 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: String) -> 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     };
 246
 247     let inserted_user = User_::create(&conn, &new_user).unwrap();
 248
 249     let new_community = CommunityForm {
 250       name: "test community".to_string(),
 251       title: "nada".to_owned(),
 252       description: None,
 253       category_id: 1,
 254       creator_id: inserted_user.id,
 255       removed: None,
 256       deleted: None,
 257       updated: None,
 258       nsfw: false,
 259       actor_id: None,
 260       local: true,
 261       private_key: None,
 262       public_key: None,
 263       last_refreshed_at: None,
 264       published: None,
 265       banner: None,
 266       icon: None,
 267     };
 268
 269     let inserted_community = Community::create(&conn, &new_community).unwrap();
 270
 271     let new_post = PostForm {
 272       name: "A test post".into(),
 273       creator_id: inserted_user.id,
 274       url: None,
 275       body: None,
 276       community_id: inserted_community.id,
 277       removed: None,
 278       deleted: None,
 279       locked: None,
 280       stickied: None,
 281       updated: None,
 282       nsfw: false,
 283       embed_title: None,
 284       embed_description: None,
 285       embed_html: None,
 286       thumbnail_url: None,
 287       ap_id: None,
 288       local: true,
 289       published: None,
 290     };
 291
 292     let inserted_post = Post::create(&conn, &new_post).unwrap();
 293
 294     let comment_form = CommentForm {
 295       content: "A test comment".into(),
 296       creator_id: inserted_user.id,
 297       post_id: inserted_post.id,
 298       removed: None,
 299       deleted: None,
 300       read: None,
 301       parent_id: None,
 302       published: None,
 303       updated: None,
 304       ap_id: None,
 305       local: true,
 306     };
 307
 308     let inserted_comment = Comment::create(&conn, &comment_form).unwrap();
 309
 310     let expected_comment = Comment {
 311       id: inserted_comment.id,
 312       content: "A test comment".into(),
 313       creator_id: inserted_user.id,
 314       post_id: inserted_post.id,
 315       removed: false,
 316       deleted: false,
 317       read: false,
 318       parent_id: None,
 319       published: inserted_comment.published,
 320       updated: None,
 321       ap_id: inserted_comment.ap_id.to_owned(),
 322       local: true,
 323     };
 324
 325     let child_comment_form = CommentForm {
 326       content: "A child comment".into(),
 327       creator_id: inserted_user.id,
 328       post_id: inserted_post.id,
 329       parent_id: Some(inserted_comment.id),
 330       removed: None,
 331       deleted: None,
 332       read: None,
 333       published: None,
 334       updated: None,
 335       ap_id: None,
 336       local: true,
 337     };
 338
 339     let inserted_child_comment = Comment::create(&conn, &child_comment_form).unwrap();
 340
 341     // Comment Like
 342     let comment_like_form = CommentLikeForm {
 343       comment_id: inserted_comment.id,
 344       post_id: inserted_post.id,
 345       user_id: inserted_user.id,
 346       score: 1,
 347     };
 348
 349     let inserted_comment_like = CommentLike::like(&conn, &comment_like_form).unwrap();
 350
 351     let expected_comment_like = CommentLike {
 352       id: inserted_comment_like.id,
 353       comment_id: inserted_comment.id,
 354       post_id: inserted_post.id,
 355       user_id: inserted_user.id,
 356       published: inserted_comment_like.published,
 357       score: 1,
 358     };
 359
 360     // Comment Saved
 361     let comment_saved_form = CommentSavedForm {
 362       comment_id: inserted_comment.id,
 363       user_id: inserted_user.id,
 364     };
 365
 366     let inserted_comment_saved = CommentSaved::save(&conn, &comment_saved_form).unwrap();
 367
 368     let expected_comment_saved = CommentSaved {
 369       id: inserted_comment_saved.id,
 370       comment_id: inserted_comment.id,
 371       user_id: inserted_user.id,
 372       published: inserted_comment_saved.published,
 373     };
 374
 375     let read_comment = Comment::read(&conn, inserted_comment.id).unwrap();
 376     let updated_comment = Comment::update(&conn, inserted_comment.id, &comment_form).unwrap();
 377     let like_removed = CommentLike::remove(&conn, inserted_user.id, inserted_comment.id).unwrap();
 378     let saved_removed = CommentSaved::unsave(&conn, &comment_saved_form).unwrap();
 379     let num_deleted = Comment::delete(&conn, inserted_comment.id).unwrap();
 380     Comment::delete(&conn, inserted_child_comment.id).unwrap();
 381     Post::delete(&conn, inserted_post.id).unwrap();
 382     Community::delete(&conn, inserted_community.id).unwrap();
 383     User_::delete(&conn, inserted_user.id).unwrap();
 384
 385     assert_eq!(expected_comment, read_comment);
 386     assert_eq!(expected_comment, inserted_comment);
 387     assert_eq!(expected_comment, updated_comment);
 388     assert_eq!(expected_comment_like, inserted_comment_like);
 389     assert_eq!(expected_comment_saved, inserted_comment_saved);
 390     assert_eq!(
 391       expected_comment.id,
 392       inserted_child_comment.parent_id.unwrap()
 393     );
 394     assert_eq!(1, like_removed);
 395     assert_eq!(1, saved_removed);
 396     assert_eq!(1, num_deleted);
 397   }
 398 }