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   use crate::{
 333     source::{
 334       community::{Community, CommunityInsertForm},
 335       instance::Instance,
 336       person::{Person, PersonInsertForm},
 337       post::{
 338         Post,
 339         PostInsertForm,
 340         PostLike,
 341         PostLikeForm,
 342         PostRead,
 343         PostReadForm,
 344         PostSaved,
 345         PostSavedForm,
 346         PostUpdateForm,
 347       },
 348     },
 349     traits::{Crud, Likeable, Readable, Saveable},
 350     utils::build_db_pool_for_tests,
 351   };
 352   use serial_test::serial;
 353
 354   #[tokio::test]
 355   #[serial]
 356   async fn test_crud() {
 357     let pool = &build_db_pool_for_tests().await;
 358     let pool = &mut pool.into();
 359
 360     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
 361       .await
 362       .unwrap();
 363
 364     let new_person = PersonInsertForm::builder()
 365       .name("jim".into())
 366       .public_key("pubkey".to_string())
 367       .instance_id(inserted_instance.id)
 368       .build();
 369
 370     let inserted_person = Person::create(pool, &new_person).await.unwrap();
 371
 372     let new_community = CommunityInsertForm::builder()
 373       .name("test community_3".to_string())
 374       .title("nada".to_owned())
 375       .public_key("pubkey".to_string())
 376       .instance_id(inserted_instance.id)
 377       .build();
 378
 379     let inserted_community = Community::create(pool, &new_community).await.unwrap();
 380
 381     let new_post = PostInsertForm::builder()
 382       .name("A test post".into())
 383       .creator_id(inserted_person.id)
 384       .community_id(inserted_community.id)
 385       .build();
 386
 387     let inserted_post = Post::create(pool, &new_post).await.unwrap();
 388
 389     let expected_post = Post {
 390       id: inserted_post.id,
 391       name: "A test post".into(),
 392       url: None,
 393       body: None,
 394       creator_id: inserted_person.id,
 395       community_id: inserted_community.id,
 396       published: inserted_post.published,
 397       removed: false,
 398       locked: false,
 399       nsfw: false,
 400       deleted: false,
 401       updated: None,
 402       embed_title: None,
 403       embed_description: None,
 404       embed_video_url: None,
 405       thumbnail_url: None,
 406       ap_id: inserted_post.ap_id.clone(),
 407       local: true,
 408       language_id: Default::default(),
 409       featured_community: false,
 410       featured_local: false,
 411     };
 412
 413     // Post Like
 414     let post_like_form = PostLikeForm {
 415       post_id: inserted_post.id,
 416       person_id: inserted_person.id,
 417       score: 1,
 418     };
 419
 420     let inserted_post_like = PostLike::like(pool, &post_like_form).await.unwrap();
 421
 422     let expected_post_like = PostLike {
 423       id: inserted_post_like.id,
 424       post_id: inserted_post.id,
 425       person_id: inserted_person.id,
 426       published: inserted_post_like.published,
 427       score: 1,
 428     };
 429
 430     // Post Save
 431     let post_saved_form = PostSavedForm {
 432       post_id: inserted_post.id,
 433       person_id: inserted_person.id,
 434     };
 435
 436     let inserted_post_saved = PostSaved::save(pool, &post_saved_form).await.unwrap();
 437
 438     let expected_post_saved = PostSaved {
 439       id: inserted_post_saved.id,
 440       post_id: inserted_post.id,
 441       person_id: inserted_person.id,
 442       published: inserted_post_saved.published,
 443     };
 444
 445     // Post Read
 446     let post_read_form = PostReadForm {
 447       post_id: inserted_post.id,
 448       person_id: inserted_person.id,
 449     };
 450
 451     let inserted_post_read = PostRead::mark_as_read(pool, &post_read_form).await.unwrap();
 452
 453     let expected_post_read = PostRead {
 454       id: inserted_post_read.id,
 455       post_id: inserted_post.id,
 456       person_id: inserted_person.id,
 457       published: inserted_post_read.published,
 458     };
 459
 460     let read_post = Post::read(pool, inserted_post.id).await.unwrap();
 461
 462     let new_post_update = PostUpdateForm::builder()
 463       .name(Some("A test post".into()))
 464       .build();
 465     let updated_post = Post::update(pool, inserted_post.id, &new_post_update)
 466       .await
 467       .unwrap();
 468
 469     let like_removed = PostLike::remove(pool, inserted_person.id, inserted_post.id)
 470       .await
 471       .unwrap();
 472     let saved_removed = PostSaved::unsave(pool, &post_saved_form).await.unwrap();
 473     let read_removed = PostRead::mark_as_unread(pool, &post_read_form)
 474       .await
 475       .unwrap();
 476     let num_deleted = Post::delete(pool, inserted_post.id).await.unwrap();
 477     Community::delete(pool, inserted_community.id)
 478       .await
 479       .unwrap();
 480     Person::delete(pool, inserted_person.id).await.unwrap();
 481     Instance::delete(pool, inserted_instance.id).await.unwrap();
 482
 483     assert_eq!(expected_post, read_post);
 484     assert_eq!(expected_post, inserted_post);
 485     assert_eq!(expected_post, updated_post);
 486     assert_eq!(expected_post_like, inserted_post_like);
 487     assert_eq!(expected_post_saved, inserted_post_saved);
 488     assert_eq!(expected_post_read, inserted_post_read);
 489     assert_eq!(1, like_removed);
 490     assert_eq!(1, saved_removed);
 491     assert_eq!(1, read_removed);
 492     assert_eq!(1, num_deleted);
 493   }
 494 }