mirror of
https://github.com/superseriousbusiness/gotosocial
synced 2024-11-23 12:53:23 +00:00
0e29f1f5bb
Co-authored-by: kim <grufwub@gmail.com> Co-authored-by: kim <89579420+NyaaaWhatsUpDoc@users.noreply.github.com>
206 lines
6.4 KiB
Go
206 lines
6.4 KiB
Go
// GoToSocial
|
|
// Copyright (C) GoToSocial Authors admin@gotosocial.org
|
|
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package ap
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/superseriousbusiness/activity/streams"
|
|
"github.com/superseriousbusiness/activity/streams/vocab"
|
|
)
|
|
|
|
// Serialize is a custom serializer for ActivityStreams types.
|
|
//
|
|
// In most cases, it will simply call the go-fed streams.Serialize function under the hood.
|
|
// However, if custom serialization is required on a specific type (eg for inter-implementation
|
|
// compatibility), it can be inserted into the switch as necessary.
|
|
//
|
|
// Callers should always call this function instead of streams.Serialize, unless there's a
|
|
// very good reason to do otherwise.
|
|
//
|
|
// Currently, the following things will be custom serialized:
|
|
//
|
|
// - OrderedCollection: 'orderedItems' property will always be made into an array.
|
|
// - Any Accountable type: 'attachment' property will always be made into an array.
|
|
// - Update: any Accountable 'object's set on an update will be custom serialized as above.
|
|
func Serialize(t vocab.Type) (m map[string]interface{}, e error) {
|
|
switch t.GetTypeName() {
|
|
case ObjectOrderedCollection:
|
|
return serializeOrderedCollection(t)
|
|
case ActorApplication, ActorGroup, ActorOrganization, ActorPerson, ActorService:
|
|
return serializeAccountable(t, true)
|
|
case ActivityUpdate:
|
|
return serializeWithObject(t)
|
|
default:
|
|
// No custom serializer necessary.
|
|
return streams.Serialize(t)
|
|
}
|
|
}
|
|
|
|
// serializeOrderedCollection is a custom serializer for an ActivityStreamsOrderedCollection.
|
|
// Unlike the standard streams.Serialize function, this serializer normalizes the orderedItems
|
|
// value to always be an array/slice, regardless of how many items are contained therein.
|
|
//
|
|
// TODO: Remove this function if we can fix the underlying issue in Go-Fed.
|
|
//
|
|
// See:
|
|
// - https://github.com/go-fed/activity/issues/139
|
|
// - https://github.com/mastodon/mastodon/issues/24225
|
|
func serializeOrderedCollection(orderedCollection vocab.Type) (map[string]interface{}, error) {
|
|
data, err := streams.Serialize(orderedCollection)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
orderedItems, ok := data["orderedItems"]
|
|
if !ok {
|
|
// No 'orderedItems', nothing to change.
|
|
return data, nil
|
|
}
|
|
|
|
if _, ok := orderedItems.([]interface{}); ok {
|
|
// Already slice.
|
|
return data, nil
|
|
}
|
|
|
|
// Coerce single-object to slice.
|
|
data["orderedItems"] = []interface{}{orderedItems}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
// SerializeAccountable is a custom serializer for any Accountable type.
|
|
// This serializer rewrites the 'attachment' value of the Accountable, if
|
|
// present, to always be an array/slice.
|
|
//
|
|
// While this is not strictly necessary in json-ld terms, most other fedi
|
|
// implementations look for attachment to be an array of PropertyValue (field)
|
|
// entries, and will not parse single-entry, non-array attachments on accounts
|
|
// properly.
|
|
//
|
|
// If the accountable is being serialized as a top-level object (eg., for serving
|
|
// in response to an account dereference request), then includeContext should be
|
|
// set to true, so as to include the json-ld '@context' entries in the data.
|
|
// If the accountable is being serialized as part of another object (eg., as the
|
|
// object of an activity), then includeContext should be set to false, as the
|
|
// @context entry should be included on the top-level/wrapping activity/object.
|
|
func serializeAccountable(accountable vocab.Type, includeContext bool) (map[string]interface{}, error) {
|
|
var (
|
|
data map[string]interface{}
|
|
err error
|
|
)
|
|
|
|
if includeContext {
|
|
data, err = streams.Serialize(accountable)
|
|
} else {
|
|
data, err = accountable.Serialize()
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
attachment, ok := data["attachment"]
|
|
if !ok {
|
|
// No 'attachment', nothing to change.
|
|
return data, nil
|
|
}
|
|
|
|
if _, ok := attachment.([]interface{}); ok {
|
|
// Already slice.
|
|
return data, nil
|
|
}
|
|
|
|
// Coerce single-object to slice.
|
|
data["attachment"] = []interface{}{attachment}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
func serializeWithObject(t vocab.Type) (map[string]interface{}, error) {
|
|
withObject, ok := t.(WithObject)
|
|
if !ok {
|
|
return nil, fmt.Errorf("serializeWithObject: could not resolve %T to WithObject", t)
|
|
}
|
|
|
|
data, err := streams.Serialize(t)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
object := withObject.GetActivityStreamsObject()
|
|
if object == nil {
|
|
// Nothing to do, bail early.
|
|
return data, nil
|
|
}
|
|
|
|
objectLen := object.Len()
|
|
if objectLen == 0 {
|
|
// Nothing to do, bail early.
|
|
return data, nil
|
|
}
|
|
|
|
// The thing we already serialized has objects
|
|
// on it, so we should see if we need to custom
|
|
// serialize any of those objects, and replace
|
|
// them on the data map as necessary.
|
|
objects := make([]interface{}, 0, objectLen)
|
|
for iter := object.Begin(); iter != object.End(); iter = iter.Next() {
|
|
if iter.IsIRI() {
|
|
// Plain IRIs don't need custom serialization.
|
|
objects = append(objects, iter.GetIRI().String())
|
|
continue
|
|
}
|
|
|
|
var (
|
|
objectType = iter.GetType()
|
|
objectSer map[string]interface{}
|
|
)
|
|
|
|
if objectType == nil {
|
|
// This is awkward.
|
|
return nil, fmt.Errorf("serializeWithObject: could not resolve object iter %T to vocab.Type", iter)
|
|
}
|
|
|
|
switch objectType.GetTypeName() {
|
|
case ActorApplication, ActorGroup, ActorOrganization, ActorPerson, ActorService:
|
|
// @context will be included in wrapping type already,
|
|
// we don't need to include it in the object itself.
|
|
objectSer, err = serializeAccountable(objectType, false)
|
|
default:
|
|
// No custom serializer for this type; serialize as normal.
|
|
objectSer, err = objectType.Serialize()
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
objects = append(objects, objectSer)
|
|
}
|
|
|
|
if objectLen == 1 {
|
|
// Unnest single object.
|
|
data["object"] = objects[0]
|
|
} else {
|
|
// Array of objects.
|
|
data["object"] = objects
|
|
}
|
|
|
|
return data, nil
|
|
}
|