2018-11-21 11:26:20 +00:00
|
|
|
package activitypub
|
|
|
|
|
|
|
|
import (
|
2021-12-30 15:15:16 +00:00
|
|
|
"bytes"
|
|
|
|
"encoding/gob"
|
2019-12-03 16:23:59 +00:00
|
|
|
"fmt"
|
2020-07-16 19:54:46 +00:00
|
|
|
"reflect"
|
2019-12-03 16:23:59 +00:00
|
|
|
"strings"
|
|
|
|
"time"
|
|
|
|
"unsafe"
|
2021-08-14 16:34:02 +00:00
|
|
|
|
|
|
|
"github.com/valyala/fastjson"
|
2018-11-21 11:26:20 +00:00
|
|
|
)
|
|
|
|
|
2019-12-04 15:28:45 +00:00
|
|
|
const (
|
2019-12-03 16:23:59 +00:00
|
|
|
ObjectType ActivityVocabularyType = "Object"
|
|
|
|
LinkType ActivityVocabularyType = "Link"
|
|
|
|
ActivityType ActivityVocabularyType = "Activity"
|
|
|
|
IntransitiveActivityType ActivityVocabularyType = "IntransitiveActivity"
|
|
|
|
ActorType ActivityVocabularyType = "Actor"
|
|
|
|
CollectionType ActivityVocabularyType = "Collection"
|
|
|
|
OrderedCollectionType ActivityVocabularyType = "OrderedCollection"
|
|
|
|
CollectionPageType ActivityVocabularyType = "CollectionPage"
|
|
|
|
OrderedCollectionPageType ActivityVocabularyType = "OrderedCollectionPage"
|
|
|
|
|
2020-06-30 11:35:04 +00:00
|
|
|
// ActivityPub Object Types
|
2019-12-03 16:23:59 +00:00
|
|
|
ArticleType ActivityVocabularyType = "Article"
|
|
|
|
AudioType ActivityVocabularyType = "Audio"
|
|
|
|
DocumentType ActivityVocabularyType = "Document"
|
|
|
|
EventType ActivityVocabularyType = "Event"
|
|
|
|
ImageType ActivityVocabularyType = "Image"
|
|
|
|
NoteType ActivityVocabularyType = "Note"
|
|
|
|
PageType ActivityVocabularyType = "Page"
|
|
|
|
PlaceType ActivityVocabularyType = "Place"
|
|
|
|
ProfileType ActivityVocabularyType = "Profile"
|
|
|
|
RelationshipType ActivityVocabularyType = "Relationship"
|
|
|
|
TombstoneType ActivityVocabularyType = "Tombstone"
|
|
|
|
VideoType ActivityVocabularyType = "Video"
|
|
|
|
|
|
|
|
// MentionType is a link type for @mentions
|
|
|
|
MentionType ActivityVocabularyType = "Mention"
|
|
|
|
)
|
|
|
|
|
2020-06-30 11:35:04 +00:00
|
|
|
var GenericTypes = ActivityVocabularyTypes{
|
2019-12-03 16:23:59 +00:00
|
|
|
ActivityType,
|
|
|
|
IntransitiveActivityType,
|
|
|
|
ObjectType,
|
|
|
|
ActorType,
|
|
|
|
}
|
|
|
|
|
|
|
|
var ObjectTypes = ActivityVocabularyTypes{
|
|
|
|
ArticleType,
|
|
|
|
AudioType,
|
|
|
|
DocumentType,
|
|
|
|
EventType,
|
|
|
|
ImageType,
|
|
|
|
NoteType,
|
|
|
|
PageType,
|
|
|
|
PlaceType,
|
|
|
|
ProfileType,
|
|
|
|
RelationshipType,
|
|
|
|
TombstoneType,
|
|
|
|
VideoType,
|
|
|
|
}
|
|
|
|
|
|
|
|
type (
|
|
|
|
// ActivityVocabularyType is the data type for an Activity type object
|
|
|
|
ActivityVocabularyType string
|
|
|
|
// ActivityObject is a subtype of Object that describes some form of action that may happen,
|
|
|
|
// is currently happening, or has already happened
|
|
|
|
ActivityObject interface {
|
|
|
|
// GetID returns the dereferenceable ActivityStreams object id
|
2019-12-05 18:02:15 +00:00
|
|
|
GetID() ID
|
2019-12-03 16:23:59 +00:00
|
|
|
// GetType returns the ActivityStreams type
|
|
|
|
GetType() ActivityVocabularyType
|
|
|
|
}
|
|
|
|
// LinkOrIRI is an interface that Object and Link structs implement, and at the same time
|
|
|
|
// they are kept disjointed
|
|
|
|
LinkOrIRI interface {
|
|
|
|
// GetLink returns the object id in IRI type
|
|
|
|
GetLink() IRI
|
|
|
|
}
|
2019-12-04 15:28:45 +00:00
|
|
|
// ObjectOrLink describes the requirements of an ActivityStreams object
|
2019-12-03 16:23:59 +00:00
|
|
|
ObjectOrLink interface {
|
|
|
|
ActivityObject
|
|
|
|
LinkOrIRI
|
|
|
|
// IsLink shows if current item represents a Link object or an IRI
|
|
|
|
IsLink() bool
|
|
|
|
// IsObject shows if current item represents an ActivityStreams object
|
|
|
|
IsObject() bool
|
|
|
|
// IsCollection shows if the current item represents an ItemCollection
|
|
|
|
IsCollection() bool
|
|
|
|
}
|
|
|
|
// Mapper interface allows external objects to implement their own mechanism for loading information
|
|
|
|
// from an ActivityStreams vocabulary object
|
|
|
|
Mapper interface {
|
|
|
|
// FromActivityStreams maps an ActivityStreams object to another struct representation
|
|
|
|
FromActivityStreams(Item) error
|
|
|
|
}
|
|
|
|
|
|
|
|
// MimeType is the type for representing MIME types in certain ActivityStreams properties
|
|
|
|
MimeType string
|
|
|
|
)
|
|
|
|
|
2019-12-15 18:05:26 +00:00
|
|
|
func (a ActivityVocabularyType) MarshalJSON() ([]byte, error) {
|
|
|
|
if len(a) == 0 {
|
|
|
|
return nil, nil
|
|
|
|
}
|
2019-12-19 16:05:12 +00:00
|
|
|
b := make([]byte, 0)
|
2021-01-01 12:59:01 +00:00
|
|
|
writeStringJSONValue(&b, string(a))
|
2019-12-19 16:05:12 +00:00
|
|
|
return b, nil
|
2019-12-15 18:05:26 +00:00
|
|
|
}
|
|
|
|
|
2021-03-14 18:36:32 +00:00
|
|
|
// GobEncode
|
|
|
|
func (a ActivityVocabularyType) GobEncode() ([]byte, error) {
|
2021-04-02 11:52:04 +00:00
|
|
|
if len(a) == 0 {
|
2021-12-30 15:22:15 +00:00
|
|
|
return []byte{}, nil
|
2021-04-02 11:52:04 +00:00
|
|
|
}
|
2021-12-30 15:22:15 +00:00
|
|
|
b := bytes.Buffer{}
|
|
|
|
gg := gob.NewEncoder(&b)
|
|
|
|
if err := encodeGobStringLikeType(gg, []byte(a)); err != nil {
|
2021-04-02 11:52:04 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
2021-12-30 15:22:15 +00:00
|
|
|
return b.Bytes(), nil
|
2021-03-14 18:36:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// GobDecode
|
2021-12-30 15:22:15 +00:00
|
|
|
func (a *ActivityVocabularyType) GobDecode(data []byte) error {
|
|
|
|
if len(data) == 0 {
|
|
|
|
// NOTE(marius): this behaviour diverges from vanilla gob package
|
|
|
|
return nil
|
|
|
|
}
|
2021-12-30 18:49:25 +00:00
|
|
|
var bb []byte
|
2021-12-30 15:22:15 +00:00
|
|
|
if err := gob.NewDecoder(bytes.NewReader(data)).Decode(&bb); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
*a = ActivityVocabularyType(bb)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
|
|
|
|
func (a *ActivityVocabularyType) UnmarshalBinary(data []byte) error {
|
|
|
|
return a.GobDecode(data)
|
|
|
|
}
|
|
|
|
|
|
|
|
// MarshalBinary implements the encoding.BinaryMarshaler interface.
|
|
|
|
func (a ActivityVocabularyType) MarshalBinary() ([]byte, error) {
|
|
|
|
return a.GobEncode()
|
2021-03-14 18:36:32 +00:00
|
|
|
}
|
|
|
|
|
2019-12-04 15:28:45 +00:00
|
|
|
// Object describes an ActivityPub object of any kind.
|
|
|
|
// It serves as the base type for most of the other kinds of objects defined in the Activity
|
2019-12-03 16:23:59 +00:00
|
|
|
// Vocabulary, including other Core types such as Activity, IntransitiveActivity, Collection and OrderedCollection.
|
2018-11-21 11:26:20 +00:00
|
|
|
type Object struct {
|
2019-12-03 16:23:59 +00:00
|
|
|
// ID provides the globally unique identifier for anActivity Pub Object or Link.
|
2019-12-05 18:02:15 +00:00
|
|
|
ID ID `jsonld:"id,omitempty"`
|
2019-12-03 16:23:59 +00:00
|
|
|
// Type identifies the Activity Pub Object or Link type. Multiple values may be specified.
|
|
|
|
Type ActivityVocabularyType `jsonld:"type,omitempty"`
|
|
|
|
// Name a simple, human-readable, plain-text name for the object.
|
|
|
|
// HTML markup MUST NOT be included. The name MAY be expressed using multiple language-tagged values.
|
|
|
|
Name NaturalLanguageValues `jsonld:"name,omitempty,collapsible"`
|
|
|
|
// Attachment identifies a resource attached or related to an object that potentially requires special handling.
|
|
|
|
// The intent is to provide a model that is at least semantically similar to attachments in email.
|
|
|
|
Attachment Item `jsonld:"attachment,omitempty"`
|
|
|
|
// AttributedTo identifies one or more entities to which this object is attributed. The attributed entities might not be Actors.
|
|
|
|
// For instance, an object might be attributed to the completion of another activity.
|
|
|
|
AttributedTo Item `jsonld:"attributedTo,omitempty"`
|
|
|
|
// Audience identifies one or more entities that represent the total population of entities
|
|
|
|
// for which the object can considered to be relevant.
|
|
|
|
Audience ItemCollection `jsonld:"audience,omitempty"`
|
|
|
|
// Content or textual representation of the Activity Pub Object encoded as a JSON string.
|
|
|
|
// By default, the value of content is HTML.
|
|
|
|
// The mediaType property can be used in the object to indicate a different content type.
|
|
|
|
// (The content MAY be expressed using multiple language-tagged values.)
|
|
|
|
Content NaturalLanguageValues `jsonld:"content,omitempty,collapsible"`
|
|
|
|
// Context identifies the context within which the object exists or an activity was performed.
|
|
|
|
// The notion of "context" used is intentionally vague.
|
|
|
|
// The intended function is to serve as a means of grouping objects and activities that share a
|
|
|
|
// common originating context or purpose. An example could be all activities relating to a common project or event.
|
|
|
|
Context Item `jsonld:"context,omitempty"`
|
|
|
|
// MediaType when used on an Object, identifies the MIME media type of the value of the content property.
|
|
|
|
// If not specified, the content property is assumed to contain text/html content.
|
|
|
|
MediaType MimeType `jsonld:"mediaType,omitempty"`
|
|
|
|
// EndTime the date and time describing the actual or expected ending time of the object.
|
|
|
|
// When used with an Activity object, for instance, the endTime property specifies the moment
|
|
|
|
// the activity concluded or is expected to conclude.
|
|
|
|
EndTime time.Time `jsonld:"endTime,omitempty"`
|
|
|
|
// Generator identifies the entity (e.g. an application) that generated the object.
|
|
|
|
Generator Item `jsonld:"generator,omitempty"`
|
|
|
|
// Icon indicates an entity that describes an icon for this object.
|
|
|
|
// The image should have an aspect ratio of one (horizontal) to one (vertical)
|
|
|
|
// and should be suitable for presentation at a small size.
|
|
|
|
Icon Item `jsonld:"icon,omitempty"`
|
|
|
|
// Image indicates an entity that describes an image for this object.
|
|
|
|
// Unlike the icon property, there are no aspect ratio or display size limitations assumed.
|
|
|
|
Image Item `jsonld:"image,omitempty"`
|
|
|
|
// InReplyTo indicates one or more entities for which this object is considered a response.
|
|
|
|
InReplyTo Item `jsonld:"inReplyTo,omitempty"`
|
|
|
|
// Location indicates one or more physical or logical locations associated with the object.
|
|
|
|
Location Item `jsonld:"location,omitempty"`
|
|
|
|
// Preview identifies an entity that provides a preview of this object.
|
|
|
|
Preview Item `jsonld:"preview,omitempty"`
|
|
|
|
// Published the date and time at which the object was published
|
|
|
|
Published time.Time `jsonld:"published,omitempty"`
|
|
|
|
// Replies identifies a Collection containing objects considered to be responses to this object.
|
|
|
|
Replies Item `jsonld:"replies,omitempty"`
|
|
|
|
// StartTime the date and time describing the actual or expected starting time of the object.
|
|
|
|
// When used with an Activity object, for instance, the startTime property specifies
|
|
|
|
// the moment the activity began or is scheduled to begin.
|
|
|
|
StartTime time.Time `jsonld:"startTime,omitempty"`
|
|
|
|
// Summary a natural language summarization of the object encoded as HTML.
|
|
|
|
// *Multiple language tagged summaries may be provided.)
|
|
|
|
Summary NaturalLanguageValues `jsonld:"summary,omitempty,collapsible"`
|
|
|
|
// Tag one or more "tags" that have been associated with an objects. A tag can be any kind of Activity Pub Object.
|
|
|
|
// The key difference between attachment and tag is that the former implies association by inclusion,
|
|
|
|
// while the latter implies associated by reference.
|
|
|
|
Tag ItemCollection `jsonld:"tag,omitempty"`
|
|
|
|
// Updated the date and time at which the object was updated
|
|
|
|
Updated time.Time `jsonld:"updated,omitempty"`
|
|
|
|
// URL identifies one or more links to representations of the object
|
|
|
|
URL LinkOrIRI `jsonld:"url,omitempty"`
|
|
|
|
// To identifies an entity considered to be part of the public primary audience of an Activity Pub Object
|
|
|
|
To ItemCollection `jsonld:"to,omitempty"`
|
|
|
|
// Bto identifies anActivity Pub Object that is part of the private primary audience of this Activity Pub Object.
|
|
|
|
Bto ItemCollection `jsonld:"bto,omitempty"`
|
|
|
|
// CC identifies anActivity Pub Object that is part of the public secondary audience of this Activity Pub Object.
|
|
|
|
CC ItemCollection `jsonld:"cc,omitempty"`
|
|
|
|
// BCC identifies one or more Objects that are part of the private secondary audience of this Activity Pub Object.
|
|
|
|
BCC ItemCollection `jsonld:"bcc,omitempty"`
|
|
|
|
// Duration when the object describes a time-bound resource, such as an audio or video, a meeting, etc,
|
|
|
|
// the duration property indicates the object's approximate duration.
|
|
|
|
// The value must be expressed as an xsd:duration as defined by [ xmlschema11-2],
|
|
|
|
// section 3.3.6 (e.g. a period of 5 seconds is represented as "PT5S").
|
|
|
|
Duration time.Duration `jsonld:"duration,omitempty"`
|
2019-09-28 07:30:01 +00:00
|
|
|
// This is a list of all Like activities with this object as the object property, added as a side effect.
|
|
|
|
// The likes collection MUST be either an OrderedCollection or a Collection and MAY be filtered on privileges
|
|
|
|
// of an authenticated user or as appropriate when no authentication is given.
|
2019-12-03 16:23:59 +00:00
|
|
|
Likes Item `jsonld:"likes,omitempty"`
|
2019-09-28 07:30:01 +00:00
|
|
|
// This is a list of all Announce activities with this object as the object property, added as a side effect.
|
|
|
|
// The shares collection MUST be either an OrderedCollection or a Collection and MAY be filtered on privileges
|
|
|
|
// of an authenticated user or as appropriate when no authentication is given.
|
2019-12-03 16:23:59 +00:00
|
|
|
Shares Item `jsonld:"shares,omitempty"`
|
2018-11-21 11:26:20 +00:00
|
|
|
// Source property is intended to convey some sort of source from which the content markup was derived,
|
|
|
|
// as a form of provenance, or to support future editing by clients.
|
|
|
|
// In general, clients do the conversion from source to content, not the other way around.
|
|
|
|
Source Source `jsonld:"source,omitempty"`
|
|
|
|
}
|
|
|
|
|
2019-12-03 16:23:59 +00:00
|
|
|
// ObjectNew initializes a new Object
|
|
|
|
func ObjectNew(typ ActivityVocabularyType) *Object {
|
|
|
|
if !(ObjectTypes.Contains(typ)) {
|
|
|
|
typ = ObjectType
|
|
|
|
}
|
|
|
|
o := Object{Type: typ}
|
|
|
|
o.Name = NaturalLanguageValuesNew()
|
|
|
|
o.Content = NaturalLanguageValuesNew()
|
|
|
|
return &o
|
|
|
|
}
|
2018-11-21 11:26:20 +00:00
|
|
|
|
2019-12-05 18:02:15 +00:00
|
|
|
// GetID returns the ID corresponding to the current Object
|
|
|
|
func (o Object) GetID() ID {
|
2019-12-03 16:23:59 +00:00
|
|
|
return o.ID
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetLink returns the IRI corresponding to the current Object
|
|
|
|
func (o Object) GetLink() IRI {
|
|
|
|
return IRI(o.ID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetType returns the type of the current Object
|
|
|
|
func (o Object) GetType() ActivityVocabularyType {
|
|
|
|
return o.Type
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsLink validates if currentActivity Pub Object is a Link
|
|
|
|
func (o Object) IsLink() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsObject validates if currentActivity Pub Object is an Object
|
|
|
|
func (o Object) IsObject() bool {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsCollection returns false for Object objects
|
|
|
|
func (o Object) IsCollection() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2021-11-12 18:10:31 +00:00
|
|
|
// UnmarshalJSON decodes an incoming JSON document into the receiver object.
|
2019-12-03 16:23:59 +00:00
|
|
|
func (o *Object) UnmarshalJSON(data []byte) error {
|
2021-08-15 11:41:01 +00:00
|
|
|
p := fastjson.Parser{}
|
|
|
|
val, err := p.ParseBytes(data)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return loadObject(val, o)
|
2019-12-03 16:23:59 +00:00
|
|
|
}
|
2018-11-21 11:26:20 +00:00
|
|
|
|
2021-11-12 18:10:31 +00:00
|
|
|
// MarshalJSON encodes the receiver object to a JSON document.
|
2019-12-15 18:05:26 +00:00
|
|
|
func (o Object) MarshalJSON() ([]byte, error) {
|
2019-12-19 16:05:12 +00:00
|
|
|
b := make([]byte, 0)
|
|
|
|
write(&b, '{')
|
2019-12-18 09:02:23 +00:00
|
|
|
|
2021-01-01 12:59:01 +00:00
|
|
|
if writeObjectJSONValue(&b, o) {
|
2019-12-19 16:05:12 +00:00
|
|
|
write(&b, '}')
|
|
|
|
return b, nil
|
2019-12-18 09:02:23 +00:00
|
|
|
}
|
|
|
|
return nil, nil
|
2019-12-15 18:05:26 +00:00
|
|
|
}
|
|
|
|
|
2021-04-02 11:52:04 +00:00
|
|
|
/*
|
2021-03-14 18:36:32 +00:00
|
|
|
// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
|
|
|
|
func (o *Object) UnmarshalBinary(data []byte) error {
|
|
|
|
return errors.New(fmt.Sprintf("UnmarshalBinary is not implemented for %T", *o))
|
|
|
|
}
|
|
|
|
|
|
|
|
// MarshalBinary implements the encoding.BinaryMarshaler interface.
|
|
|
|
func (o Object) MarshalBinary() ([]byte, error) {
|
2021-04-02 11:52:04 +00:00
|
|
|
w := &bytes.Buffer{}
|
|
|
|
enc := gobEncoder{ w: w, enc: gob.NewEncoder(w) }
|
|
|
|
if _, err := enc.writeObjectGobValue(o); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return w.Bytes(), nil
|
2021-03-14 18:36:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// GobEncode
|
|
|
|
func (o Object) GobEncode() ([]byte, error) {
|
|
|
|
return o.MarshalBinary()
|
|
|
|
}
|
|
|
|
|
|
|
|
// GobDecode
|
|
|
|
func (o *Object) GobDecode(data []byte) error {
|
|
|
|
return o.UnmarshalBinary(data)
|
|
|
|
}
|
2021-04-02 11:52:04 +00:00
|
|
|
*/
|
2021-03-14 18:36:32 +00:00
|
|
|
|
2019-12-03 16:23:59 +00:00
|
|
|
// Recipients performs recipient de-duplication on the Object's To, Bto, CC and BCC properties
|
|
|
|
func (o *Object) Recipients() ItemCollection {
|
|
|
|
var aud ItemCollection
|
2020-05-15 13:17:35 +00:00
|
|
|
return ItemCollectionDeduplication(&aud, &o.To, &o.Bto, &o.CC, &o.BCC, &o.Audience)
|
2019-12-03 16:23:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Clean removes Bto and BCC properties
|
|
|
|
func (o *Object) Clean() {
|
|
|
|
o.BCC = nil
|
|
|
|
o.Bto = nil
|
|
|
|
}
|
|
|
|
|
|
|
|
type (
|
|
|
|
// Article represents any kind of multi-paragraph written work.
|
|
|
|
Article = Object
|
|
|
|
// Audio represents an audio document of any kind.
|
|
|
|
Audio = Document
|
|
|
|
// Document represents a document of any kind.
|
|
|
|
Document = Object
|
|
|
|
// Event represents any kind of event.
|
|
|
|
Event = Object
|
|
|
|
// Image An image document of any kind
|
|
|
|
Image = Document
|
|
|
|
// Note represents a short written work typically less than a single paragraph in length.
|
|
|
|
Note = Object
|
|
|
|
// Page represents a Web Page.
|
|
|
|
Page = Document
|
|
|
|
// Video represents a video document of any kind
|
|
|
|
Video = Document
|
|
|
|
)
|
|
|
|
|
2021-11-12 18:10:31 +00:00
|
|
|
// UnmarshalJSON decodes an incoming JSON document into the receiver object.
|
2020-12-28 13:58:41 +00:00
|
|
|
func (m *MimeType) UnmarshalJSON(data []byte) error {
|
|
|
|
*m = MimeType(strings.Trim(string(data), "\""))
|
2018-11-21 11:26:20 +00:00
|
|
|
return nil
|
|
|
|
}
|
2019-09-09 18:21:45 +00:00
|
|
|
|
2021-11-12 18:10:31 +00:00
|
|
|
// MarshalJSON encodes the receiver object to a JSON document.
|
2019-12-19 12:34:04 +00:00
|
|
|
func (m MimeType) MarshalJSON() ([]byte, error) {
|
|
|
|
if len(m) == 0 {
|
2019-12-15 18:05:26 +00:00
|
|
|
return nil, nil
|
|
|
|
}
|
2019-12-19 16:05:12 +00:00
|
|
|
b := make([]byte, 0)
|
2021-01-01 12:59:01 +00:00
|
|
|
writeStringJSONValue(&b, string(m))
|
2019-12-19 16:05:12 +00:00
|
|
|
return b, nil
|
2019-12-15 18:05:26 +00:00
|
|
|
}
|
|
|
|
|
2021-12-30 15:15:16 +00:00
|
|
|
// GobEncode
|
|
|
|
func (m MimeType) GobEncode() ([]byte, error) {
|
|
|
|
if len(m) == 0 {
|
|
|
|
return []byte{}, nil
|
|
|
|
}
|
|
|
|
b := bytes.Buffer{}
|
|
|
|
gg := gob.NewEncoder(&b)
|
|
|
|
if err := encodeGobStringLikeType(gg, []byte(m)); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return b.Bytes(), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GobDecode
|
|
|
|
func (m *MimeType) GobDecode(data []byte) error {
|
|
|
|
if len(data) == 0 {
|
|
|
|
// NOTE(marius): this behaviour diverges from vanilla gob package
|
|
|
|
return nil
|
|
|
|
}
|
2021-12-30 18:49:25 +00:00
|
|
|
var bb []byte
|
2021-12-30 15:15:16 +00:00
|
|
|
if err := gob.NewDecoder(bytes.NewReader(data)).Decode(&bb); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
*m = MimeType(bb)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-03-14 18:36:32 +00:00
|
|
|
// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
|
|
|
|
func (m *MimeType) UnmarshalBinary(data []byte) error {
|
2021-12-30 15:15:16 +00:00
|
|
|
return m.GobDecode(data)
|
2021-03-14 18:36:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// MarshalBinary implements the encoding.BinaryMarshaler interface.
|
|
|
|
func (m MimeType) MarshalBinary() ([]byte, error) {
|
2021-12-30 15:15:16 +00:00
|
|
|
return m.GobEncode()
|
2021-03-14 18:36:32 +00:00
|
|
|
}
|
|
|
|
|
2020-12-28 13:59:16 +00:00
|
|
|
// ToLink returns a Link pointer to the data in the current Item
|
|
|
|
func ToLink(it Item) (*Link, error) {
|
|
|
|
switch i := it.(type) {
|
|
|
|
case *Link:
|
|
|
|
return i, nil
|
|
|
|
case Link:
|
|
|
|
return &i, nil
|
|
|
|
}
|
|
|
|
return nil, fmt.Errorf("unable to convert %q", it.GetType())
|
|
|
|
}
|
|
|
|
|
2019-12-03 16:23:59 +00:00
|
|
|
// ToObject returns an Object pointer to the data in the current Item
|
|
|
|
// It relies on the fact that all the types in this package have a data layout compatible with Object.
|
|
|
|
func ToObject(it Item) (*Object, error) {
|
2019-09-09 18:21:45 +00:00
|
|
|
switch i := it.(type) {
|
|
|
|
case *Object:
|
|
|
|
return i, nil
|
|
|
|
case Object:
|
|
|
|
return &i, nil
|
2019-12-03 16:23:59 +00:00
|
|
|
case *Place:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case Place:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
|
|
|
case *Profile:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case Profile:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
|
|
|
case *Relationship:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case Relationship:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
|
|
|
case *Tombstone:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case Tombstone:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
2019-12-04 18:34:04 +00:00
|
|
|
case *Actor:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case Actor:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
2019-12-03 16:23:59 +00:00
|
|
|
case *Activity:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case Activity:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
|
|
|
case *IntransitiveActivity:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case IntransitiveActivity:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
|
|
|
case *Question:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case Question:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
|
|
|
case *Collection:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case Collection:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
|
|
|
case *CollectionPage:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case CollectionPage:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
|
|
|
case *OrderedCollection:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case OrderedCollection:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
|
|
|
case *OrderedCollectionPage:
|
|
|
|
return (*Object)(unsafe.Pointer(i)), nil
|
|
|
|
case OrderedCollectionPage:
|
|
|
|
return (*Object)(unsafe.Pointer(&i)), nil
|
2020-07-16 19:54:46 +00:00
|
|
|
default:
|
|
|
|
// NOTE(marius): this is an ugly way of dealing with the interface conversion error: types from different scopes
|
|
|
|
typ := reflect.TypeOf(new(Object))
|
|
|
|
if reflect.TypeOf(it).ConvertibleTo(typ) {
|
|
|
|
if i, ok := reflect.ValueOf(it).Convert(typ).Interface().(*Object); ok {
|
|
|
|
return i, nil
|
|
|
|
}
|
|
|
|
}
|
2019-09-09 18:21:45 +00:00
|
|
|
}
|
2019-12-03 16:23:59 +00:00
|
|
|
return nil, fmt.Errorf("unable to convert %q", it.GetType())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Source is intended to convey some sort of source from which the content markup was derived,
|
|
|
|
// as a form of provenance, or to support future editing by clients.
|
|
|
|
type Source struct {
|
|
|
|
// Content
|
|
|
|
Content NaturalLanguageValues `jsonld:"content"`
|
|
|
|
// MediaType
|
|
|
|
MediaType MimeType `jsonld:"mediaType"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetAPSource
|
2021-08-15 11:41:01 +00:00
|
|
|
func GetAPSource(val *fastjson.Value) Source {
|
2019-12-03 16:23:59 +00:00
|
|
|
s := Source{}
|
2021-08-15 11:41:01 +00:00
|
|
|
if val == nil {
|
|
|
|
return s
|
|
|
|
}
|
2019-12-03 16:23:59 +00:00
|
|
|
|
2021-08-15 11:41:01 +00:00
|
|
|
if contBytes := val.Get("source", "content").GetStringBytes(); len(contBytes) > 0 {
|
2019-12-03 16:23:59 +00:00
|
|
|
s.Content.UnmarshalJSON(contBytes)
|
|
|
|
}
|
2021-08-15 11:41:01 +00:00
|
|
|
if mimeBytes := val.Get("source", "mediaType").GetStringBytes(); len(mimeBytes) > 0 {
|
2019-12-03 16:23:59 +00:00
|
|
|
s.MediaType.UnmarshalJSON(mimeBytes)
|
|
|
|
}
|
|
|
|
|
|
|
|
return s
|
|
|
|
}
|
|
|
|
|
2021-11-12 18:10:31 +00:00
|
|
|
// UnmarshalJSON decodes an incoming JSON document into the receiver object.
|
2019-12-03 16:23:59 +00:00
|
|
|
func (s *Source) UnmarshalJSON(data []byte) error {
|
2021-08-15 11:41:01 +00:00
|
|
|
p := fastjson.Parser{}
|
|
|
|
val, err := p.ParseBytes(data)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
*s = GetAPSource(val)
|
2019-12-03 16:23:59 +00:00
|
|
|
return nil
|
2019-09-09 18:21:45 +00:00
|
|
|
}
|
2019-12-15 18:05:26 +00:00
|
|
|
|
2021-11-12 18:10:31 +00:00
|
|
|
// MarshalJSON encodes the receiver object to a JSON document.
|
2019-12-15 18:05:26 +00:00
|
|
|
func (s Source) MarshalJSON() ([]byte, error) {
|
2019-12-19 16:05:12 +00:00
|
|
|
b := make([]byte, 0)
|
2019-12-18 09:02:23 +00:00
|
|
|
empty := true
|
2019-12-19 16:05:12 +00:00
|
|
|
write(&b, '{')
|
2019-12-15 18:05:26 +00:00
|
|
|
if len(s.MediaType) > 0 {
|
2019-12-18 09:02:23 +00:00
|
|
|
if v, err := s.MediaType.MarshalJSON(); err == nil && len(v) > 0 {
|
2021-01-01 12:59:01 +00:00
|
|
|
empty = !writeJSONProp(&b, "mediaType", v)
|
2019-12-15 18:05:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(s.Content) > 0 {
|
2021-01-01 12:59:01 +00:00
|
|
|
empty = !writeNaturalLanguageJSONProp(&b, "content", s.Content)
|
2019-12-15 18:05:26 +00:00
|
|
|
}
|
2019-12-18 09:02:23 +00:00
|
|
|
if !empty {
|
2019-12-19 16:05:12 +00:00
|
|
|
write(&b, '}')
|
|
|
|
return b, nil
|
2019-12-18 09:02:23 +00:00
|
|
|
}
|
|
|
|
return nil, nil
|
2019-12-15 18:05:26 +00:00
|
|
|
}
|
2020-05-07 14:44:17 +00:00
|
|
|
|
2021-04-02 11:52:04 +00:00
|
|
|
/*
|
2021-03-14 18:36:32 +00:00
|
|
|
// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
|
|
|
|
func (s *Source) UnmarshalBinary(data []byte) error {
|
|
|
|
return errors.New(fmt.Sprintf("UnmarshalBinary is not implemented for %T", *s))
|
|
|
|
}
|
|
|
|
|
|
|
|
// MarshalBinary implements the encoding.BinaryMarshaler interface.
|
|
|
|
func (s Source) MarshalBinary() ([]byte, error) {
|
|
|
|
return nil, errors.New(fmt.Sprintf("MarshalBinary is not implemented for %T", s))
|
|
|
|
}
|
|
|
|
|
|
|
|
// GobDecode
|
|
|
|
func (s *Source) GobDecode([]byte) error {
|
|
|
|
return errors.New(fmt.Sprintf("GobDecode is not implemented for %T", *s))
|
|
|
|
}
|
|
|
|
|
|
|
|
// GobEncode
|
|
|
|
func (s Source) GobEncode() ([]byte, error) {
|
|
|
|
return nil, errors.New(fmt.Sprintf("GobEncode is not implemented for %T", s))
|
|
|
|
}
|
2021-11-07 14:06:16 +00:00
|
|
|
*/
|
2021-03-14 18:36:32 +00:00
|
|
|
|
2020-05-07 14:44:17 +00:00
|
|
|
// Equals verifies if our receiver Object is equals with the "with" Object
|
|
|
|
func (o Object) Equals(with Item) bool {
|
|
|
|
if with.IsCollection() {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
if withID := with.GetID(); len(withID) > 0 && withID != o.ID {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
if withType := with.GetType(); len(withType) > 0 && withType != o.Type {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
if with.IsLink() && !with.GetLink().Equals(o.GetLink(), false) {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
result := true
|
|
|
|
OnObject(with, func(w *Object) error {
|
|
|
|
if len(w.Name) > 0 {
|
|
|
|
if !w.Name.Equals(o.Name) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(w.Summary) > 0 {
|
|
|
|
if !w.Summary.Equals(o.Summary) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(w.Content) > 0 {
|
|
|
|
if !w.Content.Equals(o.Content) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Attachment != nil {
|
|
|
|
if !ItemsEqual(o.Attachment, w.Attachment) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.AttributedTo != nil {
|
|
|
|
if !ItemsEqual(o.AttributedTo, w.AttributedTo) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Audience != nil {
|
|
|
|
if !ItemsEqual(o.Audience, w.Audience) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Context != nil {
|
|
|
|
if !ItemsEqual(o.Context, w.Context) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Generator != nil {
|
|
|
|
if !ItemsEqual(o.Generator, w.Generator) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Icon != nil {
|
|
|
|
if !ItemsEqual(o.Icon, w.Icon) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Image != nil {
|
|
|
|
if !ItemsEqual(o.Image, w.Image) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.InReplyTo != nil {
|
|
|
|
if !ItemsEqual(o.InReplyTo, w.InReplyTo) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Location != nil {
|
|
|
|
if !ItemsEqual(o.Location, w.Location) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Preview != nil {
|
|
|
|
if !ItemsEqual(o.Preview, w.Preview) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Replies != nil {
|
|
|
|
if !ItemsEqual(o.Replies, w.Replies) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Tag != nil {
|
|
|
|
if !ItemsEqual(o.Tag, w.Tag) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.URL != nil {
|
2020-05-15 13:17:35 +00:00
|
|
|
if o.URL == nil {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
2020-05-07 14:44:17 +00:00
|
|
|
if !w.URL.GetLink().Equals(o.URL.GetLink(), false) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.To != nil {
|
|
|
|
if !ItemsEqual(o.To, w.To) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Bto != nil {
|
|
|
|
if !ItemsEqual(o.Bto, w.Bto) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.CC != nil {
|
|
|
|
if !ItemsEqual(o.CC, w.CC) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.BCC != nil {
|
|
|
|
if !ItemsEqual(o.BCC, w.BCC) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !w.Published.IsZero() {
|
|
|
|
if !w.Published.Equal(o.Published) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !w.Updated.IsZero() {
|
|
|
|
if !w.Updated.Equal(o.Updated) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !w.StartTime.IsZero() {
|
|
|
|
if !w.StartTime.Equal(o.StartTime) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !w.EndTime.IsZero() {
|
|
|
|
if !w.EndTime.Equal(o.EndTime) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Duration != 0 {
|
|
|
|
if w.Duration != o.Duration {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Likes != nil {
|
|
|
|
if !ItemsEqual(o.Likes, w.Likes) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w.Shares != nil {
|
|
|
|
if !ItemsEqual(o.Shares, w.Shares) {
|
|
|
|
result = false
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
})
|
|
|
|
return result
|
|
|
|
}
|