3 #[derive(Serialize, Deserialize)]
4 pub struct CreatePost {
13 #[derive(Serialize, Deserialize, Clone)]
14 pub struct PostResponse {
18 #[derive(Serialize, Deserialize)]
24 #[derive(Serialize, Deserialize)]
25 pub struct GetPostResponse {
27 comments: Vec<CommentView>,
28 community: CommunityView,
29 moderators: Vec<CommunityModeratorView>,
30 admins: Vec<UserView>,
34 #[derive(Serialize, Deserialize)]
40 pub community_id: Option<i32>,
44 #[derive(Serialize, Deserialize)]
45 pub struct GetPostsResponse {
49 #[derive(Serialize, Deserialize)]
50 pub struct CreatePostLike {
56 #[derive(Serialize, Deserialize)]
64 removed: Option<bool>,
65 deleted: Option<bool>,
68 stickied: Option<bool>,
69 reason: Option<String>,
73 #[derive(Serialize, Deserialize)]
80 impl Perform for Oper<CreatePost> {
81 type Response = PostResponse;
85 pool: Pool<ConnectionManager<PgConnection>>,
86 websocket_info: Option<WebsocketInfo>,
87 ) -> Result<PostResponse, Error> {
88 let data: &CreatePost = &self.data;
90 let claims = match Claims::decode(&data.auth) {
91 Ok(claims) => claims.claims,
92 Err(_e) => return Err(APIError::err("not_logged_in").into()),
95 if let Err(slurs) = slur_check(&data.name) {
96 return Err(APIError::err(&slurs_vec_to_str(slurs)).into());
99 if let Some(body) = &data.body {
100 if let Err(slurs) = slur_check(body) {
101 return Err(APIError::err(&slurs_vec_to_str(slurs)).into());
105 let user_id = claims.id;
107 let conn = pool.get()?;
109 // Check for a community ban
110 if CommunityUserBanView::get(&conn, user_id, data.community_id).is_ok() {
111 return Err(APIError::err("community_ban").into());
114 // Check for a site ban
115 if UserView::read(&conn, user_id)?.banned {
116 return Err(APIError::err("site_ban").into());
119 // Fetch Iframely and pictrs cached image
120 let (iframely_title, iframely_description, iframely_html, pictrs_thumbnail) =
121 fetch_iframely_and_pictrs_data(data.url.to_owned());
123 let post_form = PostForm {
124 name: data.name.to_owned(),
125 url: data.url.to_owned(),
126 body: data.body.to_owned(),
127 community_id: data.community_id,
135 embed_title: iframely_title,
136 embed_description: iframely_description,
137 embed_html: iframely_html,
138 thumbnail_url: pictrs_thumbnail,
141 let inserted_post = match Post::create(&conn, &post_form) {
144 let err_type = if e.to_string() == "value too long for type character varying(200)" {
145 "post_title_too_long"
147 "couldnt_create_post"
150 return Err(APIError::err(err_type).into());
154 // They like their own post by default
155 let like_form = PostLikeForm {
156 post_id: inserted_post.id,
161 // Only add the like if the score isnt 0
162 let _inserted_like = match PostLike::like(&conn, &like_form) {
164 Err(_e) => return Err(APIError::err("couldnt_like_post").into()),
168 let post_view = match PostView::read(&conn, inserted_post.id, Some(user_id)) {
170 Err(_e) => return Err(APIError::err("couldnt_find_post").into()),
173 let res = PostResponse { post: post_view };
175 if let Some(ws) = websocket_info {
176 ws.chatserver.do_send(SendPost {
177 op: UserOperation::CreatePost,
187 impl Perform for Oper<GetPost> {
188 type Response = GetPostResponse;
192 pool: Pool<ConnectionManager<PgConnection>>,
193 websocket_info: Option<WebsocketInfo>,
194 ) -> Result<GetPostResponse, Error> {
195 let data: &GetPost = &self.data;
197 let user_id: Option<i32> = match &data.auth {
198 Some(auth) => match Claims::decode(&auth) {
200 let user_id = claims.claims.id;
208 let conn = pool.get()?;
210 let post_view = match PostView::read(&conn, data.id, user_id) {
212 Err(_e) => return Err(APIError::err("couldnt_find_post").into()),
215 let comments = CommentQueryBuilder::create(&conn)
216 .for_post_id(data.id)
221 let community = CommunityView::read(&conn, post_view.community_id, user_id)?;
223 let moderators = CommunityModeratorView::for_community(&conn, post_view.community_id)?;
225 let site_creator_id = Site::read(&conn, 1)?.creator_id;
226 let mut admins = UserView::admins(&conn)?;
227 let creator_index = admins.iter().position(|r| r.id == site_creator_id).unwrap();
228 let creator_user = admins.remove(creator_index);
229 admins.insert(0, creator_user);
231 let online = if let Some(ws) = websocket_info {
232 if let Some(id) = ws.id {
233 ws.chatserver.do_send(JoinPostRoom {
242 // ws.chatserver.send(GetPostUsersOnline {post_id: data.id}).await.unwrap()
244 // Runtime::new().unwrap().block_on(fut)
261 impl Perform for Oper<GetPosts> {
262 type Response = GetPostsResponse;
266 pool: Pool<ConnectionManager<PgConnection>>,
267 websocket_info: Option<WebsocketInfo>,
268 ) -> Result<GetPostsResponse, Error> {
269 let data: &GetPosts = &self.data;
271 let user_claims: Option<Claims> = match &data.auth {
272 Some(auth) => match Claims::decode(&auth) {
273 Ok(claims) => Some(claims.claims),
279 let user_id = match &user_claims {
280 Some(claims) => Some(claims.id),
284 let show_nsfw = match &user_claims {
285 Some(claims) => claims.show_nsfw,
289 let type_ = ListingType::from_str(&data.type_)?;
290 let sort = SortType::from_str(&data.sort)?;
292 let conn = pool.get()?;
294 let posts = match PostQueryBuilder::create(&conn)
297 .show_nsfw(show_nsfw)
298 .for_community_id(data.community_id)
305 Err(_e) => return Err(APIError::err("couldnt_get_posts").into()),
308 if let Some(ws) = websocket_info {
309 // You don't need to join the specific community room, bc this is already handled by
311 if data.community_id.is_none() {
312 if let Some(id) = ws.id {
313 // 0 is the "all" community
314 ws.chatserver.do_send(JoinCommunityRoom {
322 Ok(GetPostsResponse { posts })
326 impl Perform for Oper<CreatePostLike> {
327 type Response = PostResponse;
331 pool: Pool<ConnectionManager<PgConnection>>,
332 websocket_info: Option<WebsocketInfo>,
333 ) -> Result<PostResponse, Error> {
334 let data: &CreatePostLike = &self.data;
336 let claims = match Claims::decode(&data.auth) {
337 Ok(claims) => claims.claims,
338 Err(_e) => return Err(APIError::err("not_logged_in").into()),
341 let user_id = claims.id;
343 let conn = pool.get()?;
345 // Don't do a downvote if site has downvotes disabled
346 if data.score == -1 {
347 let site = SiteView::read(&conn)?;
348 if !site.enable_downvotes {
349 return Err(APIError::err("downvotes_disabled").into());
353 // Check for a community ban
354 let post = Post::read(&conn, data.post_id)?;
355 if CommunityUserBanView::get(&conn, user_id, post.community_id).is_ok() {
356 return Err(APIError::err("community_ban").into());
359 // Check for a site ban
360 if UserView::read(&conn, user_id)?.banned {
361 return Err(APIError::err("site_ban").into());
364 let like_form = PostLikeForm {
365 post_id: data.post_id,
370 // Remove any likes first
371 PostLike::remove(&conn, &like_form)?;
373 // Only add the like if the score isnt 0
374 let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
376 let _inserted_like = match PostLike::like(&conn, &like_form) {
378 Err(_e) => return Err(APIError::err("couldnt_like_post").into()),
382 let post_view = match PostView::read(&conn, data.post_id, Some(user_id)) {
384 Err(_e) => return Err(APIError::err("couldnt_find_post").into()),
387 let res = PostResponse { post: post_view };
389 if let Some(ws) = websocket_info {
390 ws.chatserver.do_send(SendPost {
391 op: UserOperation::CreatePostLike,
401 impl Perform for Oper<EditPost> {
402 type Response = PostResponse;
406 pool: Pool<ConnectionManager<PgConnection>>,
407 websocket_info: Option<WebsocketInfo>,
408 ) -> Result<PostResponse, Error> {
409 let data: &EditPost = &self.data;
411 if let Err(slurs) = slur_check(&data.name) {
412 return Err(APIError::err(&slurs_vec_to_str(slurs)).into());
415 if let Some(body) = &data.body {
416 if let Err(slurs) = slur_check(body) {
417 return Err(APIError::err(&slurs_vec_to_str(slurs)).into());
421 let claims = match Claims::decode(&data.auth) {
422 Ok(claims) => claims.claims,
423 Err(_e) => return Err(APIError::err("not_logged_in").into()),
426 let user_id = claims.id;
428 let conn = pool.get()?;
430 // Verify its the creator or a mod or admin
431 let mut editors: Vec<i32> = vec![data.creator_id];
433 &mut CommunityModeratorView::for_community(&conn, data.community_id)?
438 editors.append(&mut UserView::admins(&conn)?.into_iter().map(|a| a.id).collect());
439 if !editors.contains(&user_id) {
440 return Err(APIError::err("no_post_edit_allowed").into());
443 // Check for a community ban
444 if CommunityUserBanView::get(&conn, user_id, data.community_id).is_ok() {
445 return Err(APIError::err("community_ban").into());
448 // Check for a site ban
449 if UserView::read(&conn, user_id)?.banned {
450 return Err(APIError::err("site_ban").into());
453 // Fetch Iframely and Pictrs cached image
454 let (iframely_title, iframely_description, iframely_html, pictrs_thumbnail) =
455 fetch_iframely_and_pictrs_data(data.url.to_owned());
457 let post_form = PostForm {
458 name: data.name.to_owned(),
459 url: data.url.to_owned(),
460 body: data.body.to_owned(),
461 creator_id: data.creator_id.to_owned(),
462 community_id: data.community_id,
463 removed: data.removed.to_owned(),
464 deleted: data.deleted.to_owned(),
466 locked: data.locked.to_owned(),
467 stickied: data.stickied.to_owned(),
468 updated: Some(naive_now()),
469 embed_title: iframely_title,
470 embed_description: iframely_description,
471 embed_html: iframely_html,
472 thumbnail_url: pictrs_thumbnail,
475 let _updated_post = match Post::update(&conn, data.edit_id, &post_form) {
478 let err_type = if e.to_string() == "value too long for type character varying(200)" {
479 "post_title_too_long"
481 "couldnt_update_post"
484 return Err(APIError::err(err_type).into());
489 if let Some(removed) = data.removed.to_owned() {
490 let form = ModRemovePostForm {
491 mod_user_id: user_id,
492 post_id: data.edit_id,
493 removed: Some(removed),
494 reason: data.reason.to_owned(),
496 ModRemovePost::create(&conn, &form)?;
499 if let Some(locked) = data.locked.to_owned() {
500 let form = ModLockPostForm {
501 mod_user_id: user_id,
502 post_id: data.edit_id,
503 locked: Some(locked),
505 ModLockPost::create(&conn, &form)?;
508 if let Some(stickied) = data.stickied.to_owned() {
509 let form = ModStickyPostForm {
510 mod_user_id: user_id,
511 post_id: data.edit_id,
512 stickied: Some(stickied),
514 ModStickyPost::create(&conn, &form)?;
517 let post_view = PostView::read(&conn, data.edit_id, Some(user_id))?;
519 let res = PostResponse { post: post_view };
521 if let Some(ws) = websocket_info {
522 ws.chatserver.do_send(SendPost {
523 op: UserOperation::EditPost,
533 impl Perform for Oper<SavePost> {
534 type Response = PostResponse;
538 pool: Pool<ConnectionManager<PgConnection>>,
539 _websocket_info: Option<WebsocketInfo>,
540 ) -> Result<PostResponse, Error> {
541 let data: &SavePost = &self.data;
543 let claims = match Claims::decode(&data.auth) {
544 Ok(claims) => claims.claims,
545 Err(_e) => return Err(APIError::err("not_logged_in").into()),
548 let user_id = claims.id;
550 let post_saved_form = PostSavedForm {
551 post_id: data.post_id,
555 let conn = pool.get()?;
558 match PostSaved::save(&conn, &post_saved_form) {
560 Err(_e) => return Err(APIError::err("couldnt_save_post").into()),
563 match PostSaved::unsave(&conn, &post_saved_form) {
565 Err(_e) => return Err(APIError::err("couldnt_save_post").into()),
569 let post_view = PostView::read(&conn, data.post_id, Some(user_id))?;
571 Ok(PostResponse { post: post_view })