crates/api_crud/src/site/read.rs

   1 use crate::PerformCrud;
   2 use actix_web::web::Data;
   3 use lemmy_api_common::{
   4   person::Register,
   5   site::{CreateSite, GetSite, GetSiteResponse, MyUserInfo},
   6   utils::{blocking, build_federated_instances, get_local_user_settings_view_from_jwt_opt},
   7 };
   8 use lemmy_db_views::structs::SiteView;
   9 use lemmy_db_views_actor::structs::{
  10   CommunityBlockView,
  11   CommunityFollowerView,
  12   CommunityModeratorView,
  13   PersonBlockView,
  14   PersonViewSafe,
  15 };
  16 use lemmy_utils::{error::LemmyError, version, ConnectionId};
  17 use lemmy_websocket::{messages::GetUsersOnline, LemmyContext};
  18 use tracing::info;
  19
  20 #[async_trait::async_trait(?Send)]
  21 impl PerformCrud for GetSite {
  22   type Response = GetSiteResponse;
  23
  24   #[tracing::instrument(skip(context, websocket_id))]
  25   async fn perform(
  26     &self,
  27     context: &Data<LemmyContext>,
  28     websocket_id: Option<ConnectionId>,
  29   ) -> Result<GetSiteResponse, LemmyError> {
  30     let data: &GetSite = self;
  31
  32     let site_view = match blocking(context.pool(), SiteView::read_local).await? {
  33       Ok(site_view) => Some(site_view),
  34       // If the site isn't created yet, check the setup
  35       Err(_) => {
  36         if let Some(setup) = context.settings().setup.as_ref() {
  37           let register = Register {
  38             username: setup.admin_username.to_owned(),
  39             email: setup.admin_email.clone().map(|s| s.into()),
  40             password: setup.admin_password.clone().into(),
  41             password_verify: setup.admin_password.clone().into(),
  42             show_nsfw: true,
  43             captcha_uuid: None,
  44             captcha_answer: None,
  45             honeypot: None,
  46             answer: None,
  47           };
  48           let admin_jwt = register
  49             .perform(context, websocket_id)
  50             .await?
  51             .jwt
  52             .expect("jwt is returned from registration on newly created site");
  53           info!("Admin {} created", setup.admin_username);
  54
  55           let create_site = CreateSite {
  56             name: setup.site_name.to_owned(),
  57             sidebar: setup.sidebar.to_owned(),
  58             description: setup.description.to_owned(),
  59             icon: setup.icon.to_owned(),
  60             banner: setup.banner.to_owned(),
  61             enable_downvotes: setup.enable_downvotes,
  62             open_registration: setup.open_registration,
  63             enable_nsfw: setup.enable_nsfw,
  64             community_creation_admin_only: setup.community_creation_admin_only,
  65             require_email_verification: setup.require_email_verification,
  66             require_application: setup.require_application,
  67             application_question: setup.application_question.to_owned(),
  68             private_instance: setup.private_instance,
  69             default_theme: setup.default_theme.to_owned(),
  70             default_post_listing_type: setup.default_post_listing_type.to_owned(),
  71             auth: admin_jwt,
  72           };
  73           create_site.perform(context, websocket_id).await?;
  74           info!("Site {} created", setup.site_name);
  75           Some(blocking(context.pool(), SiteView::read_local).await??)
  76         } else {
  77           None
  78         }
  79       }
  80     };
  81
  82     let admins = blocking(context.pool(), PersonViewSafe::admins).await??;
  83
  84     let online = context
  85       .chat_server()
  86       .send(GetUsersOnline)
  87       .await
  88       .unwrap_or(1);
  89
  90     // Build the local user
  91     let my_user = if let Some(local_user_view) = get_local_user_settings_view_from_jwt_opt(
  92       data.auth.as_ref(),
  93       context.pool(),
  94       context.secret(),
  95     )
  96     .await?
  97     {
  98       let person_id = local_user_view.person.id;
  99       let follows = blocking(context.pool(), move |conn| {
 100         CommunityFollowerView::for_person(conn, person_id)
 101       })
 102       .await?
 103       .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
 104
 105       let person_id = local_user_view.person.id;
 106       let community_blocks = blocking(context.pool(), move |conn| {
 107         CommunityBlockView::for_person(conn, person_id)
 108       })
 109       .await?
 110       .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
 111
 112       let person_id = local_user_view.person.id;
 113       let person_blocks = blocking(context.pool(), move |conn| {
 114         PersonBlockView::for_person(conn, person_id)
 115       })
 116       .await?
 117       .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
 118
 119       let moderates = blocking(context.pool(), move |conn| {
 120         CommunityModeratorView::for_person(conn, person_id)
 121       })
 122       .await?
 123       .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
 124
 125       Some(MyUserInfo {
 126         local_user_view,
 127         follows,
 128         moderates,
 129         community_blocks,
 130         person_blocks,
 131       })
 132     } else {
 133       None
 134     };
 135
 136     let federated_instances =
 137       build_federated_instances(context.pool(), &context.settings()).await?;
 138
 139     Ok(GetSiteResponse {
 140       site_view,
 141       admins,
 142       online,
 143       version: version::VERSION.to_string(),
 144       my_user,
 145       federated_instances,
 146     })
 147   }
 148 }