]> Untitled Git - lemmy.git/blob - crates/api/src/site.rs
Merge pull request #1850 from LemmyNet/refactor-apub
[lemmy.git] / crates / api / src / site.rs
1 use crate::Perform;
2 use actix_web::web::Data;
3 use anyhow::Context;
4 use diesel::NotFound;
5 use lemmy_api_common::{
6   blocking,
7   build_federated_instances,
8   get_local_user_view_from_jwt,
9   get_local_user_view_from_jwt_opt,
10   is_admin,
11   site::*,
12 };
13 use lemmy_apub::{
14   build_actor_id_from_shortname,
15   fetcher::search::{search_by_apub_id, SearchableObjects},
16   EndpointType,
17 };
18 use lemmy_db_schema::{
19   from_opt_str_to_opt_enum,
20   newtypes::PersonId,
21   source::{moderator::*, site::Site},
22   traits::{Crud, DeleteableOrRemoveable},
23   DbPool,
24   ListingType,
25   SearchType,
26   SortType,
27 };
28 use lemmy_db_views::{
29   comment_view::{CommentQueryBuilder, CommentView},
30   post_view::{PostQueryBuilder, PostView},
31   site_view::SiteView,
32 };
33 use lemmy_db_views_actor::{
34   community_view::{CommunityQueryBuilder, CommunityView},
35   person_view::{PersonQueryBuilder, PersonViewSafe},
36 };
37 use lemmy_db_views_moderator::{
38   mod_add_community_view::ModAddCommunityView,
39   mod_add_view::ModAddView,
40   mod_ban_from_community_view::ModBanFromCommunityView,
41   mod_ban_view::ModBanView,
42   mod_lock_post_view::ModLockPostView,
43   mod_remove_comment_view::ModRemoveCommentView,
44   mod_remove_community_view::ModRemoveCommunityView,
45   mod_remove_post_view::ModRemovePostView,
46   mod_sticky_post_view::ModStickyPostView,
47   mod_transfer_community_view::ModTransferCommunityView,
48 };
49 use lemmy_utils::{
50   location_info,
51   settings::structs::Settings,
52   version,
53   ApiError,
54   ConnectionId,
55   LemmyError,
56 };
57 use lemmy_websocket::LemmyContext;
58
59 #[async_trait::async_trait(?Send)]
60 impl Perform for GetModlog {
61   type Response = GetModlogResponse;
62
63   async fn perform(
64     &self,
65     context: &Data<LemmyContext>,
66     _websocket_id: Option<ConnectionId>,
67   ) -> Result<GetModlogResponse, LemmyError> {
68     let data: &GetModlog = self;
69
70     let community_id = data.community_id;
71     let mod_person_id = data.mod_person_id;
72     let page = data.page;
73     let limit = data.limit;
74     let removed_posts = blocking(context.pool(), move |conn| {
75       ModRemovePostView::list(conn, community_id, mod_person_id, page, limit)
76     })
77     .await??;
78
79     let locked_posts = blocking(context.pool(), move |conn| {
80       ModLockPostView::list(conn, community_id, mod_person_id, page, limit)
81     })
82     .await??;
83
84     let stickied_posts = blocking(context.pool(), move |conn| {
85       ModStickyPostView::list(conn, community_id, mod_person_id, page, limit)
86     })
87     .await??;
88
89     let removed_comments = blocking(context.pool(), move |conn| {
90       ModRemoveCommentView::list(conn, community_id, mod_person_id, page, limit)
91     })
92     .await??;
93
94     let banned_from_community = blocking(context.pool(), move |conn| {
95       ModBanFromCommunityView::list(conn, community_id, mod_person_id, page, limit)
96     })
97     .await??;
98
99     let added_to_community = blocking(context.pool(), move |conn| {
100       ModAddCommunityView::list(conn, community_id, mod_person_id, page, limit)
101     })
102     .await??;
103
104     let transferred_to_community = blocking(context.pool(), move |conn| {
105       ModTransferCommunityView::list(conn, community_id, mod_person_id, page, limit)
106     })
107     .await??;
108
109     // These arrays are only for the full modlog, when a community isn't given
110     let (removed_communities, banned, added) = if data.community_id.is_none() {
111       blocking(context.pool(), move |conn| {
112         Ok((
113           ModRemoveCommunityView::list(conn, mod_person_id, page, limit)?,
114           ModBanView::list(conn, mod_person_id, page, limit)?,
115           ModAddView::list(conn, mod_person_id, page, limit)?,
116         )) as Result<_, LemmyError>
117       })
118       .await??
119     } else {
120       (Vec::new(), Vec::new(), Vec::new())
121     };
122
123     // Return the jwt
124     Ok(GetModlogResponse {
125       removed_posts,
126       locked_posts,
127       stickied_posts,
128       removed_comments,
129       removed_communities,
130       banned_from_community,
131       banned,
132       added_to_community,
133       added,
134       transferred_to_community,
135     })
136   }
137 }
138
139 #[async_trait::async_trait(?Send)]
140 impl Perform for Search {
141   type Response = SearchResponse;
142
143   async fn perform(
144     &self,
145     context: &Data<LemmyContext>,
146     _websocket_id: Option<ConnectionId>,
147   ) -> Result<SearchResponse, LemmyError> {
148     let data: &Search = self;
149
150     let local_user_view =
151       get_local_user_view_from_jwt_opt(&data.auth, context.pool(), context.secret()).await?;
152
153     let show_nsfw = local_user_view.as_ref().map(|t| t.local_user.show_nsfw);
154     let show_bot_accounts = local_user_view
155       .as_ref()
156       .map(|t| t.local_user.show_bot_accounts);
157     let show_read_posts = local_user_view
158       .as_ref()
159       .map(|t| t.local_user.show_read_posts);
160
161     let person_id = local_user_view.map(|u| u.person.id);
162
163     let mut posts = Vec::new();
164     let mut comments = Vec::new();
165     let mut communities = Vec::new();
166     let mut users = Vec::new();
167
168     // TODO no clean / non-nsfw searching rn
169
170     let q = data.q.to_owned();
171     let page = data.page;
172     let limit = data.limit;
173     let sort: Option<SortType> = from_opt_str_to_opt_enum(&data.sort);
174     let listing_type: Option<ListingType> = from_opt_str_to_opt_enum(&data.listing_type);
175     let search_type: SearchType = from_opt_str_to_opt_enum(&data.type_).unwrap_or(SearchType::All);
176     let community_id = data.community_id;
177     let community_actor_id = data
178       .community_name
179       .as_ref()
180       .map(|t| build_actor_id_from_shortname(EndpointType::Community, t, &context.settings()).ok())
181       .unwrap_or(None);
182     let creator_id = data.creator_id;
183     match search_type {
184       SearchType::Posts => {
185         posts = blocking(context.pool(), move |conn| {
186           PostQueryBuilder::create(conn)
187             .sort(sort)
188             .show_nsfw(show_nsfw)
189             .show_bot_accounts(show_bot_accounts)
190             .show_read_posts(show_read_posts)
191             .listing_type(listing_type)
192             .community_id(community_id)
193             .community_actor_id(community_actor_id)
194             .creator_id(creator_id)
195             .my_person_id(person_id)
196             .search_term(q)
197             .page(page)
198             .limit(limit)
199             .list()
200         })
201         .await??;
202       }
203       SearchType::Comments => {
204         comments = blocking(context.pool(), move |conn| {
205           CommentQueryBuilder::create(conn)
206             .sort(sort)
207             .listing_type(listing_type)
208             .search_term(q)
209             .show_bot_accounts(show_bot_accounts)
210             .community_id(community_id)
211             .community_actor_id(community_actor_id)
212             .creator_id(creator_id)
213             .my_person_id(person_id)
214             .page(page)
215             .limit(limit)
216             .list()
217         })
218         .await??;
219       }
220       SearchType::Communities => {
221         communities = blocking(context.pool(), move |conn| {
222           CommunityQueryBuilder::create(conn)
223             .sort(sort)
224             .listing_type(listing_type)
225             .search_term(q)
226             .my_person_id(person_id)
227             .page(page)
228             .limit(limit)
229             .list()
230         })
231         .await??;
232       }
233       SearchType::Users => {
234         users = blocking(context.pool(), move |conn| {
235           PersonQueryBuilder::create(conn)
236             .sort(sort)
237             .search_term(q)
238             .page(page)
239             .limit(limit)
240             .list()
241         })
242         .await??;
243       }
244       SearchType::All => {
245         // If the community or creator is included, dont search communities or users
246         let community_or_creator_included =
247           data.community_id.is_some() || data.community_name.is_some() || data.creator_id.is_some();
248         let community_actor_id_2 = community_actor_id.to_owned();
249
250         posts = blocking(context.pool(), move |conn| {
251           PostQueryBuilder::create(conn)
252             .sort(sort)
253             .show_nsfw(show_nsfw)
254             .show_bot_accounts(show_bot_accounts)
255             .show_read_posts(show_read_posts)
256             .listing_type(listing_type)
257             .community_id(community_id)
258             .community_actor_id(community_actor_id_2)
259             .creator_id(creator_id)
260             .my_person_id(person_id)
261             .search_term(q)
262             .page(page)
263             .limit(limit)
264             .list()
265         })
266         .await??;
267
268         let q = data.q.to_owned();
269         let community_actor_id = community_actor_id.to_owned();
270
271         comments = blocking(context.pool(), move |conn| {
272           CommentQueryBuilder::create(conn)
273             .sort(sort)
274             .listing_type(listing_type)
275             .search_term(q)
276             .show_bot_accounts(show_bot_accounts)
277             .community_id(community_id)
278             .community_actor_id(community_actor_id)
279             .creator_id(creator_id)
280             .my_person_id(person_id)
281             .page(page)
282             .limit(limit)
283             .list()
284         })
285         .await??;
286
287         let q = data.q.to_owned();
288
289         communities = if community_or_creator_included {
290           vec![]
291         } else {
292           blocking(context.pool(), move |conn| {
293             CommunityQueryBuilder::create(conn)
294               .sort(sort)
295               .listing_type(listing_type)
296               .search_term(q)
297               .my_person_id(person_id)
298               .page(page)
299               .limit(limit)
300               .list()
301           })
302           .await??
303         };
304
305         let q = data.q.to_owned();
306
307         users = if community_or_creator_included {
308           vec![]
309         } else {
310           blocking(context.pool(), move |conn| {
311             PersonQueryBuilder::create(conn)
312               .sort(sort)
313               .search_term(q)
314               .page(page)
315               .limit(limit)
316               .list()
317           })
318           .await??
319         };
320       }
321       SearchType::Url => {
322         posts = blocking(context.pool(), move |conn| {
323           PostQueryBuilder::create(conn)
324             .sort(sort)
325             .show_nsfw(show_nsfw)
326             .show_bot_accounts(show_bot_accounts)
327             .show_read_posts(show_read_posts)
328             .listing_type(listing_type)
329             .my_person_id(person_id)
330             .community_id(community_id)
331             .community_actor_id(community_actor_id)
332             .creator_id(creator_id)
333             .url_search(q)
334             .page(page)
335             .limit(limit)
336             .list()
337         })
338         .await??;
339       }
340     };
341
342     // Blank out deleted or removed info
343     for cv in comments
344       .iter_mut()
345       .filter(|cv| cv.comment.deleted || cv.comment.removed)
346     {
347       cv.comment = cv.to_owned().comment.blank_out_deleted_or_removed_info();
348     }
349
350     for cv in communities
351       .iter_mut()
352       .filter(|cv| cv.community.deleted || cv.community.removed)
353     {
354       cv.community = cv.to_owned().community.blank_out_deleted_or_removed_info();
355     }
356
357     for pv in posts
358       .iter_mut()
359       .filter(|p| p.post.deleted || p.post.removed)
360     {
361       pv.post = pv.to_owned().post.blank_out_deleted_or_removed_info();
362     }
363
364     // Return the jwt
365     Ok(SearchResponse {
366       type_: search_type.to_string(),
367       comments,
368       posts,
369       communities,
370       users,
371     })
372   }
373 }
374
375 #[async_trait::async_trait(?Send)]
376 impl Perform for ResolveObject {
377   type Response = ResolveObjectResponse;
378
379   async fn perform(
380     &self,
381     context: &Data<LemmyContext>,
382     _websocket_id: Option<ConnectionId>,
383   ) -> Result<ResolveObjectResponse, LemmyError> {
384     let local_user_view =
385       get_local_user_view_from_jwt_opt(&self.auth, context.pool(), context.secret()).await?;
386     let res = search_by_apub_id(&self.q, context)
387       .await
388       .map_err(|e| ApiError::err("couldnt_find_object", e))?;
389     convert_response(res, local_user_view.map(|l| l.person.id), context.pool())
390       .await
391       .map_err(|e| ApiError::err("couldnt_find_object", e).into())
392   }
393 }
394
395 async fn convert_response(
396   object: SearchableObjects,
397   user_id: Option<PersonId>,
398   pool: &DbPool,
399 ) -> Result<ResolveObjectResponse, LemmyError> {
400   let removed_or_deleted;
401   let mut res = ResolveObjectResponse {
402     comment: None,
403     post: None,
404     community: None,
405     person: None,
406   };
407   use SearchableObjects::*;
408   match object {
409     Person(p) => {
410       removed_or_deleted = p.deleted;
411       res.person = Some(blocking(pool, move |conn| PersonViewSafe::read(conn, p.id)).await??)
412     }
413     Community(c) => {
414       removed_or_deleted = c.deleted || c.removed;
415       res.community =
416         Some(blocking(pool, move |conn| CommunityView::read(conn, c.id, user_id)).await??)
417     }
418     Post(p) => {
419       removed_or_deleted = p.deleted || p.removed;
420       res.post = Some(blocking(pool, move |conn| PostView::read(conn, p.id, user_id)).await??)
421     }
422     Comment(c) => {
423       removed_or_deleted = c.deleted || c.removed;
424       res.comment = Some(blocking(pool, move |conn| CommentView::read(conn, c.id, user_id)).await??)
425     }
426   };
427   // if the object was deleted from database, dont return it
428   if removed_or_deleted {
429     return Err(NotFound {}.into());
430   }
431   Ok(res)
432 }
433
434 #[async_trait::async_trait(?Send)]
435 impl Perform for TransferSite {
436   type Response = GetSiteResponse;
437
438   async fn perform(
439     &self,
440     context: &Data<LemmyContext>,
441     _websocket_id: Option<ConnectionId>,
442   ) -> Result<GetSiteResponse, LemmyError> {
443     let data: &TransferSite = self;
444     let local_user_view =
445       get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
446
447     is_admin(&local_user_view)?;
448
449     let read_site = blocking(context.pool(), Site::read_simple).await??;
450
451     // Make sure user is the creator
452     if read_site.creator_id != local_user_view.person.id {
453       return Err(ApiError::err_plain("not_an_admin").into());
454     }
455
456     let new_creator_id = data.person_id;
457     let transfer_site = move |conn: &'_ _| Site::transfer(conn, new_creator_id);
458     blocking(context.pool(), transfer_site)
459       .await?
460       .map_err(|e| ApiError::err("couldnt_update_site", e))?;
461
462     // Mod tables
463     let form = ModAddForm {
464       mod_person_id: local_user_view.person.id,
465       other_person_id: data.person_id,
466       removed: Some(false),
467     };
468
469     blocking(context.pool(), move |conn| ModAdd::create(conn, &form)).await??;
470
471     let site_view = blocking(context.pool(), SiteView::read).await??;
472
473     let mut admins = blocking(context.pool(), PersonViewSafe::admins).await??;
474     let creator_index = admins
475       .iter()
476       .position(|r| r.person.id == site_view.creator.id)
477       .context(location_info!())?;
478     let creator_person = admins.remove(creator_index);
479     admins.insert(0, creator_person);
480
481     let banned = blocking(context.pool(), PersonViewSafe::banned).await??;
482     let federated_instances = build_federated_instances(
483       context.pool(),
484       &context.settings().federation,
485       &context.settings().hostname,
486     )
487     .await?;
488
489     Ok(GetSiteResponse {
490       site_view: Some(site_view),
491       admins,
492       banned,
493       online: 0,
494       version: version::VERSION.to_string(),
495       my_user: None,
496       federated_instances,
497     })
498   }
499 }
500
501 #[async_trait::async_trait(?Send)]
502 impl Perform for GetSiteConfig {
503   type Response = GetSiteConfigResponse;
504
505   async fn perform(
506     &self,
507     context: &Data<LemmyContext>,
508     _websocket_id: Option<ConnectionId>,
509   ) -> Result<GetSiteConfigResponse, LemmyError> {
510     let data: &GetSiteConfig = self;
511     let local_user_view =
512       get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
513
514     // Only let admins read this
515     is_admin(&local_user_view)?;
516
517     let config_hjson = Settings::read_config_file()?;
518
519     Ok(GetSiteConfigResponse { config_hjson })
520   }
521 }
522
523 #[async_trait::async_trait(?Send)]
524 impl Perform for SaveSiteConfig {
525   type Response = GetSiteConfigResponse;
526
527   async fn perform(
528     &self,
529     context: &Data<LemmyContext>,
530     _websocket_id: Option<ConnectionId>,
531   ) -> Result<GetSiteConfigResponse, LemmyError> {
532     let data: &SaveSiteConfig = self;
533     let local_user_view =
534       get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
535
536     // Only let admins read this
537     is_admin(&local_user_view)?;
538
539     // Make sure docker doesn't have :ro at the end of the volume, so its not a read-only filesystem
540     let config_hjson = Settings::save_config_file(&data.config_hjson)
541       .map_err(|e| ApiError::err("couldnt_update_site", e))?;
542
543     Ok(GetSiteConfigResponse { config_hjson })
544   }
545 }