173 lines
3.5 KiB
Go
173 lines
3.5 KiB
Go
package cache
|
|
|
|
import (
|
|
"errors"
|
|
"github.com/iancoleman/strcase"
|
|
"meow.tf/go/cacheinterface/v2/encoder"
|
|
"net/url"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// decodeQuery is a helper that behaves like gorilla/schema,
|
|
// encoding/json, etc. It takes in a url.Values and decodes it into the
|
|
// dest struct - assigning defaults if nothing is populated.
|
|
func decodeQuery(query url.Values, dest any) error {
|
|
destType := reflect.TypeOf(dest)
|
|
|
|
if destType.Kind() == reflect.Ptr {
|
|
destType = destType.Elem()
|
|
}
|
|
|
|
destVal := reflect.ValueOf(dest)
|
|
|
|
if destVal.Kind() == reflect.Ptr {
|
|
destVal = destVal.Elem()
|
|
}
|
|
|
|
for i := 0; i < destType.NumField(); i++ {
|
|
fieldType := destType.Field(i)
|
|
field := destVal.Field(i)
|
|
|
|
queryKeys := []string{
|
|
fieldType.Tag.Get("query"),
|
|
strcase.ToLowerCamel(fieldType.Name),
|
|
}
|
|
|
|
for _, key := range queryKeys {
|
|
if key == "" || !query.Has(key) {
|
|
continue
|
|
}
|
|
|
|
// Map query variable to default field name
|
|
val, err := decodeType(fieldType.Type, query[key], false)
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
field.Set(reflect.ValueOf(val))
|
|
|
|
break
|
|
}
|
|
|
|
// TODO: ignoring bool might not be the best choice.
|
|
// Maybe use bools as either pointers, or setup a "NullBool" like sql.Null*?
|
|
canHaveDefault := field.IsZero() && field.Kind() != reflect.Bool
|
|
|
|
if def := fieldType.Tag.Get("default"); canHaveDefault && def != "" {
|
|
val, err := decodeType(fieldType.Type, []string{def}, true)
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
field.Set(reflect.ValueOf(val))
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
var (
|
|
encoderType = reflect.TypeOf((*encoder.Encoder)(nil)).Elem()
|
|
durationType = reflect.TypeOf(time.Duration(0))
|
|
)
|
|
|
|
func decodeType(t reflect.Type, val []string, isDefault bool) (any, error) {
|
|
switch t {
|
|
case encoderType:
|
|
return encoder.From(val[0]), nil
|
|
case durationType:
|
|
return time.ParseDuration(val[0])
|
|
}
|
|
|
|
switch t.Kind() {
|
|
case reflect.Bool:
|
|
v, err := strconv.ParseBool(val[0])
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return v, nil
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
v, err := strconv.ParseInt(val[0], 10, 64)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch t.Kind() {
|
|
case reflect.Int:
|
|
return int(v), nil
|
|
case reflect.Int8:
|
|
return int8(v), nil
|
|
case reflect.Int16:
|
|
return int16(v), nil
|
|
case reflect.Int32:
|
|
return int32(v), nil
|
|
case reflect.Int64:
|
|
return v, nil
|
|
}
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
|
v, err := strconv.ParseUint(val[0], 10, 64)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch t.Kind() {
|
|
case reflect.Uint:
|
|
return uint(v), nil
|
|
case reflect.Uint8:
|
|
return uint8(v), nil
|
|
case reflect.Uint16:
|
|
return uint16(v), nil
|
|
case reflect.Uint32:
|
|
return uint32(v), nil
|
|
case reflect.Uint64:
|
|
return v, nil
|
|
}
|
|
case reflect.Float32, reflect.Float64:
|
|
v, err := strconv.ParseFloat(val[0], 64)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch t.Kind() {
|
|
case reflect.Float32:
|
|
return float32(v), nil
|
|
case reflect.Float64:
|
|
return v, nil
|
|
}
|
|
case reflect.String:
|
|
return val[0], nil
|
|
case reflect.Slice:
|
|
elemType := t.Elem()
|
|
|
|
if isDefault {
|
|
val = strings.Split(val[0], ",")
|
|
}
|
|
|
|
out := reflect.MakeSlice(t, 0, len(val))
|
|
|
|
for _, v := range val {
|
|
decodedVal, err := decodeType(elemType, []string{v}, isDefault)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
out = reflect.Append(out, reflect.ValueOf(decodedVal))
|
|
}
|
|
|
|
return out.Interface(), nil
|
|
}
|
|
|
|
return nil, errors.New("unknown type " + t.String())
|
|
}
|