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