marshal.go

package jsonapi

import (
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"strings"
)

// RelationshipType specifies the type of a relationship.
type RelationshipType int

// The available relationship types.
//
// Note: DefaultRelationship guesses the relationship type based on the
// pluralization of the reference name.
const (
	DefaultRelationship RelationshipType = iota
	ToOneRelationship
	ToManyRelationship
)

// The MarshalIdentifier interface is necessary to give an element a unique ID.
//
// Note: The implementation of this interface is mandatory.
type MarshalIdentifier interface {
	GetID() string
}

// ReferenceID contains all necessary information in order to reference another
// struct in JSON API.
type ReferenceID struct {
	ID           string
	Type         string
	Name         string
	Relationship RelationshipType
}

// A Reference information about possible references of a struct.
//
// Note: If IsNotLoaded is set to true, the `data` field will be omitted and only
// the `links` object will be generated. You should do this if there are some
// references, but you do not want to load them. Otherwise, if IsNotLoaded is
// false and GetReferencedIDs() returns no IDs for this reference name, an
// empty `data` field will be added which means that there are no references.
type Reference struct {
	Type         string
	Name         string
	IsNotLoaded  bool
	Relationship RelationshipType
}

// The MarshalReferences interface must be implemented if the struct to be
// serialized has relationships.
type MarshalReferences interface {
	GetReferences() []Reference
}

// The MarshalLinkedRelations interface must be implemented if there are
// reference ids that should be included in the document.
type MarshalLinkedRelations interface {
	MarshalReferences
	MarshalIdentifier
	GetReferencedIDs() []ReferenceID
}

// The MarshalIncludedRelations interface must be implemented if referenced
// structs should be included in the document.
type MarshalIncludedRelations interface {
	MarshalReferences
	MarshalIdentifier
	GetReferencedStructs() []MarshalIdentifier
}

// A ServerInformation implementor can be passed to MarshalWithURLs to generate
// the `self` and `related` urls inside `links`.
type ServerInformation interface {
	GetBaseURL() string
	GetPrefix() string
}

// MarshalWithURLs can be used to pass along a ServerInformation implementor.
func MarshalWithURLs(data interface{}, information ServerInformation) ([]byte, error) {
	document, err := MarshalToStruct(data, information, nil)
	if err != nil {
		return nil, err
	}

	return json.Marshal(document)
}

// Marshal wraps data in a Document and returns its JSON encoding.
//
// Data can be a struct, a pointer to a struct or a slice of structs. All structs
// must at least implement the `MarshalIdentifier` interface.
func Marshal(data interface{}) ([]byte, error) {
	document, err := MarshalToStruct(data, nil, nil)
	if err != nil {
		return nil, err
	}

	return json.Marshal(document)
}

func MarshalOnlyFields(data interface{}, fields FilterFields) ([]byte, error) {
	document, err := MarshalToStruct(data, nil, fields)
	if err != nil {
		return nil, err
	}

	return json.Marshal(document)
}

// MarshalToStruct marshals an api2go compatible struct into a jsonapi Document
// structure which then can be marshaled to JSON. You only need this method if
// you want to extract or extend parts of the document. You should directly use
// Marshal to get a []byte with JSON in it.
func MarshalToStruct(data interface{}, information ServerInformation, fields FilterFields) (*Document, error) {
	if data == nil {
		return &Document{}, nil
	}

	switch reflect.TypeOf(data).Kind() {
	case reflect.Slice:
		return marshalSlice(data, information, fields)
	case reflect.Struct, reflect.Ptr:
		return marshalStruct(data.(MarshalIdentifier), information, fields)
	default:
		return nil, errors.New("Marshal only accepts slice, struct or ptr types")
	}
}

func marshalSlice(data interface{}, information ServerInformation, fields FilterFields) (*Document, error) {
	result := &Document{}

	val := reflect.ValueOf(data)
	dataElements := make([]Data, val.Len())
	var referencedStructs []MarshalIdentifier

	for i := 0; i < val.Len(); i++ {
		k := val.Index(i).Interface()
		element, ok := k.(MarshalIdentifier)
		if !ok {
			return nil, errors.New("all elements within the slice must implement api2go.MarshalIdentifier")
		}

		err := marshalData(element, &dataElements[i], information, fields)
		if err != nil {
			return nil, err
		}

		included, ok := k.(MarshalIncludedRelations)
		if ok {
			referencedStructs = append(referencedStructs, included.GetReferencedStructs()...)
		}
	}

	includedElements, err := filterDuplicates(referencedStructs, information, fields)
	if err != nil {
		return nil, err
	}

	result.Data = &DataContainer{
		DataArray: dataElements,
	}

	if includedElements != nil && len(includedElements) > 0 {
		result.Included = includedElements
	}

	return result, nil
}

func filterDuplicates(input []MarshalIdentifier, information ServerInformation, fields FilterFields) ([]Data, error) {
	alreadyIncluded := map[string]map[string]bool{}
	includedElements := []Data{}

	for _, referencedStruct := range input {
		structType := getStructType(referencedStruct)

		if alreadyIncluded[structType] == nil {
			alreadyIncluded[structType] = make(map[string]bool)
		}

		if !alreadyIncluded[structType][referencedStruct.GetID()] {
			var data Data
			err := marshalData(referencedStruct, &data, information, fields)
			if err != nil {
				return nil, err
			}

			includedElements = append(includedElements, data)
			alreadyIncluded[structType][referencedStruct.GetID()] = true
		}
	}

	return includedElements, nil
}

func marshalData(element MarshalIdentifier, data *Data, information ServerInformation, fields FilterFields) error {
	refValue := reflect.ValueOf(element)
	if refValue.Kind() == reflect.Ptr && refValue.IsNil() {
		return errors.New("MarshalIdentifier must not be nil")
	}

	var attributes []byte
	var err error

	data.Type = getStructType(element)

	if len(fields[data.Type]) > 0 {
		co := CustomObject{
			Fields: fields[data.Type],
			Object: element,
		}
		attributes, err = json.Marshal(co)
		if err != nil {
			return err
		}
	} else {
		attributes, err = json.Marshal(element)
		if err != nil {
			return err
		}
	}

	data.Attributes = attributes
	data.ID = element.GetID()

	if references, ok := element.(MarshalLinkedRelations); ok {
		data.Relationships = getStructRelationships(references, information)
	}

	return nil
}

func GetInterfaceValueByFieldName(n interface{}, field_name string) (interface{}, bool) {
	s := reflect.ValueOf(n)
	if s.Kind() == reflect.Ptr {
		s = s.Elem()
	}
	if s.Kind() != reflect.Struct {
		return nil, false
	}
	f := s.FieldByName(field_name)
	if !f.IsValid() {
		return nil, false
	}
	return f.Interface(), true
}

func isToMany(relationshipType RelationshipType, name string) bool {
	if relationshipType == DefaultRelationship {
		return Pluralize(name) == name
	}

	return relationshipType == ToManyRelationship
}

func getStructRelationships(relationer MarshalLinkedRelations, information ServerInformation) map[string]Relationship {
	referencedIDs := relationer.GetReferencedIDs()
	sortedResults := map[string][]ReferenceID{}
	relationships := map[string]Relationship{}

	for _, referenceID := range referencedIDs {
		sortedResults[referenceID.Name] = append(sortedResults[referenceID.Name], referenceID)
	}

	references := relationer.GetReferences()

	// helper map to check if all references are included to also include empty ones
	notIncludedReferences := map[string]Reference{}
	for _, reference := range references {
		notIncludedReferences[reference.Name] = reference
	}

	for name, referenceIDs := range sortedResults {
		relationships[name] = Relationship{}

		// if referenceType is plural, we need to use an array for data, otherwise it's just an object
		container := RelationshipDataContainer{}

		if isToMany(referenceIDs[0].Relationship, referenceIDs[0].Name) {
			// multiple elements in links
			container.DataArray = []RelationshipData{}
			for _, referenceID := range referenceIDs {
				container.DataArray = append(container.DataArray, RelationshipData{
					Type: referenceID.Type,
					ID:   referenceID.ID,
				})
			}
		} else {
			container.DataObject = &RelationshipData{
				Type: referenceIDs[0].Type,
				ID:   referenceIDs[0].ID,
			}
		}

		// set URLs if necessary
		links := getLinksForServerInformation(relationer, name, information)

		relationship := Relationship{
			Data:  &container,
			Links: links,
		}

		relationships[name] = relationship

		// this marks the reference as already included
		delete(notIncludedReferences, referenceIDs[0].Name)
	}

	// check for empty references
	for name, reference := range notIncludedReferences {
		container := RelationshipDataContainer{}

		// Plural empty relationships need an empty array and empty to-one need a null in the json
		if !reference.IsNotLoaded && isToMany(reference.Relationship, reference.Name) {
			container.DataArray = []RelationshipData{}
		}

		links := getLinksForServerInformation(relationer, name, information)
		relationship := Relationship{
			Links: links,
		}

		// skip relationship data completely if IsNotLoaded is set
		if !reference.IsNotLoaded {
			relationship.Data = &container
		}

		relationships[name] = relationship
	}

	return relationships
}

func getLinksForServerInformation(relationer MarshalLinkedRelations, name string, information ServerInformation) *Links {
	if information == nil {
		return nil
	}

	links := &Links{}

	prefix := strings.Trim(information.GetBaseURL(), "/")
	namespace := strings.Trim(information.GetPrefix(), "/")
	structType := getStructType(relationer)

	if namespace != "" {
		prefix += "/" + namespace
	}

	links.Self = fmt.Sprintf("%s/%s/%s/relationships/%s", prefix, structType, relationer.GetID(), name)
	links.Related = fmt.Sprintf("%s/%s/%s/%s", prefix, structType, relationer.GetID(), name)

	return links
}

func marshalStruct(data MarshalIdentifier, information ServerInformation, fields FilterFields) (*Document, error) {
	var contentData Data
	err := marshalData(data, &contentData, information, fields)
	if err != nil {
		return nil, err
	}

	result := &Document{
		Data: &DataContainer{
			DataObject: &contentData,
		},
	}

	included, ok := data.(MarshalIncludedRelations)
	if ok {
		included, err := filterDuplicates(included.GetReferencedStructs(), information, fields)
		if err != nil {
			return nil, err
		}

		if len(included) > 0 {
			result.Included = included
		}
	}

	return result, nil
}

func getStructType(data interface{}) string {
	entityName, ok := data.(EntityNamer)
	if ok {
		return entityName.GetName()
	}

	reflectType := reflect.TypeOf(data)
	if reflectType.Kind() == reflect.Ptr {
		return Pluralize(Jsonify(reflectType.Elem().Name()))
	}

	return Pluralize(Jsonify(reflectType.Name()))
}

func getType(data interface{}) reflect.Type {
	reflectType := reflect.TypeOf(data)
	if reflectType.Kind() == reflect.Ptr {
		return reflectType.Elem()
	}

	return reflectType
}

func getValue(data interface{}) reflect.Value {
	reflectValue := reflect.ValueOf(data)
	if reflectValue.Kind() == reflect.Ptr {
		return reflectValue.Elem()
	}

	return reflectValue
}