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

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

import (
	"fmt"
	"net/url"
	"strconv"
	"time"

	"eintopf.info/service/search"
)

func filtersFromQuery(q url.Values, prefix string) (Filters, error) {
	filters := Filters{}

	children := q.Get(fmt.Sprintf("%schildren", prefix))
	if children == "true" {
		filters = append(filters, ChildrenFilter{
			Children: true,
		})
	} else if children == "false" {
		filters = append(filters, ChildrenFilter{
			Children: false,
		})
	} else if children != "" {
		return nil, fmt.Errorf("parse query(children): value must be true or false")
	}

	dateRaw := q.Get(fmt.Sprintf("%sdate", prefix))
	if dateRaw != "" {
		date, err := time.Parse(time.RFC3339, dateRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(date): %s", err)
		}
		filters = append(filters, DateFilter{
			Date: date,
		})
	}

	dateMinRaw := q.Get(fmt.Sprintf("%sdateMin", prefix))
	dateMin := time.Time{}
	if dateMinRaw != "" {
		var err error
		dateMin, err = time.Parse(time.RFC3339, dateMinRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(dateMin): %s", err)
		}
	}
	dateMaxRaw := q.Get(fmt.Sprintf("%sdateMax", prefix))
	dateMax := time.Time{}
	if dateMaxRaw != "" {
		var err error
		dateMax, err = time.Parse(time.RFC3339, dateMaxRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(dateMax): %s", err)
		}
	}

	if !(dateMin.IsZero() && dateMax.IsZero()) {
		filters = append(filters, DateRangeFilter{
			DateMin: dateMin,
			DateMax: dateMax,
		})
	}

	dayRaw := q.Get(fmt.Sprintf("%sday", prefix))
	if dayRaw != "" {
		day, err := time.Parse(time.RFC3339, dayRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(day): %s", err)
		}
		filters = append(filters, DayFilter{
			Day: day,
		})
	}

	dayMinRaw := q.Get(fmt.Sprintf("%sdayMin", prefix))
	dayMin := time.Time{}
	if dayMinRaw != "" {
		var err error
		dayMin, err = time.Parse(time.RFC3339, dayMinRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(dayMin): %s", err)
		}
	}
	dayMaxRaw := q.Get(fmt.Sprintf("%sdayMax", prefix))
	dayMax := time.Time{}
	if dayMaxRaw != "" {
		var err error
		dayMax, err = time.Parse(time.RFC3339, dayMaxRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(dayMax): %s", err)
		}
	}

	if !(dayMin.IsZero() && dayMax.IsZero()) {
		filters = append(filters, DayRangeFilter{
			DayMin: dayMin,
			DayMax: dayMax,
		})
	}

	endRaw := q.Get(fmt.Sprintf("%send", prefix))
	if endRaw != "" {
		end, err := time.Parse(time.RFC3339, endRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(end): %s", err)
		}
		filters = append(filters, EndFilter{
			End: end,
		})
	}

	endMinRaw := q.Get(fmt.Sprintf("%sendMin", prefix))
	endMin := time.Time{}
	if endMinRaw != "" {
		var err error
		endMin, err = time.Parse(time.RFC3339, endMinRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(endMin): %s", err)
		}
	}
	endMaxRaw := q.Get(fmt.Sprintf("%sendMax", prefix))
	endMax := time.Time{}
	if endMaxRaw != "" {
		var err error
		endMax, err = time.Parse(time.RFC3339, endMaxRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(endMax): %s", err)
		}
	}

	if !(endMin.IsZero() && endMax.IsZero()) {
		filters = append(filters, EndRangeFilter{
			EndMin: endMin,
			EndMax: endMax,
		})
	}

	groupIDs := q[fmt.Sprintf("%sgroupIDs", prefix)]
	if groupIDs != nil && len(groupIDs) > 0 {
		filters = append(filters, GroupIDsFilter{
			GroupIDs: groupIDs,
		})
	}

	ids := q[fmt.Sprintf("%sids", prefix)]
	if ids != nil && len(ids) > 0 {
		filters = append(filters, IDsFilter{
			IDs: ids,
		})
	}

	iss := q[fmt.Sprintf("%siss", prefix)]
	if iss != nil && len(iss) > 0 {
		filters = append(filters, ISsFilter{
			ISs: iss,
		})
	}

	listed := q.Get(fmt.Sprintf("%slisted", prefix))
	if listed == "true" {
		filters = append(filters, ListedFilter{
			Listed: true,
		})
	} else if listed == "false" {
		filters = append(filters, ListedFilter{
			Listed: false,
		})
	} else if listed != "" {
		return nil, fmt.Errorf("parse query(listed): value must be true or false")
	}

	locations := q[fmt.Sprintf("%slocations", prefix)]
	if locations != nil && len(locations) > 0 {
		filters = append(filters, LocationsFilter{
			Locations: locations,
		})
	}

	location2s := q[fmt.Sprintf("%slocation2s", prefix)]
	if location2s != nil && len(location2s) > 0 {
		filters = append(filters, Location2sFilter{
			Location2s: location2s,
		})
	}

	multiday := q.Get(fmt.Sprintf("%smultiday", prefix))
	if multiday != "" {
		parsed, err := strconv.Atoi(multiday)
		if err != nil {
			return nil, fmt.Errorf("parse query(multiday) '%s': %s", multiday, err)
		}
		filters = append(filters, MultidayFilter{
			Multiday: parsed,
		})
	}

	names := q[fmt.Sprintf("%snames", prefix)]
	if names != nil && len(names) > 0 {
		filters = append(filters, NamesFilter{
			Names: names,
		})
	}

	organizers := q[fmt.Sprintf("%sorganizers", prefix)]
	if organizers != nil && len(organizers) > 0 {
		filters = append(filters, OrganizersFilter{
			Organizers: organizers,
		})
	}

	ownedBys := q[fmt.Sprintf("%sownedBys", prefix)]
	if ownedBys != nil && len(ownedBys) > 0 {
		filters = append(filters, OwnedBysFilter{
			OwnedBys: ownedBys,
		})
	}

	placeIDs := q[fmt.Sprintf("%splaceIDs", prefix)]
	if placeIDs != nil && len(placeIDs) > 0 {
		filters = append(filters, PlaceIDsFilter{
			PlaceIDs: placeIDs,
		})
	}

	startRaw := q.Get(fmt.Sprintf("%sstart", prefix))
	if startRaw != "" {
		start, err := time.Parse(time.RFC3339, startRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(start): %s", err)
		}
		filters = append(filters, StartFilter{
			Start: start,
		})
	}

	startMinRaw := q.Get(fmt.Sprintf("%sstartMin", prefix))
	startMin := time.Time{}
	if startMinRaw != "" {
		var err error
		startMin, err = time.Parse(time.RFC3339, startMinRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(startMin): %s", err)
		}
	}
	startMaxRaw := q.Get(fmt.Sprintf("%sstartMax", prefix))
	startMax := time.Time{}
	if startMaxRaw != "" {
		var err error
		startMax, err = time.Parse(time.RFC3339, startMaxRaw)
		if err != nil {
			return nil, fmt.Errorf("parse query(startMax): %s", err)
		}
	}

	if !(startMin.IsZero() && startMax.IsZero()) {
		filters = append(filters, StartRangeFilter{
			StartMin: startMin,
			StartMax: startMax,
		})
	}

	tags := q[fmt.Sprintf("%stags", prefix)]
	if tags != nil && len(tags) > 0 {
		filters = append(filters, TagsFilter{
			Tags: tags,
		})
	}

	return filters, nil
}

type NotFilter struct {
	Filter Filter
}

func (n NotFilter) SearchFilter() search.Filter {
	return &search.NotFilter{Filter: n.Filter.SearchFilter()}
}

type ChildrenFilter struct {
	Children bool
}

func (f ChildrenFilter) SearchFilter() search.Filter {
	return &search.BoolFilter{Field: "children", Value: f.Children}
}

type DateFilter struct {
	Date time.Time
}

func (f DateFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "date", Terms: []string{f.Date.String()}}
}

type DateRangeFilter struct {
	DateMin time.Time
	DateMax time.Time
}

func (f DateRangeFilter) SearchFilter() search.Filter {
	return &search.DateRangeFilter{Field: "date", Min: f.DateMin, Max: f.DateMax}
}

type DayFilter struct {
	Day time.Time
}

func (f DayFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "day", Terms: []string{f.Day.String()}}
}

type DayRangeFilter struct {
	DayMin time.Time
	DayMax time.Time
}

func (f DayRangeFilter) SearchFilter() search.Filter {
	return &search.DateRangeFilter{Field: "day", Min: f.DayMin, Max: f.DayMax}
}

type EndFilter struct {
	End time.Time
}

func (f EndFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "end", Terms: []string{f.End.String()}}
}

type EndRangeFilter struct {
	EndMin time.Time
	EndMax time.Time
}

func (f EndRangeFilter) SearchFilter() search.Filter {
	return &search.DateRangeFilter{Field: "end", Min: f.EndMin, Max: f.EndMax}
}

type GroupIDFilter struct {
	GroupID string
}

func (f GroupIDFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "groupID", Terms: []string{f.GroupID}}
}

type GroupIDsFilter struct {
	GroupIDs []string
}

func (f GroupIDsFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "groupID", Terms: f.GroupIDs}
}

type IDFilter struct {
	ID string
}

func (f IDFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "id", Terms: []string{f.ID}}
}

type IDsFilter struct {
	IDs []string
}

func (f IDsFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "id", Terms: f.IDs}
}

type ISFilter struct {
	IS string
}

func (f ISFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "is", Terms: []string{f.IS}}
}

type ISsFilter struct {
	ISs []string
}

func (f ISsFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "is", Terms: f.ISs}
}

type ListedFilter struct {
	Listed bool
}

func (f ListedFilter) SearchFilter() search.Filter {
	return &search.BoolFilter{Field: "listed", Value: f.Listed}
}

type LocationFilter struct {
	Location string
}

func (f LocationFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "location", Terms: []string{f.Location}}
}

type LocationsFilter struct {
	Locations []string
}

func (f LocationsFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "location", Terms: f.Locations}
}

type Location2Filter struct {
	Location2 string
}

func (f Location2Filter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "location2", Terms: []string{f.Location2}}
}

type Location2sFilter struct {
	Location2s []string
}

func (f Location2sFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "location2", Terms: f.Location2s}
}

type MultidayFilter struct {
	Multiday int
}

func (f MultidayFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "multiday", Terms: []string{fmt.Sprintf("%d", f.Multiday)}}
}

type MultidayRangeFilter struct {
	MultidayMin *int
	MultidayMax *int
}

func (f MultidayRangeFilter) SearchFilter() search.Filter {
	filter := &search.NumericRangeFilter{Field: "multiday"}
	if f.MultidayMin != nil {
		minF := float64(*f.MultidayMin)
		filter.Min = &minF
	}
	if f.MultidayMax != nil {
		maxF := float64(*f.MultidayMax)
		filter.Max = &maxF
	}
	return filter
}

type NameFilter struct {
	Name string
}

func (f NameFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "name", Terms: []string{f.Name}}
}

type NamesFilter struct {
	Names []string
}

func (f NamesFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "name", Terms: f.Names}
}

type OrganizerFilter struct {
	Organizer string
}

func (f OrganizerFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "organizer", Terms: []string{f.Organizer}}
}

type OrganizersFilter struct {
	Organizers []string
}

func (f OrganizersFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "organizer", Terms: f.Organizers}
}

type OwnedByFilter struct {
	OwnedBy string
}

func (f OwnedByFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "ownedBy", Terms: []string{f.OwnedBy}}
}

type OwnedBysFilter struct {
	OwnedBys []string
}

func (f OwnedBysFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "ownedBy", Terms: f.OwnedBys}
}

type PlaceIDFilter struct {
	PlaceID string
}

func (f PlaceIDFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "placeID", Terms: []string{f.PlaceID}}
}

type PlaceIDsFilter struct {
	PlaceIDs []string
}

func (f PlaceIDsFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "placeID", Terms: f.PlaceIDs}
}

type StartFilter struct {
	Start time.Time
}

func (f StartFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "start", Terms: []string{f.Start.String()}}
}

type StartRangeFilter struct {
	StartMin time.Time
	StartMax time.Time
}

func (f StartRangeFilter) SearchFilter() search.Filter {
	return &search.DateRangeFilter{Field: "start", Min: f.StartMin, Max: f.StartMax}
}

type TagFilter struct {
	Tag string
}

func (f TagFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "tag", Terms: []string{f.Tag}}
}

type TagsFilter struct {
	Tags []string
}

func (f TagsFilter) SearchFilter() search.Filter {
	return &search.TermsFilter{Field: "tag", Terms: f.Tags}
}