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   UserTypes,
  14 };
  15 use activitystreams::{
  16   actor::{Actor, ApActor, ApActorExt, Endpoints},
  17   base::{BaseExt, ExtendsExt},
  18   object::{ApObject, Image, Object, ObjectExt, Tombstone},
  19 };
  20 use activitystreams_ext::Ext2;
  21 use anyhow::Context;
  22 use lemmy_api_common::blocking;
  23 use lemmy_db_queries::{ApubObject, DbPool};
  24 use lemmy_db_schema::{
  25   naive_now,
  26   source::person::{Person as DbPerson, PersonForm},
  27 };
  28 use lemmy_utils::{
  29   location_info,
  30   settings::structs::Settings,
  31   utils::{check_slurs, check_slurs_opt, convert_datetime},
  32   LemmyError,
  33 };
  34 use lemmy_websocket::LemmyContext;
  35 use url::Url;
  36
  37 #[async_trait::async_trait(?Send)]
  38 impl ToApub for DbPerson {
  39   type ApubType = PersonExt;
  40
  41   async fn to_apub(&self, _pool: &DbPool) -> Result<PersonExt, LemmyError> {
  42     let object = Object::<UserTypes>::new_none_type();
  43     let mut actor = Actor(object);
  44     let kind = if self.bot_account {
  45       UserTypes::Service
  46     } else {
  47       UserTypes::Person
  48     };
  49     actor.set_kind(kind);
  50     let mut person = ApObject::new(actor);
  51
  52     person
  53       .set_many_contexts(lemmy_context())
  54       .set_id(self.actor_id.to_owned().into_inner())
  55       .set_published(convert_datetime(self.published));
  56
  57     if let Some(u) = self.updated {
  58       person.set_updated(convert_datetime(u));
  59     }
  60
  61     if let Some(avatar_url) = &self.avatar {
  62       let mut image = Image::new();
  63       image.set_url::<Url>(avatar_url.to_owned().into());
  64       person.set_icon(image.into_any_base()?);
  65     }
  66
  67     if let Some(banner_url) = &self.banner {
  68       let mut image = Image::new();
  69       image.set_url::<Url>(banner_url.to_owned().into());
  70       person.set_image(image.into_any_base()?);
  71     }
  72
  73     if let Some(bio) = &self.bio {
  74       set_content_and_source(&mut person, bio)?;
  75     }
  76
  77     // In apub, the "name" is a display name
  78     if let Some(i) = self.display_name.to_owned() {
  79       person.set_name(i);
  80     }
  81
  82     let mut ap_actor = ApActor::new(self.inbox_url.clone().into(), person);
  83     ap_actor
  84       .set_preferred_username(self.name.to_owned())
  85       .set_outbox(self.get_outbox_url()?)
  86       .set_endpoints(Endpoints {
  87         shared_inbox: Some(self.get_shared_inbox_or_inbox_url()),
  88         ..Default::default()
  89       });
  90
  91     let person_ext = PersonExtension::new(self.matrix_user_id.to_owned())?;
  92     Ok(Ext2::new(ap_actor, person_ext, self.get_public_key_ext()?))
  93   }
  94   fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
  95     unimplemented!()
  96   }
  97 }
  98
  99 #[async_trait::async_trait(?Send)]
 100 impl FromApub for DbPerson {
 101   type ApubType = PersonExt;
 102
 103   async fn from_apub(
 104     person: &PersonExt,
 105     context: &LemmyContext,
 106     expected_domain: Url,
 107     request_counter: &mut i32,
 108     mod_action_allowed: bool,
 109   ) -> Result<DbPerson, LemmyError> {
 110     let person_id = person.id_unchecked().context(location_info!())?.to_owned();
 111     let domain = person_id.domain().context(location_info!())?;
 112     if domain == Settings::get().hostname() {
 113       let person = blocking(context.pool(), move |conn| {
 114         DbPerson::read_from_apub_id(conn, &person_id.into())
 115       })
 116       .await??;
 117       Ok(person)
 118     } else {
 119       let person_form = PersonForm::from_apub(
 120         person,
 121         context,
 122         expected_domain,
 123         request_counter,
 124         mod_action_allowed,
 125       )
 126       .await?;
 127       let person = blocking(context.pool(), move |conn| {
 128         DbPerson::upsert(conn, &person_form)
 129       })
 130       .await??;
 131       Ok(person)
 132     }
 133   }
 134 }
 135
 136 #[async_trait::async_trait(?Send)]
 137 impl FromApubToForm<PersonExt> for PersonForm {
 138   async fn from_apub(
 139     person: &PersonExt,
 140     _context: &LemmyContext,
 141     expected_domain: Url,
 142     _request_counter: &mut i32,
 143     _mod_action_allowed: bool,
 144   ) -> Result<Self, LemmyError> {
 145     let avatar = match person.icon() {
 146       Some(any_image) => Some(
 147         Image::from_any_base(any_image.as_one().context(location_info!())?.clone())?
 148           .context(location_info!())?
 149           .url()
 150           .context(location_info!())?
 151           .as_single_xsd_any_uri()
 152           .map(|url| url.to_owned()),
 153       ),
 154       None => None,
 155     };
 156
 157     let banner = match person.image() {
 158       Some(any_image) => Some(
 159         Image::from_any_base(any_image.as_one().context(location_info!())?.clone())
 160           .context(location_info!())?
 161           .context(location_info!())?
 162           .url()
 163           .context(location_info!())?
 164           .as_single_xsd_any_uri()
 165           .map(|url| url.to_owned()),
 166       ),
 167       None => None,
 168     };
 169
 170     let name: String = person
 171       .inner
 172       .preferred_username()
 173       .context(location_info!())?
 174       .to_string();
 175     let display_name: Option<String> = person
 176       .name()
 177       .map(|n| n.one())
 178       .flatten()
 179       .map(|n| n.to_owned().xsd_string())
 180       .flatten();
 181     let bio = get_source_markdown_value(person)?;
 182     let shared_inbox = person
 183       .inner
 184       .endpoints()?
 185       .map(|e| e.shared_inbox)
 186       .flatten()
 187       .map(|s| s.to_owned().into());
 188
 189     check_slurs(&name)?;
 190     check_slurs_opt(&display_name)?;
 191     check_slurs_opt(&bio)?;
 192
 193     Ok(PersonForm {
 194       name,
 195       display_name: Some(display_name),
 196       banned: None,
 197       deleted: None,
 198       avatar: avatar.map(|o| o.map(|i| i.into())),
 199       banner: banner.map(|o| o.map(|i| i.into())),
 200       published: person.inner.published().map(|u| u.to_owned().naive_local()),
 201       updated: person.updated().map(|u| u.to_owned().naive_local()),
 202       actor_id: Some(check_object_domain(person, expected_domain, false)?),
 203       bio: Some(bio),
 204       local: Some(false),
 205       admin: Some(false),
 206       bot_account: Some(person.inner.is_kind(&UserTypes::Service)),
 207       private_key: None,
 208       public_key: Some(Some(person.ext_two.public_key.to_owned().public_key_pem)),
 209       last_refreshed_at: Some(naive_now()),
 210       inbox_url: Some(person.inner.inbox()?.to_owned().into()),
 211       shared_inbox_url: Some(shared_inbox),
 212       matrix_user_id: Some(person.ext_one.matrix_user_id.to_owned()),
 213     })
 214   }
 215 }