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