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