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