2 newtypes::{CommunityId, DbUrl, PersonId, PostId},
29 traits::{Crud, Likeable, Readable, Saveable},
30 utils::{get_conn, naive_now, DbPool, DELETED_REPLACEMENT_TEXT, FETCH_LIMIT_MAX},
33 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl, TextExpressionMethods};
34 use diesel_async::RunQueryDsl;
38 type InsertForm = PostInsertForm;
39 type UpdateForm = PostUpdateForm;
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
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
51 async fn create(pool: &mut DbPool<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
52 let conn = &mut get_conn(pool).await?;
58 .get_result::<Self>(conn)
63 pool: &mut DbPool<'_>,
65 new_post: &Self::UpdateForm,
66 ) -> Result<Self, Error> {
67 let conn = &mut get_conn(pool).await?;
68 diesel::update(post.find(post_id))
70 .get_result::<Self>(conn)
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?;
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)
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?;
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)
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?;
114 diesel::update(post.filter(creator_id.eq(for_creator_id)))
116 name.eq(DELETED_REPLACEMENT_TEXT),
117 url.eq(Option::<&str>::None),
118 body.eq(DELETED_REPLACEMENT_TEXT),
120 updated.eq(naive_now()),
122 .get_results::<Self>(conn)
126 pub async fn update_removed_for_creator(
127 pool: &mut DbPool<'_>,
128 for_creator_id: PersonId,
129 for_community_id: Option<CommunityId>,
131 ) -> Result<Vec<Self>, Error> {
132 let conn = &mut get_conn(pool).await?;
134 let mut update = diesel::update(post).into_boxed();
135 update = update.filter(creator_id.eq(for_creator_id));
137 if let Some(for_community_id) = for_community_id {
138 update = update.filter(community_id.eq(for_community_id));
142 .set((removed.eq(new_removed), updated.eq(naive_now())))
143 .get_results::<Self>(conn)
147 pub fn is_post_creator(person_id: PersonId, post_creator_id: PersonId) -> bool {
148 person_id == post_creator_id
151 pub async fn read_from_apub_id(
152 pool: &mut DbPool<'_>,
154 ) -> Result<Option<Self>, Error> {
155 let conn = &mut get_conn(pool).await?;
156 let object_id: DbUrl = object_id.into();
159 .filter(ap_id.eq(object_id))
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%";
175 .filter(creator_id.eq(for_creator_id))
176 .filter(url.like(pictrs_search))
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%";
191 .filter(creator_id.eq(for_creator_id))
192 .filter(url.like(pictrs_search)),
195 url.eq::<Option<String>>(None),
196 thumbnail_url.eq::<Option<String>>(None),
198 .get_results::<Self>(conn)
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%";
209 .filter(community_id.eq(for_community_id))
210 .filter(url.like(pictrs_search))
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%";
225 .filter(community_id.eq(for_community_id))
226 .filter(url.like(pictrs_search)),
229 url.eq::<Option<String>>(None),
230 thumbnail_url.eq::<Option<String>>(None),
232 .get_results::<Self>(conn)
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))
249 .get_result::<Self>(conn)
253 pool: &mut DbPool<'_>,
256 ) -> 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: &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))
279 .set(post_saved_form)
280 .get_result::<Self>(conn)
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?;
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(
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))
310 .get_result::<Self>(conn)
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?;
322 .filter(post_id.eq(post_read_form.post_id))
323 .filter(person_id.eq(post_read_form.person_id)),
332 #![allow(clippy::unwrap_used)]
333 #![allow(clippy::indexing_slicing)]
337 community::{Community, CommunityInsertForm},
339 person::{Person, PersonInsertForm},
352 traits::{Crud, Likeable, Readable, Saveable},
353 utils::build_db_pool_for_tests,
355 use serial_test::serial;
359 async fn test_crud() {
360 let pool = &build_db_pool_for_tests().await;
361 let pool = &mut pool.into();
363 let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
367 let new_person = PersonInsertForm::builder()
369 .public_key("pubkey".to_string())
370 .instance_id(inserted_instance.id)
373 let inserted_person = Person::create(pool, &new_person).await.unwrap();
375 let new_community = CommunityInsertForm::builder()
376 .name("test community_3".to_string())
377 .title("nada".to_owned())
378 .public_key("pubkey".to_string())
379 .instance_id(inserted_instance.id)
382 let inserted_community = Community::create(pool, &new_community).await.unwrap();
384 let new_post = PostInsertForm::builder()
385 .name("A test post".into())
386 .creator_id(inserted_person.id)
387 .community_id(inserted_community.id)
390 let inserted_post = Post::create(pool, &new_post).await.unwrap();
392 let expected_post = Post {
393 id: inserted_post.id,
394 name: "A test post".into(),
397 creator_id: inserted_person.id,
398 community_id: inserted_community.id,
399 published: inserted_post.published,
406 embed_description: None,
407 embed_video_url: None,
409 ap_id: inserted_post.ap_id.clone(),
411 language_id: Default::default(),
412 featured_community: false,
413 featured_local: false,
417 let post_like_form = PostLikeForm {
418 post_id: inserted_post.id,
419 person_id: inserted_person.id,
423 let inserted_post_like = PostLike::like(pool, &post_like_form).await.unwrap();
425 let expected_post_like = PostLike {
426 id: inserted_post_like.id,
427 post_id: inserted_post.id,
428 person_id: inserted_person.id,
429 published: inserted_post_like.published,
434 let post_saved_form = PostSavedForm {
435 post_id: inserted_post.id,
436 person_id: inserted_person.id,
439 let inserted_post_saved = PostSaved::save(pool, &post_saved_form).await.unwrap();
441 let expected_post_saved = PostSaved {
442 id: inserted_post_saved.id,
443 post_id: inserted_post.id,
444 person_id: inserted_person.id,
445 published: inserted_post_saved.published,
449 let post_read_form = PostReadForm {
450 post_id: inserted_post.id,
451 person_id: inserted_person.id,
454 let inserted_post_read = PostRead::mark_as_read(pool, &post_read_form).await.unwrap();
456 let expected_post_read = PostRead {
457 id: inserted_post_read.id,
458 post_id: inserted_post.id,
459 person_id: inserted_person.id,
460 published: inserted_post_read.published,
463 let read_post = Post::read(pool, inserted_post.id).await.unwrap();
465 let new_post_update = PostUpdateForm::builder()
466 .name(Some("A test post".into()))
468 let updated_post = Post::update(pool, inserted_post.id, &new_post_update)
472 let like_removed = PostLike::remove(pool, inserted_person.id, inserted_post.id)
475 let saved_removed = PostSaved::unsave(pool, &post_saved_form).await.unwrap();
476 let read_removed = PostRead::mark_as_unread(pool, &post_read_form)
479 let num_deleted = Post::delete(pool, inserted_post.id).await.unwrap();
480 Community::delete(pool, inserted_community.id)
483 Person::delete(pool, inserted_person.id).await.unwrap();
484 Instance::delete(pool, inserted_instance.id).await.unwrap();
486 assert_eq!(expected_post, read_post);
487 assert_eq!(expected_post, inserted_post);
488 assert_eq!(expected_post, updated_post);
489 assert_eq!(expected_post_like, inserted_post_like);
490 assert_eq!(expected_post_saved, inserted_post_saved);
491 assert_eq!(expected_post_read, inserted_post_read);
492 assert_eq!(1, like_removed);
493 assert_eq!(1, saved_removed);
494 assert_eq!(1, read_removed);
495 assert_eq!(1, num_deleted);