crates/db_queries/src/source/post.rs

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