crates/apub/src/objects/person.rs

   1 use crate::{
   2   extensions::{context::lemmy_context, person_extension::PersonExtension},
   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::Ext2;
  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::person::{Person as DbPerson, PersonForm},
  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 DbPerson {
  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     let person_ext = PersonExtension::new(self.matrix_user_id.to_owned())?;
  81     Ok(Ext2::new(ap_actor, person_ext, self.get_public_key_ext()?))
  82   }
  83   fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
  84     unimplemented!()
  85   }
  86 }
  87
  88 #[async_trait::async_trait(?Send)]
  89 impl FromApub for DbPerson {
  90   type ApubType = PersonExt;
  91
  92   async fn from_apub(
  93     person: &PersonExt,
  94     context: &LemmyContext,
  95     expected_domain: Url,
  96     request_counter: &mut i32,
  97     mod_action_allowed: bool,
  98   ) -> Result<DbPerson, LemmyError> {
  99     let person_id = person.id_unchecked().context(location_info!())?.to_owned();
 100     let domain = person_id.domain().context(location_info!())?;
 101     if domain == Settings::get().hostname() {
 102       let person = blocking(context.pool(), move |conn| {
 103         DbPerson::read_from_apub_id(conn, &person_id.into())
 104       })
 105       .await??;
 106       Ok(person)
 107     } else {
 108       let person_form = PersonForm::from_apub(
 109         person,
 110         context,
 111         expected_domain,
 112         request_counter,
 113         mod_action_allowed,
 114       )
 115       .await?;
 116       let person = blocking(context.pool(), move |conn| {
 117         DbPerson::upsert(conn, &person_form)
 118       })
 119       .await??;
 120       Ok(person)
 121     }
 122   }
 123 }
 124
 125 #[async_trait::async_trait(?Send)]
 126 impl FromApubToForm<PersonExt> for PersonForm {
 127   async fn from_apub(
 128     person: &PersonExt,
 129     _context: &LemmyContext,
 130     expected_domain: Url,
 131     _request_counter: &mut i32,
 132     _mod_action_allowed: bool,
 133   ) -> Result<Self, LemmyError> {
 134     let avatar = match person.icon() {
 135       Some(any_image) => Some(
 136         Image::from_any_base(any_image.as_one().context(location_info!())?.clone())?
 137           .context(location_info!())?
 138           .url()
 139           .context(location_info!())?
 140           .as_single_xsd_any_uri()
 141           .map(|url| url.to_owned()),
 142       ),
 143       None => None,
 144     };
 145
 146     let banner = match person.image() {
 147       Some(any_image) => Some(
 148         Image::from_any_base(any_image.as_one().context(location_info!())?.clone())
 149           .context(location_info!())?
 150           .context(location_info!())?
 151           .url()
 152           .context(location_info!())?
 153           .as_single_xsd_any_uri()
 154           .map(|url| url.to_owned()),
 155       ),
 156       None => None,
 157     };
 158
 159     let name: String = person
 160       .inner
 161       .preferred_username()
 162       .context(location_info!())?
 163       .to_string();
 164     let preferred_username: Option<String> = person
 165       .name()
 166       .map(|n| n.one())
 167       .flatten()
 168       .map(|n| n.to_owned().xsd_string())
 169       .flatten();
 170     let bio = get_source_markdown_value(person)?;
 171     let shared_inbox = person
 172       .inner
 173       .endpoints()?
 174       .map(|e| e.shared_inbox)
 175       .flatten()
 176       .map(|s| s.to_owned().into());
 177
 178     check_slurs(&name)?;
 179     check_slurs_opt(&preferred_username)?;
 180     check_slurs_opt(&bio)?;
 181
 182     Ok(PersonForm {
 183       name,
 184       preferred_username: Some(preferred_username),
 185       banned: None,
 186       deleted: None,
 187       avatar: avatar.map(|o| o.map(|i| i.into())),
 188       banner: banner.map(|o| o.map(|i| i.into())),
 189       published: person.inner.published().map(|u| u.to_owned().naive_local()),
 190       updated: person.updated().map(|u| u.to_owned().naive_local()),
 191       actor_id: Some(check_object_domain(person, expected_domain)?),
 192       bio: Some(bio),
 193       local: Some(false),
 194       admin: Some(false),
 195       private_key: None,
 196       public_key: Some(Some(person.ext_two.public_key.to_owned().public_key_pem)),
 197       last_refreshed_at: Some(naive_now()),
 198       inbox_url: Some(person.inner.inbox()?.to_owned().into()),
 199       shared_inbox_url: Some(shared_inbox),
 200       matrix_user_id: Some(person.ext_one.matrix_user_id.to_owned()),
 201     })
 202   }
 203 }