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