// Required validates an interface for requiredness
func Required(path, in string, data interface{}) *errors.Validation {
val := reflect.ValueOf(data)
if val.IsValid() {
if reflect.DeepEqual(reflect.Zero(val.Type()).Interface(), val.Interface()) {
return errors.Required(path, in)
}
return nil
}
return errors.Required(path, in)
}
func (p *untypedParamBinder) setSliceFieldValue(target reflect.Value, defaultValue interface{}, data []string) error {
if len(data) == 0 && p.parameter.Required && p.parameter.Default == nil {
return errors.Required(p.Name, p.parameter.In)
}
defVal := reflect.Zero(target.Type())
if defaultValue != nil {
defVal = reflect.ValueOf(defaultValue)
}
if len(data) == 0 {
target.Set(defVal)
return nil
}
sz := len(data)
value := reflect.MakeSlice(reflect.SliceOf(target.Type().Elem()), sz, sz)
for i := 0; i < sz; i++ {
if err := p.setFieldValue(value.Index(i), nil, data[i]); err != nil {
return err
}
}
target.Set(value)
return nil
}
func (p *untypedParamBinder) setSliceFieldValue(target reflect.Value, defaultValue interface{}, data []string, hasKey bool) error {
sz := len(data)
if (!hasKey || (!p.parameter.AllowEmptyValue && (sz == 0 || (sz == 1 && data[0] == "")))) && p.parameter.Required && defaultValue == nil {
return errors.Required(p.Name, p.parameter.In)
}
defVal := reflect.Zero(target.Type())
if defaultValue != nil {
defVal = reflect.ValueOf(defaultValue)
}
if !target.CanSet() {
return nil
}
if sz == 0 {
target.Set(defVal)
return nil
}
value := reflect.MakeSlice(reflect.SliceOf(target.Type().Elem()), sz, sz)
for i := 0; i < sz; i++ {
if err := p.setFieldValue(value.Index(i), nil, data[i], hasKey); err != nil {
return err
}
}
target.Set(value)
return nil
}
func (o *FindPetsByStatusParams) bindStatus(rawData []string, hasKey bool, formats strfmt.Registry) error {
if !hasKey {
return errors.Required("status", "query")
}
var qvStatus string
if len(rawData) > 0 {
qvStatus = rawData[len(rawData)-1]
}
raw := swag.SplitByFormat(qvStatus, "csv")
size := len(raw)
if size == 0 {
return errors.Required("status", "query")
}
if size == 0 {
return nil
}
ic := raw
isz := size
var ir []string
iValidateElement := func(i int, statusI string) *errors.Validation {
if err := validate.Enum(fmt.Sprintf("%s.%v", "status", i), "query", o.Status[i], []interface{}{"available", "pending", "sold"}); err != nil {
return err
}
return nil
}
for i := 0; i < isz; i++ {
if err := iValidateElement(i, ic[i]); err != nil {
return err
}
ir = append(ir, ic[i])
}
o.Status = ir
return nil
}
func (o *FindPetsByTagsParams) bindTags(rawData []string, hasKey bool, formats strfmt.Registry) error {
if !hasKey {
return errors.Required("tags", "query")
}
var qvTags string
if len(rawData) > 0 {
qvTags = rawData[len(rawData)-1]
}
raw := swag.SplitByFormat(qvTags, "csv")
size := len(raw)
if size == 0 {
return errors.Required("tags", "query")
}
if size == 0 {
return nil
}
ic := raw
isz := size
var ir []string
iValidateElement := func(i int, tagsI string) *errors.Validation {
return nil
}
for i := 0; i < isz; i++ {
if err := iValidateElement(i, ic[i]); err != nil {
return err
}
ir = append(ir, ic[i])
}
o.Tags = ir
return nil
}
func (o *UpdatePetWithFormParams) bindName(rawData []string, hasKey bool, formats strfmt.Registry) error {
if !hasKey {
return errors.Required("name", "formData")
}
var raw string
if len(rawData) > 0 {
raw = rawData[len(rawData)-1]
}
if err := validate.RequiredString("name", "formData", raw); err != nil {
return err
}
o.Name = raw
return nil
}
func (o *LoginUserParams) bindUsername(rawData []string, hasKey bool, formats strfmt.Registry) error {
if !hasKey {
return errors.Required("username", "query")
}
var raw string
if len(rawData) > 0 {
raw = rawData[len(rawData)-1]
}
if err := validate.RequiredString("username", "query", raw); err != nil {
return err
}
o.Username = raw
return nil
}
func (o *DeletePetParams) bindAPIKey(rawData []string, hasKey bool, formats strfmt.Registry) error {
if !hasKey {
return errors.Required("api_key", "header")
}
var raw string
if len(rawData) > 0 {
raw = rawData[len(rawData)-1]
}
if err := validate.RequiredString("api_key", "header", raw); err != nil {
return err
}
o.APIKey = raw
return nil
}
func (o *FindParams) bindLimit(rawData []string, hasKey bool, formats strfmt.Registry) error {
if !hasKey {
return errors.Required("limit", "formData")
}
var raw string
if len(rawData) > 0 {
raw = rawData[len(rawData)-1]
}
value, err := swag.ConvertInt32(raw)
if err != nil {
return errors.InvalidType("limit", "formData", "int32", raw)
}
o.Limit = value
return nil
}
func (o *FindParams) bindXRateLimit(rawData []string, hasKey bool, formats strfmt.Registry) error {
if !hasKey {
return errors.Required("X-Rate-Limit", "header")
}
var raw string
if len(rawData) > 0 {
raw = rawData[len(rawData)-1]
}
if err := validate.RequiredString("X-Rate-Limit", "header", raw); err != nil {
return err
}
value, err := swag.ConvertInt32(raw)
if err != nil {
return errors.InvalidType("X-Rate-Limit", "header", "int32", raw)
}
o.XRateLimit = value
return nil
}
func (o *FindParams) bindTags(rawData []string, hasKey bool, formats strfmt.Registry) error {
if !hasKey {
return errors.Required("tags", "formData")
}
raw := rawData
size := len(raw)
if size == 0 {
return nil
}
ic := raw
isz := size
var ir []int32
iValidateElement := func(i int, tagsI int32) *errors.Validation {
return nil
}
for i := 0; i < isz; i++ {
value, err := swag.ConvertInt32(ic[i])
if err != nil {
return errors.InvalidType(fmt.Sprintf("%s.%v", "tags", i), "formData", "int32", ic[i])
}
if err := iValidateElement(i, o.Tags[i]); err != nil {
return err
}
ir = append(ir, value)
}
o.Tags = ir
return nil
}
func (p *untypedParamBinder) setFieldValue(target reflect.Value, defaultValue interface{}, data string) error {
tpe := p.parameter.Type
if p.parameter.Format != "" {
tpe = p.parameter.Format
}
if data == "" && p.parameter.Required && p.parameter.Default == nil {
return errors.Required(p.Name, p.parameter.In)
}
ok, err := p.tryUnmarshaler(target, defaultValue, data)
if err != nil {
return errors.InvalidType(p.Name, p.parameter.In, tpe, data)
}
if ok {
return nil
}
defVal := reflect.Zero(target.Type())
if defaultValue != nil {
defVal = reflect.ValueOf(defaultValue)
}
if tpe == "byte" {
if data == "" {
target.SetBytes(defVal.Bytes())
return nil
}
b, err := base64.StdEncoding.DecodeString(data)
if err != nil {
b, err = base64.URLEncoding.DecodeString(data)
if err != nil {
return errors.InvalidType(p.Name, p.parameter.In, tpe, data)
}
}
target.SetBytes(b)
return nil
}
switch target.Kind() {
case reflect.Bool:
if data == "" {
target.SetBool(defVal.Bool())
return nil
}
b, err := swag.ConvertBool(data)
if err != nil {
return err
}
target.SetBool(b)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
if data == "" {
target.SetInt(defVal.Int())
return nil
}
i, err := strconv.ParseInt(data, 10, 64)
if err != nil {
return errors.InvalidType(p.Name, p.parameter.In, tpe, data)
}
if target.OverflowInt(i) {
return errors.InvalidType(p.Name, p.parameter.In, tpe, data)
}
target.SetInt(i)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
if data == "" {
target.SetUint(defVal.Uint())
return nil
}
u, err := strconv.ParseUint(data, 10, 64)
if err != nil {
return errors.InvalidType(p.Name, p.parameter.In, tpe, data)
}
if target.OverflowUint(u) {
return errors.InvalidType(p.Name, p.parameter.In, tpe, data)
}
target.SetUint(u)
case reflect.Float32, reflect.Float64:
if data == "" {
target.SetFloat(defVal.Float())
return nil
}
f, err := strconv.ParseFloat(data, 64)
if err != nil {
return errors.InvalidType(p.Name, p.parameter.In, tpe, data)
}
if target.OverflowFloat(f) {
return errors.InvalidType(p.Name, p.parameter.In, tpe, data)
}
target.SetFloat(f)
case reflect.String:
value := data
if value == "" {
value = defVal.String()
}
// validate string
target.SetString(value)
case reflect.Ptr:
if data == "" && defVal.Kind() == reflect.Ptr {
target.Set(defVal)
return nil
}
newVal := reflect.New(target.Type().Elem())
if err := p.setFieldValue(reflect.Indirect(newVal), defVal, data); err != nil {
return err
}
target.Set(newVal)
default:
return errors.InvalidType(p.Name, p.parameter.In, tpe, data)
}
return nil
}
func requiredErrorItems(path, in string) *errors.Validation {
return errors.Required(path, in)
}
func requiredError(param *spec.Parameter) *errors.Validation {
return errors.Required(param.Name, param.In)
}
// RequiredString validates a string for requiredness
func RequiredString(path, in, data string) *errors.Validation {
if data == "" {
return errors.Required(path, in)
}
return nil
}
// RequiredNumber validates a number for requiredness
func RequiredNumber(path, in string, data float64) *errors.Validation {
if data == 0 {
return errors.Required(path, in)
}
return nil
}
func (o *objectValidator) Validate(data interface{}) *Result {
val := data.(map[string]interface{})
numKeys := int64(len(val))
if o.MinProperties != nil && numKeys < *o.MinProperties {
return sErr(errors.TooFewProperties(o.Path, o.In, *o.MinProperties))
}
if o.MaxProperties != nil && numKeys > *o.MaxProperties {
return sErr(errors.TooManyProperties(o.Path, o.In, *o.MaxProperties))
}
res := new(Result)
if len(o.Required) > 0 {
for _, k := range o.Required {
if _, ok := val[k]; !ok {
res.AddErrors(errors.Required(o.Path+"."+k, o.In))
continue
}
}
}
if o.AdditionalProperties != nil && !o.AdditionalProperties.Allows {
for k := range val {
_, regularProperty := o.Properties[k]
matched := false
for pk := range o.PatternProperties {
if matches, _ := regexp.MatchString(pk, k); matches {
matched = true
break
}
}
if !regularProperty && k != "$schema" && k != "id" && !matched {
res.AddErrors(errors.PropertyNotAllowed(o.Path, o.In, k))
}
}
} else {
for key, value := range val {
_, regularProperty := o.Properties[key]
matched, succeededOnce, _ := o.validatePatternProperty(key, value, res)
if !(regularProperty || matched || succeededOnce) {
if o.AdditionalProperties != nil && o.AdditionalProperties.Schema != nil {
res.Merge(NewSchemaValidator(o.AdditionalProperties.Schema, o.Root, o.Path+"."+key, o.KnownFormats).Validate(value))
} else if regularProperty && !(matched || succeededOnce) {
res.AddErrors(errors.FailedAllPatternProperties(o.Path, o.In, key))
}
}
}
}
for pName, pSchema := range o.Properties {
rName := pName
if o.Path != "" {
rName = o.Path + "." + pName
}
if v, ok := val[pName]; ok {
res.Merge(NewSchemaValidator(&pSchema, o.Root, rName, o.KnownFormats).Validate(v))
}
}
for key, value := range val {
_, regularProperty := o.Properties[key]
matched, succeededOnce, patterns := o.validatePatternProperty(key, value, res)
if !regularProperty && (matched || succeededOnce) {
for _, pName := range patterns {
if v, ok := o.PatternProperties[pName]; ok {
res.Merge(NewSchemaValidator(&v, o.Root, o.Path+"."+key, o.KnownFormats).Validate(value))
}
}
}
}
return res
}