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: Url) -> 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(person_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: Url) -> 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(person_id: i32, post_creator_id: i32) -> bool {
 145     person_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, person_id))
 172       .do_update()
 173       .set(post_like_form)
 174       .get_result::<Self>(conn)
 175   }
 176   fn remove(conn: &PgConnection, person_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::person_id.eq(person_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, person_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(person_id.eq(post_saved_form.person_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(person_id.eq(post_read_form.person_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     person::*,
 233   };
 234
 235   #[test]
 236   fn test_crud() {
 237     let conn = establish_unpooled_connection();
 238
 239     let new_person = PersonForm {
 240       name: "jim".into(),
 241       preferred_username: None,
 242       avatar: None,
 243       banner: None,
 244       banned: Some(false),
 245       deleted: false,
 246       published: None,
 247       updated: None,
 248       actor_id: None,
 249       bio: None,
 250       local: true,
 251       private_key: None,
 252       public_key: None,
 253       last_refreshed_at: None,
 254       inbox_url: None,
 255       shared_inbox_url: None,
 256     };
 257
 258     let inserted_person = Person::create(&conn, &new_person).unwrap();
 259
 260     let new_community = CommunityForm {
 261       name: "test community_3".to_string(),
 262       title: "nada".to_owned(),
 263       description: None,
 264       creator_id: inserted_person.id,
 265       removed: None,
 266       deleted: None,
 267       updated: None,
 268       nsfw: false,
 269       actor_id: None,
 270       local: true,
 271       private_key: None,
 272       public_key: None,
 273       last_refreshed_at: None,
 274       published: None,
 275       icon: None,
 276       banner: None,
 277       followers_url: None,
 278       inbox_url: None,
 279       shared_inbox_url: None,
 280     };
 281
 282     let inserted_community = Community::create(&conn, &new_community).unwrap();
 283
 284     let new_post = PostForm {
 285       name: "A test post".into(),
 286       url: None,
 287       body: None,
 288       creator_id: inserted_person.id,
 289       community_id: inserted_community.id,
 290       removed: None,
 291       deleted: None,
 292       locked: None,
 293       stickied: None,
 294       nsfw: false,
 295       updated: None,
 296       embed_title: None,
 297       embed_description: None,
 298       embed_html: None,
 299       thumbnail_url: None,
 300       ap_id: None,
 301       local: true,
 302       published: None,
 303     };
 304
 305     let inserted_post = Post::create(&conn, &new_post).unwrap();
 306
 307     let expected_post = Post {
 308       id: inserted_post.id,
 309       name: "A test post".into(),
 310       url: None,
 311       body: None,
 312       creator_id: inserted_person.id,
 313       community_id: inserted_community.id,
 314       published: inserted_post.published,
 315       removed: false,
 316       locked: false,
 317       stickied: false,
 318       nsfw: false,
 319       deleted: false,
 320       updated: None,
 321       embed_title: None,
 322       embed_description: None,
 323       embed_html: None,
 324       thumbnail_url: None,
 325       ap_id: inserted_post.ap_id.to_owned(),
 326       local: true,
 327     };
 328
 329     // Post Like
 330     let post_like_form = PostLikeForm {
 331       post_id: inserted_post.id,
 332       person_id: inserted_person.id,
 333       score: 1,
 334     };
 335
 336     let inserted_post_like = PostLike::like(&conn, &post_like_form).unwrap();
 337
 338     let expected_post_like = PostLike {
 339       id: inserted_post_like.id,
 340       post_id: inserted_post.id,
 341       person_id: inserted_person.id,
 342       published: inserted_post_like.published,
 343       score: 1,
 344     };
 345
 346     // Post Save
 347     let post_saved_form = PostSavedForm {
 348       post_id: inserted_post.id,
 349       person_id: inserted_person.id,
 350     };
 351
 352     let inserted_post_saved = PostSaved::save(&conn, &post_saved_form).unwrap();
 353
 354     let expected_post_saved = PostSaved {
 355       id: inserted_post_saved.id,
 356       post_id: inserted_post.id,
 357       person_id: inserted_person.id,
 358       published: inserted_post_saved.published,
 359     };
 360
 361     // Post Read
 362     let post_read_form = PostReadForm {
 363       post_id: inserted_post.id,
 364       person_id: inserted_person.id,
 365     };
 366
 367     let inserted_post_read = PostRead::mark_as_read(&conn, &post_read_form).unwrap();
 368
 369     let expected_post_read = PostRead {
 370       id: inserted_post_read.id,
 371       post_id: inserted_post.id,
 372       person_id: inserted_person.id,
 373       published: inserted_post_read.published,
 374     };
 375
 376     let read_post = Post::read(&conn, inserted_post.id).unwrap();
 377     let updated_post = Post::update(&conn, inserted_post.id, &new_post).unwrap();
 378     let like_removed = PostLike::remove(&conn, inserted_person.id, inserted_post.id).unwrap();
 379     let saved_removed = PostSaved::unsave(&conn, &post_saved_form).unwrap();
 380     let read_removed = PostRead::mark_as_unread(&conn, &post_read_form).unwrap();
 381     let num_deleted = Post::delete(&conn, inserted_post.id).unwrap();
 382     Community::delete(&conn, inserted_community.id).unwrap();
 383     Person::delete(&conn, inserted_person.id).unwrap();
 384
 385     assert_eq!(expected_post, read_post);
 386     assert_eq!(expected_post, inserted_post);
 387     assert_eq!(expected_post, updated_post);
 388     assert_eq!(expected_post_like, inserted_post_like);
 389     assert_eq!(expected_post_saved, inserted_post_saved);
 390     assert_eq!(expected_post_read, inserted_post_read);
 391     assert_eq!(1, like_removed);
 392     assert_eq!(1, saved_removed);
 393     assert_eq!(1, read_removed);
 394     assert_eq!(1, num_deleted);
 395   }
 396 }