921 lines
22 KiB
Go
921 lines
22 KiB
Go
package goap
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/datainq/xml-date-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)
|
|
}
|
|
|
|
func ParseASActorData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_ACTOR)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASActorData{FullIdType: *id}, nil
|
|
}
|
|
|
|
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}
|
|
}),
|
|
)
|
|
}
|
|
|
|
func ParseASAlsoKnownAsData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_ALSOKNOWNAS]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_ALSOKNOWNAS}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_ALSOKNOWNAS,
|
|
rawData1,
|
|
[]map[string]any{},
|
|
}
|
|
}
|
|
urls := []string{}
|
|
for _, v := range data1 {
|
|
rawData2, ok := v[KEY_ID]
|
|
if !ok {
|
|
return nil, NoRequiredSubFieldError{KEY_ACTIVITYSTREAMS_ALSOKNOWNAS, KEY_ID}
|
|
}
|
|
data2, ok := rawData2.(string)
|
|
if !ok {
|
|
return nil, BadFieldValueError[string]{KEY_ACTIVITYSTREAMS_ALSOKNOWNAS, rawData2, ""}
|
|
}
|
|
urls = append(urls, data2)
|
|
}
|
|
return &ASAlsoKnownAsData{
|
|
Next: next,
|
|
Urls: urls,
|
|
}, nil
|
|
}
|
|
|
|
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() },
|
|
),
|
|
)
|
|
}
|
|
|
|
func ParseASAttachmentsData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData, ok := raw[KEY_ACTIVITYSTREAMS_ATTACHMENTS]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_ATTACHMENTS}
|
|
}
|
|
data, ok := rawData.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_ATTACHMENTS,
|
|
rawData,
|
|
[]map[string]any{},
|
|
}
|
|
}
|
|
|
|
attachments := []Attachment{}
|
|
for _, k := range data {
|
|
a, err := ParseAttachment(k)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
attachments = append(attachments, *a)
|
|
}
|
|
return &ASAttachmentsData{
|
|
Next: next,
|
|
Attachments: attachments,
|
|
}, nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func ParseASAttributedToData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_ATTRIBUTEDTO)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASAttributedToData{FullIdType: *id}, nil
|
|
}
|
|
|
|
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}
|
|
}),
|
|
)
|
|
}
|
|
|
|
func ParseASCCData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_CC]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_CC}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_CC,
|
|
rawData1,
|
|
[]map[string]any{},
|
|
}
|
|
}
|
|
ccs := []string{}
|
|
for _, v := range data1 {
|
|
rawVal, ok := v[KEY_ID]
|
|
if !ok {
|
|
return nil, NoRequiredSubFieldError{KEY_ACTIVITYSTREAMS_CC, KEY_ID}
|
|
}
|
|
val, ok := rawVal.(string)
|
|
if !ok {
|
|
return nil, BadFieldValueError[string]{KEY_ID, rawVal, ""}
|
|
}
|
|
ccs = append(ccs, val)
|
|
}
|
|
return &ASCCData{
|
|
Next: next,
|
|
Targets: ccs,
|
|
}, nil
|
|
}
|
|
|
|
// Content is an array of string value types due to some servers including the content in multiple languages or with different metadata attached
|
|
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()
|
|
}),
|
|
)
|
|
}
|
|
|
|
func ParseASContentData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_CONTENT]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_CONTENT}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_CONTENT,
|
|
rawData1,
|
|
data1,
|
|
}
|
|
}
|
|
contents := []ValueValue[string]{}
|
|
for _, v := range data1 {
|
|
parsed, err := ParseValueValue[string](v)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
contents = append(contents, *parsed)
|
|
}
|
|
return &ASContentData{
|
|
Next: next,
|
|
Content: contents,
|
|
}, nil
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func ParseASEndpointsData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_ENDPOINTS]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_ENDPOINTS}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_ENDPOINTS,
|
|
rawData1,
|
|
data1,
|
|
}
|
|
}
|
|
if len(data1) != 1 {
|
|
return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_ENDPOINTS, 1, len(data1)}
|
|
}
|
|
data2 := data1[0]
|
|
endpoints := map[string]string{}
|
|
for k, rawV := range data2 {
|
|
v, ok := rawV.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{k, rawV, v}
|
|
}
|
|
if len(v) != 1 {
|
|
return nil, BadFieldArrayLengthError{k, 1, len(v)}
|
|
}
|
|
rawV2, ok := v[0][KEY_ID]
|
|
if !ok {
|
|
return nil, NoRequiredSubFieldError{KEY_ACTIVITYSTREAMS_ENDPOINTS, KEY_ID}
|
|
}
|
|
v2, ok := rawV2.(string)
|
|
if !ok {
|
|
return nil, BadFieldValueError[string]{k, rawV2, ""}
|
|
}
|
|
endpoints[k] = v2
|
|
}
|
|
return &ASEndpointsData{
|
|
Next: next,
|
|
Endpoints: endpoints,
|
|
}, nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func ParseASFollowersData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_FOLLOWERS)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASAttributedToData{FullIdType: *id}, nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func ParseASFollowingData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_FOLLOWING)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASAttributedToData{FullIdType: *id}, nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func ParseASHrefData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_HREF)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASAttributedToData{FullIdType: *id}, nil
|
|
}
|
|
|
|
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()},
|
|
)
|
|
}
|
|
|
|
func ParseASIconData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
dataRaw, ok := raw[KEY_ACTIVITYSTREAMS_ICON]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_ICON}
|
|
}
|
|
data, ok := dataRaw.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_ICON, dataRaw, data}
|
|
}
|
|
if len(data) != 1 {
|
|
return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_ICON, 1, len(data)}
|
|
}
|
|
m, err := ParseMedia(data[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASIconData{
|
|
Media: *m,
|
|
Next: next,
|
|
}, nil
|
|
}
|
|
|
|
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()},
|
|
)
|
|
}
|
|
|
|
func ParseASImageData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
dataRaw, ok := raw[KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE}
|
|
}
|
|
data, ok := dataRaw.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE,
|
|
dataRaw,
|
|
data,
|
|
}
|
|
}
|
|
if len(data) != 1 {
|
|
return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE, 1, len(data)}
|
|
}
|
|
m, err := ParseMedia(data[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASImageData{
|
|
Media: *m,
|
|
Next: next,
|
|
}, nil
|
|
}
|
|
|
|
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(),
|
|
)
|
|
}
|
|
|
|
func ParseASMediaTypeData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_MEDIATYPE]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_MEDIATYPE}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_MEDIATYPE,
|
|
rawData1,
|
|
data1,
|
|
}
|
|
}
|
|
if len(data1) != 1 {
|
|
return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_MEDIATYPE, 1, len(data1)}
|
|
}
|
|
tmp, err := ParseValueValue[string](data1[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASMediaTypeData{
|
|
Next: next,
|
|
Type: tmp.Value,
|
|
}, nil
|
|
}
|
|
|
|
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()},
|
|
)
|
|
}
|
|
|
|
func ParseASNameData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_NAME]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_NAME}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_NAME,
|
|
rawData1,
|
|
data1,
|
|
}
|
|
}
|
|
if len(data1) != 1 {
|
|
return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_NAME, 1, len(data1)}
|
|
}
|
|
tmp, err := ParseValueValue[string](data1[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASNameData{
|
|
Next: next,
|
|
Name: *tmp,
|
|
}, nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func ParseASOutboxData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_OUTBOX)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASOutboxData{FullIdType: *id}, nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func ParseASObjectData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_OBJECT)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASObjectData{FullIdType: *id}, nil
|
|
}
|
|
|
|
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()},
|
|
)
|
|
}
|
|
|
|
func ParseASPreferredNameData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME,
|
|
rawData1,
|
|
data1,
|
|
}
|
|
}
|
|
if len(data1) != 1 {
|
|
return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME, 1, len(data1)}
|
|
}
|
|
tmp, err := ParseValueValue[string](data1[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASPreferredNameData{
|
|
Next: next,
|
|
Name: *tmp,
|
|
}, nil
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func ParseASPublishedData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_PUBLISHED]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_PUBLISHED}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_PUBLISHED,
|
|
rawData1,
|
|
data1,
|
|
}
|
|
}
|
|
if len(data1) != 1 {
|
|
return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_PUBLISHED, 1, len(data1)}
|
|
}
|
|
tmp, err := ParseValueValue[string](data1[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
t, err := xmldatetime.Parse(tmp.Value)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASPublishedData{
|
|
Next: next,
|
|
Timestamp: t,
|
|
}, nil
|
|
}
|
|
|
|
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()},
|
|
)
|
|
}
|
|
|
|
func ParseASRestrictedData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW,
|
|
rawData1,
|
|
data1,
|
|
}
|
|
}
|
|
if len(data1) != 1 {
|
|
return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW, 1, len(data1)}
|
|
}
|
|
tmp, err := ParseValueValue[bool](data1[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASRestrictedFollowData{
|
|
Next: next,
|
|
Value: *tmp,
|
|
}, nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func ParseASRepliesData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_REPLIES)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASRepliesData{FullIdType: *id}, nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func ParseASSharedInboxData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_SHAREDINBOX)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASSharedInboxData{FullIdType: *id}, nil
|
|
}
|
|
|
|
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()},
|
|
)
|
|
}
|
|
|
|
func ParseASSummaryData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_SUMMARY]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_SUMMARY}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_SUMMARY,
|
|
rawData1,
|
|
data1,
|
|
}
|
|
}
|
|
if len(data1) != 1 {
|
|
return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_SUMMARY, 1, len(data1)}
|
|
}
|
|
tmp, err := ParseValueValue[string](data1[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASSummaryData{
|
|
Next: next,
|
|
Name: *tmp,
|
|
}, nil
|
|
}
|
|
|
|
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()},
|
|
)
|
|
}
|
|
|
|
func ParseASSensitiveData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
rawData1, ok := raw[KEY_ACTIVITYSTREAMS_SENSITIVE]
|
|
if !ok {
|
|
return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_SENSITIVE}
|
|
}
|
|
data1, ok := rawData1.([]map[string]any)
|
|
if !ok {
|
|
return nil, BadFieldValueError[[]map[string]any]{
|
|
KEY_ACTIVITYSTREAMS_SENSITIVE,
|
|
rawData1,
|
|
data1,
|
|
}
|
|
}
|
|
if len(data1) != 1 {
|
|
return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_SENSITIVE, 1, len(data1)}
|
|
}
|
|
tmp, err := ParseValueValue[bool](data1[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASSensitiveData{
|
|
Next: next,
|
|
Name: *tmp,
|
|
}, nil
|
|
}
|
|
|
|
type ASTagData struct {
|
|
Next BaseApChain
|
|
Tags []Tag
|
|
}
|
|
|
|
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 Tag) map[string]any {
|
|
return t.Marshal()
|
|
}),
|
|
)
|
|
}
|
|
|
|
func ParseASTagData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
return nil, NotImplementedError{}
|
|
}
|
|
|
|
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}
|
|
}),
|
|
)
|
|
}
|
|
|
|
func ParseASToData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
return nil, NotImplementedError{}
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func ParseASUrlData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_URL)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ASUrlData{FullIdType: *id}, nil
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func ParseASUpdatedData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
|
|
return nil, NotImplementedError{}
|
|
}
|