2 newtypes::{CommunityId, DbUrl, PersonId, PostId},
29 traits::{Crud, Likeable, Readable, Saveable},
34 DELETED_REPLACEMENT_TEXT,
35 DELETED_REPLACEMENT_URL,
40 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl, TextExpressionMethods};
41 use diesel_async::RunQueryDsl;
45 type InsertForm = PostInsertForm;
46 type UpdateForm = PostUpdateForm;
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
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
58 async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
59 let conn = &mut get_conn(pool).await?;
65 .get_result::<Self>(conn)
72 new_post: &Self::UpdateForm,
73 ) -> Result<Self, Error> {
74 let conn = &mut get_conn(pool).await?;
75 diesel::update(post.find(post_id))
77 .get_result::<Self>(conn)
83 pub async fn list_for_community(
85 the_community_id: CommunityId,
86 ) -> Result<Vec<Self>, Error> {
87 let conn = &mut get_conn(pool).await?;
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)
99 pub async fn list_featured_for_community(
101 the_community_id: CommunityId,
102 ) -> Result<Vec<Self>, Error> {
103 let conn = &mut get_conn(pool).await?;
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)
115 pub async fn permadelete_for_creator(
117 for_creator_id: PersonId,
118 ) -> Result<Vec<Self>, Error> {
119 let conn = &mut get_conn(pool).await?;
121 diesel::update(post.filter(creator_id.eq(for_creator_id)))
123 name.eq(DELETED_REPLACEMENT_TEXT),
124 url.eq(DELETED_REPLACEMENT_URL),
125 body.eq(DELETED_REPLACEMENT_TEXT),
127 updated.eq(naive_now()),
129 .get_results::<Self>(conn)
133 pub async fn update_removed_for_creator(
135 for_creator_id: PersonId,
136 for_community_id: Option<CommunityId>,
138 ) -> Result<Vec<Self>, Error> {
139 let conn = &mut get_conn(pool).await?;
141 let mut update = diesel::update(post).into_boxed();
142 update = update.filter(creator_id.eq(for_creator_id));
144 if let Some(for_community_id) = for_community_id {
145 update = update.filter(community_id.eq(for_community_id));
149 .set((removed.eq(new_removed), updated.eq(naive_now())))
150 .get_results::<Self>(conn)
154 pub fn is_post_creator(person_id: PersonId, post_creator_id: PersonId) -> bool {
155 person_id == post_creator_id
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();
163 .filter(ap_id.eq(object_id))
171 pub async fn fetch_pictrs_posts_for_creator(
173 for_creator_id: PersonId,
174 ) -> Result<Vec<Self>, Error> {
175 let conn = &mut get_conn(pool).await?;
176 let pictrs_search = "%pictrs/image%";
179 .filter(creator_id.eq(for_creator_id))
180 .filter(url.like(pictrs_search))
185 /// Sets the url and thumbnails fields to None
186 pub async fn remove_pictrs_post_images_and_thumbnails_for_creator(
188 for_creator_id: PersonId,
189 ) -> Result<Vec<Self>, Error> {
190 let conn = &mut get_conn(pool).await?;
191 let pictrs_search = "%pictrs/image%";
195 .filter(creator_id.eq(for_creator_id))
196 .filter(url.like(pictrs_search)),
199 url.eq::<Option<String>>(None),
200 thumbnail_url.eq::<Option<String>>(None),
202 .get_results::<Self>(conn)
206 pub async fn fetch_pictrs_posts_for_community(
208 for_community_id: CommunityId,
209 ) -> Result<Vec<Self>, Error> {
210 let conn = &mut get_conn(pool).await?;
211 let pictrs_search = "%pictrs/image%";
213 .filter(community_id.eq(for_community_id))
214 .filter(url.like(pictrs_search))
219 /// Sets the url and thumbnails fields to None
220 pub async fn remove_pictrs_post_images_and_thumbnails_for_community(
222 for_community_id: CommunityId,
223 ) -> Result<Vec<Self>, Error> {
224 let conn = &mut get_conn(pool).await?;
225 let pictrs_search = "%pictrs/image%";
229 .filter(community_id.eq(for_community_id))
230 .filter(url.like(pictrs_search)),
233 url.eq::<Option<String>>(None),
234 thumbnail_url.eq::<Option<String>>(None),
236 .get_results::<Self>(conn)
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))
253 .get_result::<Self>(conn)
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?;
261 .filter(dsl::post_id.eq(post_id))
262 .filter(dsl::person_id.eq(person_id)),
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))
279 .set(post_saved_form)
280 .get_result::<Self>(conn)
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?;
288 .filter(post_id.eq(post_saved_form.post_id))
289 .filter(person_id.eq(post_saved_form.person_id)),
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))
307 .get_result::<Self>(conn)
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?;
316 .filter(post_id.eq(post_read_form.post_id))
317 .filter(person_id.eq(post_read_form.person_id)),
328 community::{Community, CommunityInsertForm},
330 person::{Person, PersonInsertForm},
343 traits::{Crud, Likeable, Readable, Saveable},
344 utils::build_db_pool_for_tests,
346 use serial_test::serial;
350 async fn test_crud() {
351 let pool = &build_db_pool_for_tests().await;
353 let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
357 let new_person = PersonInsertForm::builder()
359 .public_key("pubkey".to_string())
360 .instance_id(inserted_instance.id)
363 let inserted_person = Person::create(pool, &new_person).await.unwrap();
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)
372 let inserted_community = Community::create(pool, &new_community).await.unwrap();
374 let new_post = PostInsertForm::builder()
375 .name("A test post".into())
376 .creator_id(inserted_person.id)
377 .community_id(inserted_community.id)
380 let inserted_post = Post::create(pool, &new_post).await.unwrap();
382 let expected_post = Post {
383 id: inserted_post.id,
384 name: "A test post".into(),
387 creator_id: inserted_person.id,
388 community_id: inserted_community.id,
389 published: inserted_post.published,
396 embed_description: None,
397 embed_video_url: None,
399 ap_id: inserted_post.ap_id.clone(),
401 language_id: Default::default(),
402 featured_community: false,
403 featured_local: false,
407 let post_like_form = PostLikeForm {
408 post_id: inserted_post.id,
409 person_id: inserted_person.id,
413 let inserted_post_like = PostLike::like(pool, &post_like_form).await.unwrap();
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,
424 let post_saved_form = PostSavedForm {
425 post_id: inserted_post.id,
426 person_id: inserted_person.id,
429 let inserted_post_saved = PostSaved::save(pool, &post_saved_form).await.unwrap();
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,
439 let post_read_form = PostReadForm {
440 post_id: inserted_post.id,
441 person_id: inserted_person.id,
444 let inserted_post_read = PostRead::mark_as_read(pool, &post_read_form).await.unwrap();
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,
453 let read_post = Post::read(pool, inserted_post.id).await.unwrap();
455 let new_post_update = PostUpdateForm::builder()
456 .name(Some("A test post".into()))
458 let updated_post = Post::update(pool, inserted_post.id, &new_post_update)
462 let like_removed = PostLike::remove(pool, inserted_person.id, inserted_post.id)
465 let saved_removed = PostSaved::unsave(pool, &post_saved_form).await.unwrap();
466 let read_removed = PostRead::mark_as_unread(pool, &post_read_form)
469 let num_deleted = Post::delete(pool, inserted_post.id).await.unwrap();
470 Community::delete(pool, inserted_community.id)
473 Person::delete(pool, inserted_person.id).await.unwrap();
474 Instance::delete(pool, inserted_instance.id).await.unwrap();
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);