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(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: &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: &DbPool,
 110     for_creator_id: PersonId,
 111   ) -> Result<Vec<Self>, Error> {
 112     let conn = &mut get_conn(pool).await?;
 113
 114     let perma_deleted = "*Permananently Deleted*";
 115     let perma_deleted_url = "https://deleted.com";
 116
 117     diesel::update(post.filter(creator_id.eq(for_creator_id)))
 118       .set((
 119         name.eq(perma_deleted),
 120         url.eq(perma_deleted_url),
 121         body.eq(perma_deleted),
 122         deleted.eq(true),
 123         updated.eq(naive_now()),
 124       ))
 125       .get_results::<Self>(conn)
 126       .await
 127   }
 128
 129   pub async fn update_removed_for_creator(
 130     pool: &DbPool,
 131     for_creator_id: PersonId,
 132     for_community_id: Option<CommunityId>,
 133     new_removed: bool,
 134   ) -> Result<Vec<Self>, Error> {
 135     let conn = &mut get_conn(pool).await?;
 136
 137     let mut update = diesel::update(post).into_boxed();
 138     update = update.filter(creator_id.eq(for_creator_id));
 139
 140     if let Some(for_community_id) = for_community_id {
 141       update = update.filter(community_id.eq(for_community_id));
 142     }
 143
 144     update
 145       .set((removed.eq(new_removed), updated.eq(naive_now())))
 146       .get_results::<Self>(conn)
 147       .await
 148   }
 149
 150   pub fn is_post_creator(person_id: PersonId, post_creator_id: PersonId) -> bool {
 151     person_id == post_creator_id
 152   }
 153
 154   pub async fn read_from_apub_id(pool: &DbPool, object_id: Url) -> 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: &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: &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: &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: &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: &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(pool: &DbPool, person_id: PersonId, post_id: PostId) -> Result<usize, Error> {
 253     use crate::schema::post_like::dsl;
 254     let conn = &mut get_conn(pool).await?;
 255     diesel::delete(
 256       dsl::post_like
 257         .filter(dsl::post_id.eq(post_id))
 258         .filter(dsl::person_id.eq(person_id)),
 259     )
 260     .execute(conn)
 261     .await
 262   }
 263 }
 264
 265 #[async_trait]
 266 impl Saveable for PostSaved {
 267   type Form = PostSavedForm;
 268   async fn save(pool: &DbPool, post_saved_form: &PostSavedForm) -> Result<Self, Error> {
 269     use crate::schema::post_saved::dsl::{person_id, post_id, post_saved};
 270     let conn = &mut get_conn(pool).await?;
 271     insert_into(post_saved)
 272       .values(post_saved_form)
 273       .on_conflict((post_id, person_id))
 274       .do_update()
 275       .set(post_saved_form)
 276       .get_result::<Self>(conn)
 277       .await
 278   }
 279   async fn unsave(pool: &DbPool, post_saved_form: &PostSavedForm) -> Result<usize, Error> {
 280     use crate::schema::post_saved::dsl::{person_id, post_id, post_saved};
 281     let conn = &mut get_conn(pool).await?;
 282     diesel::delete(
 283       post_saved
 284         .filter(post_id.eq(post_saved_form.post_id))
 285         .filter(person_id.eq(post_saved_form.person_id)),
 286     )
 287     .execute(conn)
 288     .await
 289   }
 290 }
 291
 292 #[async_trait]
 293 impl Readable for PostRead {
 294   type Form = PostReadForm;
 295   async fn mark_as_read(pool: &DbPool, post_read_form: &PostReadForm) -> Result<Self, Error> {
 296     use crate::schema::post_read::dsl::{person_id, post_id, post_read};
 297     let conn = &mut get_conn(pool).await?;
 298     insert_into(post_read)
 299       .values(post_read_form)
 300       .on_conflict((post_id, person_id))
 301       .do_update()
 302       .set(post_read_form)
 303       .get_result::<Self>(conn)
 304       .await
 305   }
 306
 307   async fn mark_as_unread(pool: &DbPool, post_read_form: &PostReadForm) -> Result<usize, Error> {
 308     use crate::schema::post_read::dsl::{person_id, post_id, post_read};
 309     let conn = &mut get_conn(pool).await?;
 310     diesel::delete(
 311       post_read
 312         .filter(post_id.eq(post_read_form.post_id))
 313         .filter(person_id.eq(post_read_form.person_id)),
 314     )
 315     .execute(conn)
 316     .await
 317   }
 318 }
 319
 320 impl DeleteableOrRemoveable for Post {
 321   fn blank_out_deleted_or_removed_info(mut self) -> Self {
 322     self.name = String::new();
 323     self.url = None;
 324     self.body = None;
 325     self.embed_title = None;
 326     self.embed_description = None;
 327     self.embed_video_url = None;
 328     self.thumbnail_url = None;
 329
 330     self
 331   }
 332 }
 333
 334 #[cfg(test)]
 335 mod tests {
 336   use crate::{
 337     source::{
 338       community::{Community, CommunityInsertForm},
 339       instance::Instance,
 340       person::{Person, PersonInsertForm},
 341       post::{
 342         Post,
 343         PostInsertForm,
 344         PostLike,
 345         PostLikeForm,
 346         PostRead,
 347         PostReadForm,
 348         PostSaved,
 349         PostSavedForm,
 350         PostUpdateForm,
 351       },
 352     },
 353     traits::{Crud, Likeable, Readable, Saveable},
 354     utils::build_db_pool_for_tests,
 355   };
 356   use serial_test::serial;
 357
 358   #[tokio::test]
 359   #[serial]
 360   async fn test_crud() {
 361     let pool = &build_db_pool_for_tests().await;
 362
 363     let inserted_instance = Instance::create(pool, "my_domain.tld").await.unwrap();
 364
 365     let new_person = PersonInsertForm::builder()
 366       .name("jim".into())
 367       .public_key("pubkey".to_string())
 368       .instance_id(inserted_instance.id)
 369       .build();
 370
 371     let inserted_person = Person::create(pool, &new_person).await.unwrap();
 372
 373     let new_community = CommunityInsertForm::builder()
 374       .name("test community_3".to_string())
 375       .title("nada".to_owned())
 376       .public_key("pubkey".to_string())
 377       .instance_id(inserted_instance.id)
 378       .build();
 379
 380     let inserted_community = Community::create(pool, &new_community).await.unwrap();
 381
 382     let new_post = PostInsertForm::builder()
 383       .name("A test post".into())
 384       .creator_id(inserted_person.id)
 385       .community_id(inserted_community.id)
 386       .build();
 387
 388     let inserted_post = Post::create(pool, &new_post).await.unwrap();
 389
 390     let expected_post = Post {
 391       id: inserted_post.id,
 392       name: "A test post".into(),
 393       url: None,
 394       body: None,
 395       creator_id: inserted_person.id,
 396       community_id: inserted_community.id,
 397       published: inserted_post.published,
 398       removed: false,
 399       locked: false,
 400       nsfw: false,
 401       deleted: false,
 402       updated: None,
 403       embed_title: None,
 404       embed_description: None,
 405       embed_video_url: None,
 406       thumbnail_url: None,
 407       ap_id: inserted_post.ap_id.clone(),
 408       local: true,
 409       language_id: Default::default(),
 410       featured_community: false,
 411       featured_local: false,
 412     };
 413
 414     // Post Like
 415     let post_like_form = PostLikeForm {
 416       post_id: inserted_post.id,
 417       person_id: inserted_person.id,
 418       score: 1,
 419     };
 420
 421     let inserted_post_like = PostLike::like(pool, &post_like_form).await.unwrap();
 422
 423     let expected_post_like = PostLike {
 424       id: inserted_post_like.id,
 425       post_id: inserted_post.id,
 426       person_id: inserted_person.id,
 427       published: inserted_post_like.published,
 428       score: 1,
 429     };
 430
 431     // Post Save
 432     let post_saved_form = PostSavedForm {
 433       post_id: inserted_post.id,
 434       person_id: inserted_person.id,
 435     };
 436
 437     let inserted_post_saved = PostSaved::save(pool, &post_saved_form).await.unwrap();
 438
 439     let expected_post_saved = PostSaved {
 440       id: inserted_post_saved.id,
 441       post_id: inserted_post.id,
 442       person_id: inserted_person.id,
 443       published: inserted_post_saved.published,
 444     };
 445
 446     // Post Read
 447     let post_read_form = PostReadForm {
 448       post_id: inserted_post.id,
 449       person_id: inserted_person.id,
 450     };
 451
 452     let inserted_post_read = PostRead::mark_as_read(pool, &post_read_form).await.unwrap();
 453
 454     let expected_post_read = PostRead {
 455       id: inserted_post_read.id,
 456       post_id: inserted_post.id,
 457       person_id: inserted_person.id,
 458       published: inserted_post_read.published,
 459     };
 460
 461     let read_post = Post::read(pool, inserted_post.id).await.unwrap();
 462
 463     let new_post_update = PostUpdateForm::builder()
 464       .name(Some("A test post".into()))
 465       .build();
 466     let updated_post = Post::update(pool, inserted_post.id, &new_post_update)
 467       .await
 468       .unwrap();
 469
 470     let like_removed = PostLike::remove(pool, inserted_person.id, inserted_post.id)
 471       .await
 472       .unwrap();
 473     let saved_removed = PostSaved::unsave(pool, &post_saved_form).await.unwrap();
 474     let read_removed = PostRead::mark_as_unread(pool, &post_read_form)
 475       .await
 476       .unwrap();
 477     let num_deleted = Post::delete(pool, inserted_post.id).await.unwrap();
 478     Community::delete(pool, inserted_community.id)
 479       .await
 480       .unwrap();
 481     Person::delete(pool, inserted_person.id).await.unwrap();
 482     Instance::delete(pool, inserted_instance.id).await.unwrap();
 483
 484     assert_eq!(expected_post, read_post);
 485     assert_eq!(expected_post, inserted_post);
 486     assert_eq!(expected_post, updated_post);
 487     assert_eq!(expected_post_like, inserted_post_like);
 488     assert_eq!(expected_post_saved, inserted_post_saved);
 489     assert_eq!(expected_post_read, inserted_post_read);
 490     assert_eq!(1, like_removed);
 491     assert_eq!(1, saved_removed);
 492     assert_eq!(1, read_removed);
 493     assert_eq!(1, num_deleted);
 494   }
 495 }