linstrom/ap/type_parsers.go

package ap

import (
	"net/url"
	"time"
)

// Try and parse a value into an IdType
// Returns nil if failed
func TryParseIdType(rawIn any) *IdType {
	switch in := rawIn.(type) {
	case []any:
		if len(in) == 0 {
			return nil
		}
		m, ok := in[0].(map[string]any)
		if !ok {
			return nil
		}
		return TryParseIdType(m)
	case map[string]any:
		vRaw, ok := in[KEY_ID]
		if !ok {
			return nil
		}
		v, ok := vRaw.(string)
		if !ok {
			return nil
		}
		u, err := url.Parse(v)
		if err != nil {
			return nil
		}
		return &IdType{
			Id: u,
		}
	default:
		return nil
	}
}

func TryParseValueType[T any](rawIn any) *ValueType[T] {
	switch in := rawIn.(type) {
	case map[string]any:
		vRaw, ok := in[KEY_ID]
		if !ok {
			return nil
		}
		v, ok := vRaw.(T)
		if !ok {
			return nil
		}
		return &ValueType[T]{
			Value: v,
		}
	case []any:
		if len(in) == 0 {
			return nil
		}
		v, ok := in[0].(map[string]any)
		if !ok {
			return nil
		}
		return TryParseValueType[T](v)
	default:
		return nil
	}
}

func TryParseActivityStreamsPublicKey(rawIn any) *W3SecurityPublicKey {
	switch in := rawIn.(type) {
	case map[string]any:
		asIdType := TryParseIdType(in)
		if asIdType == nil {
			return nil
		}
		ownerType := TryParseIdType(in[KEY_W3_SECURITY_OWNER])
		if ownerType == nil {
			return nil
		}
		keyValue := TryParseValueType[string](in[KEY_W3_SECURITY_PUBLICKEYPEM])
		if keyValue == nil {
			return nil
		}
		return &W3SecurityPublicKey{
			Id:     asIdType.Id,
			Owner:  ownerType.Id,
			KeyPem: keyValue.Value,
		}
	case []any:
		if len(in) == 0 {
			return nil
		}
		return TryParseActivityStreamsPublicKey(in[0])
	default:
		return nil
	}
}

func TryParseActivityStreamsAttachment(rawIn any) *ActivityStreamsAttachment {
	switch in := rawIn.(type) {
	case []any:
		if len(in) == 0 {
			return nil
		}
		return TryParseActivityStreamsAttachment(in[0])
	case map[string]any:
		rawType, ok := in[KEY_TYPE]
		if !ok {
			return nil
		}
		strType, ok := rawType.(string)
		if !ok {
			return nil
		}
		urlType, err := url.Parse(strType)
		if err != nil {
			return nil
		}
		value := TryParseValueType[string](in[KEY_SCHEMA_VALUE])
		if value == nil {
			return nil
		}
		name := TryParseValueType[string](in[KEY_ACTIVITYSTREAMS_NAME])
		if name == nil {
			return nil
		}
		return &ActivityStreamsAttachment{
			Type:  urlType,
			Name:  name.Value,
			Value: value.Value,
		}
	default:
		return nil
	}
}

func TryParseActivityStreamsPublished(rawIn any) *ActivityStreamsPublished {
	switch in := rawIn.(type) {
	case []any:
		if len(in) == 0 {
			return nil
		}
		return TryParseActivityStreamsPublished(in[0])
	case map[string]any:
		rawType, ok := in[KEY_TYPE]
		if !ok {
			return nil
		}
		strType, ok := rawType.(string)
		if !ok {
			return nil
		}
		value := TryParseValueType[string](in)
		tv, err := time.Parse("2006-01-02T04:05:06Z", value.Value)
		if err != nil {
			return nil
		}
		return &ActivityStreamsPublished{
			Type:  strType,
			Value: tv,
		}
	default:
		return nil
	}
}

// NOTE: Since I do not know if tags are consistent with the struct yet,
// This funtion does not do anything yet and should not be used
func TryParseActivityStreamsTag(rawIn any) *ActivityStreamsTag {
	return nil
}