diff --git a/commonTypes.go b/commonTypes.go index 3a1fd0c..100819d 100644 --- a/commonTypes.go +++ b/commonTypes.go @@ -45,8 +45,55 @@ func ParseIdTypeWithName(m map[string]any, b BaseApChain, name string) (*FullIdT if !ok { return nil, BadFieldValueError[string]{name, rawData2, ""} } + delete(m, name) return &FullIdType{ Next: b, Id: data2, }, nil } + +type FullValueType[T any] struct { + Next BaseApChain + Value ValueValue[T] +} + +func (v *FullValueType[T]) GetSelfOrBase() (BaseApChain, bool) { + return v.Next, true +} + +func (v *FullValueType[T]) MarshalToMapWithName(name string) map[string]any { + m := v.Next.MarshalToMap() + m[name] = []map[string]any{v.Value.Marshal()} + return m +} + +func ParseValueTypeWithName[T any]( + m map[string]any, + b BaseApChain, + name string, +) (*FullValueType[T], error) { + rawData1, ok := m[name] + if !ok { + return nil, NoRequiredFieldError{name} + } + data1, ok := rawData1.([]map[string]any) + if !ok { + return nil, BadFieldValueError[[]map[string]any]{ + name, + rawData1, + data1, + } + } + if len(data1) != 1 { + return nil, BadFieldArrayLengthError{name, 1, len(data1)} + } + tmp, err := ParseValueValue[T](data1[0]) + if err != nil { + return nil, err + } + delete(m, name) + return &FullValueType[T]{ + Next: b, + Value: *tmp, + }, nil +} diff --git a/constants.go b/constants.go index ad3ff91..4a1b391 100644 --- a/constants.go +++ b/constants.go @@ -22,7 +22,7 @@ const ( KEY_W3_SECURITY_OWNER = "https://w3id.org/security#owner" // Owner of the public key KEY_W3_SECURITY_PUBLICKEY = "https://w3id.org/security#publicKey" // Public key of the account KEY_W3_SECURITY_PUBLICKEYPEM = "https://w3id.org/security#publicKeyPem" // Pem content of the key - KEY_W3_VCARD_ADRESS = "http://www.w3.org/2006/vcard/ns#Address" // Vcard address of an account + KEY_W3_VCARD_ADDRESS = "http://www.w3.org/2006/vcard/ns#Address" // Vcard address of an account KEY_W3_VCARD_BIRTHDAY = "http://www.w3.org/2006/vcard/ns#bday" // Vcard birthday of an account KEY_W3_SECURITY_KEY = "https://w3id.org/security#Key" // Object is a PublicKey diff --git a/nsActivitystreams.go b/nsActivitystreams.go index 516d0ab..2a49b05 100644 --- a/nsActivitystreams.go +++ b/nsActivitystreams.go @@ -71,6 +71,7 @@ func ParseASAlsoKnownAsData(raw map[string]any, next BaseApChain) (BaseApChain, } urls = append(urls, data2) } + delete(raw, KEY_ACTIVITYSTREAMS_ALSOKNOWNAS) return &ASAlsoKnownAsData{ Next: next, Urls: urls, @@ -119,6 +120,7 @@ func ParseASAttachmentsData(raw map[string]any, next BaseApChain) (BaseApChain, } attachments = append(attachments, *a) } + delete(raw, KEY_ACTIVITYSTREAMS_ATTACHMENTS) return &ASAttachmentsData{ Next: next, Attachments: attachments, @@ -189,6 +191,7 @@ func ParseASCCData(raw map[string]any, next BaseApChain) (BaseApChain, error) { } ccs = append(ccs, val) } + delete(raw, KEY_ACTIVITYSTREAMS_CC) return &ASCCData{ Next: next, Targets: ccs, @@ -236,6 +239,7 @@ func ParseASContentData(raw map[string]any, next BaseApChain) (BaseApChain, erro } contents = append(contents, *parsed) } + delete(raw, KEY_ACTIVITYSTREAMS_CONTENT) return &ASContentData{ Next: next, Content: contents, @@ -299,6 +303,7 @@ func ParseASEndpointsData(raw map[string]any, next BaseApChain) (BaseApChain, er } endpoints[k] = v2 } + delete(raw, KEY_ACTIVITYSTREAMS_ENDPOINTS) return &ASEndpointsData{ Next: next, Endpoints: endpoints, @@ -398,6 +403,7 @@ func ParseASIconData(raw map[string]any, next BaseApChain) (BaseApChain, error) if err != nil { return nil, err } + delete(raw, KEY_ACTIVITYSTREAMS_ICON) return &ASIconData{ Media: *m, Next: next, @@ -441,6 +447,7 @@ func ParseASImageData(raw map[string]any, next BaseApChain) (BaseApChain, error) if err != nil { return nil, err } + delete(raw, KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE) return &ASImageData{ Media: *m, Next: next, @@ -448,8 +455,7 @@ func ParseASImageData(raw map[string]any, next BaseApChain) (BaseApChain, error) } type ASMediaTypeData struct { - Next BaseApChain - Type string + FullValueType[string] } func (mediatypedata *ASMediaTypeData) GetSelfOrBase() (BaseApChain, bool) { @@ -457,46 +463,19 @@ func (mediatypedata *ASMediaTypeData) GetSelfOrBase() (BaseApChain, bool) { } 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(), - ) + return mediatypedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_MEDIATYPE) } 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]) + tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_MEDIATYPE) if err != nil { return nil, err } - return &ASMediaTypeData{ - Next: next, - Type: tmp.Value, - }, nil + return &ASMediaTypeData{*tmp}, nil } type ASNameData struct { - Next BaseApChain - Name ValueValue[string] + FullValueType[string] } func (namedata *ASNameData) GetSelfOrBase() (BaseApChain, bool) { @@ -504,37 +483,15 @@ func (namedata *ASNameData) GetSelfOrBase() (BaseApChain, bool) { } func (namedata *ASNameData) MarshalToMap() map[string]any { - return appendWithKey( - namedata.Next.MarshalToMap(), - KEY_ACTIVITYSTREAMS_NAME, - []map[string]any{namedata.Name.Marshal()}, - ) + return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_NAME) } 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]) + tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_NAME) if err != nil { return nil, err } - return &ASNameData{ - Next: next, - Name: *tmp, - }, nil + return &ASNameData{*tmp}, nil } type ASOutboxData struct { @@ -578,8 +535,7 @@ func ParseASObjectData(raw map[string]any, next BaseApChain) (BaseApChain, error } type ASPreferredNameData struct { - Next BaseApChain - Name ValueValue[string] + FullValueType[string] } func (namedata *ASPreferredNameData) GetSelfOrBase() (BaseApChain, bool) { @@ -587,37 +543,15 @@ func (namedata *ASPreferredNameData) GetSelfOrBase() (BaseApChain, bool) { } func (namedata *ASPreferredNameData) MarshalToMap() map[string]any { - return appendWithKey( - namedata.Next.MarshalToMap(), - KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME, - []map[string]any{namedata.Name.Marshal()}, - ) + return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME) } 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]) + tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME) if err != nil { return nil, err } - return &ASPreferredNameData{ - Next: next, - Name: *tmp, - }, nil + return &ASPreferredNameData{*tmp}, nil } type ASPublishedData struct { @@ -660,6 +594,7 @@ func ParseASPublishedData(raw map[string]any, next BaseApChain) (BaseApChain, er if err != nil { return nil, err } + delete(raw, KEY_ACTIVITYSTREAMS_PUBLISHED) return &ASPublishedData{ Next: next, Timestamp: t, @@ -667,8 +602,7 @@ func ParseASPublishedData(raw map[string]any, next BaseApChain) (BaseApChain, er } type ASRestrictedFollowData struct { - Next BaseApChain - Value ValueValue[bool] + FullValueType[bool] } func (namedata *ASRestrictedFollowData) GetSelfOrBase() (BaseApChain, bool) { @@ -676,37 +610,15 @@ func (namedata *ASRestrictedFollowData) GetSelfOrBase() (BaseApChain, bool) { } func (namedata *ASRestrictedFollowData) MarshalToMap() map[string]any { - return appendWithKey( - namedata.Next.MarshalToMap(), - KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW, - []map[string]any{namedata.Value.Marshal()}, - ) + return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW) } 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]) + tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW) if err != nil { return nil, err } - return &ASRestrictedFollowData{ - Next: next, - Value: *tmp, - }, nil + return &ASRestrictedFollowData{*tmp}, nil } type ASRepliesData struct { @@ -750,8 +662,7 @@ func ParseASSharedInboxData(raw map[string]any, next BaseApChain) (BaseApChain, } type ASSummaryData struct { - Next BaseApChain - Name ValueValue[string] + FullValueType[string] } func (namedata *ASSummaryData) GetSelfOrBase() (BaseApChain, bool) { @@ -759,42 +670,19 @@ func (namedata *ASSummaryData) GetSelfOrBase() (BaseApChain, bool) { } func (namedata *ASSummaryData) MarshalToMap() map[string]any { - return appendWithKey( - namedata.Next.MarshalToMap(), - KEY_ACTIVITYSTREAMS_SUMMARY, - []map[string]any{namedata.Name.Marshal()}, - ) + return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SUMMARY) } 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]) + tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_SUMMARY) if err != nil { return nil, err } - return &ASSummaryData{ - Next: next, - Name: *tmp, - }, nil + return &ASSummaryData{*tmp}, nil } type ASSensitiveData struct { - Next BaseApChain - Name ValueValue[bool] + FullValueType[bool] } func (namedata *ASSensitiveData) GetSelfOrBase() (BaseApChain, bool) { @@ -802,37 +690,15 @@ func (namedata *ASSensitiveData) GetSelfOrBase() (BaseApChain, bool) { } func (namedata *ASSensitiveData) MarshalToMap() map[string]any { - return appendWithKey( - namedata.Next.MarshalToMap(), - KEY_ACTIVITYSTREAMS_SENSITIVE, - []map[string]any{namedata.Name.Marshal()}, - ) + return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SENSITIVE) } 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]) + tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_ACTIVITYSTREAMS_SENSITIVE) if err != nil { return nil, err } - return &ASSensitiveData{ - Next: next, - Name: *tmp, - }, nil + return &ASSensitiveData{*tmp}, nil } type ASTagData struct { @@ -855,7 +721,27 @@ func (tagdata *ASTagData) MarshalToMap() map[string]any { } func ParseASTagData(raw map[string]any, next BaseApChain) (BaseApChain, error) { - return nil, NotImplementedError{} + rawData, ok := raw[KEY_ACTIVITYSTREAMS_TAG] + if !ok { + return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_TAG} + } + data, ok := rawData.([]map[string]any) + if !ok { + return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_TAG, rawData, data} + } + tags := []Tag{} + for _, v := range data { + tag, err := ParseTag(v) + if err != nil { + return nil, err + } + tags = append(tags, tag) + } + delete(raw, KEY_ACTIVITYSTREAMS_TAG) + return &ASTagData{ + Next: next, + Tags: tags, + }, nil } type ASToData struct { @@ -878,7 +764,32 @@ func (cc *ASToData) MarshalToMap() map[string]any { } func ParseASToData(raw map[string]any, next BaseApChain) (BaseApChain, error) { - return nil, NotImplementedError{} + rawData1, ok := raw[KEY_ACTIVITYSTREAMS_TO] + if !ok { + return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_TO} + } + data1, ok := rawData1.([]map[string]any) + if !ok { + return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_TO, rawData1, data1} + } + targets := []string{} + for _, v := range data1 { + rawData2, ok := v[KEY_ID] + if !ok { + return nil, NoRequiredSubFieldError{KEY_ACTIVITYSTREAMS_TO, KEY_ID} + } + data2, ok := rawData2.(string) + if !ok { + return nil, BadFieldValueError[string]{KEY_ID, rawData2, data2} + } + targets = append(targets, data2) + } + + delete(raw, KEY_ACTIVITYSTREAMS_TO) + return &ASToData{ + Next: next, + Targets: targets, + }, nil } type ASUrlData struct { @@ -912,10 +823,38 @@ func (publisheddata *ASUpdatedData) GetSelfOrBase() (BaseApChain, bool) { func (publisheddata *ASUpdatedData) MarshalToMap() map[string]any { m := publisheddata.Next.MarshalToMap() - m[KEY_ACTIVITYSTREAMS_PUBLISHED] = timeToXmlTime(publisheddata.Timestamp) + m[KEY_ACTIVITYSTREAMS_UPDATED] = timeToXmlTime(publisheddata.Timestamp) return m } func ParseASUpdatedData(raw map[string]any, next BaseApChain) (BaseApChain, error) { - return nil, NotImplementedError{} + rawData1, ok := raw[KEY_ACTIVITYSTREAMS_UPDATED] + if !ok { + return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_UPDATED} + } + data1, ok := rawData1.([]map[string]any) + if !ok { + return nil, BadFieldValueError[[]map[string]any]{ + KEY_ACTIVITYSTREAMS_UPDATED, + rawData1, + data1, + } + } + if len(data1) != 1 { + return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_UPDATED, 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 + } + delete(raw, KEY_ACTIVITYSTREAMS_UPDATED) + return &ASPublishedData{ + Next: next, + Timestamp: t, + }, nil } diff --git a/nsAll.go b/nsAll.go deleted file mode 100644 index a8d2dd8..0000000 --- a/nsAll.go +++ /dev/null @@ -1 +0,0 @@ -package goap diff --git a/nsLitepub.go b/nsLitepub.go index 3526e6c..d77d8a6 100644 --- a/nsLitepub.go +++ b/nsLitepub.go @@ -2,7 +2,7 @@ package goap type LitepubCapabilitiesData struct { Next BaseApChain - Capabilities []map[string]any + Capabilities []map[string]any // I have no idea what the data inside there looks like } func (capabilitiesdata *LitepubCapabilitiesData) GetSelfOrBase() (BaseApChain, bool) { @@ -17,6 +17,21 @@ func (capabilitiesdata *LitepubCapabilitiesData) MarshalToMap() map[string]any { ) } +func ParseLitepubCapabilitiesData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + rawData, ok := raw[KEY_LITEPUB_CAPABILITIES] + if !ok { + return nil, NoRequiredFieldError{KEY_LITEPUB_CAPABILITIES} + } + data, ok := rawData.([]map[string]any) + if !ok { + return nil, BadFieldValueError[[]map[string]any]{KEY_LITEPUB_CAPABILITIES, rawData, data} + } + return &LitepubCapabilitiesData{ + Next: next, + Capabilities: data, + }, nil +} + type LitepubOauthRegistrationEndpointData struct { FullIdType } @@ -30,3 +45,14 @@ func (oauthregistrationendpointdata *LitepubOauthRegistrationEndpointData) Marsh KEY_ACTIVITYSTREAMS_OAUTHAUTHORIZATION, ) } + +func ParseLitepubOauthRegistrationEndpointData( + raw map[string]any, + next BaseApChain, +) (BaseApChain, error) { + id, err := ParseIdTypeWithName(raw, next, KEY_LITEPUB_OAUTHREGISTRATION) + if err != nil { + return nil, err + } + return &LitepubOauthRegistrationEndpointData{FullIdType: *id}, nil +} diff --git a/nsMasto.go b/nsMasto.go index 7a85a44..8f671f7 100644 --- a/nsMasto.go +++ b/nsMasto.go @@ -12,9 +12,16 @@ func (actor *MastoDevicesData) MarshalToMap() map[string]any { return actor.FullIdType.MarshalToMapWithName(KEY_MASTO_DEVICES) } +func ParseMastoDevicesData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + id, err := ParseIdTypeWithName(raw, next, KEY_MASTO_DEVICES) + if err != nil { + return nil, err + } + return &MastoDevicesData{FullIdType: *id}, nil +} + type MastoDiscoverableData struct { - Next BaseApChain - Value ValueValue[bool] + FullValueType[bool] } func (namedata *MastoDiscoverableData) GetSelfOrBase() (BaseApChain, bool) { @@ -22,11 +29,15 @@ func (namedata *MastoDiscoverableData) GetSelfOrBase() (BaseApChain, bool) { } func (namedata *MastoDiscoverableData) MarshalToMap() map[string]any { - return appendWithKey( - namedata.Next.MarshalToMap(), - KEY_MASTO_DISCOVERABLE, - []map[string]any{namedata.Value.Marshal()}, - ) + return namedata.MarshalToMapWithName(KEY_MASTO_DISCOVERABLE) +} + +func ParseMastoDiscoverableData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_MASTO_DISCOVERABLE) + if err != nil { + return nil, err + } + return &MastoDiscoverableData{*tmp}, nil } type MastoFeaturedData struct { @@ -41,6 +52,14 @@ func (actor *MastoFeaturedData) MarshalToMap() map[string]any { return actor.FullIdType.MarshalToMapWithName(KEY_MASTO_FEATURED) } +func ParseMastoFeaturedData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + id, err := ParseIdTypeWithName(raw, next, KEY_MASTO_FEATURED) + if err != nil { + return nil, err + } + return &MastoFeaturedData{FullIdType: *id}, nil +} + type MastoFeaturedTagsData struct { FullIdType } @@ -53,9 +72,16 @@ func (actor *MastoFeaturedTagsData) MarshalToMap() map[string]any { return actor.FullIdType.MarshalToMapWithName(KEY_MASTO_FEATURED_TAGS) } +func ParseMastoFeaturedTagsData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + id, err := ParseIdTypeWithName(raw, next, KEY_MASTO_FEATURED_TAGS) + if err != nil { + return nil, err + } + return &MastoFeaturedTagsData{FullIdType: *id}, nil +} + type MastoIndexableData struct { - Next BaseApChain - Value ValueValue[bool] + FullValueType[bool] } func (namedata *MastoIndexableData) GetSelfOrBase() (BaseApChain, bool) { @@ -63,16 +89,19 @@ func (namedata *MastoIndexableData) GetSelfOrBase() (BaseApChain, bool) { } func (namedata *MastoIndexableData) MarshalToMap() map[string]any { - return appendWithKey( - namedata.Next.MarshalToMap(), - KEY_MASTO_INDEXABLE, - []map[string]any{namedata.Value.Marshal()}, - ) + return namedata.MarshalToMapWithName(KEY_MASTO_INDEXABLE) +} + +func ParseMastoIndexableData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_MASTO_INDEXABLE) + if err != nil { + return nil, err + } + return &MastoIndexableData{*tmp}, nil } type MastoMemorialData struct { - Next BaseApChain - Value ValueValue[bool] + FullValueType[bool] } func (namedata *MastoMemorialData) GetSelfOrBase() (BaseApChain, bool) { @@ -80,9 +109,13 @@ func (namedata *MastoMemorialData) GetSelfOrBase() (BaseApChain, bool) { } func (namedata *MastoMemorialData) MarshalToMap() map[string]any { - return appendWithKey( - namedata.Next.MarshalToMap(), - KEY_MASTO_MEMORIAL, - []map[string]any{namedata.Value.Marshal()}, - ) + return namedata.MarshalToMapWithName(KEY_MASTO_MEMORIAL) +} + +func ParseMastoMemorialData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_MASTO_MEMORIAL) + if err != nil { + return nil, err + } + return &MastoMemorialData{*tmp}, nil } diff --git a/nsMisskey.go b/nsMisskey.go index a01f290..1bfbd2f 100644 --- a/nsMisskey.go +++ b/nsMisskey.go @@ -3,8 +3,7 @@ package goap // NOTE: Different to ASSummaryData // Misskey summary is the raw text without formatting applied while the Activitystreams summary already contains the preformatted summary type MKSummaryData struct { - Next BaseApChain - Summary string + FullValueType[string] } func (misskeysummarydata *MKSummaryData) GetSelfOrBase() (BaseApChain, bool) { @@ -12,16 +11,19 @@ func (misskeysummarydata *MKSummaryData) GetSelfOrBase() (BaseApChain, bool) { } func (misskeysummarydata *MKSummaryData) MarshalToMap() map[string]any { - return appendWithKey( - misskeysummarydata.Next.MarshalToMap(), - KEY_MISSKEY_MKSUMMARY, - []map[string]any{{KEY_VALUE: misskeysummarydata.Summary}}, - ) + return misskeysummarydata.MarshalToMapWithName(KEY_MISSKEY_MKSUMMARY) +} + +func ParseMKSummaryData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseValueTypeWithName[string](raw, next, KEY_MISSKEY_MKSUMMARY) + if err != nil { + return nil, err + } + return &MKSummaryData{*tmp}, nil } type MKIsCatData struct { - Next BaseApChain - IsCat bool + FullValueType[bool] } func (iscatdata *MKIsCatData) GetSelfOrBase() (BaseApChain, bool) { @@ -29,26 +31,33 @@ func (iscatdata *MKIsCatData) GetSelfOrBase() (BaseApChain, bool) { } func (iscatdata *MKIsCatData) MarshalToMap() map[string]any { - return appendWithKey( - iscatdata.Next.MarshalToMap(), - KEY_MISSKEY_ISCAT, - []map[string]any{{KEY_VALUE: iscatdata.IsCat}}, - ) + return iscatdata.MarshalToMapWithName(KEY_MISSKEY_ISCAT) } -type MKSpeakAsCatData struct { - Next BaseApChain - SpeaksAsCat bool +func ParseMKIsCatData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_MISSKEY_ISCAT) + if err != nil { + return nil, err + } + return &MKIsCatData{*tmp}, nil } -func (iscatdata *MKSpeakAsCatData) GetSelfOrBase() (BaseApChain, bool) { +type FFSpeakAsCatData struct { + FullValueType[bool] +} + +func (iscatdata *FFSpeakAsCatData) GetSelfOrBase() (BaseApChain, bool) { return iscatdata.Next, true } -func (iscatdata *MKSpeakAsCatData) MarshalToMap() map[string]any { - return appendWithKey( - iscatdata.Next.MarshalToMap(), - KEY_FIREFISH_SPEAKASCAT, - []map[string]any{{KEY_VALUE: iscatdata.SpeaksAsCat}}, - ) +func (iscatdata *FFSpeakAsCatData) MarshalToMap() map[string]any { + return iscatdata.MarshalToMapWithName(KEY_FIREFISH_SPEAKASCAT) +} + +func ParseFFSpeakAsCatData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_FIREFISH_SPEAKASCAT) + if err != nil { + return nil, err + } + return &FFSpeakAsCatData{*tmp}, nil } diff --git a/nsOstatus.go b/nsOstatus.go index c3942d2..99b0235 100644 --- a/nsOstatus.go +++ b/nsOstatus.go @@ -2,7 +2,7 @@ package goap type OstatusAtomUriData struct { Next BaseApChain - Uri string + Uri ValueValue[string] } func (atomurivalue *OstatusAtomUriData) GetSelfOrBase() (BaseApChain, bool) { @@ -13,13 +13,40 @@ func (atomurivalue *OstatusAtomUriData) MarshalToMap() map[string]any { return appendWithKey( atomurivalue.Next.MarshalToMap(), KEY_OSTATUS_ATOMURI, - []map[string]any{{KEY_VALUE: atomurivalue.Uri}}, + []map[string]any{atomurivalue.Uri.Marshal()}, ) } +func ParseOstatusAtomUriData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + rawData1, ok := raw[KEY_OSTATUS_ATOMURI] + if !ok { + return nil, NoRequiredFieldError{KEY_OSTATUS_ATOMURI} + } + data1, ok := rawData1.([]map[string]any) + if !ok { + return nil, BadFieldValueError[[]map[string]any]{ + KEY_OSTATUS_ATOMURI, + rawData1, + data1, + } + } + if len(data1) != 1 { + return nil, BadFieldArrayLengthError{KEY_OSTATUS_ATOMURI, 1, len(data1)} + } + tmp, err := ParseValueValue[string](data1[0]) + if err != nil { + return nil, err + } + delete(raw, KEY_OSTATUS_ATOMURI) + return &OstatusAtomUriData{ + Next: next, + Uri: *tmp, + }, nil +} + type OstatusConversationData struct { Next BaseApChain - Uri string + Uri ValueValue[string] } func (atomurivalue *OstatusConversationData) GetSelfOrBase() (BaseApChain, bool) { @@ -30,6 +57,33 @@ func (atomurivalue *OstatusConversationData) MarshalToMap() map[string]any { return appendWithKey( atomurivalue.Next.MarshalToMap(), KEY_OSTATUS_CONVERSATION, - []map[string]any{{KEY_VALUE: atomurivalue.Uri}}, + []map[string]any{atomurivalue.Uri.Marshal()}, ) } + +func ParseOstatusConversationData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + rawData1, ok := raw[KEY_OSTATUS_CONVERSATION] + if !ok { + return nil, NoRequiredFieldError{KEY_OSTATUS_CONVERSATION} + } + data1, ok := rawData1.([]map[string]any) + if !ok { + return nil, BadFieldValueError[[]map[string]any]{ + KEY_OSTATUS_CONVERSATION, + rawData1, + data1, + } + } + if len(data1) != 1 { + return nil, BadFieldArrayLengthError{KEY_OSTATUS_CONVERSATION, 1, len(data1)} + } + tmp, err := ParseValueValue[string](data1[0]) + if err != nil { + return nil, err + } + delete(raw, KEY_OSTATUS_CONVERSATION) + return &OstatusConversationData{ + Next: next, + Uri: *tmp, + }, nil +} diff --git a/nsSchema.go b/nsSchema.go index 7d9f385..3924817 100644 --- a/nsSchema.go +++ b/nsSchema.go @@ -1,8 +1,7 @@ package goap type SchemaValueData struct { - Next BaseApChain - Value ValueValue[string] + FullValueType[string] } func (namedata *SchemaValueData) GetSelfOrBase() (BaseApChain, bool) { @@ -10,9 +9,13 @@ func (namedata *SchemaValueData) GetSelfOrBase() (BaseApChain, bool) { } func (namedata *SchemaValueData) MarshalToMap() map[string]any { - return appendWithKey( - namedata.Next.MarshalToMap(), - KEY_SCHEMA_VALUE, - []map[string]any{namedata.Value.Marshal()}, - ) + return namedata.MarshalToMapWithName(KEY_SCHEMA_VALUE) +} + +func ParseSchemaValueData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseValueTypeWithName[string](raw, next, KEY_SCHEMA_VALUE) + if err != nil { + return nil, err + } + return &SchemaValueData{*tmp}, nil } diff --git a/nsW3.go b/nsW3.go index b4b3b6f..81ef724 100644 --- a/nsW3.go +++ b/nsW3.go @@ -11,3 +11,11 @@ func (actor *W3InboxData) GetSelfOrBase() (BaseApChain, bool) { func (actor *W3InboxData) MarshalToMap() map[string]any { return actor.FullIdType.MarshalToMapWithName(KEY_W3_INBOX) } + +func ParseW3InboxData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseIdTypeWithName(raw, next, KEY_W3_INBOX) + if err != nil { + return nil, err + } + return &W3InboxData{*tmp}, nil +} diff --git a/nsW3Security.go b/nsW3Security.go index d0431f4..e22704b 100644 --- a/nsW3Security.go +++ b/nsW3Security.go @@ -12,6 +12,15 @@ func (actor *W3SecurityOwnerData) MarshalToMap() map[string]any { return actor.FullIdType.MarshalToMapWithName(KEY_W3_SECURITY_OWNER) } +func ParseW3SecurityOwnerData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseIdTypeWithName(raw, next, KEY_W3_SECURITY_OWNER) + if err != nil { + return nil, err + } + return &W3SecurityOwnerData{*tmp}, nil +} + +// TODO: Handle case with multiple public keys (if allowed, idk if it is) type W3SecurityPublicKeyData struct { Next BaseApChain Id string @@ -33,9 +42,43 @@ func (publickeydata *W3SecurityPublicKeyData) MarshalToMap() map[string]any { return m } +func ParseW3SecurityPublicKeyData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + rawData1, ok := raw[KEY_W3_SECURITY_PUBLICKEY] + if !ok { + return nil, NoRequiredFieldError{KEY_W3_SECURITY_PUBLICKEY} + } + data1, ok := rawData1.([]map[string]any) + if !ok { + return nil, BadFieldValueError[[]map[string]any]{KEY_W3_SECURITY_PUBLICKEY, rawData1, data1} + } + if len(data1) != 1 { + return nil, BadFieldArrayLengthError{KEY_W3_SECURITY_PUBLICKEY, 1, len(data1)} + } + Id, err := ParseIdValue(data1[0]) + if err != nil { + return nil, err + } + rawPem, err := ParseW3SecurityPublicKeyPemData(data1[0], nil) + if err != nil { + return nil, err + } + rawOwner, err := ParseW3SecurityOwnerData(data1[0], nil) + if err != nil { + return nil, err + } + owner := rawOwner.(*W3SecurityOwnerData) + + pem := rawPem.(*W3SecurityPublicKeyPemData) + return &W3SecurityPublicKeyData{ + Next: next, + Id: Id.Id, + Key: pem.Value.Value, + Owner: owner.Id, + }, nil +} + type W3SecurityPublicKeyPemData struct { - Next BaseApChain - Value ValueValue[bool] + FullValueType[string] } func (namedata *W3SecurityPublicKeyPemData) GetSelfOrBase() (BaseApChain, bool) { @@ -43,9 +86,13 @@ func (namedata *W3SecurityPublicKeyPemData) GetSelfOrBase() (BaseApChain, bool) } func (namedata *W3SecurityPublicKeyPemData) MarshalToMap() map[string]any { - return appendWithKey( - namedata.Next.MarshalToMap(), - KEY_W3_SECURITY_PUBLICKEYPEM, - []map[string]any{namedata.Value.Marshal()}, - ) + return namedata.MarshalToMapWithName(KEY_W3_SECURITY_PUBLICKEYPEM) +} + +func ParseW3SecurityPublicKeyPemData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseValueTypeWithName[string](raw, next, KEY_W3_SECURITY_PUBLICKEYPEM) + if err != nil { + return nil, err + } + return &W3SecurityPublicKeyPemData{*tmp}, nil } diff --git a/nsW3Vcard.go b/nsW3Vcard.go index c505a6b..b01ebaa 100644 --- a/nsW3Vcard.go +++ b/nsW3Vcard.go @@ -1,8 +1,7 @@ package goap type W3VcardAddressData struct { - Next BaseApChain - Address string + FullValueType[string] } func (misskeysummarydata *W3VcardAddressData) GetSelfOrBase() (BaseApChain, bool) { @@ -10,16 +9,19 @@ func (misskeysummarydata *W3VcardAddressData) GetSelfOrBase() (BaseApChain, bool } func (misskeysummarydata *W3VcardAddressData) MarshalToMap() map[string]any { - return appendWithKey( - misskeysummarydata.Next.MarshalToMap(), - KEY_W3_VCARD_ADRESS, - []map[string]any{{KEY_VALUE: misskeysummarydata.Address}}, - ) + return misskeysummarydata.MarshalToMapWithName(KEY_W3_VCARD_ADDRESS) +} + +func ParseW3VcardAddressData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseValueTypeWithName[string](raw, next, KEY_W3_VCARD_ADDRESS) + if err != nil { + return nil, err + } + return &W3VcardAddressData{*tmp}, nil } type W3VcardBirthdayData struct { - Next BaseApChain - Birthday string + FullValueType[string] } func (misskeysummarydata *W3VcardBirthdayData) GetSelfOrBase() (BaseApChain, bool) { @@ -27,9 +29,13 @@ func (misskeysummarydata *W3VcardBirthdayData) GetSelfOrBase() (BaseApChain, boo } func (misskeysummarydata *W3VcardBirthdayData) MarshalToMap() map[string]any { - return appendWithKey( - misskeysummarydata.Next.MarshalToMap(), - KEY_W3_VCARD_BIRTHDAY, - []map[string]any{{KEY_VALUE: misskeysummarydata.Birthday}}, - ) + return misskeysummarydata.MarshalToMapWithName(KEY_W3_VCARD_BIRTHDAY) +} + +func ParseW3VcardBirthdayData(raw map[string]any, next BaseApChain) (BaseApChain, error) { + tmp, err := ParseValueTypeWithName[string](raw, next, KEY_W3_VCARD_BIRTHDAY) + if err != nil { + return nil, err + } + return &W3VcardBirthdayData{*tmp}, nil } diff --git a/nsXmlschema.go b/nsXmlschema.go deleted file mode 100644 index a8d2dd8..0000000 --- a/nsXmlschema.go +++ /dev/null @@ -1 +0,0 @@ -package goap diff --git a/tags.go b/tags.go index 4f17a65..b39efb2 100644 --- a/tags.go +++ b/tags.go @@ -122,9 +122,35 @@ func parseEmojiTag(raw map[string]any) (*TagEmoji, error) { } func parseMentionTag(raw map[string]any) (*TagMention, error) { - return nil, NotImplementedError{} + rawHref, err := ParseASHrefData(raw, nil) + if err != nil { + return nil, err + } + href := rawHref.(*ASHrefData) + rawName, err := ParseASNameData(raw, nil) + if err != nil { + return nil, err + } + name := rawName.(*ASNameData) + return &TagMention{ + TargetId: href.Id, + TargetName: name.Name.Value, + }, nil } func parseHashtagTag(raw map[string]any) (*TagHashtag, error) { - return nil, NotImplementedError{} + rawHref, err := ParseASHrefData(raw, nil) + if err != nil { + return nil, err + } + href := rawHref.(*ASHrefData) + rawName, err := ParseASNameData(raw, nil) + if err != nil { + return nil, err + } + name := rawName.(*ASNameData) + return &TagHashtag{ + Url: href.Id, + Name: name.Name.Value, + }, nil } diff --git a/variousTypes.go b/variousTypes.go index 4e84fe1..4e9cb75 100644 --- a/variousTypes.go +++ b/variousTypes.go @@ -192,8 +192,16 @@ func ParseMedia(raw map[string]any) (*Media, error) { return &media, nil } -func ParseIdValue(_ map[string]any) (IdValue, error) { - return IdValue{}, NotImplementedError{} +func ParseIdValue(r map[string]any) (*IdValue, error) { + rawId, ok := r[KEY_ID] + if !ok { + return nil, NoRequiredFieldError{KEY_ID} + } + id, ok := rawId.(string) + if !ok { + return nil, BadFieldValueError[string]{KEY_ID, rawId, id} + } + return &IdValue{Id: id}, nil } func ParseValueValue[T any](raw map[string]any) (*ValueValue[T], error) {