mirror of
https://git.asonix.dog/asonix/activitystreams.git
synced 2024-09-24 13:00:00 +00:00
1567 lines
48 KiB
Rust
1567 lines
48 KiB
Rust
//! Types and traits for dealing with Actor attributes
|
|
//!
|
|
//! ```rust
|
|
//! # fn main() -> Result<(), anyhow::Error> {
|
|
//! use activitystreams::{
|
|
//! actor::{ApActor, Person},
|
|
//! prelude::*,
|
|
//! iri,
|
|
//! };
|
|
//!
|
|
//! let mut person = ApActor::new(
|
|
//! iri!("https://example.com/actor/inbox"),
|
|
//! Person::new(),
|
|
//! );
|
|
//!
|
|
//! person
|
|
//! .set_outbox(iri!("https://example.com/actor/outbox"))
|
|
//! .set_following(iri!("https://example.com/actor/following"))
|
|
//! .set_followers(iri!("https://example.com/actor/followers"));
|
|
//! #
|
|
//! # Ok(())
|
|
//! # }
|
|
//! ```
|
|
use std::collections::HashMap;
|
|
|
|
use crate::{
|
|
base::{AsBase, Base, Extends},
|
|
checked::CheckError,
|
|
markers,
|
|
object::{ApObject, AsApObject, AsObject, Object},
|
|
prelude::BaseExt,
|
|
primitives::OneOrMany,
|
|
unparsed::{Unparsed, UnparsedMut, UnparsedMutExt},
|
|
};
|
|
use iri_string::{components::AuthorityComponents, types::IriString};
|
|
|
|
pub use activitystreams_kinds::actor as kind;
|
|
|
|
use self::kind::*;
|
|
|
|
fn check_opt(
|
|
iri: &IriString,
|
|
authority_components: Option<&AuthorityComponents>,
|
|
) -> Result<(), CheckError> {
|
|
if iri.authority_components().as_ref() == authority_components {
|
|
Ok(())
|
|
} else {
|
|
Err(CheckError(Some(iri.clone())))
|
|
}
|
|
}
|
|
|
|
/// Implementation trait for deriving ActivityPub Actor methods for a type
|
|
///
|
|
/// Any type implementing AsObject will automatically gain methods provided by ApActorExt
|
|
pub trait AsApActor: markers::Actor {
|
|
type Inner;
|
|
|
|
/// Immutable borrow of `ApActor<Inner>`
|
|
fn ap_actor_ref(&self) -> &ApActor<Self::Inner>;
|
|
|
|
/// Mutable borrow of `ApActor<Inner>`
|
|
fn ap_actor_mut(&mut self) -> &mut ApActor<Self::Inner>;
|
|
}
|
|
|
|
/// Helper methods for interacting with ActivityPub Actor types
|
|
///
|
|
/// This trait represents methods valid for any ActivityPub Actor.
|
|
///
|
|
/// Documentation for the fields related to these methods can be found on the `ApActor` struct
|
|
pub trait ApActorExt: AsApActor {
|
|
/// Fetch the inbox for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// let inbox_ref = person.inbox();
|
|
/// ```
|
|
fn inbox<'a>(&'a self) -> Result<&'a IriString, CheckError>
|
|
where
|
|
Self::Inner: 'a,
|
|
Self: BaseExt,
|
|
{
|
|
let inbox = self.inbox_unchecked();
|
|
self.check_authority(inbox)
|
|
}
|
|
|
|
/// Fetch the inbox for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// let inbox_ref = person.inbox_unchecked();
|
|
/// ```
|
|
fn inbox_unchecked<'a>(&'a self) -> &'a IriString
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
&self.ap_actor_ref().inbox
|
|
}
|
|
|
|
/// Fetch a mutable referece to the current actor's inbox
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// let inbox_mut = person.inbox_mut();
|
|
/// ```
|
|
fn inbox_mut<'a>(&'a mut self) -> &'a mut IriString
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
&mut self.ap_actor_mut().inbox
|
|
}
|
|
|
|
/// Set the inbox for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// person.set_inbox(iri!("https://example.com/inbox"));
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn set_inbox(&mut self, inbox: IriString) -> &mut Self {
|
|
self.ap_actor_mut().inbox = inbox;
|
|
self
|
|
}
|
|
|
|
/// Fetch the outbox for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// let outbox_ref = person.outbox();
|
|
/// ```
|
|
fn outbox<'a>(&'a self) -> Result<Option<&'a IriString>, CheckError>
|
|
where
|
|
Self::Inner: 'a,
|
|
Self: BaseExt,
|
|
{
|
|
self.outbox_unchecked()
|
|
.map(|outbox| self.check_authority(outbox))
|
|
.transpose()
|
|
}
|
|
|
|
/// Fetch the outbox for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// let outbox_ref = person.outbox_unchecked();
|
|
/// ```
|
|
fn outbox_unchecked<'a>(&'a self) -> Option<&'a IriString>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_ref().outbox.as_ref()
|
|
}
|
|
|
|
/// Mutably fetch the outbox for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(outbox) = person.outbox_mut() {
|
|
/// println!("{:?}", outbox);
|
|
/// }
|
|
/// ```
|
|
fn outbox_mut<'a>(&'a mut self) -> Option<&'a mut IriString>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_mut().outbox.as_mut()
|
|
}
|
|
|
|
/// Set the outbox for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// person.set_outbox(iri!("https://example.com/outbox"));
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn set_outbox(&mut self, outbox: IriString) -> &mut Self {
|
|
self.ap_actor_mut().outbox = Some(outbox);
|
|
self
|
|
}
|
|
|
|
/// Take the outbox from the current actor, leaving nothing
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(outbox) = person.take_outbox() {
|
|
/// println!("{:?}", outbox);
|
|
/// }
|
|
/// ```
|
|
fn take_outbox(&mut self) -> Option<IriString> {
|
|
self.ap_actor_mut().outbox.take()
|
|
}
|
|
|
|
/// Delete the outbox from the current object
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// # person.set_outbox(iri!("https://example.com/outbox"));
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// assert!(person.outbox_unchecked().is_some());
|
|
/// person.delete_outbox();
|
|
/// assert!(person.outbox_unchecked().is_none());
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn delete_outbox(&mut self) -> &mut Self {
|
|
self.ap_actor_mut().outbox = None;
|
|
self
|
|
}
|
|
|
|
/// Fetch the following link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Ok(following) = person.following() {
|
|
/// println!("{:?}", following);
|
|
/// }
|
|
/// ```
|
|
fn following<'a>(&'a self) -> Result<Option<&'a IriString>, CheckError>
|
|
where
|
|
Self::Inner: 'a,
|
|
Self: BaseExt,
|
|
{
|
|
self.following_unchecked()
|
|
.map(|following| self.check_authority(following))
|
|
.transpose()
|
|
}
|
|
|
|
/// Fetch the following link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(following) = person.following_unchecked() {
|
|
/// println!("{:?}", following);
|
|
/// }
|
|
/// ```
|
|
fn following_unchecked<'a>(&'a self) -> Option<&'a IriString>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_ref().following.as_ref()
|
|
}
|
|
|
|
/// Mutably fetch the following link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(following) = person.following_mut() {
|
|
/// println!("{:?}", following);
|
|
/// }
|
|
/// ```
|
|
fn following_mut<'a>(&'a mut self) -> Option<&'a mut IriString>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_mut().following.as_mut()
|
|
}
|
|
|
|
/// Set the following link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// person.set_following(iri!("https://example.com/following"));
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn set_following(&mut self, following: IriString) -> &mut Self {
|
|
self.ap_actor_mut().following = Some(following);
|
|
self
|
|
}
|
|
|
|
/// Take the following link from the current actor, leaving nothing
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(following) = person.take_following() {
|
|
/// println!("{:?}", following);
|
|
/// }
|
|
/// ```
|
|
fn take_following(&mut self) -> Option<IriString> {
|
|
self.ap_actor_mut().following.take()
|
|
}
|
|
|
|
/// Delete the following link from the current object
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// # person.set_following(iri!("https://example.com/following"));
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// assert!(person.following_unchecked().is_some());
|
|
/// person.delete_following();
|
|
/// assert!(person.following_unchecked().is_none());
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn delete_following(&mut self) -> &mut Self {
|
|
self.ap_actor_mut().following = None;
|
|
self
|
|
}
|
|
|
|
/// Fetch the followers link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Ok(followers) = person.followers() {
|
|
/// println!("{:?}", followers);
|
|
/// }
|
|
/// ```
|
|
fn followers<'a>(&'a self) -> Result<Option<&'a IriString>, CheckError>
|
|
where
|
|
Self::Inner: 'a,
|
|
Self: BaseExt,
|
|
{
|
|
self.followers_unchecked()
|
|
.map(|followers| self.check_authority(followers))
|
|
.transpose()
|
|
}
|
|
|
|
/// Fetch the followers link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(followers) = person.followers_unchecked() {
|
|
/// println!("{:?}", followers);
|
|
/// }
|
|
/// ```
|
|
fn followers_unchecked<'a>(&'a self) -> Option<&'a IriString>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_ref().followers.as_ref()
|
|
}
|
|
|
|
/// Mutably fetch the followers link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(followers) = person.followers_mut() {
|
|
/// println!("{:?}", followers);
|
|
/// }
|
|
/// ```
|
|
fn followers_mut<'a>(&'a mut self) -> Option<&'a mut IriString>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_mut().followers.as_mut()
|
|
}
|
|
|
|
/// Set the followers link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// person.set_followers(iri!("https://example.com/followers"));
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn set_followers(&mut self, followers: IriString) -> &mut Self {
|
|
self.ap_actor_mut().followers = Some(followers);
|
|
self
|
|
}
|
|
|
|
/// Take the followers link from the current actor, leaving nothing
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(followers) = person.take_followers() {
|
|
/// println!("{:?}", followers);
|
|
/// }
|
|
/// ```
|
|
fn take_followers(&mut self) -> Option<IriString> {
|
|
self.ap_actor_mut().followers.take()
|
|
}
|
|
|
|
/// Delete the followers link from the current object
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// # person.set_followers(iri!("https://example.com/followers"));
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// assert!(person.followers_unchecked().is_some());
|
|
/// person.delete_followers();
|
|
/// assert!(person.followers_unchecked().is_none());
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn delete_followers(&mut self) -> &mut Self {
|
|
self.ap_actor_mut().followers = None;
|
|
self
|
|
}
|
|
|
|
/// Fetch the liked link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Ok(liked) = person.liked() {
|
|
/// println!("{:?}", liked);
|
|
/// }
|
|
/// ```
|
|
fn liked<'a>(&'a self) -> Result<Option<&'a IriString>, CheckError>
|
|
where
|
|
Self::Inner: 'a,
|
|
Self: BaseExt,
|
|
{
|
|
self.liked_unchecked()
|
|
.map(|liked| self.check_authority(liked))
|
|
.transpose()
|
|
}
|
|
|
|
/// Fetch the liked link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(liked) = person.liked_unchecked() {
|
|
/// println!("{:?}", liked);
|
|
/// }
|
|
/// ```
|
|
fn liked_unchecked<'a>(&'a self) -> Option<&'a IriString>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_ref().liked.as_ref()
|
|
}
|
|
|
|
/// Mutably fetch the liked link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(liked) = person.liked_mut() {
|
|
/// println!("{:?}", liked);
|
|
/// }
|
|
/// ```
|
|
fn liked_mut<'a>(&'a mut self) -> Option<&'a mut IriString>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_mut().liked.as_mut()
|
|
}
|
|
|
|
/// Set the liked link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// person.set_stream(iri!("https://example.com/liked"));
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn set_liked(&mut self, liked: IriString) -> &mut Self {
|
|
self.ap_actor_mut().liked = Some(liked);
|
|
self
|
|
}
|
|
|
|
/// Take the liked link from the current actor, leaving nothing
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(liked) = person.take_liked() {
|
|
/// println!("{:?}", liked);
|
|
/// }
|
|
/// ```
|
|
fn take_liked(&mut self) -> Option<IriString> {
|
|
self.ap_actor_mut().liked.take()
|
|
}
|
|
|
|
/// Delete the liked link from the current object
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// # person.set_liked(iri!("https://example.com/liked"));
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// assert!(person.liked_unchecked().is_some());
|
|
/// person.delete_liked();
|
|
/// assert!(person.liked_unchecked().is_none());
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn delete_liked(&mut self) -> &mut Self {
|
|
self.ap_actor_mut().liked = None;
|
|
self
|
|
}
|
|
|
|
/// Fetch the streams links for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Ok(streams) = person.streams() {
|
|
/// println!("{:?}", streams);
|
|
/// }
|
|
/// ```
|
|
fn streams<'a>(&'a self) -> Result<Option<OneOrMany<&'a IriString>>, CheckError>
|
|
where
|
|
Self::Inner: 'a,
|
|
Self: BaseExt,
|
|
{
|
|
if let Some(streams) = self.streams_unchecked() {
|
|
for id in &streams {
|
|
self.check_authority(id)?;
|
|
}
|
|
|
|
Ok(Some(streams))
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
/// Fetch the streams links for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(streams) = person.streams_unchecked() {
|
|
/// println!("{:?}", streams);
|
|
/// }
|
|
/// ```
|
|
fn streams_unchecked<'a>(&'a self) -> Option<OneOrMany<&'a IriString>>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_ref().streams.as_ref().map(|o| o.as_ref())
|
|
}
|
|
|
|
/// Mutably fetch the streams links for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(mut streams) = person.streams_mut() {
|
|
/// for url in streams.iter_mut() {
|
|
/// // whatever
|
|
/// }
|
|
/// println!("{:?}", streams);
|
|
/// }
|
|
/// ```
|
|
fn streams_mut<'a>(&'a mut self) -> Option<OneOrMany<&'a mut IriString>>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_mut().streams.as_mut().map(|o| o.as_mut())
|
|
}
|
|
|
|
/// Set the streams links for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// person.set_stream(iri!("https://example.com/streams"));
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn set_stream(&mut self, streams: IriString) -> &mut Self {
|
|
self.ap_actor_mut().streams = Some(streams.into());
|
|
self
|
|
}
|
|
|
|
/// Set many streams links for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// person.set_many_streams(vec![
|
|
/// iri!("https://example.com/streams1"),
|
|
/// iri!("https://example.com/streams2"),
|
|
/// ]);
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn set_many_streams<I, U>(&mut self, items: I) -> &mut Self
|
|
where
|
|
I: IntoIterator<Item = U>,
|
|
U: Into<IriString>,
|
|
{
|
|
let v: Vec<IriString> = items.into_iter().map(|u| u.into()).collect();
|
|
self.ap_actor_mut().streams = Some(v.into());
|
|
self
|
|
}
|
|
|
|
/// Add a streams link for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// person
|
|
/// .add_stream(iri!("https://example.com/streams1"))
|
|
/// .add_stream(iri!("https://example.com/streams2"));
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn add_stream(&mut self, stream: IriString) -> &mut Self {
|
|
let v = match self.ap_actor_mut().streams.take() {
|
|
Some(mut v) => {
|
|
v.add(stream);
|
|
v
|
|
}
|
|
None => vec![stream].into(),
|
|
};
|
|
self.ap_actor_mut().streams = Some(v);
|
|
self
|
|
}
|
|
|
|
/// Take the streams links from the current actor, leaving nothing
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(streams) = person.take_streams() {
|
|
/// println!("{:?}", streams);
|
|
/// }
|
|
/// ```
|
|
fn take_streams(&mut self) -> Option<OneOrMany<IriString>> {
|
|
self.ap_actor_mut().streams.take()
|
|
}
|
|
|
|
/// Delete the streams links from the current object
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// # person.set_stream(iri!("https://example.com/streams"));
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// assert!(person.streams_unchecked().is_some());
|
|
/// person.delete_streams();
|
|
/// assert!(person.streams_unchecked().is_none());
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn delete_streams(&mut self) -> &mut Self {
|
|
self.ap_actor_mut().streams = None;
|
|
self
|
|
}
|
|
|
|
/// Fetch the preferred_username for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(preferred_username) = person.preferred_username() {
|
|
/// println!("{:?}", preferred_username);
|
|
/// }
|
|
/// ```
|
|
fn preferred_username<'a>(&'a self) -> Option<&'a str>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_ref().preferred_username.as_deref()
|
|
}
|
|
|
|
/// Set the preferred_username for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// person.set_preferred_username("user123");
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn set_preferred_username<T>(&mut self, string: T) -> &mut Self
|
|
where
|
|
T: Into<String>,
|
|
{
|
|
self.ap_actor_mut().preferred_username = Some(string.into());
|
|
self
|
|
}
|
|
|
|
/// Take the preferred_username from the current actor, leaving nothing
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(preferred_username) = person.take_preferred_username() {
|
|
/// println!("{:?}", preferred_username);
|
|
/// }
|
|
/// ```
|
|
fn take_preferred_username(&mut self) -> Option<String> {
|
|
self.ap_actor_mut().preferred_username.take()
|
|
}
|
|
|
|
/// Delete the preferred_username from the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// # person.set_preferred_username("hey");
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// assert!(person.preferred_username().is_some());
|
|
/// person.delete_preferred_username();
|
|
/// assert!(person.preferred_username().is_none());
|
|
/// ```
|
|
fn delete_preferred_username(&mut self) -> &mut Self {
|
|
self.ap_actor_mut().preferred_username = None;
|
|
self
|
|
}
|
|
|
|
/// Fetch the endpoints for the current actor, erroring if the Endpoints' domains do not
|
|
/// match the ID's domain
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Endpoints, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// # person.set_id(context()).set_endpoints(Endpoints {
|
|
/// # shared_inbox: Some(context()),
|
|
/// # ..Default::default()
|
|
/// # });
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(endpoints) = person.endpoints()? {
|
|
/// println!("{:?}", endpoints);
|
|
/// }
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn endpoints<'a>(&'a self) -> Result<Option<&'a Endpoints<IriString>>, CheckError>
|
|
where
|
|
Self: BaseExt,
|
|
Self::Inner: 'a,
|
|
{
|
|
if let Some(endpoints) = self.endpoints_unchecked() {
|
|
let authority_opt = self.id_unchecked().and_then(|id| id.authority_components());
|
|
|
|
endpoints
|
|
.proxy_url
|
|
.as_ref()
|
|
.map(|i| check_opt(i, authority_opt.as_ref()))
|
|
.transpose()?;
|
|
endpoints
|
|
.oauth_authorization_endpoint
|
|
.as_ref()
|
|
.map(|i| check_opt(i, authority_opt.as_ref()))
|
|
.transpose()?;
|
|
endpoints
|
|
.oauth_token_endpoint
|
|
.as_ref()
|
|
.map(|i| check_opt(i, authority_opt.as_ref()))
|
|
.transpose()?;
|
|
endpoints
|
|
.provide_client_key
|
|
.as_ref()
|
|
.map(|i| check_opt(i, authority_opt.as_ref()))
|
|
.transpose()?;
|
|
endpoints
|
|
.sign_client_key
|
|
.as_ref()
|
|
.map(|i| check_opt(i, authority_opt.as_ref()))
|
|
.transpose()?;
|
|
endpoints
|
|
.shared_inbox
|
|
.as_ref()
|
|
.map(|i| check_opt(i, authority_opt.as_ref()))
|
|
.transpose()?;
|
|
endpoints
|
|
.nonstandard
|
|
.values()
|
|
.map(|v| check_opt(v, authority_opt.as_ref()))
|
|
.collect::<Result<(), _>>()?;
|
|
|
|
return Ok(Some(endpoints));
|
|
}
|
|
|
|
Ok(None)
|
|
}
|
|
|
|
/// Fetch the endpoints for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(endpoints) = person.endpoints_unchecked() {
|
|
/// println!("{:?}", endpoints);
|
|
/// }
|
|
/// ```
|
|
fn endpoints_unchecked<'a>(&'a self) -> Option<&'a Endpoints<IriString>>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_ref().endpoints.as_ref()
|
|
}
|
|
|
|
/// Mutably fetch the endpoints for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(mut endpoints) = person.endpoints_mut() {
|
|
/// if let Some(url) = endpoints.shared_inbox.as_mut() {
|
|
/// // whatever
|
|
/// }
|
|
/// println!("{:?}", endpoints);
|
|
/// }
|
|
/// ```
|
|
fn endpoints_mut<'a>(&'a mut self) -> Option<&'a mut Endpoints<IriString>>
|
|
where
|
|
Self::Inner: 'a,
|
|
{
|
|
self.ap_actor_mut().endpoints.as_mut()
|
|
}
|
|
|
|
/// Set the endpoints for the current actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// # use activitystreams::{actor::{ApActor, Endpoints, Person}, context, iri};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// person.set_endpoints(Endpoints {
|
|
/// shared_inbox: Some(iri!("https://example.com/inbox")),
|
|
/// ..Default::default()
|
|
/// });
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
fn set_endpoints(&mut self, endpoints: Endpoints<IriString>) -> &mut Self {
|
|
self.ap_actor_mut().endpoints = Some(endpoints);
|
|
self
|
|
}
|
|
|
|
/// Take the endpoints from the current actor, leaving nothing
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// if let Some(endpoints) = person.take_endpoints() {
|
|
/// println!("{:?}", endpoints);
|
|
/// }
|
|
/// ```
|
|
fn take_endpoints(&mut self) -> Option<Endpoints<IriString>> {
|
|
self.ap_actor_mut().endpoints.take()
|
|
}
|
|
|
|
/// Delete the endpoints from the current actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{actor::{ApActor, Person}, context};
|
|
/// # let mut person = ApActor::new(context(), Person::new());
|
|
/// # person.set_endpoints(Default::default());
|
|
/// use activitystreams::prelude::*;
|
|
///
|
|
/// assert!(person.endpoints_unchecked().is_some());
|
|
/// person.delete_endpoints();
|
|
/// assert!(person.endpoints_unchecked().is_none());
|
|
/// ```
|
|
fn delete_endpoints(&mut self) -> &mut Self {
|
|
self.ap_actor_mut().endpoints = None;
|
|
self
|
|
}
|
|
}
|
|
|
|
/// Describes a software application.
|
|
///
|
|
/// This is just an alias for `Actor<ApplicationType>` because there's no fields inherent to
|
|
/// Application that aren't already present on an Actor.
|
|
pub type Application = Actor<ApplicationType>;
|
|
|
|
/// Represents a formal or informal collective of Actors.
|
|
///
|
|
/// This is just an alias for `Actor<GroupType>` because there's no fields inherent to
|
|
/// Group that aren't already present on an Actor.
|
|
pub type Group = Actor<GroupType>;
|
|
|
|
/// Represents an organization.
|
|
///
|
|
/// This is just an alias for `Actor<OrganizationType>` because there's no fields inherent to
|
|
/// Organization that aren't already present on an Actor.
|
|
pub type Organization = Actor<OrganizationType>;
|
|
|
|
/// Represents an individual person.
|
|
///
|
|
/// This is just an alias for `Actor<PersonType>` because there's no fields inherent to
|
|
/// Person that aren't already present on an Actor.
|
|
pub type Person = Actor<PersonType>;
|
|
|
|
/// Represents a service of any kind.
|
|
///
|
|
/// This is just an alias for `Actor<ServiceType>` because there's no fields inherent to
|
|
/// Service that aren't already present on an Actor.
|
|
pub type Service = Actor<ServiceType>;
|
|
|
|
/// Actor types are Object types that are capable of performing activities.
|
|
///
|
|
/// This specification intentionally defines Actors in only the most generalized way, stopping
|
|
/// short of defining semantically specific properties for each. All Actor objects are
|
|
/// specializations of Object and inherit all of the core properties common to all Objects.
|
|
/// External vocabularies can be used to express additional detail not covered by the Activity
|
|
/// Vocabulary. VCard [vcard-rdf SHOULD be used to provide additional metadata for Person, Group,
|
|
/// and Organization instances.
|
|
///
|
|
/// While implementations are free to introduce new types of Actors beyond those defined by the
|
|
/// Activity Vocabulary, interoperability issues can arise when applications rely too much on
|
|
/// extension types that are not recognized by other implementations. Care should be taken to not
|
|
/// unduly overlap with or duplicate the existing Actor types.
|
|
///
|
|
/// When an implementation uses an extension type that overlaps with a core vocabulary type, the
|
|
/// implementation MUST also specify the core vocabulary type. For instance, some vocabularies
|
|
/// (e.g. VCard) define their own types for describing people. An implementation that wishes, for
|
|
/// example, to use a vcard:Individual as an Actor MUST also identify that Actor as a Person.
|
|
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct ApActor<Inner> {
|
|
/// A reference to an [ActivityStreams] OrderedCollection comprised of all the messages received by the actor.
|
|
///
|
|
/// - Range: xsd:anyUri
|
|
/// - Functional: true
|
|
inbox: IriString,
|
|
|
|
/// An ActivityStreams] OrderedCollection comprised of all the messages produced by the actor.
|
|
///
|
|
/// - Range: xsd:anyUri
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
outbox: Option<IriString>,
|
|
|
|
/// A link to an [ActivityStreams] collection of the actors that this actor is following.
|
|
///
|
|
/// - Range: xsd:anyUri
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
following: Option<IriString>,
|
|
|
|
/// A link to an [ActivityStreams] collection of the actors that follow this actor.
|
|
///
|
|
/// - Range: xsd:anyUri
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
followers: Option<IriString>,
|
|
|
|
/// A link to an [ActivityStreams] collection of objects this actor has liked.
|
|
///
|
|
/// - Range: xsd:anyUri
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
liked: Option<IriString>,
|
|
|
|
/// A list of supplementary Collections which may be of interest.
|
|
///
|
|
/// - Range: xsd:anyUri
|
|
/// - Functional: false
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
streams: Option<OneOrMany<IriString>>,
|
|
|
|
/// A short username which may be used to refer to the actor, with no uniqueness guarantees.
|
|
///
|
|
/// - Range: xsd:string
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
preferred_username: Option<String>,
|
|
|
|
/// A json object which maps additional (typically server/domain-wide) endpoints which may be
|
|
/// useful either for this actor or someone referencing this actor.
|
|
///
|
|
/// This mapping may be nested inside the actor document as the value or may be a link to a
|
|
/// JSON-LD document with these properties.
|
|
///
|
|
/// - Range: Endpoint
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
endpoints: Option<Endpoints<IriString>>,
|
|
|
|
/// base fields and unparsed json ends up here
|
|
#[serde(flatten)]
|
|
inner: Inner,
|
|
}
|
|
|
|
/// A json object which maps additional (typically server/domain-wide) endpoints which may be
|
|
/// useful either for this actor or someone referencing this actor.
|
|
///
|
|
/// This mapping may be nested inside the actor document as the value or may be a link to a
|
|
/// JSON-LD document with these properties.
|
|
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Endpoints<T> {
|
|
/// Endpoint URI so this actor's clients may access remote ActivityStreams objects which
|
|
/// require authentication to access.
|
|
///
|
|
/// To use this endpoint, the client posts an x-www-form-urlencoded id parameter with the
|
|
/// value being the id of the requested ActivityStreams object.
|
|
///
|
|
/// - Range: anyUri
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub proxy_url: Option<T>,
|
|
|
|
/// If OAuth 2.0 bearer tokens [RFC6749](https://tools.ietf.org/html/rfc6749)
|
|
/// [RFC6750](https://tools.ietf.org/html/rfc6750) are being used for authenticating client to
|
|
/// server interactions, this endpoint specifies a URI at which a browser-authenticated user
|
|
/// may obtain a new authorization grant.
|
|
///
|
|
/// - Range: anyUri
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub oauth_authorization_endpoint: Option<T>,
|
|
|
|
/// If OAuth 2.0 bearer tokens [RFC6749](https://tools.ietf.org/html/rfc6749)
|
|
/// [RFC6750](https://tools.ietf.org/html/rfc6750) are being used for authenticating client to
|
|
/// server interactions, this endpoint specifies a URI at which a client may acquire an access
|
|
/// token.
|
|
///
|
|
/// - Range: anyUri
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub oauth_token_endpoint: Option<T>,
|
|
|
|
/// If Linked Data Signatures and HTTP Signatures are being used for authentication and
|
|
/// authorization, this endpoint specifies a URI at which browser-authenticated users may
|
|
/// authorize a client's public key for client to server interactions.
|
|
///
|
|
/// - Range: anyUri
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub provide_client_key: Option<T>,
|
|
|
|
/// If Linked Data Signatures and HTTP Signatures are being used for authentication and
|
|
/// authorization, this endpoint specifies a URI at which a client key may be signed by the
|
|
/// actor's key for a time window to act on behalf of the actor in interacting with foreign
|
|
/// servers.
|
|
///
|
|
/// - Range: anyUri
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub sign_client_key: Option<T>,
|
|
|
|
/// An optional endpoint used for wide delivery of publicly addressed activities and
|
|
/// activities sent to followers.
|
|
///
|
|
/// shared_inbox endpoints SHOULD also be publicly readable OrderedCollection objects
|
|
/// containing objects addressed to the Public special collection. Reading from the
|
|
/// shared_inbox endpoint MUST NOT present objects which are not addressed to the Public
|
|
/// endpoint.
|
|
///
|
|
/// - Range: anyUri
|
|
/// - Functional: true
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub shared_inbox: Option<T>,
|
|
|
|
/// Any nonstandard endpoints present in the endpoints record end up here.
|
|
///
|
|
/// Software like Pleroma and Akkoma provide additional URLs here and extending Endpoints
|
|
/// specifically the way objects are normally extended isn't possible for nested structs like
|
|
/// this.
|
|
#[serde(flatten)]
|
|
pub nonstandard: HashMap<String, T>,
|
|
}
|
|
|
|
/// A simple type to create an Actor out of any Object
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::{object::Object, actor::Actor, prelude::*};
|
|
/// let object = Object::<String>::new();
|
|
/// let mut actor = Actor(object);
|
|
/// actor.set_kind("MyCustomActor".into());
|
|
/// ```
|
|
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
|
|
#[serde(transparent)]
|
|
pub struct Actor<Kind>(pub Object<Kind>);
|
|
|
|
impl<Kind> Actor<Kind> {
|
|
/// Create a new Actor
|
|
///
|
|
/// ```rust
|
|
/// # use activitystreams::actor::Actor;
|
|
/// let actor = Actor::<String>::new();
|
|
/// ```
|
|
pub fn new() -> Self
|
|
where
|
|
Kind: Default,
|
|
{
|
|
Actor(Object::new())
|
|
}
|
|
|
|
/// Create a new actor with `None` for it's `kind` property
|
|
///
|
|
/// This means that no `type` field will be present in serialized JSON
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// use activitystreams::actor::Actor;
|
|
///
|
|
/// let actor = Actor::<()>::new_none_type();
|
|
///
|
|
/// let s = serde_json::to_string(&actor)?;
|
|
///
|
|
/// assert_eq!(s, "{}");
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub fn new_none_type() -> Self {
|
|
Actor(Object::new_none_type())
|
|
}
|
|
}
|
|
|
|
impl<Inner> ApActor<Inner> {
|
|
/// Create a new ActivityPub Actor
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// use activitystreams::{actor::{ApActor, Person}, iri};
|
|
///
|
|
/// let actor = ApActor::new(
|
|
/// iri!("https://example.com/inbox"),
|
|
/// Person::new(),
|
|
/// );
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub fn new(inbox: IriString, inner: Inner) -> Self
|
|
where
|
|
Inner: markers::Actor,
|
|
{
|
|
ApActor {
|
|
inbox,
|
|
outbox: None,
|
|
following: None,
|
|
followers: None,
|
|
liked: None,
|
|
streams: None,
|
|
preferred_username: None,
|
|
endpoints: None,
|
|
inner,
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::type_complexity)]
|
|
/// Deconstruct the ApActor into its parts
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// use activitystreams::{actor::{ApActor, Person}, iri};
|
|
///
|
|
/// let actor = ApActor::new(iri!("https://inbox.url"), Person::new());
|
|
///
|
|
/// let (
|
|
/// inbox,
|
|
/// outbox,
|
|
/// following,
|
|
/// followers,
|
|
/// liked,
|
|
/// streams,
|
|
/// preferred_username,
|
|
/// endpoints,
|
|
/// person,
|
|
/// ) = actor.into_parts();
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub fn into_parts(
|
|
self,
|
|
) -> (
|
|
IriString,
|
|
Option<IriString>,
|
|
Option<IriString>,
|
|
Option<IriString>,
|
|
Option<IriString>,
|
|
Option<OneOrMany<IriString>>,
|
|
Option<String>,
|
|
Option<Endpoints<IriString>>,
|
|
Inner,
|
|
) {
|
|
(
|
|
self.inbox,
|
|
self.outbox,
|
|
self.following,
|
|
self.followers,
|
|
self.liked,
|
|
self.streams,
|
|
self.preferred_username,
|
|
self.endpoints,
|
|
self.inner,
|
|
)
|
|
}
|
|
|
|
fn extending(mut inner: Inner) -> Result<Self, serde_json::Error>
|
|
where
|
|
Inner: UnparsedMut + markers::Actor,
|
|
{
|
|
let inbox = inner.remove("inbox")?;
|
|
let outbox = inner.remove("outbox")?;
|
|
let following = inner.remove("following")?;
|
|
let followers = inner.remove("followers")?;
|
|
let liked = inner.remove("liked")?;
|
|
let streams = inner.remove("streams")?;
|
|
let preferred_username = inner.remove("preferredUsername")?;
|
|
let endpoints = inner.remove("endpoints")?;
|
|
|
|
Ok(ApActor {
|
|
inbox,
|
|
outbox,
|
|
following,
|
|
followers,
|
|
liked,
|
|
streams,
|
|
preferred_username,
|
|
endpoints,
|
|
inner,
|
|
})
|
|
}
|
|
|
|
fn retracting(self) -> Result<Inner, serde_json::Error>
|
|
where
|
|
Inner: UnparsedMut + markers::Actor,
|
|
{
|
|
let ApActor {
|
|
inbox,
|
|
outbox,
|
|
following,
|
|
followers,
|
|
liked,
|
|
streams,
|
|
preferred_username,
|
|
endpoints,
|
|
mut inner,
|
|
} = self;
|
|
|
|
inner
|
|
.insert("endpoints", endpoints)?
|
|
.insert("preferredUsername", preferred_username)?
|
|
.insert("streams", streams)?
|
|
.insert("liked", liked)?
|
|
.insert("followers", followers)?
|
|
.insert("following", following)?
|
|
.insert("outbox", outbox)?
|
|
.insert("inbox", inbox)?;
|
|
|
|
Ok(inner)
|
|
}
|
|
}
|
|
|
|
impl<T> Endpoints<T> {
|
|
/// Map the URLs in Endpoints from T to U
|
|
///
|
|
/// ```rust
|
|
/// # fn main() -> Result<(), anyhow::Error> {
|
|
/// use activitystreams::{actor::Endpoints, iri};
|
|
/// use iri_string::types::IriString;
|
|
///
|
|
/// let endpoints: Endpoints<IriString> = Endpoints {
|
|
/// shared_inbox: Some(iri!("https://example.com")),
|
|
/// ..Default::default()
|
|
/// };
|
|
///
|
|
/// let endpoint_strings = endpoints.map(|u| u.to_string());
|
|
///
|
|
/// assert_eq!(endpoint_strings.shared_inbox, Some(String::from("https://example.com")));
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub fn map<F, U>(self, f: F) -> Endpoints<U>
|
|
where
|
|
F: Fn(T) -> U + Copy,
|
|
{
|
|
Endpoints {
|
|
proxy_url: self.proxy_url.map(f),
|
|
oauth_authorization_endpoint: self.oauth_authorization_endpoint.map(f),
|
|
oauth_token_endpoint: self.oauth_token_endpoint.map(f),
|
|
provide_client_key: self.provide_client_key.map(f),
|
|
sign_client_key: self.sign_client_key.map(f),
|
|
shared_inbox: self.shared_inbox.map(f),
|
|
nonstandard: self
|
|
.nonstandard
|
|
.into_iter()
|
|
.map(|(k, v)| (k, (f)(v)))
|
|
.collect(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T> Default for Endpoints<T> {
|
|
fn default() -> Self {
|
|
Endpoints {
|
|
proxy_url: None,
|
|
oauth_authorization_endpoint: None,
|
|
oauth_token_endpoint: None,
|
|
provide_client_key: None,
|
|
sign_client_key: None,
|
|
shared_inbox: None,
|
|
nonstandard: HashMap::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<Kind> markers::Base for Actor<Kind> {}
|
|
impl<Kind> markers::Object for Actor<Kind> {}
|
|
impl<Kind> markers::Actor for Actor<Kind> {}
|
|
|
|
impl<Inner> markers::Base for ApActor<Inner> where Inner: markers::Base {}
|
|
impl<Inner> markers::Object for ApActor<Inner> where Inner: markers::Object {}
|
|
impl<Inner> markers::Actor for ApActor<Inner> where Inner: markers::Actor {}
|
|
|
|
impl<Inner> markers::Actor for ApObject<Inner> where Inner: markers::Actor {}
|
|
|
|
impl<Inner, Error> Extends for ApActor<Inner>
|
|
where
|
|
Inner: Extends<Error = Error> + UnparsedMut + markers::Actor,
|
|
Error: From<serde_json::Error> + std::error::Error,
|
|
{
|
|
type Kind = Inner::Kind;
|
|
type Error = Error;
|
|
|
|
fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
|
|
let inner = Inner::extends(base)?;
|
|
Ok(Self::extending(inner)?)
|
|
}
|
|
|
|
fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
|
|
let inner = self.retracting()?;
|
|
inner.retracts()
|
|
}
|
|
}
|
|
|
|
impl<Inner> UnparsedMut for ApActor<Inner>
|
|
where
|
|
Inner: UnparsedMut,
|
|
{
|
|
fn unparsed_mut(&mut self) -> &mut Unparsed {
|
|
self.inner.unparsed_mut()
|
|
}
|
|
}
|
|
|
|
impl<Inner> AsBase for ApActor<Inner>
|
|
where
|
|
Inner: AsBase,
|
|
{
|
|
type Kind = Inner::Kind;
|
|
|
|
fn base_ref(&self) -> &Base<Self::Kind> {
|
|
self.inner.base_ref()
|
|
}
|
|
|
|
fn base_mut(&mut self) -> &mut Base<Self::Kind> {
|
|
self.inner.base_mut()
|
|
}
|
|
}
|
|
|
|
impl<Inner> AsObject for ApActor<Inner>
|
|
where
|
|
Inner: AsObject,
|
|
{
|
|
type Kind = Inner::Kind;
|
|
|
|
fn object_ref(&self) -> &Object<Self::Kind> {
|
|
self.inner.object_ref()
|
|
}
|
|
|
|
fn object_mut(&mut self) -> &mut Object<Self::Kind> {
|
|
self.inner.object_mut()
|
|
}
|
|
}
|
|
|
|
impl<Inner> AsApActor for ApActor<Inner>
|
|
where
|
|
Inner: markers::Actor,
|
|
{
|
|
type Inner = Inner;
|
|
|
|
fn ap_actor_ref(&self) -> &ApActor<Self::Inner> {
|
|
self
|
|
}
|
|
|
|
fn ap_actor_mut(&mut self) -> &mut ApActor<Self::Inner> {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<Inner> AsApObject for ApActor<Inner>
|
|
where
|
|
Inner: AsApObject,
|
|
{
|
|
type Inner = Inner::Inner;
|
|
|
|
fn ap_object_ref(&self) -> &ApObject<Self::Inner> {
|
|
self.inner.ap_object_ref()
|
|
}
|
|
|
|
fn ap_object_mut(&mut self) -> &mut ApObject<Self::Inner> {
|
|
self.inner.ap_object_mut()
|
|
}
|
|
}
|
|
|
|
impl<Kind> Extends for Actor<Kind> {
|
|
type Kind = Kind;
|
|
|
|
type Error = serde_json::Error;
|
|
|
|
fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
|
|
Object::extends(base).map(Actor)
|
|
}
|
|
|
|
fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
|
|
self.0.retracts()
|
|
}
|
|
}
|
|
|
|
impl<Kind> UnparsedMut for Actor<Kind> {
|
|
fn unparsed_mut(&mut self) -> &mut Unparsed {
|
|
self.0.unparsed_mut()
|
|
}
|
|
}
|
|
|
|
impl<Kind> AsBase for Actor<Kind> {
|
|
type Kind = Kind;
|
|
|
|
fn base_ref(&self) -> &Base<Self::Kind> {
|
|
self.0.base_ref()
|
|
}
|
|
|
|
fn base_mut(&mut self) -> &mut Base<Self::Kind> {
|
|
self.0.base_mut()
|
|
}
|
|
}
|
|
|
|
impl<Kind> AsObject for Actor<Kind> {
|
|
type Kind = Kind;
|
|
|
|
fn object_ref(&self) -> &Object<Self::Kind> {
|
|
self.0.object_ref()
|
|
}
|
|
|
|
fn object_mut(&mut self) -> &mut Object<Self::Kind> {
|
|
self.0.object_mut()
|
|
}
|
|
}
|
|
|
|
impl<T> ApActorExt for T where T: AsApActor {}
|
|
|
|
impl<Inner> AsApActor for ApObject<Inner>
|
|
where
|
|
Inner: AsApActor,
|
|
{
|
|
type Inner = Inner::Inner;
|
|
|
|
fn ap_actor_ref(&self) -> &ApActor<Self::Inner> {
|
|
self.inner().ap_actor_ref()
|
|
}
|
|
|
|
fn ap_actor_mut(&mut self) -> &mut ApActor<Self::Inner> {
|
|
self.inner_mut().ap_actor_mut()
|
|
}
|
|
}
|
|
|
|
impl<Kind> Default for Actor<Kind>
|
|
where
|
|
Kind: Default,
|
|
{
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|