crates/api_crud/src/post/read.rs

   1 use crate::PerformCrud;
   2 use actix_web::web::Data;
   3 use lemmy_api_common::{blocking, get_local_user_view_from_jwt_opt, mark_post_as_read, post::*};
   4 use lemmy_apub::{build_actor_id_from_shortname, EndpointType};
   5 use lemmy_db_queries::{from_opt_str_to_opt_enum, DeleteableOrRemoveable, ListingType, SortType};
   6 use lemmy_db_views::{
   7   comment_view::CommentQueryBuilder,
   8   post_view::{PostQueryBuilder, PostView},
   9 };
  10 use lemmy_db_views_actor::{
  11   community_moderator_view::CommunityModeratorView,
  12   community_view::CommunityView,
  13 };
  14 use lemmy_utils::{ApiError, ConnectionId, LemmyError};
  15 use lemmy_websocket::{messages::GetPostUsersOnline, LemmyContext};
  16
  17 #[async_trait::async_trait(?Send)]
  18 impl PerformCrud for GetPost {
  19   type Response = GetPostResponse;
  20
  21   async fn perform(
  22     &self,
  23     context: &Data<LemmyContext>,
  24     _websocket_id: Option<ConnectionId>,
  25   ) -> Result<GetPostResponse, LemmyError> {
  26     let data: &GetPost = self;
  27     let local_user_view =
  28       get_local_user_view_from_jwt_opt(&data.auth, context.pool(), context.secret()).await?;
  29
  30     let show_bot_accounts = local_user_view
  31       .as_ref()
  32       .map(|t| t.local_user.show_bot_accounts);
  33     let person_id = local_user_view.map(|u| u.person.id);
  34
  35     let id = data.id;
  36     let mut post_view = blocking(context.pool(), move |conn| {
  37       PostView::read(conn, id, person_id)
  38     })
  39     .await?
  40     .map_err(|_| ApiError::err("couldnt_find_post"))?;
  41
  42     // Blank out deleted info
  43     if post_view.post.deleted || post_view.post.removed {
  44       post_view.post = post_view.post.blank_out_deleted_or_removed_info();
  45     }
  46
  47     // Mark the post as read
  48     if let Some(person_id) = person_id {
  49       mark_post_as_read(person_id, id, context.pool()).await?;
  50     }
  51
  52     let id = data.id;
  53     let mut comments = blocking(context.pool(), move |conn| {
  54       CommentQueryBuilder::create(conn)
  55         .my_person_id(person_id)
  56         .show_bot_accounts(show_bot_accounts)
  57         .post_id(id)
  58         .limit(9999)
  59         .list()
  60     })
  61     .await??;
  62
  63     // Blank out deleted or removed info
  64     for cv in comments
  65       .iter_mut()
  66       .filter(|cv| cv.comment.deleted || cv.comment.removed)
  67     {
  68       cv.comment = cv.to_owned().comment.blank_out_deleted_or_removed_info();
  69     }
  70
  71     let community_id = post_view.community.id;
  72     let moderators = blocking(context.pool(), move |conn| {
  73       CommunityModeratorView::for_community(conn, community_id)
  74     })
  75     .await??;
  76
  77     // Necessary for the sidebar
  78     let mut community_view = blocking(context.pool(), move |conn| {
  79       CommunityView::read(conn, community_id, person_id)
  80     })
  81     .await?
  82     .map_err(|_| ApiError::err("couldnt_find_community"))?;
  83
  84     // Blank out deleted or removed info
  85     if community_view.community.deleted || community_view.community.removed {
  86       community_view.community = community_view.community.blank_out_deleted_or_removed_info();
  87     }
  88
  89     let online = context
  90       .chat_server()
  91       .send(GetPostUsersOnline { post_id: data.id })
  92       .await
  93       .unwrap_or(1);
  94
  95     // Return the jwt
  96     Ok(GetPostResponse {
  97       post_view,
  98       community_view,
  99       comments,
 100       moderators,
 101       online,
 102     })
 103   }
 104 }
 105
 106 #[async_trait::async_trait(?Send)]
 107 impl PerformCrud for GetPosts {
 108   type Response = GetPostsResponse;
 109
 110   async fn perform(
 111     &self,
 112     context: &Data<LemmyContext>,
 113     _websocket_id: Option<ConnectionId>,
 114   ) -> Result<GetPostsResponse, LemmyError> {
 115     let data: &GetPosts = self;
 116     let local_user_view =
 117       get_local_user_view_from_jwt_opt(&data.auth, context.pool(), context.secret()).await?;
 118
 119     let person_id = local_user_view.to_owned().map(|l| l.person.id);
 120
 121     let show_nsfw = local_user_view.as_ref().map(|t| t.local_user.show_nsfw);
 122     let show_bot_accounts = local_user_view
 123       .as_ref()
 124       .map(|t| t.local_user.show_bot_accounts);
 125     let show_read_posts = local_user_view
 126       .as_ref()
 127       .map(|t| t.local_user.show_read_posts);
 128
 129     let sort: Option<SortType> = from_opt_str_to_opt_enum(&data.sort);
 130     let listing_type: Option<ListingType> = from_opt_str_to_opt_enum(&data.type_);
 131
 132     let page = data.page;
 133     let limit = data.limit;
 134     let community_id = data.community_id;
 135     let community_actor_id = data
 136       .community_name
 137       .as_ref()
 138       .map(|t| build_actor_id_from_shortname(EndpointType::Community, t, &context.settings()).ok())
 139       .unwrap_or(None);
 140     let saved_only = data.saved_only;
 141
 142     let mut posts = blocking(context.pool(), move |conn| {
 143       PostQueryBuilder::create(conn)
 144         .listing_type(listing_type)
 145         .sort(sort)
 146         .show_nsfw(show_nsfw)
 147         .show_bot_accounts(show_bot_accounts)
 148         .show_read_posts(show_read_posts)
 149         .community_id(community_id)
 150         .community_actor_id(community_actor_id)
 151         .saved_only(saved_only)
 152         .my_person_id(person_id)
 153         .page(page)
 154         .limit(limit)
 155         .list()
 156     })
 157     .await?
 158     .map_err(|_| ApiError::err("couldnt_get_posts"))?;
 159
 160     // Blank out deleted or removed info
 161     for pv in posts
 162       .iter_mut()
 163       .filter(|p| p.post.deleted || p.post.removed)
 164     {
 165       pv.post = pv.to_owned().post.blank_out_deleted_or_removed_info();
 166     }
 167
 168     Ok(GetPostsResponse { posts })
 169   }
 170 }