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