crates/api_crud/src/site/read.rs

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