crates/apub/src/objects/user.rs

   1 use crate::{
   2   extensions::context::lemmy_context,
   3   objects::{
   4     check_object_domain,
   5     get_source_markdown_value,
   6     set_content_and_source,
   7     FromApub,
   8     FromApubToForm,
   9     ToApub,
  10   },
  11   ActorType,
  12   PersonExt,
  13 };
  14 use activitystreams::{
  15   actor::{ApActor, Endpoints, Person},
  16   object::{ApObject, Image, Tombstone},
  17   prelude::*,
  18 };
  19 use activitystreams_ext::Ext1;
  20 use anyhow::Context;
  21 use lemmy_api_structs::blocking;
  22 use lemmy_db_queries::{ApubObject, DbPool};
  23 use lemmy_db_schema::{
  24   naive_now,
  25   source::user::{UserForm, User_},
  26 };
  27 use lemmy_utils::{
  28   location_info,
  29   settings::structs::Settings,
  30   utils::{check_slurs, check_slurs_opt, convert_datetime},
  31   LemmyError,
  32 };
  33 use lemmy_websocket::LemmyContext;
  34 use url::Url;
  35
  36 #[async_trait::async_trait(?Send)]
  37 impl ToApub for User_ {
  38   type ApubType = PersonExt;
  39
  40   async fn to_apub(&self, _pool: &DbPool) -> Result<PersonExt, LemmyError> {
  41     let mut person = ApObject::new(Person::new());
  42     person
  43       .set_many_contexts(lemmy_context()?)
  44       .set_id(self.actor_id.to_owned().into_inner())
  45       .set_published(convert_datetime(self.published));
  46
  47     if let Some(u) = self.updated {
  48       person.set_updated(convert_datetime(u));
  49     }
  50
  51     if let Some(avatar_url) = &self.avatar {
  52       let mut image = Image::new();
  53       image.set_url::<Url>(avatar_url.to_owned().into());
  54       person.set_icon(image.into_any_base()?);
  55     }
  56
  57     if let Some(banner_url) = &self.banner {
  58       let mut image = Image::new();
  59       image.set_url::<Url>(banner_url.to_owned().into());
  60       person.set_image(image.into_any_base()?);
  61     }
  62
  63     if let Some(bio) = &self.bio {
  64       set_content_and_source(&mut person, bio)?;
  65     }
  66
  67     if let Some(i) = self.preferred_username.to_owned() {
  68       person.set_name(i);
  69     }
  70
  71     let mut ap_actor = ApActor::new(self.inbox_url.clone().into(), person);
  72     ap_actor
  73       .set_preferred_username(self.name.to_owned())
  74       .set_outbox(self.get_outbox_url()?)
  75       .set_endpoints(Endpoints {
  76         shared_inbox: Some(self.get_shared_inbox_or_inbox_url()),
  77         ..Default::default()
  78       });
  79
  80     Ok(Ext1::new(ap_actor, self.get_public_key_ext()?))
  81   }
  82   fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
  83     unimplemented!()
  84   }
  85 }
  86
  87 #[async_trait::async_trait(?Send)]
  88 impl FromApub for User_ {
  89   type ApubType = PersonExt;
  90
  91   async fn from_apub(
  92     person: &PersonExt,
  93     context: &LemmyContext,
  94     expected_domain: Url,
  95     request_counter: &mut i32,
  96   ) -> Result<User_, LemmyError> {
  97     let user_id = person.id_unchecked().context(location_info!())?.to_owned();
  98     let domain = user_id.domain().context(location_info!())?;
  99     if domain == Settings::get().hostname() {
 100       let user = blocking(context.pool(), move |conn| {
 101         User_::read_from_apub_id(conn, &user_id.into())
 102       })
 103       .await??;
 104       Ok(user)
 105     } else {
 106       let user_form =
 107         UserForm::from_apub(person, context, expected_domain, request_counter).await?;
 108       let user = blocking(context.pool(), move |conn| User_::upsert(conn, &user_form)).await??;
 109       Ok(user)
 110     }
 111   }
 112 }
 113
 114 #[async_trait::async_trait(?Send)]
 115 impl FromApubToForm<PersonExt> for UserForm {
 116   async fn from_apub(
 117     person: &PersonExt,
 118     _context: &LemmyContext,
 119     expected_domain: Url,
 120     _request_counter: &mut i32,
 121   ) -> Result<Self, LemmyError> {
 122     let avatar = match person.icon() {
 123       Some(any_image) => Some(
 124         Image::from_any_base(any_image.as_one().context(location_info!())?.clone())?
 125           .context(location_info!())?
 126           .url()
 127           .context(location_info!())?
 128           .as_single_xsd_any_uri()
 129           .map(|url| url.to_owned()),
 130       ),
 131       None => None,
 132     };
 133
 134     let banner = match person.image() {
 135       Some(any_image) => Some(
 136         Image::from_any_base(any_image.as_one().context(location_info!())?.clone())
 137           .context(location_info!())?
 138           .context(location_info!())?
 139           .url()
 140           .context(location_info!())?
 141           .as_single_xsd_any_uri()
 142           .map(|url| url.to_owned()),
 143       ),
 144       None => None,
 145     };
 146
 147     let name: String = person
 148       .inner
 149       .preferred_username()
 150       .context(location_info!())?
 151       .to_string();
 152     let preferred_username: Option<String> = person
 153       .name()
 154       .map(|n| n.one())
 155       .flatten()
 156       .map(|n| n.to_owned().xsd_string())
 157       .flatten();
 158     let bio = get_source_markdown_value(person)?;
 159     let shared_inbox = person
 160       .inner
 161       .endpoints()?
 162       .map(|e| e.shared_inbox)
 163       .flatten()
 164       .map(|s| s.to_owned().into());
 165
 166     check_slurs(&name)?;
 167     check_slurs_opt(&preferred_username)?;
 168     check_slurs_opt(&bio)?;
 169
 170     Ok(UserForm {
 171       name,
 172       preferred_username: Some(preferred_username),
 173       password_encrypted: "".to_string(),
 174       admin: false,
 175       banned: None,
 176       email: None,
 177       avatar: avatar.map(|o| o.map(|i| i.into())),
 178       banner: banner.map(|o| o.map(|i| i.into())),
 179       published: person.inner.published().map(|u| u.to_owned().naive_local()),
 180       updated: person.updated().map(|u| u.to_owned().naive_local()),
 181       show_nsfw: false,
 182       theme: "".to_string(),
 183       default_sort_type: 0,
 184       default_listing_type: 0,
 185       lang: "".to_string(),
 186       show_avatars: false,
 187       send_notifications_to_email: false,
 188       matrix_user_id: None,
 189       actor_id: Some(check_object_domain(person, expected_domain)?),
 190       bio: Some(bio),
 191       local: false,
 192       private_key: None,
 193       public_key: Some(person.ext_one.public_key.to_owned().public_key_pem),
 194       last_refreshed_at: Some(naive_now()),
 195       inbox_url: Some(person.inner.inbox()?.to_owned().into()),
 196       shared_inbox_url: Some(shared_inbox),
 197     })
 198   }
 199 }