2 newtypes::{CommunityId, DbUrl, PersonId, PostId},
29 traits::{Crud, DeleteableOrRemoveable, Likeable, Readable, Saveable},
30 utils::{get_conn, naive_now, DbPool, 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: &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: &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: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
52 let conn = &mut get_conn(pool).await?;
58 .get_result::<Self>(conn)
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(
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(published.desc())
86 .then_order_by(featured_community.desc())
87 .limit(FETCH_LIMIT_MAX)
92 pub async fn permadelete_for_creator(
94 for_creator_id: PersonId,
95 ) -> Result<Vec<Self>, Error> {
96 let conn = &mut get_conn(pool).await?;
98 let perma_deleted = "*Permananently Deleted*";
99 let perma_deleted_url = "https://deleted.com";
101 diesel::update(post.filter(creator_id.eq(for_creator_id)))
103 name.eq(perma_deleted),
104 url.eq(perma_deleted_url),
105 body.eq(perma_deleted),
107 updated.eq(naive_now()),
109 .get_results::<Self>(conn)
113 pub async fn update_removed_for_creator(
115 for_creator_id: PersonId,
116 for_community_id: Option<CommunityId>,
118 ) -> Result<Vec<Self>, Error> {
119 let conn = &mut get_conn(pool).await?;
121 let mut update = diesel::update(post).into_boxed();
122 update = update.filter(creator_id.eq(for_creator_id));
124 if let Some(for_community_id) = for_community_id {
125 update = update.filter(community_id.eq(for_community_id));
129 .set((removed.eq(new_removed), updated.eq(naive_now())))
130 .get_results::<Self>(conn)
134 pub fn is_post_creator(person_id: PersonId, post_creator_id: PersonId) -> bool {
135 person_id == post_creator_id
138 pub async fn read_from_apub_id(pool: &DbPool, object_id: Url) -> Result<Option<Self>, Error> {
139 let conn = &mut get_conn(pool).await?;
140 let object_id: DbUrl = object_id.into();
143 .filter(ap_id.eq(object_id))
151 pub async fn fetch_pictrs_posts_for_creator(
153 for_creator_id: PersonId,
154 ) -> Result<Vec<Self>, Error> {
155 let conn = &mut get_conn(pool).await?;
156 let pictrs_search = "%pictrs/image%";
159 .filter(creator_id.eq(for_creator_id))
160 .filter(url.like(pictrs_search))
165 /// Sets the url and thumbnails fields to None
166 pub async fn remove_pictrs_post_images_and_thumbnails_for_creator(
168 for_creator_id: PersonId,
169 ) -> Result<Vec<Self>, Error> {
170 let conn = &mut get_conn(pool).await?;
171 let pictrs_search = "%pictrs/image%";
175 .filter(creator_id.eq(for_creator_id))
176 .filter(url.like(pictrs_search)),
179 url.eq::<Option<String>>(None),
180 thumbnail_url.eq::<Option<String>>(None),
182 .get_results::<Self>(conn)
186 pub async fn fetch_pictrs_posts_for_community(
188 for_community_id: CommunityId,
189 ) -> Result<Vec<Self>, Error> {
190 let conn = &mut get_conn(pool).await?;
191 let pictrs_search = "%pictrs/image%";
193 .filter(community_id.eq(for_community_id))
194 .filter(url.like(pictrs_search))
199 /// Sets the url and thumbnails fields to None
200 pub async fn remove_pictrs_post_images_and_thumbnails_for_community(
202 for_community_id: CommunityId,
203 ) -> Result<Vec<Self>, Error> {
204 let conn = &mut get_conn(pool).await?;
205 let pictrs_search = "%pictrs/image%";
209 .filter(community_id.eq(for_community_id))
210 .filter(url.like(pictrs_search)),
213 url.eq::<Option<String>>(None),
214 thumbnail_url.eq::<Option<String>>(None),
216 .get_results::<Self>(conn)
222 impl Likeable for PostLike {
223 type Form = PostLikeForm;
224 type IdType = PostId;
225 async fn like(pool: &DbPool, post_like_form: &PostLikeForm) -> Result<Self, Error> {
226 use crate::schema::post_like::dsl::{person_id, post_id, post_like};
227 let conn = &mut get_conn(pool).await?;
228 insert_into(post_like)
229 .values(post_like_form)
230 .on_conflict((post_id, person_id))
233 .get_result::<Self>(conn)
236 async fn remove(pool: &DbPool, person_id: PersonId, post_id: PostId) -> Result<usize, Error> {
237 use crate::schema::post_like::dsl;
238 let conn = &mut get_conn(pool).await?;
241 .filter(dsl::post_id.eq(post_id))
242 .filter(dsl::person_id.eq(person_id)),
250 impl Saveable for PostSaved {
251 type Form = PostSavedForm;
252 async fn save(pool: &DbPool, post_saved_form: &PostSavedForm) -> Result<Self, Error> {
253 use crate::schema::post_saved::dsl::{person_id, post_id, post_saved};
254 let conn = &mut get_conn(pool).await?;
255 insert_into(post_saved)
256 .values(post_saved_form)
257 .on_conflict((post_id, person_id))
259 .set(post_saved_form)
260 .get_result::<Self>(conn)
263 async fn unsave(pool: &DbPool, post_saved_form: &PostSavedForm) -> Result<usize, Error> {
264 use crate::schema::post_saved::dsl::{person_id, post_id, post_saved};
265 let conn = &mut get_conn(pool).await?;
268 .filter(post_id.eq(post_saved_form.post_id))
269 .filter(person_id.eq(post_saved_form.person_id)),
277 impl Readable for PostRead {
278 type Form = PostReadForm;
279 async fn mark_as_read(pool: &DbPool, post_read_form: &PostReadForm) -> Result<Self, Error> {
280 use crate::schema::post_read::dsl::{person_id, post_id, post_read};
281 let conn = &mut get_conn(pool).await?;
282 insert_into(post_read)
283 .values(post_read_form)
284 .on_conflict((post_id, person_id))
287 .get_result::<Self>(conn)
291 async fn mark_as_unread(pool: &DbPool, post_read_form: &PostReadForm) -> Result<usize, Error> {
292 use crate::schema::post_read::dsl::{person_id, post_id, post_read};
293 let conn = &mut get_conn(pool).await?;
296 .filter(post_id.eq(post_read_form.post_id))
297 .filter(person_id.eq(post_read_form.person_id)),
304 impl DeleteableOrRemoveable for Post {
305 fn blank_out_deleted_or_removed_info(mut self) -> Self {
306 self.name = String::new();
309 self.embed_title = None;
310 self.embed_description = None;
311 self.embed_video_url = None;
312 self.thumbnail_url = None;
322 community::{Community, CommunityInsertForm},
324 person::{Person, PersonInsertForm},
337 traits::{Crud, Likeable, Readable, Saveable},
338 utils::build_db_pool_for_tests,
340 use serial_test::serial;
344 async fn test_crud() {
345 let pool = &build_db_pool_for_tests().await;
347 let inserted_instance = Instance::create(pool, "my_domain.tld").await.unwrap();
349 let new_person = PersonInsertForm::builder()
351 .public_key("pubkey".to_string())
352 .instance_id(inserted_instance.id)
355 let inserted_person = Person::create(pool, &new_person).await.unwrap();
357 let new_community = CommunityInsertForm::builder()
358 .name("test community_3".to_string())
359 .title("nada".to_owned())
360 .public_key("pubkey".to_string())
361 .instance_id(inserted_instance.id)
364 let inserted_community = Community::create(pool, &new_community).await.unwrap();
366 let new_post = PostInsertForm::builder()
367 .name("A test post".into())
368 .creator_id(inserted_person.id)
369 .community_id(inserted_community.id)
372 let inserted_post = Post::create(pool, &new_post).await.unwrap();
374 let expected_post = Post {
375 id: inserted_post.id,
376 name: "A test post".into(),
379 creator_id: inserted_person.id,
380 community_id: inserted_community.id,
381 published: inserted_post.published,
388 embed_description: None,
389 embed_video_url: None,
391 ap_id: inserted_post.ap_id.clone(),
393 language_id: Default::default(),
394 featured_community: false,
395 featured_local: false,
399 let post_like_form = PostLikeForm {
400 post_id: inserted_post.id,
401 person_id: inserted_person.id,
405 let inserted_post_like = PostLike::like(pool, &post_like_form).await.unwrap();
407 let expected_post_like = PostLike {
408 id: inserted_post_like.id,
409 post_id: inserted_post.id,
410 person_id: inserted_person.id,
411 published: inserted_post_like.published,
416 let post_saved_form = PostSavedForm {
417 post_id: inserted_post.id,
418 person_id: inserted_person.id,
421 let inserted_post_saved = PostSaved::save(pool, &post_saved_form).await.unwrap();
423 let expected_post_saved = PostSaved {
424 id: inserted_post_saved.id,
425 post_id: inserted_post.id,
426 person_id: inserted_person.id,
427 published: inserted_post_saved.published,
431 let post_read_form = PostReadForm {
432 post_id: inserted_post.id,
433 person_id: inserted_person.id,
436 let inserted_post_read = PostRead::mark_as_read(pool, &post_read_form).await.unwrap();
438 let expected_post_read = PostRead {
439 id: inserted_post_read.id,
440 post_id: inserted_post.id,
441 person_id: inserted_person.id,
442 published: inserted_post_read.published,
445 let read_post = Post::read(pool, inserted_post.id).await.unwrap();
447 let new_post_update = PostUpdateForm::builder()
448 .name(Some("A test post".into()))
450 let updated_post = Post::update(pool, inserted_post.id, &new_post_update)
454 let like_removed = PostLike::remove(pool, inserted_person.id, inserted_post.id)
457 let saved_removed = PostSaved::unsave(pool, &post_saved_form).await.unwrap();
458 let read_removed = PostRead::mark_as_unread(pool, &post_read_form)
461 let num_deleted = Post::delete(pool, inserted_post.id).await.unwrap();
462 Community::delete(pool, inserted_community.id)
465 Person::delete(pool, inserted_person.id).await.unwrap();
466 Instance::delete(pool, inserted_instance.id).await.unwrap();
468 assert_eq!(expected_post, read_post);
469 assert_eq!(expected_post, inserted_post);
470 assert_eq!(expected_post, updated_post);
471 assert_eq!(expected_post_like, inserted_post_like);
472 assert_eq!(expected_post_saved, inserted_post_saved);
473 assert_eq!(expected_post_read, inserted_post_read);
474 assert_eq!(1, like_removed);
475 assert_eq!(1, saved_removed);
476 assert_eq!(1, read_removed);
477 assert_eq!(1, num_deleted);