2021-01-17 21:46:25 +08:00
|
|
|
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
2019-11-29 22:02:19 +08:00
|
|
|
//
|
|
|
|
// This Source Code Form is subject to the terms of the MIT License.
|
|
|
|
// If a copy of the MIT was not distributed with this file,
|
|
|
|
// You can obtain one at https://github.com/gogf/gf.
|
|
|
|
|
|
|
|
package ghttp
|
|
|
|
|
|
|
|
import (
|
|
|
|
"github.com/gogf/gf/container/gvar"
|
2020-11-08 15:44:04 +08:00
|
|
|
"github.com/gogf/gf/internal/empty"
|
|
|
|
"github.com/gogf/gf/internal/structs"
|
2019-11-29 22:02:19 +08:00
|
|
|
"github.com/gogf/gf/util/gconv"
|
2020-11-08 15:44:04 +08:00
|
|
|
"github.com/gogf/gf/util/gutil"
|
2019-11-29 22:02:19 +08:00
|
|
|
)
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequest retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as interface{}, no matter what HTTP method the client is using. The
|
|
|
|
// parameter <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
//
|
2019-12-01 14:07:36 +08:00
|
|
|
// GetRequest is one of the most commonly used functions for retrieving parameters.
|
|
|
|
//
|
2020-03-19 13:38:42 +08:00
|
|
|
// Note that if there're multiple parameters with the same name, the parameters are
|
|
|
|
// retrieved and overwrote in order of priority: router < query < body < form < custom.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequest(key string, def ...interface{}) interface{} {
|
2019-12-01 14:07:36 +08:00
|
|
|
value := r.GetParam(key)
|
2019-12-05 10:44:31 +08:00
|
|
|
if value == nil {
|
|
|
|
value = r.GetForm(key)
|
|
|
|
}
|
2019-12-01 14:07:36 +08:00
|
|
|
if value == nil {
|
2020-01-01 14:18:00 +08:00
|
|
|
r.parseBody()
|
2019-12-01 14:07:36 +08:00
|
|
|
if len(r.bodyMap) > 0 {
|
|
|
|
value = r.bodyMap[key]
|
2019-11-30 09:42:07 +08:00
|
|
|
}
|
2019-11-29 22:02:19 +08:00
|
|
|
}
|
2019-12-01 14:07:36 +08:00
|
|
|
if value == nil {
|
|
|
|
value = r.GetQuery(key)
|
2019-11-29 22:02:19 +08:00
|
|
|
}
|
2019-12-01 14:07:36 +08:00
|
|
|
if value == nil {
|
|
|
|
value = r.GetRouterValue(key)
|
2019-11-29 22:02:19 +08:00
|
|
|
}
|
2019-12-01 14:07:36 +08:00
|
|
|
if value != nil {
|
|
|
|
return value
|
2019-11-29 22:02:19 +08:00
|
|
|
}
|
|
|
|
if len(def) > 0 {
|
|
|
|
return def[0]
|
|
|
|
}
|
2019-12-01 14:07:36 +08:00
|
|
|
return value
|
2019-11-29 22:02:19 +08:00
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestVar retrieves and returns the parameter named <key> passed from client and
|
2020-06-16 17:38:05 +08:00
|
|
|
// custom params as gvar.Var, no matter what HTTP method the client is using. The parameter
|
2020-03-19 13:38:42 +08:00
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2020-06-29 13:40:19 +08:00
|
|
|
func (r *Request) GetRequestVar(key string, def ...interface{}) *gvar.Var {
|
2019-11-29 22:02:19 +08:00
|
|
|
return gvar.New(r.GetRequest(key, def...))
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestString retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as string, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestString(key string, def ...interface{}) string {
|
|
|
|
return r.GetRequestVar(key, def...).String()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestBool retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as bool, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestBool(key string, def ...interface{}) bool {
|
|
|
|
return r.GetRequestVar(key, def...).Bool()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestInt retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as int, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestInt(key string, def ...interface{}) int {
|
|
|
|
return r.GetRequestVar(key, def...).Int()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestInt32 retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as int32, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestInt32(key string, def ...interface{}) int32 {
|
|
|
|
return r.GetRequestVar(key, def...).Int32()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestInt64 retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as int64, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestInt64(key string, def ...interface{}) int64 {
|
|
|
|
return r.GetRequestVar(key, def...).Int64()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestInts retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as []int, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestInts(key string, def ...interface{}) []int {
|
|
|
|
return r.GetRequestVar(key, def...).Ints()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestUint retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as uint, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestUint(key string, def ...interface{}) uint {
|
|
|
|
return r.GetRequestVar(key, def...).Uint()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestUint32 retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as uint32, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestUint32(key string, def ...interface{}) uint32 {
|
|
|
|
return r.GetRequestVar(key, def...).Uint32()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestUint64 retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as uint64, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestUint64(key string, def ...interface{}) uint64 {
|
|
|
|
return r.GetRequestVar(key, def...).Uint64()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestFloat32 retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as float32, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestFloat32(key string, def ...interface{}) float32 {
|
|
|
|
return r.GetRequestVar(key, def...).Float32()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestFloat64 retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as float64, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestFloat64(key string, def ...interface{}) float64 {
|
|
|
|
return r.GetRequestVar(key, def...).Float64()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestFloats retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as []float64, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestFloats(key string, def ...interface{}) []float64 {
|
|
|
|
return r.GetRequestVar(key, def...).Floats()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestArray retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as []string, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestArray(key string, def ...interface{}) []string {
|
|
|
|
return r.GetRequestVar(key, def...).Strings()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestStrings retrieves and returns the parameter named <key> passed from client and
|
|
|
|
// custom params as []string, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestStrings(key string, def ...interface{}) []string {
|
|
|
|
return r.GetRequestVar(key, def...).Strings()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestInterfaces retrieves and returns the parameter named <key> passed from client
|
|
|
|
// and custom params as []interface{}, no matter what HTTP method the client is using. The
|
|
|
|
// parameter <def> specifies the default value if the <key> does not exist.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestInterfaces(key string, def ...interface{}) []interface{} {
|
|
|
|
return r.GetRequestVar(key, def...).Interfaces()
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestMap retrieves and returns all parameters passed from client and custom params
|
|
|
|
// as map, no matter what HTTP method the client is using. The parameter <kvMap> specifies
|
|
|
|
// the keys retrieving from client parameters, the associated values are the default values
|
|
|
|
// if the client does not pass the according keys.
|
2019-12-01 14:07:36 +08:00
|
|
|
//
|
|
|
|
// GetRequestMap is one of the most commonly used functions for retrieving parameters.
|
|
|
|
//
|
2020-03-19 13:38:42 +08:00
|
|
|
// Note that if there're multiple parameters with the same name, the parameters are retrieved
|
|
|
|
// and overwrote in order of priority: router < query < body < form < custom.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestMap(kvMap ...map[string]interface{}) map[string]interface{} {
|
2020-01-01 14:18:00 +08:00
|
|
|
r.parseQuery()
|
|
|
|
r.parseForm()
|
|
|
|
r.parseBody()
|
2019-12-01 14:07:36 +08:00
|
|
|
var ok, filter bool
|
|
|
|
var length int
|
|
|
|
if len(kvMap) > 0 && kvMap[0] != nil {
|
|
|
|
length = len(kvMap[0])
|
|
|
|
filter = true
|
|
|
|
} else {
|
|
|
|
length = len(r.routerMap) + len(r.queryMap) + len(r.formMap) + len(r.bodyMap) + len(r.paramsMap)
|
|
|
|
}
|
|
|
|
m := make(map[string]interface{}, length)
|
|
|
|
for k, v := range r.routerMap {
|
|
|
|
if filter {
|
|
|
|
if _, ok = kvMap[0][k]; !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
m[k] = v
|
|
|
|
}
|
2019-11-30 09:42:07 +08:00
|
|
|
for k, v := range r.queryMap {
|
2019-12-01 14:07:36 +08:00
|
|
|
if filter {
|
|
|
|
if _, ok = kvMap[0][k]; !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
2019-11-30 09:42:07 +08:00
|
|
|
m[k] = v
|
|
|
|
}
|
|
|
|
for k, v := range r.formMap {
|
2019-12-01 14:07:36 +08:00
|
|
|
if filter {
|
|
|
|
if _, ok = kvMap[0][k]; !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
2019-11-29 22:02:19 +08:00
|
|
|
m[k] = v
|
|
|
|
}
|
2019-11-30 09:42:07 +08:00
|
|
|
for k, v := range r.bodyMap {
|
2019-12-01 14:07:36 +08:00
|
|
|
if filter {
|
|
|
|
if _, ok = kvMap[0][k]; !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
2019-11-29 22:02:19 +08:00
|
|
|
m[k] = v
|
|
|
|
}
|
2019-12-01 14:07:36 +08:00
|
|
|
for k, v := range r.paramsMap {
|
|
|
|
if filter {
|
2019-11-30 09:42:07 +08:00
|
|
|
if _, ok = kvMap[0][k]; !ok {
|
2019-12-01 14:07:36 +08:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
m[k] = v
|
|
|
|
}
|
|
|
|
// Check none exist parameters and assign it with default value.
|
|
|
|
if filter {
|
|
|
|
for k, v := range kvMap[0] {
|
|
|
|
if _, ok = m[k]; !ok {
|
|
|
|
m[k] = v
|
2019-11-30 09:42:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-11-29 22:02:19 +08:00
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestMapStrStr retrieves and returns all parameters passed from client and custom
|
|
|
|
// params as map[string]string, no matter what HTTP method the client is using. The parameter
|
|
|
|
// <kvMap> specifies the keys retrieving from client parameters, the associated values are the
|
|
|
|
// default values if the client does not pass.
|
2019-11-29 22:02:19 +08:00
|
|
|
func (r *Request) GetRequestMapStrStr(kvMap ...map[string]interface{}) map[string]string {
|
|
|
|
requestMap := r.GetRequestMap(kvMap...)
|
|
|
|
if len(requestMap) > 0 {
|
2019-12-01 14:07:36 +08:00
|
|
|
m := make(map[string]string, len(requestMap))
|
2019-11-29 22:02:19 +08:00
|
|
|
for k, v := range requestMap {
|
|
|
|
m[k] = gconv.String(v)
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestMapStrVar retrieves and returns all parameters passed from client and custom
|
2020-06-29 13:40:19 +08:00
|
|
|
// params as map[string]*gvar.Var, no matter what HTTP method the client is using. The parameter
|
2020-03-19 13:38:42 +08:00
|
|
|
// <kvMap> specifies the keys retrieving from client parameters, the associated values are the
|
|
|
|
// default values if the client does not pass.
|
2020-06-29 13:40:19 +08:00
|
|
|
func (r *Request) GetRequestMapStrVar(kvMap ...map[string]interface{}) map[string]*gvar.Var {
|
2019-11-29 22:02:19 +08:00
|
|
|
requestMap := r.GetRequestMap(kvMap...)
|
|
|
|
if len(requestMap) > 0 {
|
2020-06-29 13:40:19 +08:00
|
|
|
m := make(map[string]*gvar.Var, len(requestMap))
|
2019-11-29 22:02:19 +08:00
|
|
|
for k, v := range requestMap {
|
|
|
|
m[k] = gvar.New(v)
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-03-19 13:38:42 +08:00
|
|
|
// GetRequestStruct retrieves all parameters passed from client and custom params no matter
|
|
|
|
// what HTTP method the client is using, and converts them to given struct object. Note that
|
|
|
|
// the parameter <pointer> is a pointer to the struct object.
|
2019-11-29 22:02:19 +08:00
|
|
|
// The optional parameter <mapping> is used to specify the key to attribute mapping.
|
2019-12-19 15:14:05 +08:00
|
|
|
func (r *Request) GetRequestStruct(pointer interface{}, mapping ...map[string]string) error {
|
2021-05-12 00:01:52 +08:00
|
|
|
_, err := r.doGetRequestStruct(pointer, mapping...)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (r *Request) doGetRequestStruct(pointer interface{}, mapping ...map[string]string) (data map[string]interface{}, err error) {
|
|
|
|
data = r.GetRequestMap()
|
2020-11-08 15:44:04 +08:00
|
|
|
if data == nil {
|
|
|
|
data = map[string]interface{}{}
|
2020-08-13 18:51:59 +08:00
|
|
|
}
|
2020-11-08 15:44:04 +08:00
|
|
|
if err := r.mergeDefaultStructValue(data, pointer); err != nil {
|
2021-05-12 00:01:52 +08:00
|
|
|
return data, nil
|
2020-11-08 15:44:04 +08:00
|
|
|
}
|
2021-05-12 00:01:52 +08:00
|
|
|
return data, gconv.Struct(data, pointer, mapping...)
|
2019-11-29 22:02:19 +08:00
|
|
|
}
|
2019-12-19 15:14:05 +08:00
|
|
|
|
2020-11-08 15:44:04 +08:00
|
|
|
// mergeDefaultStructValue merges the request parameters with default values from struct tag definition.
|
|
|
|
func (r *Request) mergeDefaultStructValue(data map[string]interface{}, pointer interface{}) error {
|
|
|
|
tagFields, err := structs.TagFields(pointer, defaultValueTags)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if len(tagFields) > 0 {
|
|
|
|
var (
|
|
|
|
foundKey string
|
|
|
|
foundValue interface{}
|
|
|
|
)
|
|
|
|
for _, field := range tagFields {
|
|
|
|
foundKey, foundValue = gutil.MapPossibleItemByKey(data, field.Name())
|
|
|
|
if foundKey == "" {
|
|
|
|
data[field.Name()] = field.TagValue
|
|
|
|
} else {
|
|
|
|
if empty.IsEmpty(foundValue) {
|
|
|
|
data[foundKey] = field.TagValue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
2019-12-19 15:14:05 +08:00
|
|
|
}
|