// 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 }