// WriteToRequest writes these params to a swagger request
func (o *ChangeTagImageParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
var res []error
if o.Body == nil {
o.Body = new(models.MoveTag)
}
if err := r.SetBodyParam(o.Body); err != nil {
return err
}
// path param repository
if err := r.SetPathParam("repository", o.Repository); err != nil {
return err
}
// path param tag
if err := r.SetPathParam("tag", o.Tag); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *GetCatalogsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
r.SetTimeout(o.timeout)
var res []error
if o.Query != nil {
// query param query
var qrQuery string
if o.Query != nil {
qrQuery = *o.Query
}
qQuery := qrQuery
if qQuery != "" {
if err := r.SetQueryParam("query", qQuery); err != nil {
return err
}
}
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *ManuallyStartBuildTriggerParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
var res []error
if o.Body == nil {
o.Body = new(models.RunParameters)
}
if err := r.SetBodyParam(o.Body); err != nil {
return err
}
// path param repository
if err := r.SetPathParam("repository", o.Repository); err != nil {
return err
}
// path param trigger_uuid
if err := r.SetPathParam("trigger_uuid", o.TriggerUUID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *PostNodesIdentifierWorkflowsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
r.SetTimeout(o.timeout)
var res []error
if err := r.SetBodyParam(o.Body); err != nil {
return err
}
// path param identifier
if err := r.SetPathParam("identifier", o.Identifier); err != nil {
return err
}
// query param name
qrName := o.Name
qName := qrName
if qName != "" {
if err := r.SetQueryParam("name", qName); err != nil {
return err
}
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
// for simple values it will use straight method calls
func (o *GetTaskCommentsParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
o.HTTPRequest = r
qs := runtime.Values(r.URL.Query())
rID, rhkID, _ := route.Params.GetOK("id")
if err := o.bindID(rID, rhkID, route.Formats); err != nil {
res = append(res, err)
}
qPageSize, qhkPageSize, _ := qs.GetOK("pageSize")
if err := o.bindPageSize(qPageSize, qhkPageSize, route.Formats); err != nil {
res = append(res, err)
}
qSince, qhkSince, _ := qs.GetOK("since")
if err := o.bindSince(qSince, qhkSince, route.Formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *UpdateOrganizationTeamParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
var res []error
if o.Body == nil {
o.Body = new(models.TeamDescription)
}
if err := r.SetBodyParam(o.Body); err != nil {
return err
}
// path param orgname
if err := r.SetPathParam("orgname", o.Orgname); err != nil {
return err
}
// path param teamname
if err := r.SetPathParam("teamname", o.Teamname); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *DiscoveryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
var res []error
if o.Internal != nil {
// query param internal
var qrInternal bool
if o.Internal != nil {
qrInternal = *o.Internal
}
qInternal := swag.FormatBool(qrInternal)
if qInternal != "" {
if err := r.SetQueryParam("internal", qInternal); err != nil {
return err
}
}
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// Validate validates this alias
func (m *Alias) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateAlias(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateDeleted(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateID(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateOrganizationID(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// Validate validates this notification create request
func (m *NotificationCreateRequest) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateConfig(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateEvent(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateEventConfig(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateMethod(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *ChangeTeamPermissionsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
var res []error
if o.Body == nil {
o.Body = new(models.TeamPermission)
}
if err := r.SetBodyParam(o.Body); err != nil {
return err
}
// path param repository
if err := r.SetPathParam("repository", o.Repository); err != nil {
return err
}
// path param teamname
if err := r.SetPathParam("teamname", o.Teamname); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
// for simple values it will use straight method calls
func (o *UpdatePetWithFormParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
o.HTTPRequest = r
if err := r.ParseMultipartForm(32 << 20); err != nil {
if err != http.ErrNotMultipart {
return err
} else if err := r.ParseForm(); err != nil {
return err
}
}
fds := runtime.Values(r.Form)
fdName, fdhkName, _ := fds.GetOK("name")
if err := o.bindName(fdName, fdhkName, route.Formats); err != nil {
res = append(res, err)
}
rPetID, rhkPetID, _ := route.Params.GetOK("petId")
if err := o.bindPetID(rPetID, rhkPetID, route.Formats); err != nil {
res = append(res, err)
}
fdStatus, fdhkStatus, _ := fds.GetOK("status")
if err := o.bindStatus(fdStatus, fdhkStatus, route.Formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *ListTagImagesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
var res []error
if o.Owned != nil {
// query param owned
var qrOwned bool
if o.Owned != nil {
qrOwned = *o.Owned
}
qOwned := swag.FormatBool(qrOwned)
if qOwned != "" {
if err := r.SetQueryParam("owned", qOwned); err != nil {
return err
}
}
}
// path param repository
if err := r.SetPathParam("repository", o.Repository); err != nil {
return err
}
// path param tag
if err := r.SetPathParam("tag", o.Tag); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
// for simple values it will use straight method calls
func (o *FindParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
o.HTTPRequest = r
if err := r.ParseMultipartForm(32 << 20); err != nil {
if err != http.ErrNotMultipart {
return err
} else if err := r.ParseForm(); err != nil {
return err
}
}
fds := runtime.Values(r.Form)
if err := o.bindXRateLimit(r.Header[http.CanonicalHeaderKey("X-Rate-Limit")], true, route.Formats); err != nil {
res = append(res, err)
}
fdLimit, fdhkLimit, _ := fds.GetOK("limit")
if err := o.bindLimit(fdLimit, fdhkLimit, route.Formats); err != nil {
res = append(res, err)
}
fdTags, fdhkTags, _ := fds.GetOK("tags")
if err := o.bindTags(fdTags, fdhkTags, route.Formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// Validate validates this j credential
func (m *JCredential) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateFields(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateIdentifier(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateOriginID(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateProvider(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateTitle(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// AgainstSchema validates the specified data with the provided schema, when no schema
// is provided it uses the json schema as default
func AgainstSchema(schema *spec.Schema, data interface{}, formats strfmt.Registry) error {
res := NewSchemaValidator(schema, nil, "", formats).Validate(data)
if res.HasErrors() {
return errors.CompositeValidationError(res.Errors...)
}
return nil
}
// Validate validates this j compute stack
func (m *JComputeStack) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateGroup(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateOriginID(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateStatus(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateTitle(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
// for simple values it will use straight method calls
func (o *AddCommentToTaskParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
o.HTTPRequest = r
if runtime.HasBody(r) {
defer r.Body.Close()
var body AddCommentToTaskBody
if err := route.Consumer.Consume(r.Body, &body); err != nil {
res = append(res, errors.NewParseError("body", "body", "", err))
} else {
if len(res) == 0 {
o.Body = body
}
}
}
rID, rhkID, _ := route.Params.GetOK("id")
if err := o.bindID(rID, rhkID, route.Formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// Validate validates this create profile address request
func (m *CreateProfileAddressRequest) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateAddressLine1(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateCity(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateCountry(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validatePostcode(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateProvince(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// Validate validates this task
func (m *Task) Validate(formats strfmt.Registry) error {
var res []error
if err := m.TaskCard.Validate(formats); err != nil {
res = append(res, err)
}
if err := m.validateAttachments(formats); err != nil {
res = append(res, err)
}
if err := m.validateComments(formats); err != nil {
res = append(res, err)
}
if err := m.validateLastUpdatedBy(formats); err != nil {
res = append(res, err)
}
if err := m.validateReportedBy(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *FindParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
var res []error
// header param X-Rate-Limit
if err := r.SetHeaderParam("X-Rate-Limit", swag.FormatInt32(o.XRateLimit)); err != nil {
return err
}
// form param limit
frLimit := o.Limit
fLimit := swag.FormatInt32(frLimit)
if err := r.SetFormParam("limit", fLimit); err != nil {
return err
}
var valuesTags []string
for _, v := range o.Tags {
valuesTags = append(valuesTags, swag.FormatInt32(v))
}
joinedTags := swag.JoinByFormat(valuesTags, "multi")
// form array param tags
if err := r.SetFormParam("tags", joinedTags...); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *SetMetadataForProductParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
var res []error
if err := r.SetBodyParam(o.Metadata); err != nil {
return err
}
valuesOrganizations := o.Organizations
joinedOrganizations := swag.JoinByFormat(valuesOrganizations, "multi")
// query array param organizations
if err := r.SetQueryParam("organizations", joinedOrganizations...); err != nil {
return err
}
// path param product-ID
if err := r.SetPathParam("product-ID", o.ProductID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *GetLookupsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
r.SetTimeout(o.timeout)
var res []error
if o.Q != nil {
// query param q
var qrQ string
if o.Q != nil {
qrQ = *o.Q
}
qQ := qrQ
if qQ != "" {
if err := r.SetQueryParam("q", qQ); err != nil {
return err
}
}
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// Validate validates this pet
func (m *Pet) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCategory(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateName(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validatePhotoUrls(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateTags(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// WriteToRequest writes these params to a swagger request
func (o *GetRepoImageSecurityParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
var res []error
// path param imageid
if err := r.SetPathParam("imageid", o.Imageid); err != nil {
return err
}
// path param repository
if err := r.SetPathParam("repository", o.Repository); err != nil {
return err
}
if o.Vulnerabilities != nil {
// query param vulnerabilities
var qrVulnerabilities bool
if o.Vulnerabilities != nil {
qrVulnerabilities = *o.Vulnerabilities
}
qVulnerabilities := swag.FormatBool(qrVulnerabilities)
if qVulnerabilities != "" {
if err := r.SetQueryParam("vulnerabilities", qVulnerabilities); err != nil {
return err
}
}
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
// for simple values it will use straight method calls
func (o *PlaceOrderParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
o.HTTPRequest = r
if runtime.HasBody(r) {
defer r.Body.Close()
var body models.Order
if err := route.Consumer.Consume(r.Body, &body); err != nil {
res = append(res, errors.NewParseError("body", "body", "", err))
} else {
if err := body.Validate(route.Formats); err != nil {
res = append(res, err)
}
if len(res) == 0 {
o.Body = &body
}
}
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// Validate validates this unit of measure
func (m *UnitOfMeasure) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateDeleted(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateDisplayedAs(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateName(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateOrganizationID(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// Validate validates this location dto
func (m *LocationDto) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCountry(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateCountryCode(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateLocationType(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateName(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// Spec validates a spec document
// It validates the spec json against the json schema for swagger
// and then validates a number of extra rules that can't be expressed in json schema:
//
// - definition can't declare a property that's already defined by one of its ancestors
// - definition's ancestor can't be a descendant of the same model
// - each api path should be non-verbatim (account for path param names) unique per method
// - each security reference should contain only unique scopes
// - each security scope in a security definition should be unique
// - each path parameter should correspond to a parameter placeholder and vice versa
// - each referencable definition must have references
// - each definition property listed in the required array must be defined in the properties of the model
// - each parameter should have a unique `name` and `type` combination
// - each operation should have only 1 parameter of type body
// - each reference must point to a valid object
// - every default value that is specified must validate against the schema for that property
// - items property is required for all schemas/definitions of type `array`
func Spec(doc *loads.Document, formats strfmt.Registry) error {
errs, _ /*warns*/ := NewSpecValidator(doc.Schema(), formats).Validate(doc)
if errs.HasErrors() {
return errors.CompositeValidationError(errs.Errors...)
}
return nil
}
// Validate validates this coordinate dto
func (m *CoordinateDto) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateCountryCode(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateEasting(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateNorthing(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validateSrID(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
// for simple values it will use straight method calls
func (o *CreateUsersWithArrayInputParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
o.HTTPRequest = r
if runtime.HasBody(r) {
defer r.Body.Close()
var body []*models.User
if err := route.Consumer.Consume(r.Body, &body); err != nil {
res = append(res, errors.NewParseError("body", "body", "", err))
} else {
for _, io := range o.Body {
if err := io.Validate(route.Formats); err != nil {
res = append(res, err)
break
}
}
if len(res) == 0 {
o.Body = body
}
}
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
