detectsapi_aggregate_alert_query_request.go

// Code generated by go-swagger; DO NOT EDIT.

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"context"
	"strconv"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// DetectsapiAggregateAlertQueryRequest detectsapi aggregate alert query request
//
// swagger:model detectsapi.AggregateAlertQueryRequest
type DetectsapiAggregateAlertQueryRequest struct {

	// DateRanges applies to date_range aggregations.
	// Required: true
	DateRanges []*MsaDateRangeSpec `json:"date_ranges"`

	// Exclude Post-filtering on queried fields
	// Required: true
	Exclude *string `json:"exclude"`

	// Field applies for example to date_histogram and range aggregations.
	// Required: true
	Field *string `json:"field"`

	// FQL query specifying the filter parameters.
	// Required: true
	Filter *string `json:"filter"`

	// used in bucket sort aggregations as an offset
	// Required: true
	From *int32 `json:"from"`

	// Include Post-filtering on queried fields
	// Required: true
	Include *string `json:"include"`

	// Interval applies for example to date_histogram aggregations (uses calendar_interval). Possible values: year, month, week, day, hour, minute.
	// Required: true
	Interval *string `json:"interval"`

	// only return terms that match less than a configured number of hits.
	MaxDocCount int64 `json:"max_doc_count,omitempty"`

	// only return terms that match more than a configured number of hits.
	MinDocCount int64 `json:"min_doc_count,omitempty"`

	// Missing is a value for missing term field. The behavior that query should return if the document does not have the field in the query
	// Required: true
	Missing *string `json:"missing"`

	// Name of the aggregate query
	// Required: true
	Name *string `json:"name"`

	// represents full text query
	// Required: true
	Q *string `json:"q"`

	// Ranges applies to range aggregations.
	// Required: true
	Ranges []*MsaRangeSpec `json:"ranges"`

	// how many term buckets should be returned.
	// Required: true
	Size *int32 `json:"size"`

	// Sort spec, ex: 'pattern_id|desc'.
	// Required: true
	Sort *string `json:"sort"`

	// sub aggregate alert query.
	// Required: true
	SubAggregates []*DetectsapiAggregateAlertQueryRequest `json:"sub_aggregates"`

	// TimeZone timezone to specify when bucketing results.
	// Required: true
	TimeZone *string `json:"time_zone"`

	// Datastore supported value types: term, terms, date_histogram, facet, range, cardinality. Exact allowed values specific to endpoint.
	// Required: true
	Type *string `json:"type"`
}

// Validate validates this detectsapi aggregate alert query request
func (m *DetectsapiAggregateAlertQueryRequest) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateDateRanges(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateExclude(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateField(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateFilter(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateFrom(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateInclude(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateInterval(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateMissing(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateName(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateQ(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateRanges(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSize(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSort(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSubAggregates(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateTimeZone(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateType(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateDateRanges(formats strfmt.Registry) error {

	if err := validate.Required("date_ranges", "body", m.DateRanges); err != nil {
		return err
	}

	for i := 0; i < len(m.DateRanges); i++ {
		if swag.IsZero(m.DateRanges[i]) { // not required
			continue
		}

		if m.DateRanges[i] != nil {
			if err := m.DateRanges[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("date_ranges" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("date_ranges" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateExclude(formats strfmt.Registry) error {

	if err := validate.Required("exclude", "body", m.Exclude); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateField(formats strfmt.Registry) error {

	if err := validate.Required("field", "body", m.Field); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateFilter(formats strfmt.Registry) error {

	if err := validate.Required("filter", "body", m.Filter); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateFrom(formats strfmt.Registry) error {

	if err := validate.Required("from", "body", m.From); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateInclude(formats strfmt.Registry) error {

	if err := validate.Required("include", "body", m.Include); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateInterval(formats strfmt.Registry) error {

	if err := validate.Required("interval", "body", m.Interval); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateMissing(formats strfmt.Registry) error {

	if err := validate.Required("missing", "body", m.Missing); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateName(formats strfmt.Registry) error {

	if err := validate.Required("name", "body", m.Name); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateQ(formats strfmt.Registry) error {

	if err := validate.Required("q", "body", m.Q); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateRanges(formats strfmt.Registry) error {

	if err := validate.Required("ranges", "body", m.Ranges); err != nil {
		return err
	}

	for i := 0; i < len(m.Ranges); i++ {
		if swag.IsZero(m.Ranges[i]) { // not required
			continue
		}

		if m.Ranges[i] != nil {
			if err := m.Ranges[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("ranges" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("ranges" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateSize(formats strfmt.Registry) error {

	if err := validate.Required("size", "body", m.Size); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateSort(formats strfmt.Registry) error {

	if err := validate.Required("sort", "body", m.Sort); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateSubAggregates(formats strfmt.Registry) error {

	if err := validate.Required("sub_aggregates", "body", m.SubAggregates); err != nil {
		return err
	}

	for i := 0; i < len(m.SubAggregates); i++ {
		if swag.IsZero(m.SubAggregates[i]) { // not required
			continue
		}

		if m.SubAggregates[i] != nil {
			if err := m.SubAggregates[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("sub_aggregates" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("sub_aggregates" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateTimeZone(formats strfmt.Registry) error {

	if err := validate.Required("time_zone", "body", m.TimeZone); err != nil {
		return err
	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) validateType(formats strfmt.Registry) error {

	if err := validate.Required("type", "body", m.Type); err != nil {
		return err
	}

	return nil
}

// ContextValidate validate this detectsapi aggregate alert query request based on the context it is used
func (m *DetectsapiAggregateAlertQueryRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateDateRanges(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateRanges(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSubAggregates(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) contextValidateDateRanges(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.DateRanges); i++ {

		if m.DateRanges[i] != nil {

			if swag.IsZero(m.DateRanges[i]) { // not required
				return nil
			}

			if err := m.DateRanges[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("date_ranges" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("date_ranges" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) contextValidateRanges(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.Ranges); i++ {

		if m.Ranges[i] != nil {

			if swag.IsZero(m.Ranges[i]) { // not required
				return nil
			}

			if err := m.Ranges[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("ranges" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("ranges" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *DetectsapiAggregateAlertQueryRequest) contextValidateSubAggregates(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.SubAggregates); i++ {

		if m.SubAggregates[i] != nil {

			if swag.IsZero(m.SubAggregates[i]) { // not required
				return nil
			}

			if err := m.SubAggregates[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("sub_aggregates" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("sub_aggregates" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

// MarshalBinary interface implementation
func (m *DetectsapiAggregateAlertQueryRequest) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *DetectsapiAggregateAlertQueryRequest) UnmarshalBinary(b []byte) error {
	var res DetectsapiAggregateAlertQueryRequest
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}