get_vulnerabilities_urlbuilder.go

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

package operations

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

import (
	"errors"
	"net/url"
	golangswaggerpaths "path"

	"github.com/go-openapi/swag"
)

// GetVulnerabilitiesURL generates an URL for the get vulnerabilities operation
type GetVulnerabilitiesURL struct {
	ApplicationID                          *string
	ApplicationResourceID                  *string
	ApplicationResourcesGte                *int64
	ApplicationResourcesIsNot              []int64
	ApplicationResourcesIs                 []int64
	ApplicationResourcesLte                *int64
	ApplicationsGte                        *int64
	ApplicationsIsNot                      []int64
	ApplicationsIs                         []int64
	ApplicationsLte                        *int64
	CurrentRuntimeScan                     *bool
	HasFixVersionIs                        *bool
	PackageNameContains                    []string
	PackageNameEnd                         *string
	PackageNameIsNot                       []string
	PackageNameIs                          []string
	PackageNameStart                       *string
	PackageVersionContains                 []string
	PackageVersionEnd                      *string
	PackageVersionIsNot                    []string
	PackageVersionIs                       []string
	PackageVersionStart                    *string
	Page                                   int64
	PageSize                               int64
	ReportingScannersContainElements       []string
	ReportingScannersDoesntContainElements []string
	SortDir                                *string
	SortKey                                string
	VulnerabilityNameContains              []string
	VulnerabilityNameEnd                   *string
	VulnerabilityNameIsNot                 []string
	VulnerabilityNameIs                    []string
	VulnerabilityNameStart                 *string
	VulnerabilitySeverityGte               *string
	VulnerabilitySeverityIsNot             []string
	VulnerabilitySeverityIs                []string
	VulnerabilitySeverityLte               *string
	VulnerabilitySourceIs                  []string

	_basePath string
	// avoid unkeyed usage
	_ struct{}
}

// WithBasePath sets the base path for this url builder, only required when it's different from the
// base path specified in the swagger spec.
// When the value of the base path is an empty string
func (o *GetVulnerabilitiesURL) WithBasePath(bp string) *GetVulnerabilitiesURL {
	o.SetBasePath(bp)
	return o
}

// SetBasePath sets the base path for this url builder, only required when it's different from the
// base path specified in the swagger spec.
// When the value of the base path is an empty string
func (o *GetVulnerabilitiesURL) SetBasePath(bp string) {
	o._basePath = bp
}

// Build a url path and query string
func (o *GetVulnerabilitiesURL) Build() (*url.URL, error) {
	var _result url.URL

	var _path = "/vulnerabilities"

	_basePath := o._basePath
	if _basePath == "" {
		_basePath = "/api"
	}
	_result.Path = golangswaggerpaths.Join(_basePath, _path)

	qs := make(url.Values)

	var applicationIDQ string
	if o.ApplicationID != nil {
		applicationIDQ = *o.ApplicationID
	}
	if applicationIDQ != "" {
		qs.Set("applicationID", applicationIDQ)
	}

	var applicationResourceIDQ string
	if o.ApplicationResourceID != nil {
		applicationResourceIDQ = *o.ApplicationResourceID
	}
	if applicationResourceIDQ != "" {
		qs.Set("applicationResourceID", applicationResourceIDQ)
	}

	var applicationResourcesGteQ string
	if o.ApplicationResourcesGte != nil {
		applicationResourcesGteQ = swag.FormatInt64(*o.ApplicationResourcesGte)
	}
	if applicationResourcesGteQ != "" {
		qs.Set("applicationResources[gte]", applicationResourcesGteQ)
	}

	var applicationResourcesIsNotIR []string
	for _, applicationResourcesIsNotI := range o.ApplicationResourcesIsNot {
		applicationResourcesIsNotIS := swag.FormatInt64(applicationResourcesIsNotI)
		if applicationResourcesIsNotIS != "" {
			applicationResourcesIsNotIR = append(applicationResourcesIsNotIR, applicationResourcesIsNotIS)
		}
	}

	applicationResourcesIsNot := swag.JoinByFormat(applicationResourcesIsNotIR, "")

	if len(applicationResourcesIsNot) > 0 {
		qsv := applicationResourcesIsNot[0]
		if qsv != "" {
			qs.Set("applicationResources[isNot]", qsv)
		}
	}

	var applicationResourcesIsIR []string
	for _, applicationResourcesIsI := range o.ApplicationResourcesIs {
		applicationResourcesIsIS := swag.FormatInt64(applicationResourcesIsI)
		if applicationResourcesIsIS != "" {
			applicationResourcesIsIR = append(applicationResourcesIsIR, applicationResourcesIsIS)
		}
	}

	applicationResourcesIs := swag.JoinByFormat(applicationResourcesIsIR, "")

	if len(applicationResourcesIs) > 0 {
		qsv := applicationResourcesIs[0]
		if qsv != "" {
			qs.Set("applicationResources[is]", qsv)
		}
	}

	var applicationResourcesLteQ string
	if o.ApplicationResourcesLte != nil {
		applicationResourcesLteQ = swag.FormatInt64(*o.ApplicationResourcesLte)
	}
	if applicationResourcesLteQ != "" {
		qs.Set("applicationResources[lte]", applicationResourcesLteQ)
	}

	var applicationsGteQ string
	if o.ApplicationsGte != nil {
		applicationsGteQ = swag.FormatInt64(*o.ApplicationsGte)
	}
	if applicationsGteQ != "" {
		qs.Set("applications[gte]", applicationsGteQ)
	}

	var applicationsIsNotIR []string
	for _, applicationsIsNotI := range o.ApplicationsIsNot {
		applicationsIsNotIS := swag.FormatInt64(applicationsIsNotI)
		if applicationsIsNotIS != "" {
			applicationsIsNotIR = append(applicationsIsNotIR, applicationsIsNotIS)
		}
	}

	applicationsIsNot := swag.JoinByFormat(applicationsIsNotIR, "")

	if len(applicationsIsNot) > 0 {
		qsv := applicationsIsNot[0]
		if qsv != "" {
			qs.Set("applications[isNot]", qsv)
		}
	}

	var applicationsIsIR []string
	for _, applicationsIsI := range o.ApplicationsIs {
		applicationsIsIS := swag.FormatInt64(applicationsIsI)
		if applicationsIsIS != "" {
			applicationsIsIR = append(applicationsIsIR, applicationsIsIS)
		}
	}

	applicationsIs := swag.JoinByFormat(applicationsIsIR, "")

	if len(applicationsIs) > 0 {
		qsv := applicationsIs[0]
		if qsv != "" {
			qs.Set("applications[is]", qsv)
		}
	}

	var applicationsLteQ string
	if o.ApplicationsLte != nil {
		applicationsLteQ = swag.FormatInt64(*o.ApplicationsLte)
	}
	if applicationsLteQ != "" {
		qs.Set("applications[lte]", applicationsLteQ)
	}

	var currentRuntimeScanQ string
	if o.CurrentRuntimeScan != nil {
		currentRuntimeScanQ = swag.FormatBool(*o.CurrentRuntimeScan)
	}
	if currentRuntimeScanQ != "" {
		qs.Set("currentRuntimeScan", currentRuntimeScanQ)
	}

	var hasFixVersionIsQ string
	if o.HasFixVersionIs != nil {
		hasFixVersionIsQ = swag.FormatBool(*o.HasFixVersionIs)
	}
	if hasFixVersionIsQ != "" {
		qs.Set("hasFixVersion[is]", hasFixVersionIsQ)
	}

	var packageNameContainsIR []string
	for _, packageNameContainsI := range o.PackageNameContains {
		packageNameContainsIS := packageNameContainsI
		if packageNameContainsIS != "" {
			packageNameContainsIR = append(packageNameContainsIR, packageNameContainsIS)
		}
	}

	packageNameContains := swag.JoinByFormat(packageNameContainsIR, "")

	if len(packageNameContains) > 0 {
		qsv := packageNameContains[0]
		if qsv != "" {
			qs.Set("packageName[contains]", qsv)
		}
	}

	var packageNameEndQ string
	if o.PackageNameEnd != nil {
		packageNameEndQ = *o.PackageNameEnd
	}
	if packageNameEndQ != "" {
		qs.Set("packageName[end]", packageNameEndQ)
	}

	var packageNameIsNotIR []string
	for _, packageNameIsNotI := range o.PackageNameIsNot {
		packageNameIsNotIS := packageNameIsNotI
		if packageNameIsNotIS != "" {
			packageNameIsNotIR = append(packageNameIsNotIR, packageNameIsNotIS)
		}
	}

	packageNameIsNot := swag.JoinByFormat(packageNameIsNotIR, "")

	if len(packageNameIsNot) > 0 {
		qsv := packageNameIsNot[0]
		if qsv != "" {
			qs.Set("packageName[isNot]", qsv)
		}
	}

	var packageNameIsIR []string
	for _, packageNameIsI := range o.PackageNameIs {
		packageNameIsIS := packageNameIsI
		if packageNameIsIS != "" {
			packageNameIsIR = append(packageNameIsIR, packageNameIsIS)
		}
	}

	packageNameIs := swag.JoinByFormat(packageNameIsIR, "")

	if len(packageNameIs) > 0 {
		qsv := packageNameIs[0]
		if qsv != "" {
			qs.Set("packageName[is]", qsv)
		}
	}

	var packageNameStartQ string
	if o.PackageNameStart != nil {
		packageNameStartQ = *o.PackageNameStart
	}
	if packageNameStartQ != "" {
		qs.Set("packageName[start]", packageNameStartQ)
	}

	var packageVersionContainsIR []string
	for _, packageVersionContainsI := range o.PackageVersionContains {
		packageVersionContainsIS := packageVersionContainsI
		if packageVersionContainsIS != "" {
			packageVersionContainsIR = append(packageVersionContainsIR, packageVersionContainsIS)
		}
	}

	packageVersionContains := swag.JoinByFormat(packageVersionContainsIR, "")

	if len(packageVersionContains) > 0 {
		qsv := packageVersionContains[0]
		if qsv != "" {
			qs.Set("packageVersion[contains]", qsv)
		}
	}

	var packageVersionEndQ string
	if o.PackageVersionEnd != nil {
		packageVersionEndQ = *o.PackageVersionEnd
	}
	if packageVersionEndQ != "" {
		qs.Set("packageVersion[end]", packageVersionEndQ)
	}

	var packageVersionIsNotIR []string
	for _, packageVersionIsNotI := range o.PackageVersionIsNot {
		packageVersionIsNotIS := packageVersionIsNotI
		if packageVersionIsNotIS != "" {
			packageVersionIsNotIR = append(packageVersionIsNotIR, packageVersionIsNotIS)
		}
	}

	packageVersionIsNot := swag.JoinByFormat(packageVersionIsNotIR, "")

	if len(packageVersionIsNot) > 0 {
		qsv := packageVersionIsNot[0]
		if qsv != "" {
			qs.Set("packageVersion[isNot]", qsv)
		}
	}

	var packageVersionIsIR []string
	for _, packageVersionIsI := range o.PackageVersionIs {
		packageVersionIsIS := packageVersionIsI
		if packageVersionIsIS != "" {
			packageVersionIsIR = append(packageVersionIsIR, packageVersionIsIS)
		}
	}

	packageVersionIs := swag.JoinByFormat(packageVersionIsIR, "")

	if len(packageVersionIs) > 0 {
		qsv := packageVersionIs[0]
		if qsv != "" {
			qs.Set("packageVersion[is]", qsv)
		}
	}

	var packageVersionStartQ string
	if o.PackageVersionStart != nil {
		packageVersionStartQ = *o.PackageVersionStart
	}
	if packageVersionStartQ != "" {
		qs.Set("packageVersion[start]", packageVersionStartQ)
	}

	pageQ := swag.FormatInt64(o.Page)
	if pageQ != "" {
		qs.Set("page", pageQ)
	}

	pageSizeQ := swag.FormatInt64(o.PageSize)
	if pageSizeQ != "" {
		qs.Set("pageSize", pageSizeQ)
	}

	var reportingScannersContainElementsIR []string
	for _, reportingScannersContainElementsI := range o.ReportingScannersContainElements {
		reportingScannersContainElementsIS := reportingScannersContainElementsI
		if reportingScannersContainElementsIS != "" {
			reportingScannersContainElementsIR = append(reportingScannersContainElementsIR, reportingScannersContainElementsIS)
		}
	}

	reportingScannersContainElements := swag.JoinByFormat(reportingScannersContainElementsIR, "")

	if len(reportingScannersContainElements) > 0 {
		qsv := reportingScannersContainElements[0]
		if qsv != "" {
			qs.Set("reportingScanners[containElements]", qsv)
		}
	}

	var reportingScannersDoesntContainElementsIR []string
	for _, reportingScannersDoesntContainElementsI := range o.ReportingScannersDoesntContainElements {
		reportingScannersDoesntContainElementsIS := reportingScannersDoesntContainElementsI
		if reportingScannersDoesntContainElementsIS != "" {
			reportingScannersDoesntContainElementsIR = append(reportingScannersDoesntContainElementsIR, reportingScannersDoesntContainElementsIS)
		}
	}

	reportingScannersDoesntContainElements := swag.JoinByFormat(reportingScannersDoesntContainElementsIR, "")

	if len(reportingScannersDoesntContainElements) > 0 {
		qsv := reportingScannersDoesntContainElements[0]
		if qsv != "" {
			qs.Set("reportingScanners[doesntContainElements]", qsv)
		}
	}

	var sortDirQ string
	if o.SortDir != nil {
		sortDirQ = *o.SortDir
	}
	if sortDirQ != "" {
		qs.Set("sortDir", sortDirQ)
	}

	sortKeyQ := o.SortKey
	if sortKeyQ != "" {
		qs.Set("sortKey", sortKeyQ)
	}

	var vulnerabilityNameContainsIR []string
	for _, vulnerabilityNameContainsI := range o.VulnerabilityNameContains {
		vulnerabilityNameContainsIS := vulnerabilityNameContainsI
		if vulnerabilityNameContainsIS != "" {
			vulnerabilityNameContainsIR = append(vulnerabilityNameContainsIR, vulnerabilityNameContainsIS)
		}
	}

	vulnerabilityNameContains := swag.JoinByFormat(vulnerabilityNameContainsIR, "")

	if len(vulnerabilityNameContains) > 0 {
		qsv := vulnerabilityNameContains[0]
		if qsv != "" {
			qs.Set("vulnerabilityName[contains]", qsv)
		}
	}

	var vulnerabilityNameEndQ string
	if o.VulnerabilityNameEnd != nil {
		vulnerabilityNameEndQ = *o.VulnerabilityNameEnd
	}
	if vulnerabilityNameEndQ != "" {
		qs.Set("vulnerabilityName[end]", vulnerabilityNameEndQ)
	}

	var vulnerabilityNameIsNotIR []string
	for _, vulnerabilityNameIsNotI := range o.VulnerabilityNameIsNot {
		vulnerabilityNameIsNotIS := vulnerabilityNameIsNotI
		if vulnerabilityNameIsNotIS != "" {
			vulnerabilityNameIsNotIR = append(vulnerabilityNameIsNotIR, vulnerabilityNameIsNotIS)
		}
	}

	vulnerabilityNameIsNot := swag.JoinByFormat(vulnerabilityNameIsNotIR, "")

	if len(vulnerabilityNameIsNot) > 0 {
		qsv := vulnerabilityNameIsNot[0]
		if qsv != "" {
			qs.Set("vulnerabilityName[isNot]", qsv)
		}
	}

	var vulnerabilityNameIsIR []string
	for _, vulnerabilityNameIsI := range o.VulnerabilityNameIs {
		vulnerabilityNameIsIS := vulnerabilityNameIsI
		if vulnerabilityNameIsIS != "" {
			vulnerabilityNameIsIR = append(vulnerabilityNameIsIR, vulnerabilityNameIsIS)
		}
	}

	vulnerabilityNameIs := swag.JoinByFormat(vulnerabilityNameIsIR, "")

	if len(vulnerabilityNameIs) > 0 {
		qsv := vulnerabilityNameIs[0]
		if qsv != "" {
			qs.Set("vulnerabilityName[is]", qsv)
		}
	}

	var vulnerabilityNameStartQ string
	if o.VulnerabilityNameStart != nil {
		vulnerabilityNameStartQ = *o.VulnerabilityNameStart
	}
	if vulnerabilityNameStartQ != "" {
		qs.Set("vulnerabilityName[start]", vulnerabilityNameStartQ)
	}

	var vulnerabilitySeverityGteQ string
	if o.VulnerabilitySeverityGte != nil {
		vulnerabilitySeverityGteQ = *o.VulnerabilitySeverityGte
	}
	if vulnerabilitySeverityGteQ != "" {
		qs.Set("vulnerabilitySeverity[gte]", vulnerabilitySeverityGteQ)
	}

	var vulnerabilitySeverityIsNotIR []string
	for _, vulnerabilitySeverityIsNotI := range o.VulnerabilitySeverityIsNot {
		vulnerabilitySeverityIsNotIS := vulnerabilitySeverityIsNotI
		if vulnerabilitySeverityIsNotIS != "" {
			vulnerabilitySeverityIsNotIR = append(vulnerabilitySeverityIsNotIR, vulnerabilitySeverityIsNotIS)
		}
	}

	vulnerabilitySeverityIsNot := swag.JoinByFormat(vulnerabilitySeverityIsNotIR, "")

	if len(vulnerabilitySeverityIsNot) > 0 {
		qsv := vulnerabilitySeverityIsNot[0]
		if qsv != "" {
			qs.Set("vulnerabilitySeverity[isNot]", qsv)
		}
	}

	var vulnerabilitySeverityIsIR []string
	for _, vulnerabilitySeverityIsI := range o.VulnerabilitySeverityIs {
		vulnerabilitySeverityIsIS := vulnerabilitySeverityIsI
		if vulnerabilitySeverityIsIS != "" {
			vulnerabilitySeverityIsIR = append(vulnerabilitySeverityIsIR, vulnerabilitySeverityIsIS)
		}
	}

	vulnerabilitySeverityIs := swag.JoinByFormat(vulnerabilitySeverityIsIR, "")

	if len(vulnerabilitySeverityIs) > 0 {
		qsv := vulnerabilitySeverityIs[0]
		if qsv != "" {
			qs.Set("vulnerabilitySeverity[is]", qsv)
		}
	}

	var vulnerabilitySeverityLteQ string
	if o.VulnerabilitySeverityLte != nil {
		vulnerabilitySeverityLteQ = *o.VulnerabilitySeverityLte
	}
	if vulnerabilitySeverityLteQ != "" {
		qs.Set("vulnerabilitySeverity[lte]", vulnerabilitySeverityLteQ)
	}

	var vulnerabilitySourceIsIR []string
	for _, vulnerabilitySourceIsI := range o.VulnerabilitySourceIs {
		vulnerabilitySourceIsIS := vulnerabilitySourceIsI
		if vulnerabilitySourceIsIS != "" {
			vulnerabilitySourceIsIR = append(vulnerabilitySourceIsIR, vulnerabilitySourceIsIS)
		}
	}

	vulnerabilitySourceIs := swag.JoinByFormat(vulnerabilitySourceIsIR, "")

	if len(vulnerabilitySourceIs) > 0 {
		qsv := vulnerabilitySourceIs[0]
		if qsv != "" {
			qs.Set("vulnerabilitySource[is]", qsv)
		}
	}

	_result.RawQuery = qs.Encode()

	return &_result, nil
}

// Must is a helper function to panic when the url builder returns an error
func (o *GetVulnerabilitiesURL) Must(u *url.URL, err error) *url.URL {
	if err != nil {
		panic(err)
	}
	if u == nil {
		panic("url can't be nil")
	}
	return u
}

// String returns the string representation of the path with query string
func (o *GetVulnerabilitiesURL) String() string {
	return o.Must(o.Build()).String()
}

// BuildFull builds a full url with scheme, host, path and query string
func (o *GetVulnerabilitiesURL) BuildFull(scheme, host string) (*url.URL, error) {
	if scheme == "" {
		return nil, errors.New("scheme is required for a full url on GetVulnerabilitiesURL")
	}
	if host == "" {
		return nil, errors.New("host is required for a full url on GetVulnerabilitiesURL")
	}

	base, err := o.Build()
	if err != nil {
		return nil, err
	}

	base.Scheme = scheme
	base.Host = host
	return base, nil
}

// StringFull returns the string representation of a complete url
func (o *GetVulnerabilitiesURL) StringFull(scheme, host string) string {
	return o.Must(o.BuildFull(scheme, host)).String()
}