106 lines
2.2 KiB
Go
106 lines
2.2 KiB
Go
package validation
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
)
|
|
|
|
// IntList represents a list of IntFields for validating multiple integer values
|
|
type IntList struct {
|
|
FieldBase
|
|
Fields []*IntField
|
|
}
|
|
|
|
// newIntList creates a new IntList from form/query values
|
|
func newIntList(key string, g Getter) *IntList {
|
|
items := g.GetList(key)
|
|
list := &IntList{
|
|
FieldBase: newField(key, g),
|
|
Fields: make([]*IntField, 0, len(items)),
|
|
}
|
|
|
|
for _, item := range items {
|
|
if item == "" {
|
|
continue // Skip empty values
|
|
}
|
|
|
|
var val int
|
|
var err error
|
|
val, err = strconv.Atoi(item)
|
|
if err != nil {
|
|
g.AddCheck(newFailedCheck(
|
|
"Value is not a number",
|
|
fmt.Sprintf("%s contains invalid integer: %s", key, item),
|
|
))
|
|
continue
|
|
}
|
|
|
|
// Create an IntField directly with the value
|
|
field := &IntField{
|
|
Value: val,
|
|
FieldBase: newField(key, g),
|
|
}
|
|
list.Fields = append(list.Fields, field)
|
|
}
|
|
|
|
return list
|
|
}
|
|
|
|
// Values returns all int values in the list
|
|
func (l *IntList) Values() []int {
|
|
values := make([]int, len(l.Fields))
|
|
for i, field := range l.Fields {
|
|
values[i] = field.Value
|
|
}
|
|
return values
|
|
}
|
|
|
|
// Required enforces at least one value in the list
|
|
func (l *IntList) Required() *IntList {
|
|
if len(l.Fields) == 0 {
|
|
l.getter.AddCheck(newFailedCheck(
|
|
"Field not provided",
|
|
fmt.Sprintf("%s is required", l.Key),
|
|
))
|
|
}
|
|
return l
|
|
}
|
|
|
|
// MinItems enforces a minimum number of items in the list
|
|
func (l *IntList) MinItems(min int) *IntList {
|
|
if len(l.Fields) < min {
|
|
l.getter.AddCheck(newFailedCheck(
|
|
"Too few items",
|
|
fmt.Sprintf("%s requires at least %d item(s)", l.Key, min),
|
|
))
|
|
}
|
|
return l
|
|
}
|
|
|
|
// MaxItems enforces a maximum number of items in the list
|
|
func (l *IntList) MaxItems(max int) *IntList {
|
|
if len(l.Fields) > max {
|
|
l.getter.AddCheck(newFailedCheck(
|
|
"Too many items",
|
|
fmt.Sprintf("%s allows at most %d item(s)", l.Key, max),
|
|
))
|
|
}
|
|
return l
|
|
}
|
|
|
|
// Max enforces a maximum value for each item
|
|
func (l *IntList) Max(max int) *IntList {
|
|
for _, field := range l.Fields {
|
|
field.Max(max)
|
|
}
|
|
return l
|
|
}
|
|
|
|
// Min enforces a minimum value for each item
|
|
func (l *IntList) Min(min int) *IntList {
|
|
for _, field := range l.Fields {
|
|
field.Min(min)
|
|
}
|
|
return l
|
|
}
|