goap/nsActivitystreams.go

package goap

import (
	"time"

	"gitlab.com/mstarongitlab/goutils/sliceutils"
)

type ASActorData struct {
	FullIdType
}

func (actor *ASActorData) GetSelfOrBase() (BaseApChain, bool) {
	return actor.FullIdType.GetSelfOrBase()
}

func (actor *ASActorData) MarshalToMap() map[string]any {
	return actor.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_ACTOR)
}

type ASAlsoKnownAsData struct {
	Next BaseApChain
	Urls []string
}

func (cc *ASAlsoKnownAsData) GetSelfOrBase() (BaseApChain, bool) {
	return cc.Next, true
}

func (cc *ASAlsoKnownAsData) MarshalToMap() map[string]any {
	return appendWithKey(
		cc.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_ALSOKNOWNAS,
		sliceutils.Map(cc.Urls, func(t string) map[string]any {
			return map[string]any{KEY_ID: t}
		}),
	)
}

type ASAttachmentsData struct {
	Next        BaseApChain
	Attachments []Attachment
}

func (attachmentsdata *ASAttachmentsData) GetSelfOrBase() (BaseApChain, bool) {
	return attachmentsdata.Next, true
}

func (attachmentsdata *ASAttachmentsData) MarshalToMap() map[string]any {
	return appendWithKey(
		attachmentsdata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_ATTACHMENTS,
		sliceutils.Map(
			attachmentsdata.Attachments,
			func(t Attachment) map[string]any { return t.Marshal() },
		),
	)
}

type ASAttributedToData struct {
	FullIdType
}

func (attributedtodata *ASAttributedToData) GetSelfOrBase() (BaseApChain, bool) {
	return attributedtodata.FullIdType.Next, true
}

func (attributedtodata *ASAttributedToData) MarshalToMap() map[string]any {
	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_ATTRIBUTEDTO)
}

type ASCCData struct {
	Next    BaseApChain
	Targets []string
}

func (cc *ASCCData) GetSelfOrBase() (BaseApChain, bool) {
	return cc.Next, true
}

func (cc *ASCCData) MarshalToMap() map[string]any {
	return appendWithKey(
		cc.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_CC,
		sliceutils.Map(cc.Targets, func(t string) map[string]any {
			return map[string]any{KEY_ID: t}
		}),
	)
}

type ASContentData struct {
	Next    BaseApChain
	Content []ValueValue[string]
}

func (contentdata *ASContentData) GetSelfOrBase() (BaseApChain, bool) {
	return contentdata.Next, true
}

func (contentdata *ASContentData) MarshalToMap() map[string]any {
	return appendWithKey(
		contentdata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_CONTENT,
		sliceutils.Map(contentdata.Content, func(t ValueValue[string]) map[string]any {
			return t.Marshal()
		}),
	)
}

type ASEndpointsData struct {
	Next      BaseApChain
	Endpoints map[string]string
}

func (endpointsdata *ASEndpointsData) GetSelfOrBase() (BaseApChain, bool) {
	return endpointsdata.Next, true
}

func (endpointsdata *ASEndpointsData) MarshalToMap() map[string]any {
	m := endpointsdata.Next.MarshalToMap()
	arr := []map[string]any{}
	for k, v := range endpointsdata.Endpoints {
		arr = append(arr, map[string]any{
			k: []map[string]any{{KEY_ID: v}},
		})
	}
	m[KEY_ACTIVITYSTREAMS_ENDPOINTS] = arr
	return m
}

type ASFollowersData struct {
	FullIdType
}

func (attributedtodata *ASFollowersData) GetSelfOrBase() (BaseApChain, bool) {
	return attributedtodata.FullIdType.Next, true
}

func (attributedtodata *ASFollowersData) MarshalToMap() map[string]any {
	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_FOLLOWERS)
}

type ASFollowingData struct {
	FullIdType
}

func (attributedtodata *ASFollowingData) GetSelfOrBase() (BaseApChain, bool) {
	return attributedtodata.FullIdType.Next, true
}

func (attributedtodata *ASFollowingData) MarshalToMap() map[string]any {
	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_FOLLOWING)
}

type ASHrefData struct {
	FullIdType
}

func (attributedtodata *ASHrefData) GetSelfOrBase() (BaseApChain, bool) {
	return attributedtodata.FullIdType.Next, true
}

func (attributedtodata *ASHrefData) MarshalToMap() map[string]any {
	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_HREF)
}

type ASIconData struct {
	Next  BaseApChain
	Media Media
}

func (icondata *ASIconData) GetSelfOrBase() (BaseApChain, bool) {
	return icondata.Next, true
}

func (icondata *ASIconData) MarshalToMap() map[string]any {
	return appendWithKey(
		icondata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_ICON,
		[]map[string]any{icondata.Media.Marshal()},
	)
}

type ASImageData struct {
	Next  BaseApChain
	Media Media
}

func (icondata *ASImageData) GetSelfOrBase() (BaseApChain, bool) {
	return icondata.Next, true
}

func (icondata *ASImageData) MarshalToMap() map[string]any {
	return appendWithKey(
		icondata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE,
		[]map[string]any{icondata.Media.Marshal()},
	)
}

type ASMediaTypeData struct {
	Next BaseApChain
	Type string
}

func (mediatypedata *ASMediaTypeData) GetSelfOrBase() (BaseApChain, bool) {
	return mediatypedata.Next, true
}

func (mediatypedata *ASMediaTypeData) MarshalToMap() map[string]any {
	return appendWithKey(
		mediatypedata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_MEDIATYPE,
		ValueValue[string]{
			Value:       mediatypedata.Type,
			Type:        nil,
			OtherThings: map[string]any{},
		}.Marshal(),
	)
}

type ASNameData struct {
	Next BaseApChain
	Name ValueValue[string]
}

func (namedata *ASNameData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASNameData) MarshalToMap() map[string]any {
	return appendWithKey(
		namedata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_NAME,
		[]map[string]any{namedata.Name.Marshal()},
	)
}

type ASOutboxData struct {
	FullIdType
}

func (attributedtodata *ASOutboxData) GetSelfOrBase() (BaseApChain, bool) {
	return attributedtodata.FullIdType.Next, true
}

func (attributedtodata *ASOutboxData) MarshalToMap() map[string]any {
	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_HREF)
}

type ASObjectData struct {
	FullIdType
}

func (object *ASObjectData) GetSelfOrBase() (BaseApChain, bool) {
	return object.FullIdType.Next, true
}

func (object *ASObjectData) MarshalToMap() map[string]any {
	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_OBJECT)
}

type ASPreferredNameData struct {
	Next BaseApChain
	Name ValueValue[string]
}

func (namedata *ASPreferredNameData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASPreferredNameData) MarshalToMap() map[string]any {
	return appendWithKey(
		namedata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME,
		[]map[string]any{namedata.Name.Marshal()},
	)
}

type ASPublishedData struct {
	Next      BaseApChain
	Timestamp time.Time
}

func (publisheddata *ASPublishedData) GetSelfOrBase() (BaseApChain, bool) {
	return publisheddata.Next, true
}

func (publisheddata *ASPublishedData) MarshalToMap() map[string]any {
	m := publisheddata.Next.MarshalToMap()
	m[KEY_ACTIVITYSTREAMS_PUBLISHED] = timeToXmlTime(publisheddata.Timestamp)
	return m
}

type ASRestrictedFollowData struct {
	Next  BaseApChain
	Value ValueValue[bool]
}

func (namedata *ASRestrictedFollowData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASRestrictedFollowData) MarshalToMap() map[string]any {
	return appendWithKey(
		namedata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW,
		[]map[string]any{namedata.Value.Marshal()},
	)
}

type ASRepliesData struct {
	FullIdType
}

func (object *ASRepliesData) GetSelfOrBase() (BaseApChain, bool) {
	return object.FullIdType.Next, true
}

func (object *ASRepliesData) MarshalToMap() map[string]any {
	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_REPLIES)
}

type ASSharedInboxData struct {
	FullIdType
}

func (object *ASSharedInboxData) GetSelfOrBase() (BaseApChain, bool) {
	return object.FullIdType.Next, true
}

func (object *ASSharedInboxData) MarshalToMap() map[string]any {
	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SHAREDINBOX)
}

type ASSummaryData struct {
	Next BaseApChain
	Name ValueValue[string]
}

func (namedata *ASSummaryData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASSummaryData) MarshalToMap() map[string]any {
	return appendWithKey(
		namedata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_SUMMARY,
		[]map[string]any{namedata.Name.Marshal()},
	)
}

type ASSensitiveData struct {
	Next BaseApChain
	Name ValueValue[bool]
}

func (namedata *ASSensitiveData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASSensitiveData) MarshalToMap() map[string]any {
	return appendWithKey(
		namedata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_SENSITIVE,
		[]map[string]any{namedata.Name.Marshal()},
	)
}

type ASTagData struct {
	Next BaseApChain
	Tags []string
}

func (tagdata *ASTagData) GetSelfOrBase() (BaseApChain, bool) {
	return tagdata.Next, true
}

func (tagdata *ASTagData) MarshalToMap() map[string]any {
	return appendWithKey(
		tagdata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_TAG,
		sliceutils.Map(tagdata.Tags, func(t string) map[string]any {
			return map[string]any{KEY_ID: t}
		}),
	)
}

type ASToData struct {
	Next    BaseApChain
	Targets []string
}

func (cc *ASToData) GetSelfOrBase() (BaseApChain, bool) {
	return cc.Next, true
}

func (cc *ASToData) MarshalToMap() map[string]any {
	return appendWithKey(
		cc.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_TO,
		sliceutils.Map(cc.Targets, func(t string) map[string]any {
			return map[string]any{KEY_ID: t}
		}),
	)
}

type ASUrlData struct {
	FullIdType
}

func (object *ASUrlData) GetSelfOrBase() (BaseApChain, bool) {
	return object.FullIdType.Next, true
}

func (object *ASUrlData) MarshalToMap() map[string]any {
	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SHAREDINBOX)
}

type ASUpdatedData struct {
	Next      BaseApChain
	Timestamp time.Time
}

func (publisheddata *ASUpdatedData) GetSelfOrBase() (BaseApChain, bool) {
	return publisheddata.Next, true
}

func (publisheddata *ASUpdatedData) MarshalToMap() map[string]any {
	m := publisheddata.Next.MarshalToMap()
	m[KEY_ACTIVITYSTREAMS_PUBLISHED] = timeToXmlTime(publisheddata.Timestamp)
	return m
}