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