server/src/apub/user.rs

   1 use crate::{
   2   apub::{activities::send_activity, create_apub_response, ActorType, FromApub, PersonExt, ToApub},
   3   blocking,
   4   convert_datetime,
   5   db::{
   6     activity::insert_activity,
   7     user::{UserForm, User_},
   8   },
   9   naive_now,
  10   routes::DbPoolParam,
  11   DbPool,
  12   LemmyError,
  13 };
  14 use activitystreams_ext::Ext1;
  15 use activitystreams_new::{
  16   activity::{Follow, Undo},
  17   actor::{ApActor, Endpoints, Person},
  18   context,
  19   object::{Image, Tombstone},
  20   prelude::*,
  21   primitives::{XsdAnyUri, XsdDateTime},
  22 };
  23 use actix_web::{body::Body, client::Client, web, HttpResponse};
  24 use failure::_core::str::FromStr;
  25 use serde::Deserialize;
  26
  27 #[derive(Deserialize)]
  28 pub struct UserQuery {
  29   user_name: String,
  30 }
  31
  32 #[async_trait::async_trait(?Send)]
  33 impl ToApub for User_ {
  34   type Response = PersonExt;
  35
  36   // Turn a Lemmy Community into an ActivityPub group that can be sent out over the network.
  37   async fn to_apub(&self, _pool: &DbPool) -> Result<PersonExt, LemmyError> {
  38     // TODO go through all these to_string and to_owned()
  39     let mut person = Person::new();
  40     person
  41       .set_context(context())
  42       .set_id(XsdAnyUri::from_str(&self.actor_id)?)
  43       .set_name(self.name.to_owned())
  44       .set_published(XsdDateTime::from(convert_datetime(self.published)));
  45
  46     if let Some(u) = self.updated {
  47       person.set_updated(XsdDateTime::from(convert_datetime(u)));
  48     }
  49
  50     if let Some(avatar_url) = &self.avatar {
  51       let mut image = Image::new();
  52       image.set_url(avatar_url.to_owned());
  53       person.set_icon(image.into_any_base()?);
  54     }
  55
  56     let mut ap_actor = ApActor::new(self.get_inbox_url().parse()?, person);
  57     ap_actor
  58       .set_outbox(self.get_outbox_url().parse()?)
  59       .set_followers(self.get_followers_url().parse()?)
  60       .set_following(self.get_following_url().parse()?)
  61       .set_liked(self.get_liked_url().parse()?)
  62       .set_endpoints(Endpoints {
  63         shared_inbox: Some(self.get_shared_inbox_url().parse()?),
  64         ..Default::default()
  65       });
  66
  67     if let Some(i) = &self.preferred_username {
  68       ap_actor.set_preferred_username(i.to_owned());
  69     }
  70
  71     Ok(Ext1::new(ap_actor, self.get_public_key_ext()))
  72   }
  73   fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
  74     unimplemented!()
  75   }
  76 }
  77
  78 #[async_trait::async_trait(?Send)]
  79 impl ActorType for User_ {
  80   fn actor_id(&self) -> String {
  81     self.actor_id.to_owned()
  82   }
  83
  84   fn public_key(&self) -> String {
  85     self.public_key.to_owned().unwrap()
  86   }
  87
  88   fn private_key(&self) -> String {
  89     self.private_key.to_owned().unwrap()
  90   }
  91
  92   /// As a given local user, send out a follow request to a remote community.
  93   async fn send_follow(
  94     &self,
  95     follow_actor_id: &str,
  96     client: &Client,
  97     pool: &DbPool,
  98   ) -> Result<(), LemmyError> {
  99     let id = format!("{}/follow/{}", self.actor_id, uuid::Uuid::new_v4());
 100     let mut follow = Follow::new(self.actor_id.to_owned(), follow_actor_id);
 101     follow.set_context(context()).set_id(id.parse()?);
 102     let to = format!("{}/inbox", follow_actor_id);
 103
 104     insert_activity(self.id, follow.clone(), true, pool).await?;
 105
 106     send_activity(client, &follow, self, vec![to]).await?;
 107     Ok(())
 108   }
 109
 110   async fn send_unfollow(
 111     &self,
 112     follow_actor_id: &str,
 113     client: &Client,
 114     pool: &DbPool,
 115   ) -> Result<(), LemmyError> {
 116     let id = format!("{}/follow/{}", self.actor_id, uuid::Uuid::new_v4());
 117     let mut follow = Follow::new(self.actor_id.to_owned(), follow_actor_id);
 118     follow.set_context(context()).set_id(id.parse()?);
 119
 120     let to = format!("{}/inbox", follow_actor_id);
 121
 122     // TODO
 123     // Undo that fake activity
 124     let undo_id = format!("{}/undo/follow/{}", self.actor_id, uuid::Uuid::new_v4());
 125     let mut undo = Undo::new(self.actor_id.parse::<XsdAnyUri>()?, follow.into_any_base()?);
 126     undo.set_context(context()).set_id(undo_id.parse()?);
 127
 128     insert_activity(self.id, undo.clone(), true, pool).await?;
 129
 130     send_activity(client, &undo, self, vec![to]).await?;
 131     Ok(())
 132   }
 133
 134   async fn send_delete(
 135     &self,
 136     _creator: &User_,
 137     _client: &Client,
 138     _pool: &DbPool,
 139   ) -> Result<(), LemmyError> {
 140     unimplemented!()
 141   }
 142
 143   async fn send_undo_delete(
 144     &self,
 145     _creator: &User_,
 146     _client: &Client,
 147     _pool: &DbPool,
 148   ) -> Result<(), LemmyError> {
 149     unimplemented!()
 150   }
 151
 152   async fn send_remove(
 153     &self,
 154     _creator: &User_,
 155     _client: &Client,
 156     _pool: &DbPool,
 157   ) -> Result<(), LemmyError> {
 158     unimplemented!()
 159   }
 160
 161   async fn send_undo_remove(
 162     &self,
 163     _creator: &User_,
 164     _client: &Client,
 165     _pool: &DbPool,
 166   ) -> Result<(), LemmyError> {
 167     unimplemented!()
 168   }
 169
 170   async fn send_accept_follow(
 171     &self,
 172     _follow: &Follow,
 173     _client: &Client,
 174     _pool: &DbPool,
 175   ) -> Result<(), LemmyError> {
 176     unimplemented!()
 177   }
 178
 179   async fn get_follower_inboxes(&self, _pool: &DbPool) -> Result<Vec<String>, LemmyError> {
 180     unimplemented!()
 181   }
 182 }
 183
 184 #[async_trait::async_trait(?Send)]
 185 impl FromApub for UserForm {
 186   type ApubType = PersonExt;
 187   /// Parse an ActivityPub person received from another instance into a Lemmy user.
 188   async fn from_apub(person: &mut PersonExt, _: &Client, _: &DbPool) -> Result<Self, LemmyError> {
 189     let avatar = match person.take_icon() {
 190       Some(any_image) => Image::from_any_base(any_image.as_one().unwrap().clone())
 191         .unwrap()
 192         .unwrap()
 193         .url
 194         .unwrap()
 195         .as_single_xsd_any_uri()
 196         .map(|u| u.to_string()),
 197       None => None,
 198     };
 199
 200     Ok(UserForm {
 201       name: person
 202         .take_name()
 203         .unwrap()
 204         .as_single_xsd_string()
 205         .unwrap()
 206         .into(),
 207       preferred_username: person.inner.take_preferred_username(),
 208       password_encrypted: "".to_string(),
 209       admin: false,
 210       banned: false,
 211       email: None,
 212       avatar,
 213       updated: person
 214         .take_updated()
 215         .map(|u| u.as_ref().to_owned().naive_local()),
 216       show_nsfw: false,
 217       theme: "".to_string(),
 218       default_sort_type: 0,
 219       default_listing_type: 0,
 220       lang: "".to_string(),
 221       show_avatars: false,
 222       send_notifications_to_email: false,
 223       matrix_user_id: None,
 224       actor_id: person.id().unwrap().to_string(),
 225       bio: person
 226         .take_summary()
 227         .map(|s| s.as_single_xsd_string().unwrap().into()),
 228       local: false,
 229       private_key: None,
 230       public_key: Some(person.ext_one.public_key.to_owned().public_key_pem),
 231       last_refreshed_at: Some(naive_now()),
 232     })
 233   }
 234 }
 235
 236 /// Return the user json over HTTP.
 237 pub async fn get_apub_user_http(
 238   info: web::Path<UserQuery>,
 239   db: DbPoolParam,
 240 ) -> Result<HttpResponse<Body>, LemmyError> {
 241   let user_name = info.into_inner().user_name;
 242   let user = blocking(&db, move |conn| {
 243     User_::find_by_email_or_username(conn, &user_name)
 244   })
 245   .await??;
 246   let u = user.to_apub(&db).await?;
 247   Ok(create_apub_response(&u))
 248 }