crates/db_schema/src/impls/post.rs

   1 use crate::{
   2   newtypes::{CommunityId, DbUrl, PersonId, PostId},
   3   schema::post::dsl::{
   4     ap_id,
   5     body,
   6     community_id,
   7     creator_id,
   8     deleted,
   9     featured_community,
  10     name,
  11     post,
  12     published,
  13     removed,
  14     thumbnail_url,
  15     updated,
  16     url,
  17   },
  18   source::post::{
  19     Post,
  20     PostInsertForm,
  21     PostLike,
  22     PostLikeForm,
  23     PostRead,
  24     PostReadForm,
  25     PostSaved,
  26     PostSavedForm,
  27     PostUpdateForm,
  28   },
  29   traits::{Crud, DeleteableOrRemoveable, Likeable, Readable, Saveable},
  30   utils::{get_conn, naive_now, DbPool, FETCH_LIMIT_MAX},
  31 };
  32 use ::url::Url;
  33 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl, TextExpressionMethods};
  34 use diesel_async::RunQueryDsl;
  35
  36 #[async_trait]
  37 impl Crud for Post {
  38   type InsertForm = PostInsertForm;
  39   type UpdateForm = PostUpdateForm;
  40   type IdType = PostId;
  41   async fn read(pool: &DbPool, post_id: PostId) -> Result<Self, Error> {
  42     let conn = &mut get_conn(pool).await?;
  43     post.find(post_id).first::<Self>(conn).await
  44   }
  45
  46   async fn delete(pool: &DbPool, post_id: PostId) -> Result<usize, Error> {
  47     let conn = &mut get_conn(pool).await?;
  48     diesel::delete(post.find(post_id)).execute(conn).await
  49   }
  50
  51   async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
  52     let conn = &mut get_conn(pool).await?;
  53     insert_into(post)
  54       .values(form)
  55       .on_conflict(ap_id)
  56       .do_update()
  57       .set(form)
  58       .get_result::<Self>(conn)
  59       .await
  60   }
  61
  62   async fn update(
  63     pool: &DbPool,
  64     post_id: PostId,
  65     new_post: &Self::UpdateForm,
  66   ) -> Result<Self, Error> {
  67     let conn = &mut get_conn(pool).await?;
  68     diesel::update(post.find(post_id))
  69       .set(new_post)
  70       .get_result::<Self>(conn)
  71       .await
  72   }
  73 }
  74
  75 impl Post {
  76   pub async fn list_for_community(
  77     pool: &DbPool,
  78     the_community_id: CommunityId,
  79   ) -> Result<Vec<Self>, Error> {
  80     let conn = &mut get_conn(pool).await?;
  81     post
  82       .filter(community_id.eq(the_community_id))
  83       .filter(deleted.eq(false))
  84       .filter(removed.eq(false))
  85       .then_order_by(published.desc())
  86       .then_order_by(featured_community.desc())
  87       .limit(FETCH_LIMIT_MAX)
  88       .load::<Self>(conn)
  89       .await
  90   }
  91
  92   pub async fn permadelete_for_creator(
  93     pool: &DbPool,
  94     for_creator_id: PersonId,
  95   ) -> Result<Vec<Self>, Error> {
  96     let conn = &mut get_conn(pool).await?;
  97
  98     let perma_deleted = "*Permananently Deleted*";
  99     let perma_deleted_url = "https://deleted.com";
 100
 101     diesel::update(post.filter(creator_id.eq(for_creator_id)))
 102       .set((
 103         name.eq(perma_deleted),
 104         url.eq(perma_deleted_url),
 105         body.eq(perma_deleted),
 106         deleted.eq(true),
 107         updated.eq(naive_now()),
 108       ))
 109       .get_results::<Self>(conn)
 110       .await
 111   }
 112
 113   pub async fn update_removed_for_creator(
 114     pool: &DbPool,
 115     for_creator_id: PersonId,
 116     for_community_id: Option<CommunityId>,
 117     new_removed: bool,
 118   ) -> Result<Vec<Self>, Error> {
 119     let conn = &mut get_conn(pool).await?;
 120
 121     let mut update = diesel::update(post).into_boxed();
 122     update = update.filter(creator_id.eq(for_creator_id));
 123
 124     if let Some(for_community_id) = for_community_id {
 125       update = update.filter(community_id.eq(for_community_id));
 126     }
 127
 128     update
 129       .set((removed.eq(new_removed), updated.eq(naive_now())))
 130       .get_results::<Self>(conn)
 131       .await
 132   }
 133
 134   pub fn is_post_creator(person_id: PersonId, post_creator_id: PersonId) -> bool {
 135     person_id == post_creator_id
 136   }
 137
 138   pub async fn read_from_apub_id(pool: &DbPool, object_id: Url) -> Result<Option<Self>, Error> {
 139     let conn = &mut get_conn(pool).await?;
 140     let object_id: DbUrl = object_id.into();
 141     Ok(
 142       post
 143         .filter(ap_id.eq(object_id))
 144         .first::<Post>(conn)
 145         .await
 146         .ok()
 147         .map(Into::into),
 148     )
 149   }
 150
 151   pub async fn fetch_pictrs_posts_for_creator(
 152     pool: &DbPool,
 153     for_creator_id: PersonId,
 154   ) -> Result<Vec<Self>, Error> {
 155     let conn = &mut get_conn(pool).await?;
 156     let pictrs_search = "%pictrs/image%";
 157
 158     post
 159       .filter(creator_id.eq(for_creator_id))
 160       .filter(url.like(pictrs_search))
 161       .load::<Self>(conn)
 162       .await
 163   }
 164
 165   /// Sets the url and thumbnails fields to None
 166   pub async fn remove_pictrs_post_images_and_thumbnails_for_creator(
 167     pool: &DbPool,
 168     for_creator_id: PersonId,
 169   ) -> Result<Vec<Self>, Error> {
 170     let conn = &mut get_conn(pool).await?;
 171     let pictrs_search = "%pictrs/image%";
 172
 173     diesel::update(
 174       post
 175         .filter(creator_id.eq(for_creator_id))
 176         .filter(url.like(pictrs_search)),
 177     )
 178     .set((
 179       url.eq::<Option<String>>(None),
 180       thumbnail_url.eq::<Option<String>>(None),
 181     ))
 182     .get_results::<Self>(conn)
 183     .await
 184   }
 185
 186   pub async fn fetch_pictrs_posts_for_community(
 187     pool: &DbPool,
 188     for_community_id: CommunityId,
 189   ) -> Result<Vec<Self>, Error> {
 190     let conn = &mut get_conn(pool).await?;
 191     let pictrs_search = "%pictrs/image%";
 192     post
 193       .filter(community_id.eq(for_community_id))
 194       .filter(url.like(pictrs_search))
 195       .load::<Self>(conn)
 196       .await
 197   }
 198
 199   /// Sets the url and thumbnails fields to None
 200   pub async fn remove_pictrs_post_images_and_thumbnails_for_community(
 201     pool: &DbPool,
 202     for_community_id: CommunityId,
 203   ) -> Result<Vec<Self>, Error> {
 204     let conn = &mut get_conn(pool).await?;
 205     let pictrs_search = "%pictrs/image%";
 206
 207     diesel::update(
 208       post
 209         .filter(community_id.eq(for_community_id))
 210         .filter(url.like(pictrs_search)),
 211     )
 212     .set((
 213       url.eq::<Option<String>>(None),
 214       thumbnail_url.eq::<Option<String>>(None),
 215     ))
 216     .get_results::<Self>(conn)
 217     .await
 218   }
 219 }
 220
 221 #[async_trait]
 222 impl Likeable for PostLike {
 223   type Form = PostLikeForm;
 224   type IdType = PostId;
 225   async fn like(pool: &DbPool, post_like_form: &PostLikeForm) -> Result<Self, Error> {
 226     use crate::schema::post_like::dsl::{person_id, post_id, post_like};
 227     let conn = &mut get_conn(pool).await?;
 228     insert_into(post_like)
 229       .values(post_like_form)
 230       .on_conflict((post_id, person_id))
 231       .do_update()
 232       .set(post_like_form)
 233       .get_result::<Self>(conn)
 234       .await
 235   }
 236   async fn remove(pool: &DbPool, person_id: PersonId, post_id: PostId) -> Result<usize, Error> {
 237     use crate::schema::post_like::dsl;
 238     let conn = &mut get_conn(pool).await?;
 239     diesel::delete(
 240       dsl::post_like
 241         .filter(dsl::post_id.eq(post_id))
 242         .filter(dsl::person_id.eq(person_id)),
 243     )
 244     .execute(conn)
 245     .await
 246   }
 247 }
 248
 249 #[async_trait]
 250 impl Saveable for PostSaved {
 251   type Form = PostSavedForm;
 252   async fn save(pool: &DbPool, post_saved_form: &PostSavedForm) -> Result<Self, Error> {
 253     use crate::schema::post_saved::dsl::{person_id, post_id, post_saved};
 254     let conn = &mut get_conn(pool).await?;
 255     insert_into(post_saved)
 256       .values(post_saved_form)
 257       .on_conflict((post_id, person_id))
 258       .do_update()
 259       .set(post_saved_form)
 260       .get_result::<Self>(conn)
 261       .await
 262   }
 263   async fn unsave(pool: &DbPool, post_saved_form: &PostSavedForm) -> Result<usize, Error> {
 264     use crate::schema::post_saved::dsl::{person_id, post_id, post_saved};
 265     let conn = &mut get_conn(pool).await?;
 266     diesel::delete(
 267       post_saved
 268         .filter(post_id.eq(post_saved_form.post_id))
 269         .filter(person_id.eq(post_saved_form.person_id)),
 270     )
 271     .execute(conn)
 272     .await
 273   }
 274 }
 275
 276 #[async_trait]
 277 impl Readable for PostRead {
 278   type Form = PostReadForm;
 279   async fn mark_as_read(pool: &DbPool, post_read_form: &PostReadForm) -> Result<Self, Error> {
 280     use crate::schema::post_read::dsl::{person_id, post_id, post_read};
 281     let conn = &mut get_conn(pool).await?;
 282     insert_into(post_read)
 283       .values(post_read_form)
 284       .on_conflict((post_id, person_id))
 285       .do_update()
 286       .set(post_read_form)
 287       .get_result::<Self>(conn)
 288       .await
 289   }
 290
 291   async fn mark_as_unread(pool: &DbPool, post_read_form: &PostReadForm) -> Result<usize, Error> {
 292     use crate::schema::post_read::dsl::{person_id, post_id, post_read};
 293     let conn = &mut get_conn(pool).await?;
 294     diesel::delete(
 295       post_read
 296         .filter(post_id.eq(post_read_form.post_id))
 297         .filter(person_id.eq(post_read_form.person_id)),
 298     )
 299     .execute(conn)
 300     .await
 301   }
 302 }
 303
 304 impl DeleteableOrRemoveable for Post {
 305   fn blank_out_deleted_or_removed_info(mut self) -> Self {
 306     self.name = String::new();
 307     self.url = None;
 308     self.body = None;
 309     self.embed_title = None;
 310     self.embed_description = None;
 311     self.embed_video_url = None;
 312     self.thumbnail_url = None;
 313
 314     self
 315   }
 316 }
 317
 318 #[cfg(test)]
 319 mod tests {
 320   use crate::{
 321     source::{
 322       community::{Community, CommunityInsertForm},
 323       instance::Instance,
 324       person::{Person, PersonInsertForm},
 325       post::{
 326         Post,
 327         PostInsertForm,
 328         PostLike,
 329         PostLikeForm,
 330         PostRead,
 331         PostReadForm,
 332         PostSaved,
 333         PostSavedForm,
 334         PostUpdateForm,
 335       },
 336     },
 337     traits::{Crud, Likeable, Readable, Saveable},
 338     utils::build_db_pool_for_tests,
 339   };
 340   use serial_test::serial;
 341
 342   #[tokio::test]
 343   #[serial]
 344   async fn test_crud() {
 345     let pool = &build_db_pool_for_tests().await;
 346
 347     let inserted_instance = Instance::create(pool, "my_domain.tld").await.unwrap();
 348
 349     let new_person = PersonInsertForm::builder()
 350       .name("jim".into())
 351       .public_key("pubkey".to_string())
 352       .instance_id(inserted_instance.id)
 353       .build();
 354
 355     let inserted_person = Person::create(pool, &new_person).await.unwrap();
 356
 357     let new_community = CommunityInsertForm::builder()
 358       .name("test community_3".to_string())
 359       .title("nada".to_owned())
 360       .public_key("pubkey".to_string())
 361       .instance_id(inserted_instance.id)
 362       .build();
 363
 364     let inserted_community = Community::create(pool, &new_community).await.unwrap();
 365
 366     let new_post = PostInsertForm::builder()
 367       .name("A test post".into())
 368       .creator_id(inserted_person.id)
 369       .community_id(inserted_community.id)
 370       .build();
 371
 372     let inserted_post = Post::create(pool, &new_post).await.unwrap();
 373
 374     let expected_post = Post {
 375       id: inserted_post.id,
 376       name: "A test post".into(),
 377       url: None,
 378       body: None,
 379       creator_id: inserted_person.id,
 380       community_id: inserted_community.id,
 381       published: inserted_post.published,
 382       removed: false,
 383       locked: false,
 384       nsfw: false,
 385       deleted: false,
 386       updated: None,
 387       embed_title: None,
 388       embed_description: None,
 389       embed_video_url: None,
 390       thumbnail_url: None,
 391       ap_id: inserted_post.ap_id.clone(),
 392       local: true,
 393       language_id: Default::default(),
 394       featured_community: false,
 395       featured_local: false,
 396     };
 397
 398     // Post Like
 399     let post_like_form = PostLikeForm {
 400       post_id: inserted_post.id,
 401       person_id: inserted_person.id,
 402       score: 1,
 403     };
 404
 405     let inserted_post_like = PostLike::like(pool, &post_like_form).await.unwrap();
 406
 407     let expected_post_like = PostLike {
 408       id: inserted_post_like.id,
 409       post_id: inserted_post.id,
 410       person_id: inserted_person.id,
 411       published: inserted_post_like.published,
 412       score: 1,
 413     };
 414
 415     // Post Save
 416     let post_saved_form = PostSavedForm {
 417       post_id: inserted_post.id,
 418       person_id: inserted_person.id,
 419     };
 420
 421     let inserted_post_saved = PostSaved::save(pool, &post_saved_form).await.unwrap();
 422
 423     let expected_post_saved = PostSaved {
 424       id: inserted_post_saved.id,
 425       post_id: inserted_post.id,
 426       person_id: inserted_person.id,
 427       published: inserted_post_saved.published,
 428     };
 429
 430     // Post Read
 431     let post_read_form = PostReadForm {
 432       post_id: inserted_post.id,
 433       person_id: inserted_person.id,
 434     };
 435
 436     let inserted_post_read = PostRead::mark_as_read(pool, &post_read_form).await.unwrap();
 437
 438     let expected_post_read = PostRead {
 439       id: inserted_post_read.id,
 440       post_id: inserted_post.id,
 441       person_id: inserted_person.id,
 442       published: inserted_post_read.published,
 443     };
 444
 445     let read_post = Post::read(pool, inserted_post.id).await.unwrap();
 446
 447     let new_post_update = PostUpdateForm::builder()
 448       .name(Some("A test post".into()))
 449       .build();
 450     let updated_post = Post::update(pool, inserted_post.id, &new_post_update)
 451       .await
 452       .unwrap();
 453
 454     let like_removed = PostLike::remove(pool, inserted_person.id, inserted_post.id)
 455       .await
 456       .unwrap();
 457     let saved_removed = PostSaved::unsave(pool, &post_saved_form).await.unwrap();
 458     let read_removed = PostRead::mark_as_unread(pool, &post_read_form)
 459       .await
 460       .unwrap();
 461     let num_deleted = Post::delete(pool, inserted_post.id).await.unwrap();
 462     Community::delete(pool, inserted_community.id)
 463       .await
 464       .unwrap();
 465     Person::delete(pool, inserted_person.id).await.unwrap();
 466     Instance::delete(pool, inserted_instance.id).await.unwrap();
 467
 468     assert_eq!(expected_post, read_post);
 469     assert_eq!(expected_post, inserted_post);
 470     assert_eq!(expected_post, updated_post);
 471     assert_eq!(expected_post_like, inserted_post_like);
 472     assert_eq!(expected_post_saved, inserted_post_saved);
 473     assert_eq!(expected_post_read, inserted_post_read);
 474     assert_eq!(1, like_removed);
 475     assert_eq!(1, saved_removed);
 476     assert_eq!(1, read_removed);
 477     assert_eq!(1, num_deleted);
 478   }
 479 }