mirror of
https://github.com/astaxie/beego.git
synced 2024-11-17 00:20:55 +00:00
120 lines
3.0 KiB
Go
120 lines
3.0 KiB
Go
package param
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
|
|
beecontext "github.com/astaxie/beego/context"
|
|
"github.com/astaxie/beego/logs"
|
|
)
|
|
|
|
//Keeps param information to be auto passed to controller methods
|
|
type MethodParam struct {
|
|
name string
|
|
parser paramParser
|
|
location paramLocation
|
|
required bool
|
|
defValue string
|
|
}
|
|
|
|
type paramLocation byte
|
|
|
|
const (
|
|
param paramLocation = iota
|
|
body
|
|
header
|
|
)
|
|
|
|
type MethodParamOption func(*MethodParam)
|
|
|
|
func Bool(name string, opts ...MethodParamOption) *MethodParam {
|
|
return newParam(name, boolParser{}, opts)
|
|
}
|
|
|
|
func String(name string, opts ...MethodParamOption) *MethodParam {
|
|
return newParam(name, stringParser{}, opts)
|
|
}
|
|
|
|
func Int(name string, opts ...MethodParamOption) *MethodParam {
|
|
return newParam(name, intParser{}, opts)
|
|
}
|
|
|
|
func Float(name string, opts ...MethodParamOption) *MethodParam {
|
|
return newParam(name, floatParser{}, opts)
|
|
}
|
|
|
|
func Time(name string, opts ...MethodParamOption) *MethodParam {
|
|
return newParam(name, timeParser{}, opts)
|
|
}
|
|
|
|
func Json(name string, opts ...MethodParamOption) *MethodParam {
|
|
return newParam(name, jsonParser{}, opts)
|
|
}
|
|
|
|
func newParam(name string, parser paramParser, opts []MethodParamOption) (param *MethodParam) {
|
|
param = &MethodParam{name: name, parser: parser}
|
|
for _, option := range opts {
|
|
option(param)
|
|
}
|
|
return
|
|
}
|
|
|
|
func convertParam(param *MethodParam, paramType reflect.Type, ctx *beecontext.Context) (result reflect.Value) {
|
|
var strValue string
|
|
var reflectValue reflect.Value
|
|
switch param.location {
|
|
case body:
|
|
strValue = string(ctx.Input.RequestBody)
|
|
case header:
|
|
strValue = ctx.Input.Header(param.name)
|
|
default:
|
|
strValue = ctx.Input.Query(param.name)
|
|
}
|
|
|
|
if strValue == "" {
|
|
if param.required {
|
|
ctx.Abort(400, fmt.Sprintf("Missing parameter %s", param.name))
|
|
} else {
|
|
strValue = param.defValue
|
|
}
|
|
}
|
|
if strValue == "" {
|
|
reflectValue = reflect.Zero(paramType)
|
|
} else {
|
|
value, err := param.parser.parse(strValue, paramType)
|
|
if err != nil {
|
|
logs.Debug(fmt.Sprintf("Error converting param %s to type %s. Value: %s, Parser: %s, Error: %s", param.name, paramType.Name(), strValue, reflect.TypeOf(param.parser).Name(), err))
|
|
ctx.Abort(400, fmt.Sprintf("Invalid parameter %s. Can not convert %s to type %s", param.name, strValue, paramType.Name()))
|
|
}
|
|
|
|
reflectValue, err = safeConvert(reflect.ValueOf(value), paramType)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
return reflectValue
|
|
}
|
|
|
|
func ConvertParams(methodParams []*MethodParam, methodType reflect.Type, ctx *beecontext.Context) (result []reflect.Value) {
|
|
result = make([]reflect.Value, 0, len(methodParams))
|
|
for i := 0; i < len(methodParams); i++ {
|
|
reflectValue := convertParam(methodParams[i], methodType.In(i), ctx)
|
|
result = append(result, reflectValue)
|
|
}
|
|
return
|
|
}
|
|
|
|
func safeConvert(value reflect.Value, t reflect.Type) (result reflect.Value, err error) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
var ok bool
|
|
err, ok = r.(error)
|
|
if !ok {
|
|
err = fmt.Errorf("%v", r)
|
|
}
|
|
}
|
|
}()
|
|
result = value.Convert(t)
|
|
return
|
|
}
|