crates/apub/src/api/search.rs

   1 use crate::{fetcher::resolve_actor_identifier, objects::community::ApubCommunity};
   2 use activitypub_federation::config::Data;
   3 use actix_web::web::{Json, Query};
   4 use lemmy_api_common::{
   5   context::LemmyContext,
   6   site::{Search, SearchResponse},
   7   utils::{check_private_instance, is_admin, local_user_view_from_jwt_opt},
   8 };
   9 use lemmy_db_schema::{
  10   source::{community::Community, local_site::LocalSite},
  11   utils::post_to_comment_sort_type,
  12   SearchType,
  13 };
  14 use lemmy_db_views::{comment_view::CommentQuery, post_view::PostQuery};
  15 use lemmy_db_views_actor::{community_view::CommunityQuery, person_view::PersonQuery};
  16 use lemmy_utils::error::LemmyError;
  17
  18 #[tracing::instrument(skip(context))]
  19 pub async fn search(
  20   data: Query<Search>,
  21   context: Data<LemmyContext>,
  22 ) -> Result<Json<SearchResponse>, LemmyError> {
  23   let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), &context).await;
  24   let local_site = LocalSite::read(&mut context.pool()).await?;
  25
  26   check_private_instance(&local_user_view, &local_site)?;
  27
  28   let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
  29
  30   let mut posts = Vec::new();
  31   let mut comments = Vec::new();
  32   let mut communities = Vec::new();
  33   let mut users = Vec::new();
  34
  35   // TODO no clean / non-nsfw searching rn
  36
  37   let q = data.q.clone();
  38   let page = data.page;
  39   let limit = data.limit;
  40   let sort = data.sort;
  41   let listing_type = data.listing_type;
  42   let search_type = data.type_.unwrap_or(SearchType::All);
  43   let community_id = if let Some(name) = &data.community_name {
  44     Some(
  45       resolve_actor_identifier::<ApubCommunity, Community>(name, &context, &local_user_view, false)
  46         .await?,
  47     )
  48     .map(|c| c.id)
  49   } else {
  50     data.community_id
  51   };
  52   let creator_id = data.creator_id;
  53   let local_user = local_user_view.map(|l| l.local_user);
  54   match search_type {
  55     SearchType::Posts => {
  56       posts = PostQuery::builder()
  57         .pool(&mut context.pool())
  58         .sort(sort)
  59         .listing_type(listing_type)
  60         .community_id(community_id)
  61         .creator_id(creator_id)
  62         .local_user(local_user.as_ref())
  63         .search_term(Some(q))
  64         .is_mod_or_admin(is_admin)
  65         .page(page)
  66         .limit(limit)
  67         .build()
  68         .list()
  69         .await?;
  70     }
  71     SearchType::Comments => {
  72       comments = CommentQuery::builder()
  73         .pool(&mut context.pool())
  74         .sort(sort.map(post_to_comment_sort_type))
  75         .listing_type(listing_type)
  76         .search_term(Some(q))
  77         .community_id(community_id)
  78         .creator_id(creator_id)
  79         .local_user(local_user.as_ref())
  80         .page(page)
  81         .limit(limit)
  82         .build()
  83         .list()
  84         .await?;
  85     }
  86     SearchType::Communities => {
  87       communities = CommunityQuery::builder()
  88         .pool(&mut context.pool())
  89         .sort(sort)
  90         .listing_type(listing_type)
  91         .search_term(Some(q))
  92         .local_user(local_user.as_ref())
  93         .is_mod_or_admin(is_admin)
  94         .page(page)
  95         .limit(limit)
  96         .build()
  97         .list()
  98         .await?;
  99     }
 100     SearchType::Users => {
 101       users = PersonQuery::builder()
 102         .pool(&mut context.pool())
 103         .sort(sort)
 104         .search_term(Some(q))
 105         .page(page)
 106         .limit(limit)
 107         .build()
 108         .list()
 109         .await?;
 110     }
 111     SearchType::All => {
 112       // If the community or creator is included, dont search communities or users
 113       let community_or_creator_included =
 114         data.community_id.is_some() || data.community_name.is_some() || data.creator_id.is_some();
 115
 116       let local_user_ = local_user.clone();
 117       posts = PostQuery::builder()
 118         .pool(&mut context.pool())
 119         .sort(sort)
 120         .listing_type(listing_type)
 121         .community_id(community_id)
 122         .creator_id(creator_id)
 123         .local_user(local_user_.as_ref())
 124         .search_term(Some(q))
 125         .is_mod_or_admin(is_admin)
 126         .page(page)
 127         .limit(limit)
 128         .build()
 129         .list()
 130         .await?;
 131
 132       let q = data.q.clone();
 133
 134       let local_user_ = local_user.clone();
 135       comments = CommentQuery::builder()
 136         .pool(&mut context.pool())
 137         .sort(sort.map(post_to_comment_sort_type))
 138         .listing_type(listing_type)
 139         .search_term(Some(q))
 140         .community_id(community_id)
 141         .creator_id(creator_id)
 142         .local_user(local_user_.as_ref())
 143         .page(page)
 144         .limit(limit)
 145         .build()
 146         .list()
 147         .await?;
 148
 149       let q = data.q.clone();
 150
 151       communities = if community_or_creator_included {
 152         vec![]
 153       } else {
 154         CommunityQuery::builder()
 155           .pool(&mut context.pool())
 156           .sort(sort)
 157           .listing_type(listing_type)
 158           .search_term(Some(q))
 159           .local_user(local_user.as_ref())
 160           .is_mod_or_admin(is_admin)
 161           .page(page)
 162           .limit(limit)
 163           .build()
 164           .list()
 165           .await?
 166       };
 167
 168       let q = data.q.clone();
 169
 170       users = if community_or_creator_included {
 171         vec![]
 172       } else {
 173         PersonQuery::builder()
 174           .pool(&mut context.pool())
 175           .sort(sort)
 176           .search_term(Some(q))
 177           .page(page)
 178           .limit(limit)
 179           .build()
 180           .list()
 181           .await?
 182       };
 183     }
 184     SearchType::Url => {
 185       posts = PostQuery::builder()
 186         .pool(&mut context.pool())
 187         .sort(sort)
 188         .listing_type(listing_type)
 189         .community_id(community_id)
 190         .creator_id(creator_id)
 191         .url_search(Some(q))
 192         .is_mod_or_admin(is_admin)
 193         .page(page)
 194         .limit(limit)
 195         .build()
 196         .list()
 197         .await?;
 198     }
 199   };
 200
 201   // Return the jwt
 202   Ok(Json(SearchResponse {
 203     type_: search_type,
 204     comments,
 205     posts,
 206     communities,
 207     users,
 208   }))
 209 }