eintopf.info@v0.13.16/service/eventsearch/aggregation.go

// Code generated by scripts/gen/go/searchaggregation/main.go. DO NOT EDIT.
package eventsearch

import (
	"encoding/json"
	"fmt"
	"net/url"
	"strings"

	"eintopf.info/service/event"
	"eintopf.info/service/search"
)

func aggregationsFromQuery(q url.Values) (Aggregations, error) {
	aggregationsRaw := q["aggregations"]
	aggregations := make(Aggregations, len(aggregationsRaw))
	for _, a := range aggregationsRaw {
		splitted := strings.Split(a, "-")
		if len(splitted) != 3 {
			return nil, fmt.Errorf("parse aggregation(%s): must be of form 'name-field-type'", a)
		}
		name := splitted[0]
		field := splitted[1]
		typ := splitted[2]
		filters, err := filtersFromQuery(q, fmt.Sprintf("%s-", name))
		if err != nil {
			return nil, fmt.Errorf("parse aggregation(%s): %s", a, err)
		}
		switch field {

		case "children":

			if typ == "terms" {
				aggregations[name] = ChildrenTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "date":

			if typ == "terms" {
				aggregations[name] = DateTermsAggregation{Filters: filters}
				continue
			}
			if typ == "terms" {
				aggregations[name] = DateTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "day":

			if typ == "terms" {
				aggregations[name] = DayTermsAggregation{Filters: filters}
				continue
			}
			if typ == "terms" {
				aggregations[name] = DayTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "end":

			if typ == "terms" {
				aggregations[name] = EndTermsAggregation{Filters: filters}
				continue
			}
			if typ == "terms" {
				aggregations[name] = EndTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "groupID":

			if typ == "terms" {
				aggregations[name] = GroupIDTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "id":

			if typ == "terms" {
				aggregations[name] = IDTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "involved":

			if typ == "object" {
				aggregations[name] = InvolvedObjectsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "is":

			if typ == "terms" {
				aggregations[name] = ISTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "listed":

			if typ == "terms" {
				aggregations[name] = ListedTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "location":

			if typ == "terms" {
				aggregations[name] = LocationTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "location2":

			if typ == "terms" {
				aggregations[name] = Location2TermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "multiday":

			if typ == "terms" {
				aggregations[name] = MultidayTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "name":

			if typ == "terms" {
				aggregations[name] = NameTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "organizer":

			if typ == "terms" {
				aggregations[name] = OrganizerTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "ownedBy":

			if typ == "terms" {
				aggregations[name] = OwnedByTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "placeID":

			if typ == "terms" {
				aggregations[name] = PlaceIDTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "start":

			if typ == "terms" {
				aggregations[name] = StartTermsAggregation{Filters: filters}
				continue
			}
			if typ == "terms" {
				aggregations[name] = StartTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		case "tag":

			if typ == "terms" {
				aggregations[name] = TagTermsAggregation{Filters: filters}
				continue
			}
			return nil, fmt.Errorf("parse aggregation(%s): invalid aggregation type: %s", a, typ)

		}
	}
	return aggregations, nil
}

type ChildrenTermsAggregation struct {
	Filters Filters
}

func (a ChildrenTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "children",
		Filters: a.Filters.SearchFilters(),
	}
}

type DateTermsAggregation struct {
	Filters Filters
}

func (a DateTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "date",
		Filters: a.Filters.SearchFilters(),
	}
}

type DateDateRangeAggregation struct {
	Filters Filters
}

func (a DateDateRangeAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.DateRangeAggregation,
		Field:   "date",
		Filters: a.Filters.SearchFilters(),
	}
}

type DayTermsAggregation struct {
	Filters Filters
}

func (a DayTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "day",
		Filters: a.Filters.SearchFilters(),
	}
}

type DayDateRangeAggregation struct {
	Filters Filters
}

func (a DayDateRangeAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.DateRangeAggregation,
		Field:   "day",
		Filters: a.Filters.SearchFilters(),
	}
}

type EndTermsAggregation struct {
	Filters Filters
}

func (a EndTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "end",
		Filters: a.Filters.SearchFilters(),
	}
}

type EndDateRangeAggregation struct {
	Filters Filters
}

func (a EndDateRangeAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.DateRangeAggregation,
		Field:   "end",
		Filters: a.Filters.SearchFilters(),
	}
}

type GroupIDTermsAggregation struct {
	Filters Filters
}

func (a GroupIDTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "groupID",
		Filters: a.Filters.SearchFilters(),
	}
}

type IDTermsAggregation struct {
	Filters Filters
}

func (a IDTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "id",
		Filters: a.Filters.SearchFilters(),
	}
}

type InvolvedObjectsAggregation struct {
	Filters Filters
}

func (a InvolvedObjectsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "involved",
		Filters: a.Filters.SearchFilters(),
	}
}

type ISTermsAggregation struct {
	Filters Filters
}

func (a ISTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "is",
		Filters: a.Filters.SearchFilters(),
	}
}

type ListedTermsAggregation struct {
	Filters Filters
}

func (a ListedTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "listed",
		Filters: a.Filters.SearchFilters(),
	}
}

type LocationTermsAggregation struct {
	Filters Filters
}

func (a LocationTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "location",
		Filters: a.Filters.SearchFilters(),
	}
}

type Location2TermsAggregation struct {
	Filters Filters
}

func (a Location2TermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "location2",
		Filters: a.Filters.SearchFilters(),
	}
}

type MultidayTermsAggregation struct {
	Filters Filters
}

func (a MultidayTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "multiday",
		Filters: a.Filters.SearchFilters(),
	}
}

type NameTermsAggregation struct {
	Filters Filters
}

func (a NameTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "name",
		Filters: a.Filters.SearchFilters(),
	}
}

type OrganizerTermsAggregation struct {
	Filters Filters
}

func (a OrganizerTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "organizer",
		Filters: a.Filters.SearchFilters(),
	}
}

type OwnedByTermsAggregation struct {
	Filters Filters
}

func (a OwnedByTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "ownedBy",
		Filters: a.Filters.SearchFilters(),
	}
}

type PlaceIDTermsAggregation struct {
	Filters Filters
}

func (a PlaceIDTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "placeID",
		Filters: a.Filters.SearchFilters(),
	}
}

type StartTermsAggregation struct {
	Filters Filters
}

func (a StartTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "start",
		Filters: a.Filters.SearchFilters(),
	}
}

type StartDateRangeAggregation struct {
	Filters Filters
}

func (a StartDateRangeAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.DateRangeAggregation,
		Field:   "start",
		Filters: a.Filters.SearchFilters(),
	}
}

type TagTermsAggregation struct {
	Filters Filters
}

func (a TagTermsAggregation) SearchAggregation() search.Aggregation {
	return search.Aggregation{
		Type:    search.TermsAggregation,
		Field:   "tag",
		Filters: a.Filters.SearchFilters(),
	}
}

func convertSearchBuckets(buckets map[string]search.Bucket, aggregations Aggregations) map[string]search.Bucket {
	for k, b := range buckets {

		if aggregations[k].SearchAggregation().Field == "involved" {
			involvedBucket := make(InvolvedBucket, 0)
			for _, t := range b.(search.TermsBucket) {
				involved := event.Involved{}
				err := json.Unmarshal([]byte(t.Term), &involved)
				if err == nil {
					involvedBucket = append(involvedBucket, involved)
				}
			}

			buckets[k] = involvedBucket
		}

	}
	return buckets
}

type InvolvedBucket []event.Involved

func (i InvolvedBucket) BucketType() search.AggregationType {
	return "involved"
}