// 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 := validate.NewSchemaValidator(schema, nil, "", formats).Validate(data)
if res.HasErrors() {
return errors.CompositeValidationError(res.Errors...)
}
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 defintion 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 *spec.Document, formats strfmt.Registry) error {
errs, _ /*warns*/ := validate.NewSpecValidator(doc.Schema(), formats).Validate(doc)
if errs.HasErrors() {
return errors.CompositeValidationError(errs.Errors...)
}
return nil
}
// BindAndValidate binds and validates the request
func (c *Context) BindAndValidate(request *http.Request, matched *MatchedRoute) (interface{}, error) {
if v, ok := context.GetOk(request, ctxBoundParams); ok {
if val, ok := v.(*validation); ok {
if len(val.result) > 0 {
return val.bound, errors.CompositeValidationError(val.result...)
}
return val.bound, nil
}
}
result := validateRequest(c, request, matched)
if result != nil {
context.Set(request, ctxBoundParams, result)
}
if len(result.result) > 0 {
return result.bound, errors.CompositeValidationError(result.result...)
}
return result.bound, nil
}
// Bind perform the databinding and validation
func (o *untypedRequestBinder) Bind(request *http.Request, routeParams RouteParams, consumer httpkit.Consumer, data interface{}) error {
val := reflect.Indirect(reflect.ValueOf(data))
isMap := val.Kind() == reflect.Map
var result []error
for fieldName, param := range o.Parameters {
binder := o.paramBinders[fieldName]
var target reflect.Value
if !isMap {
binder.Name = fieldName
target = val.FieldByName(fieldName)
}
if isMap {
tpe := binder.Type()
if tpe == nil {
if param.Schema.Type.Contains("array") {
tpe = reflect.TypeOf([]interface{}{})
} else {
tpe = reflect.TypeOf(map[string]interface{}{})
}
}
target = reflect.Indirect(reflect.New(tpe))
}
if !target.IsValid() {
result = append(result, errors.New(500, "parameter name %q is an unknown field", binder.Name))
continue
}
if err := binder.Bind(request, routeParams, consumer, target); err != nil {
result = append(result, err)
continue
}
if binder.validator != nil {
rr := binder.validator.Validate(target.Interface())
if rr != nil && rr.HasErrors() {
result = append(result, rr.AsError())
}
}
if isMap {
val.SetMapIndex(reflect.ValueOf(param.Name), target)
}
}
if len(result) > 0 {
return errors.CompositeValidationError(result...)
}
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 *DeleteOrderParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
if err := o.bindOrderID(route.Params.Get("orderId"), route.Formats); err != nil {
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 *GetUserByNameParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
if err := o.bindUsername(route.Params.Get("username"), route.Formats); err != nil {
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 *FindPetsByTagsParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
qs := r.URL.Query()
if err := o.bindTags(swag.SplitByFormat(qs.Get("tags"), "multi"), route.Formats); err != nil {
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 *DeletePetParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
if err := o.bindAPIKey(r.Header.Get("apiKey"), route.Formats); err != nil {
res = append(res, err)
}
if err := o.bindPetID(route.Params.Get("petId"), route.Formats); err != nil {
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 *CreateUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
if err := route.Consumer.Consume(r.Body, &o.Body); err != nil {
res = append(res, errors.NewParseError("body", "body", "", err))
} else {
if err := o.Body.Validate(route.Formats); err != nil {
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 *LoginUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
qs := r.URL.Query()
if err := o.bindUsername(qs.Get("username"), route.Formats); err != nil {
res = append(res, err)
}
if err := o.bindPassword(qs.Get("password"), route.Formats); err != nil {
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 *UpdatePetWithFormParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
if err := o.bindPetID(route.Params.Get("petId"), route.Formats); err != nil {
res = append(res, err)
}
if err := o.bindName(r.FormValue("name"), route.Formats); err != nil {
res = append(res, err)
}
if err := o.bindStatus(r.FormValue("status"), route.Formats); err != nil {
res = append(res, 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.validateName(formats); err != nil {
res = append(res, err)
}
if err := m.validatePhotoUrls(formats); err != nil {
res = append(res, err)
}
if err := m.validateTags(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// BindValidRequest binds a params object to a request but only when the request is valid
// if the request is not valid an error will be returned
func (c *Context) BindValidRequest(request *http.Request, route *MatchedRoute, binder RequestBinder) error {
var res []error
// check and validate content type, select consumer
if httpkit.CanHaveBody(request.Method) {
ct, _, err := httpkit.ContentType(request.Header)
if err != nil {
res = append(res, err)
} else {
if err := validateContentType(route.Consumes, ct); err != nil {
res = append(res, err)
}
route.Consumer = route.Consumers[ct]
}
}
// check and validate the response format
if len(res) == 0 {
if str := httputil.NegotiateContentType(request, route.Produces, ""); str == "" {
res = append(res, errors.InvalidResponseFormat(request.Header.Get(httpkit.HeaderAccept), route.Produces))
}
}
// now bind the request with the provided binder
// it's assumed the binder will also validate the request and return an error if the
// request is invalid
if binder != nil && len(res) == 0 {
if err := binder.BindRequest(request, route); err != nil {
res = append(res, err)
}
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
func (r *Result) AsError() error {
if r.IsValid() {
return nil
}
return errors.CompositeValidationError(r.Errors...)
}
