crates/apub/src/objects/person.rs

   1 use crate::{
   2   check_is_apub_id_valid,
   3   generate_outbox_url,
   4   objects::{get_summary_from_string_or_source, ImageObject, Source},
   5 };
   6 use activitystreams::{actor::Endpoints, object::kind::ImageType, unparsed::Unparsed};
   7 use chrono::{DateTime, FixedOffset, NaiveDateTime};
   8 use lemmy_api_common::blocking;
   9 use lemmy_apub_lib::{
  10   signatures::PublicKey,
  11   traits::{ActorType, ApubObject},
  12   values::MediaTypeMarkdown,
  13   verify::verify_domains_match,
  14 };
  15 use lemmy_db_schema::{
  16   naive_now,
  17   source::person::{Person as DbPerson, PersonForm},
  18 };
  19 use lemmy_utils::{
  20   utils::{check_slurs, check_slurs_opt, convert_datetime, markdown_to_html},
  21   LemmyError,
  22 };
  23 use lemmy_websocket::LemmyContext;
  24 use serde::{Deserialize, Serialize};
  25 use serde_with::skip_serializing_none;
  26 use std::ops::Deref;
  27 use url::Url;
  28
  29 #[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq)]
  30 pub enum UserTypes {
  31   Person,
  32   Service,
  33 }
  34
  35 #[skip_serializing_none]
  36 #[derive(Clone, Debug, Deserialize, Serialize)]
  37 #[serde(rename_all = "camelCase")]
  38 pub struct Person {
  39   #[serde(rename = "type")]
  40   kind: UserTypes,
  41   id: Url,
  42   /// username, set at account creation and can never be changed
  43   preferred_username: String,
  44   /// displayname (can be changed at any time)
  45   name: Option<String>,
  46   summary: Option<String>,
  47   source: Option<Source>,
  48   /// user avatar
  49   icon: Option<ImageObject>,
  50   /// user banner
  51   image: Option<ImageObject>,
  52   matrix_user_id: Option<String>,
  53   inbox: Url,
  54   /// mandatory field in activitypub, currently empty in lemmy
  55   outbox: Url,
  56   endpoints: Endpoints<Url>,
  57   public_key: PublicKey,
  58   published: Option<DateTime<FixedOffset>>,
  59   updated: Option<DateTime<FixedOffset>>,
  60   #[serde(flatten)]
  61   unparsed: Unparsed,
  62 }
  63
  64 // TODO: can generate this with a derive macro
  65 impl Person {
  66   pub(crate) fn id(&self, expected_domain: &Url) -> Result<&Url, LemmyError> {
  67     verify_domains_match(&self.id, expected_domain)?;
  68     Ok(&self.id)
  69   }
  70 }
  71
  72 #[derive(Clone, Debug, PartialEq)]
  73 pub struct ApubPerson(DbPerson);
  74
  75 impl Deref for ApubPerson {
  76   type Target = DbPerson;
  77   fn deref(&self) -> &Self::Target {
  78     &self.0
  79   }
  80 }
  81
  82 impl From<DbPerson> for ApubPerson {
  83   fn from(p: DbPerson) -> Self {
  84     ApubPerson { 0: p }
  85   }
  86 }
  87
  88 #[async_trait::async_trait(?Send)]
  89 impl ApubObject for ApubPerson {
  90   type DataType = LemmyContext;
  91   type ApubType = Person;
  92   type TombstoneType = ();
  93
  94   fn last_refreshed_at(&self) -> Option<NaiveDateTime> {
  95     Some(self.last_refreshed_at)
  96   }
  97
  98   async fn read_from_apub_id(
  99     object_id: Url,
 100     context: &LemmyContext,
 101   ) -> Result<Option<Self>, LemmyError> {
 102     Ok(
 103       blocking(context.pool(), move |conn| {
 104         DbPerson::read_from_apub_id(conn, object_id)
 105       })
 106       .await??
 107       .map(Into::into),
 108     )
 109   }
 110
 111   async fn delete(self, context: &LemmyContext) -> Result<(), LemmyError> {
 112     blocking(context.pool(), move |conn| {
 113       DbPerson::update_deleted(conn, self.id, true)
 114     })
 115     .await??;
 116     Ok(())
 117   }
 118
 119   async fn to_apub(&self, _pool: &LemmyContext) -> Result<Person, LemmyError> {
 120     let kind = if self.bot_account {
 121       UserTypes::Service
 122     } else {
 123       UserTypes::Person
 124     };
 125     let source = self.bio.clone().map(|bio| Source {
 126       content: bio,
 127       media_type: MediaTypeMarkdown::Markdown,
 128     });
 129     let icon = self.avatar.clone().map(|url| ImageObject {
 130       kind: ImageType::Image,
 131       url: url.into(),
 132     });
 133     let image = self.banner.clone().map(|url| ImageObject {
 134       kind: ImageType::Image,
 135       url: url.into(),
 136     });
 137
 138     let person = Person {
 139       kind,
 140       id: self.actor_id.to_owned().into_inner(),
 141       preferred_username: self.name.clone(),
 142       name: self.display_name.clone(),
 143       summary: self.bio.as_ref().map(|b| markdown_to_html(b)),
 144       source,
 145       icon,
 146       image,
 147       matrix_user_id: self.matrix_user_id.clone(),
 148       published: Some(convert_datetime(self.published)),
 149       outbox: generate_outbox_url(&self.actor_id)?.into(),
 150       endpoints: Endpoints {
 151         shared_inbox: self.shared_inbox_url.clone().map(|s| s.into()),
 152         ..Default::default()
 153       },
 154       public_key: self.get_public_key()?,
 155       updated: self.updated.map(convert_datetime),
 156       unparsed: Default::default(),
 157       inbox: self.inbox_url.clone().into(),
 158     };
 159     Ok(person)
 160   }
 161
 162   fn to_tombstone(&self) -> Result<(), LemmyError> {
 163     unimplemented!()
 164   }
 165
 166   async fn from_apub(
 167     person: &Person,
 168     context: &LemmyContext,
 169     expected_domain: &Url,
 170     _request_counter: &mut i32,
 171   ) -> Result<ApubPerson, LemmyError> {
 172     let actor_id = Some(person.id(expected_domain)?.clone().into());
 173     let name = person.preferred_username.clone();
 174     let display_name: Option<String> = person.name.clone();
 175     let bio = get_summary_from_string_or_source(&person.summary, &person.source);
 176     let shared_inbox = person.endpoints.shared_inbox.clone().map(|s| s.into());
 177     let bot_account = match person.kind {
 178       UserTypes::Person => false,
 179       UserTypes::Service => true,
 180     };
 181
 182     let slur_regex = &context.settings().slur_regex();
 183     check_slurs(&name, slur_regex)?;
 184     check_slurs_opt(&display_name, slur_regex)?;
 185     check_slurs_opt(&bio, slur_regex)?;
 186
 187     check_is_apub_id_valid(&person.id, false, &context.settings())?;
 188
 189     let person_form = PersonForm {
 190       name,
 191       display_name: Some(display_name),
 192       banned: None,
 193       deleted: None,
 194       avatar: Some(person.icon.clone().map(|i| i.url.into())),
 195       banner: Some(person.image.clone().map(|i| i.url.into())),
 196       published: person.published.map(|u| u.clone().naive_local()),
 197       updated: person.updated.map(|u| u.clone().naive_local()),
 198       actor_id,
 199       bio: Some(bio),
 200       local: Some(false),
 201       admin: Some(false),
 202       bot_account: Some(bot_account),
 203       private_key: None,
 204       public_key: Some(Some(person.public_key.public_key_pem.clone())),
 205       last_refreshed_at: Some(naive_now()),
 206       inbox_url: Some(person.inbox.to_owned().into()),
 207       shared_inbox_url: Some(shared_inbox),
 208       matrix_user_id: Some(person.matrix_user_id.clone()),
 209     };
 210     let person = blocking(context.pool(), move |conn| {
 211       DbPerson::upsert(conn, &person_form)
 212     })
 213     .await??;
 214     Ok(person.into())
 215   }
 216 }
 217
 218 impl ActorType for ApubPerson {
 219   fn is_local(&self) -> bool {
 220     self.local
 221   }
 222   fn actor_id(&self) -> Url {
 223     self.actor_id.to_owned().into_inner()
 224   }
 225   fn name(&self) -> String {
 226     self.name.clone()
 227   }
 228
 229   fn public_key(&self) -> Option<String> {
 230     self.public_key.to_owned()
 231   }
 232
 233   fn private_key(&self) -> Option<String> {
 234     self.private_key.to_owned()
 235   }
 236
 237   fn inbox_url(&self) -> Url {
 238     self.inbox_url.clone().into()
 239   }
 240
 241   fn shared_inbox_url(&self) -> Option<Url> {
 242     self.shared_inbox_url.clone().map(|s| s.into_inner())
 243   }
 244 }
 245
 246 #[cfg(test)]
 247 mod tests {
 248   use super::*;
 249   use crate::objects::tests::{file_to_json_object, init_context};
 250   use assert_json_diff::assert_json_include;
 251   use lemmy_db_schema::traits::Crud;
 252   use serial_test::serial;
 253
 254   #[actix_rt::test]
 255   #[serial]
 256   async fn test_parse_lemmy_person() {
 257     let context = init_context();
 258     let json = file_to_json_object("assets/lemmy-person.json");
 259     let url = Url::parse("https://enterprise.lemmy.ml/u/picard").unwrap();
 260     let mut request_counter = 0;
 261     let person = ApubPerson::from_apub(&json, &context, &url, &mut request_counter)
 262       .await
 263       .unwrap();
 264
 265     assert_eq!(person.actor_id.clone().into_inner(), url);
 266     assert_eq!(person.display_name, Some("Jean-Luc Picard".to_string()));
 267     assert!(person.public_key.is_some());
 268     assert!(!person.local);
 269     assert_eq!(person.bio.as_ref().unwrap().len(), 39);
 270     assert_eq!(request_counter, 0);
 271
 272     let to_apub = person.to_apub(&context).await.unwrap();
 273     assert_json_include!(actual: json, expected: to_apub);
 274
 275     DbPerson::delete(&*context.pool().get().unwrap(), person.id).unwrap();
 276   }
 277
 278   #[actix_rt::test]
 279   #[serial]
 280   async fn test_parse_pleroma_person() {
 281     let context = init_context();
 282     let json = file_to_json_object("assets/pleroma-person.json");
 283     let url = Url::parse("https://queer.hacktivis.me/users/lanodan").unwrap();
 284     let mut request_counter = 0;
 285     let person = ApubPerson::from_apub(&json, &context, &url, &mut request_counter)
 286       .await
 287       .unwrap();
 288
 289     assert_eq!(person.actor_id.clone().into_inner(), url);
 290     assert_eq!(person.name, "lanodan");
 291     assert!(person.public_key.is_some());
 292     assert!(!person.local);
 293     assert_eq!(request_counter, 0);
 294     assert_eq!(person.bio.as_ref().unwrap().len(), 873);
 295
 296     DbPerson::delete(&*context.pool().get().unwrap(), person.id).unwrap();
 297   }
 298 }