crates/apub/src/api/search.rs

   1 use crate::{
   2   api::PerformApub,
   3   fetcher::resolve_actor_identifier,
   4   objects::community::ApubCommunity,
   5 };
   6 use actix_web::web::Data;
   7 use lemmy_api_common::{
   8   context::LemmyContext,
   9   site::{Search, SearchResponse},
  10   utils::{check_private_instance, get_local_user_view_from_jwt_opt},
  11 };
  12 use lemmy_db_schema::{
  13   source::{community::Community, local_site::LocalSite},
  14   traits::DeleteableOrRemoveable,
  15   utils::post_to_comment_sort_type,
  16   SearchType,
  17 };
  18 use lemmy_db_views::{comment_view::CommentQuery, post_view::PostQuery};
  19 use lemmy_db_views_actor::{community_view::CommunityQuery, person_view::PersonQuery};
  20 use lemmy_utils::{error::LemmyError, ConnectionId};
  21
  22 #[async_trait::async_trait(?Send)]
  23 impl PerformApub for Search {
  24   type Response = SearchResponse;
  25
  26   #[tracing::instrument(skip(context, _websocket_id))]
  27   async fn perform(
  28     &self,
  29     context: &Data<LemmyContext>,
  30     _websocket_id: Option<ConnectionId>,
  31   ) -> Result<SearchResponse, LemmyError> {
  32     let data: &Search = self;
  33
  34     let local_user_view =
  35       get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret())
  36         .await?;
  37     let local_site = LocalSite::read(context.pool()).await?;
  38
  39     check_private_instance(&local_user_view, &local_site)?;
  40
  41     let person_id = local_user_view.as_ref().map(|u| u.person.id);
  42     let local_user = local_user_view.map(|l| l.local_user);
  43
  44     let mut posts = Vec::new();
  45     let mut comments = Vec::new();
  46     let mut communities = Vec::new();
  47     let mut users = Vec::new();
  48
  49     // TODO no clean / non-nsfw searching rn
  50
  51     let q = data.q.clone();
  52     let page = data.page;
  53     let limit = data.limit;
  54     let sort = data.sort;
  55     let listing_type = data.listing_type;
  56     let search_type = data.type_.unwrap_or(SearchType::All);
  57     let community_id = data.community_id;
  58     let community_actor_id = if let Some(name) = &data.community_name {
  59       resolve_actor_identifier::<ApubCommunity, Community>(name, context, false)
  60         .await
  61         .ok()
  62         .map(|c| c.actor_id)
  63     } else {
  64       None
  65     };
  66     let creator_id = data.creator_id;
  67     match search_type {
  68       SearchType::Posts => {
  69         posts = PostQuery::builder()
  70           .pool(context.pool())
  71           .sort(sort)
  72           .listing_type(listing_type)
  73           .community_id(community_id)
  74           .community_actor_id(community_actor_id)
  75           .creator_id(creator_id)
  76           .local_user(local_user.as_ref())
  77           .search_term(Some(q))
  78           .page(page)
  79           .limit(limit)
  80           .build()
  81           .list()
  82           .await?;
  83       }
  84       SearchType::Comments => {
  85         comments = CommentQuery::builder()
  86           .pool(context.pool())
  87           .sort(sort.map(post_to_comment_sort_type))
  88           .listing_type(listing_type)
  89           .search_term(Some(q))
  90           .community_id(community_id)
  91           .community_actor_id(community_actor_id)
  92           .creator_id(creator_id)
  93           .local_user(local_user.as_ref())
  94           .page(page)
  95           .limit(limit)
  96           .build()
  97           .list()
  98           .await?;
  99       }
 100       SearchType::Communities => {
 101         communities = CommunityQuery::builder()
 102           .pool(context.pool())
 103           .sort(sort)
 104           .listing_type(listing_type)
 105           .search_term(Some(q))
 106           .local_user(local_user.as_ref())
 107           .page(page)
 108           .limit(limit)
 109           .build()
 110           .list()
 111           .await?;
 112       }
 113       SearchType::Users => {
 114         users = PersonQuery::builder()
 115           .pool(context.pool())
 116           .sort(sort)
 117           .search_term(Some(q))
 118           .page(page)
 119           .limit(limit)
 120           .build()
 121           .list()
 122           .await?;
 123       }
 124       SearchType::All => {
 125         // If the community or creator is included, dont search communities or users
 126         let community_or_creator_included =
 127           data.community_id.is_some() || data.community_name.is_some() || data.creator_id.is_some();
 128         let community_actor_id_2 = community_actor_id.clone();
 129
 130         let local_user_ = local_user.clone();
 131         posts = PostQuery::builder()
 132           .pool(context.pool())
 133           .sort(sort)
 134           .listing_type(listing_type)
 135           .community_id(community_id)
 136           .community_actor_id(community_actor_id_2)
 137           .creator_id(creator_id)
 138           .local_user(local_user_.as_ref())
 139           .search_term(Some(q))
 140           .page(page)
 141           .limit(limit)
 142           .build()
 143           .list()
 144           .await?;
 145
 146         let q = data.q.clone();
 147         let community_actor_id = community_actor_id.clone();
 148
 149         let local_user_ = local_user.clone();
 150         comments = CommentQuery::builder()
 151           .pool(context.pool())
 152           .sort(sort.map(post_to_comment_sort_type))
 153           .listing_type(listing_type)
 154           .search_term(Some(q))
 155           .community_id(community_id)
 156           .community_actor_id(community_actor_id)
 157           .creator_id(creator_id)
 158           .local_user(local_user_.as_ref())
 159           .page(page)
 160           .limit(limit)
 161           .build()
 162           .list()
 163           .await?;
 164
 165         let q = data.q.clone();
 166
 167         communities = if community_or_creator_included {
 168           vec![]
 169         } else {
 170           CommunityQuery::builder()
 171             .pool(context.pool())
 172             .sort(sort)
 173             .listing_type(listing_type)
 174             .search_term(Some(q))
 175             .local_user(local_user.as_ref())
 176             .page(page)
 177             .limit(limit)
 178             .build()
 179             .list()
 180             .await?
 181         };
 182
 183         let q = data.q.clone();
 184
 185         users = if community_or_creator_included {
 186           vec![]
 187         } else {
 188           PersonQuery::builder()
 189             .pool(context.pool())
 190             .sort(sort)
 191             .search_term(Some(q))
 192             .page(page)
 193             .limit(limit)
 194             .build()
 195             .list()
 196             .await?
 197         };
 198       }
 199       SearchType::Url => {
 200         posts = PostQuery::builder()
 201           .pool(context.pool())
 202           .sort(sort)
 203           .listing_type(listing_type)
 204           .community_id(community_id)
 205           .community_actor_id(community_actor_id)
 206           .creator_id(creator_id)
 207           .url_search(Some(q))
 208           .page(page)
 209           .limit(limit)
 210           .build()
 211           .list()
 212           .await?;
 213       }
 214     };
 215
 216     // Blank out deleted or removed info for non logged in users
 217     if person_id.is_none() {
 218       for cv in communities
 219         .iter_mut()
 220         .filter(|cv| cv.community.deleted || cv.community.removed)
 221       {
 222         cv.community = cv.clone().community.blank_out_deleted_or_removed_info();
 223       }
 224
 225       for pv in posts
 226         .iter_mut()
 227         .filter(|p| p.post.deleted || p.post.removed)
 228       {
 229         pv.post = pv.clone().post.blank_out_deleted_or_removed_info();
 230       }
 231
 232       for cv in comments
 233         .iter_mut()
 234         .filter(|cv| cv.comment.deleted || cv.comment.removed)
 235       {
 236         cv.comment = cv.clone().comment.blank_out_deleted_or_removed_info();
 237       }
 238     }
 239
 240     // Return the jwt
 241     Ok(SearchResponse {
 242       type_: search_type.to_string(),
 243       comments,
 244       posts,
 245       communities,
 246       users,
 247     })
 248   }
 249 }