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             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).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(LemmyError::from)
 104       .map_err(|e| e.with_message("system_err_login"))?;
 105
 106       let person_id = local_user_view.person.id;
 107       let community_blocks = blocking(context.pool(), move |conn| {
 108         CommunityBlockView::for_person(conn, person_id)
 109       })
 110       .await?
 111       .map_err(LemmyError::from)
 112       .map_err(|e| e.with_message("system_err_login"))?;
 113
 114       let person_id = local_user_view.person.id;
 115       let person_blocks = blocking(context.pool(), move |conn| {
 116         PersonBlockView::for_person(conn, person_id)
 117       })
 118       .await?
 119       .map_err(LemmyError::from)
 120       .map_err(|e| e.with_message("system_err_login"))?;
 121
 122       let moderates = blocking(context.pool(), move |conn| {
 123         CommunityModeratorView::for_person(conn, person_id)
 124       })
 125       .await?
 126       .map_err(LemmyError::from)
 127       .map_err(|e| e.with_message("system_err_login"))?;
 128
 129       Some(MyUserInfo {
 130         local_user_view,
 131         follows,
 132         moderates,
 133         community_blocks,
 134         person_blocks,
 135       })
 136     } else {
 137       None
 138     };
 139
 140     let federated_instances = build_federated_instances(
 141       context.pool(),
 142       &context.settings().federation,
 143       &context.settings().hostname,
 144     )
 145     .await?;
 146
 147     Ok(GetSiteResponse {
 148       site_view,
 149       admins,
 150       online,
 151       version: version::VERSION.to_string(),
 152       my_user,
 153       federated_instances,
 154     })
 155   }
 156 }