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