3 newtypes::{CommunityId, DbUrl, PersonId, PostId},
14 traits::{Crud, DeleteableOrRemoveable, Likeable, Readable, Saveable},
16 use diesel::{dsl::*, result::Error, ExpressionMethods, PgConnection, QueryDsl, RunQueryDsl};
22 fn read(conn: &PgConnection, post_id: PostId) -> Result<Self, Error> {
23 use crate::schema::post::dsl::*;
24 post.find(post_id).first::<Self>(conn)
27 fn delete(conn: &PgConnection, post_id: PostId) -> Result<usize, Error> {
28 use crate::schema::post::dsl::*;
29 diesel::delete(post.find(post_id)).execute(conn)
32 fn create(conn: &PgConnection, new_post: &PostForm) -> Result<Self, Error> {
33 use crate::schema::post::dsl::*;
34 insert_into(post).values(new_post).get_result::<Self>(conn)
37 fn update(conn: &PgConnection, post_id: PostId, new_post: &PostForm) -> Result<Self, Error> {
38 use crate::schema::post::dsl::*;
39 diesel::update(post.find(post_id))
41 .get_result::<Self>(conn)
46 pub fn list_for_community(
48 the_community_id: CommunityId,
49 ) -> Result<Vec<Self>, Error> {
50 use crate::schema::post::dsl::*;
52 .filter(community_id.eq(the_community_id))
53 .then_order_by(published.desc())
54 .then_order_by(stickied.desc())
59 pub fn update_ap_id(conn: &PgConnection, post_id: PostId, apub_id: DbUrl) -> Result<Self, Error> {
60 use crate::schema::post::dsl::*;
62 diesel::update(post.find(post_id))
63 .set(ap_id.eq(apub_id))
64 .get_result::<Self>(conn)
67 pub fn permadelete_for_creator(
69 for_creator_id: PersonId,
70 ) -> Result<Vec<Self>, Error> {
71 use crate::schema::post::dsl::*;
73 let perma_deleted = "*Permananently Deleted*";
74 let perma_deleted_url = "https://deleted.com";
76 diesel::update(post.filter(creator_id.eq(for_creator_id)))
78 name.eq(perma_deleted),
79 url.eq(perma_deleted_url),
80 body.eq(perma_deleted),
82 updated.eq(naive_now()),
84 .get_results::<Self>(conn)
87 pub fn update_deleted(
91 ) -> Result<Self, Error> {
92 use crate::schema::post::dsl::*;
93 diesel::update(post.find(post_id))
94 .set((deleted.eq(new_deleted), updated.eq(naive_now())))
95 .get_result::<Self>(conn)
98 pub fn update_removed(
102 ) -> Result<Self, Error> {
103 use crate::schema::post::dsl::*;
104 diesel::update(post.find(post_id))
105 .set((removed.eq(new_removed), updated.eq(naive_now())))
106 .get_result::<Self>(conn)
109 pub fn update_removed_for_creator(
111 for_creator_id: PersonId,
112 for_community_id: Option<CommunityId>,
114 ) -> Result<Vec<Self>, Error> {
115 use crate::schema::post::dsl::*;
117 let mut update = diesel::update(post).into_boxed();
118 update = update.filter(creator_id.eq(for_creator_id));
120 if let Some(for_community_id) = for_community_id {
121 update = update.filter(community_id.eq(for_community_id));
125 .set((removed.eq(new_removed), updated.eq(naive_now())))
126 .get_results::<Self>(conn)
129 pub fn update_locked(
133 ) -> Result<Self, Error> {
134 use crate::schema::post::dsl::*;
135 diesel::update(post.find(post_id))
136 .set(locked.eq(new_locked))
137 .get_result::<Self>(conn)
140 pub fn update_stickied(
144 ) -> Result<Self, Error> {
145 use crate::schema::post::dsl::*;
146 diesel::update(post.find(post_id))
147 .set(stickied.eq(new_stickied))
148 .get_result::<Self>(conn)
151 pub fn is_post_creator(person_id: PersonId, post_creator_id: PersonId) -> bool {
152 person_id == post_creator_id
155 pub fn upsert(conn: &PgConnection, post_form: &PostForm) -> Result<Post, Error> {
156 use crate::schema::post::dsl::*;
162 .get_result::<Self>(conn)
164 pub fn read_from_apub_id(conn: &PgConnection, object_id: Url) -> Result<Option<Self>, Error> {
165 use crate::schema::post::dsl::*;
166 let object_id: DbUrl = object_id.into();
169 .filter(ap_id.eq(object_id))
177 impl Likeable for PostLike {
178 type Form = PostLikeForm;
179 type IdType = PostId;
180 fn like(conn: &PgConnection, post_like_form: &PostLikeForm) -> Result<Self, Error> {
181 use crate::schema::post_like::dsl::*;
182 insert_into(post_like)
183 .values(post_like_form)
184 .on_conflict((post_id, person_id))
187 .get_result::<Self>(conn)
189 fn remove(conn: &PgConnection, person_id: PersonId, post_id: PostId) -> Result<usize, Error> {
190 use crate::schema::post_like::dsl;
193 .filter(dsl::post_id.eq(post_id))
194 .filter(dsl::person_id.eq(person_id)),
200 impl Saveable for PostSaved {
201 type Form = PostSavedForm;
202 fn save(conn: &PgConnection, post_saved_form: &PostSavedForm) -> Result<Self, Error> {
203 use crate::schema::post_saved::dsl::*;
204 insert_into(post_saved)
205 .values(post_saved_form)
206 .on_conflict((post_id, person_id))
208 .set(post_saved_form)
209 .get_result::<Self>(conn)
211 fn unsave(conn: &PgConnection, post_saved_form: &PostSavedForm) -> Result<usize, Error> {
212 use crate::schema::post_saved::dsl::*;
215 .filter(post_id.eq(post_saved_form.post_id))
216 .filter(person_id.eq(post_saved_form.person_id)),
222 impl Readable for PostRead {
223 type Form = PostReadForm;
224 fn mark_as_read(conn: &PgConnection, post_read_form: &PostReadForm) -> Result<Self, Error> {
225 use crate::schema::post_read::dsl::*;
226 insert_into(post_read)
227 .values(post_read_form)
228 .on_conflict((post_id, person_id))
231 .get_result::<Self>(conn)
234 fn mark_as_unread(conn: &PgConnection, post_read_form: &PostReadForm) -> Result<usize, Error> {
235 use crate::schema::post_read::dsl::*;
238 .filter(post_id.eq(post_read_form.post_id))
239 .filter(person_id.eq(post_read_form.person_id)),
245 impl DeleteableOrRemoveable for Post {
246 fn blank_out_deleted_or_removed_info(mut self) -> Self {
247 self.name = "".into();
250 self.embed_title = None;
251 self.embed_description = None;
252 self.embed_html = None;
253 self.thumbnail_url = None;
262 establish_unpooled_connection,
264 community::{Community, CommunityForm},
268 traits::{Crud, Likeable, Readable, Saveable},
270 use serial_test::serial;
275 let conn = establish_unpooled_connection();
277 let new_person = PersonForm {
279 ..PersonForm::default()
282 let inserted_person = Person::create(&conn, &new_person).unwrap();
284 let new_community = CommunityForm {
285 name: "test community_3".to_string(),
286 title: "nada".to_owned(),
287 ..CommunityForm::default()
290 let inserted_community = Community::create(&conn, &new_community).unwrap();
292 let new_post = PostForm {
293 name: "A test post".into(),
294 creator_id: inserted_person.id,
295 community_id: inserted_community.id,
296 ..PostForm::default()
299 let inserted_post = Post::create(&conn, &new_post).unwrap();
301 let expected_post = Post {
302 id: inserted_post.id,
303 name: "A test post".into(),
306 creator_id: inserted_person.id,
307 community_id: inserted_community.id,
308 published: inserted_post.published,
316 embed_description: None,
319 ap_id: inserted_post.ap_id.to_owned(),
324 let post_like_form = PostLikeForm {
325 post_id: inserted_post.id,
326 person_id: inserted_person.id,
330 let inserted_post_like = PostLike::like(&conn, &post_like_form).unwrap();
332 let expected_post_like = PostLike {
333 id: inserted_post_like.id,
334 post_id: inserted_post.id,
335 person_id: inserted_person.id,
336 published: inserted_post_like.published,
341 let post_saved_form = PostSavedForm {
342 post_id: inserted_post.id,
343 person_id: inserted_person.id,
346 let inserted_post_saved = PostSaved::save(&conn, &post_saved_form).unwrap();
348 let expected_post_saved = PostSaved {
349 id: inserted_post_saved.id,
350 post_id: inserted_post.id,
351 person_id: inserted_person.id,
352 published: inserted_post_saved.published,
356 let post_read_form = PostReadForm {
357 post_id: inserted_post.id,
358 person_id: inserted_person.id,
361 let inserted_post_read = PostRead::mark_as_read(&conn, &post_read_form).unwrap();
363 let expected_post_read = PostRead {
364 id: inserted_post_read.id,
365 post_id: inserted_post.id,
366 person_id: inserted_person.id,
367 published: inserted_post_read.published,
370 let read_post = Post::read(&conn, inserted_post.id).unwrap();
371 let updated_post = Post::update(&conn, inserted_post.id, &new_post).unwrap();
372 let like_removed = PostLike::remove(&conn, inserted_person.id, inserted_post.id).unwrap();
373 let saved_removed = PostSaved::unsave(&conn, &post_saved_form).unwrap();
374 let read_removed = PostRead::mark_as_unread(&conn, &post_read_form).unwrap();
375 let num_deleted = Post::delete(&conn, inserted_post.id).unwrap();
376 Community::delete(&conn, inserted_community.id).unwrap();
377 Person::delete(&conn, inserted_person.id).unwrap();
379 assert_eq!(expected_post, read_post);
380 assert_eq!(expected_post, inserted_post);
381 assert_eq!(expected_post, updated_post);
382 assert_eq!(expected_post_like, inserted_post_like);
383 assert_eq!(expected_post_saved, inserted_post_saved);
384 assert_eq!(expected_post_read, inserted_post_read);
385 assert_eq!(1, like_removed);
386 assert_eq!(1, saved_removed);
387 assert_eq!(1, read_removed);
388 assert_eq!(1, num_deleted);