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
}
// Required validates an interface for requiredness
func Required(path, in string, data interface{}) *errors.Validation {
val := reflect.ValueOf(data)
if reflect.DeepEqual(reflect.Zero(val.Type()), val) {
return errors.Required(path, in)
}
return nil
}
// 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 (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 (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))
}
}
// Pattern Properties
return res
}
func requiredError(param *spec.Parameter) *errors.Validation {
return errors.Required(param.Name, param.In)
}
func requiredErrorItems(path, in string) *errors.Validation {
return errors.Required(path, in)
}