As requested, changed JSON to upper case

notzippy · notzippy · commit 116f4e920339 · 2017-05-31T17:08:14.000-07:00
Updated params so that Params.Bind() does not blindly bind json data
Added Params.BindJSON() to provide JSON bind functionality
diff --git a/binder.go b/binder.go
@@ -5,6 +5,7 @@
 package revel
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -14,7 +15,6 @@ import (
 	"strconv"
 	"strings"
 	"time"
-	"encoding/json"
 )
 
 // A Binder translates between string parameters and Go data structures.
@@ -293,9 +293,9 @@ func unbindSlice(output map[string]string, name string, val interface{}) {
 func bindStruct(params *Params, name string, typ reflect.Type) reflect.Value {
 	resultPointer := reflect.New(typ)
 	result := resultPointer.Elem()
-	if params.Json!=nil {
+	if params.JSON != nil {
 		// Try to inject the response as a json into the created result
-		if err := json.Unmarshal(params.Json, resultPointer.Interface()); err != nil {
+		if err := json.Unmarshal(params.JSON, resultPointer.Interface()); err != nil {
 			WARN.Println("W: bindStruct: Unable to unmarshal request:", name, err)
 		}
 		return result
@@ -422,9 +422,9 @@ func bindMap(params *Params, name string, typ reflect.Type) reflect.Value {
 		result    = resultPtr.Elem()
 	)
 	result.Set(reflect.MakeMap(typ))
-	if params.Json!=nil {
+	if params.JSON != nil {
 		// Try to inject the response as a json into the created result
-		if err := json.Unmarshal(params.Json, resultPtr.Interface()); err != nil {
+		if err := json.Unmarshal(params.JSON, resultPtr.Interface()); err != nil {
 			WARN.Println("W: bindMap: Unable to unmarshal request:", name, err)
 		}
 		return result
diff --git a/binder_test.go b/binder_test.go
@@ -170,24 +170,24 @@ func TestJsonBinder(t *testing.T) {
 	// create a structure to be populated
 	{
 		d, _ := json.Marshal(map[string]int{"a": 1})
-		params := &Params{Json: d}
+		params := &Params{JSON: d}
 		foo := struct{ A int }{}
 		ParseParams(params, NewRequest(getMultipartRequest()))
 		actual := Bind(params, "test", reflect.TypeOf(foo))
 		valEq(t, "TestJsonBinder", reflect.ValueOf(actual.Interface().(struct{ A int }).A), reflect.ValueOf(1))
 	}
 	{
-		d, _ := json.Marshal(map[string]interface{}{"a": map[string]int{"b":45}})
-		params := &Params{Json: d}
+		d, _ := json.Marshal(map[string]interface{}{"a": map[string]int{"b": 45}})
+		params := &Params{JSON: d}
 		testMap := map[string]interface{}{}
 		actual := Bind(params, "test", reflect.TypeOf(testMap)).Interface().(map[string]interface{})
-		if actual["a"].(map[string]interface{})["b"].(float64)!=45 {
-			t.Errorf("Failed to fetch map value %#v",actual["a"])
+		if actual["a"].(map[string]interface{})["b"].(float64) != 45 {
+			t.Errorf("Failed to fetch map value %#v", actual["a"])
 		}
 		// Check to see if a named map works
 		actualb := Bind(params, "test", reflect.TypeOf(map[string]map[string]float64{})).Interface().(map[string]map[string]float64)
-		if actualb["a"]["b"]!=45 {
-			t.Errorf("Failed to fetch map value %#v",actual["a"])
+		if actualb["a"]["b"] != 45 {
+			t.Errorf("Failed to fetch map value %#v", actual["a"])
 		}
 
 	}
diff --git a/params.go b/params.go
@@ -5,11 +5,13 @@
 package revel
 
 import (
+	"encoding/json"
+	"io/ioutil"
 	"mime/multipart"
 	"net/url"
 	"os"
 	"reflect"
-	"io/ioutil"
+	"errors"
 )
 
 // Params provides a unified view of the request params.
@@ -32,7 +34,7 @@ type Params struct {
 
 	Files    map[string][]*multipart.FileHeader // Files uploaded in a multipart form
 	tmpFiles []*os.File                         // Temp files used during the request.
-	Json        []byte                          // JSON data from request body
+	JSON     []byte                             // JSON data from request body
 }
 
 // ParseParams parses the `http.Request` params into `revel.Controller.Params`
@@ -61,12 +63,12 @@ func ParseParams(params *Params, req *Request) {
 	case "application/json":
 		fallthrough
 	case "text/json":
-		if req.Body!=nil {
-			if content, err := ioutil.ReadAll(req.Body);err==nil{
+		if req.Body != nil {
+			if content, err := ioutil.ReadAll(req.Body); err == nil {
 				// We wont bind it until we determine what we are binding too
-				params.Json = content
+				params.JSON = content
 			} else {
-				ERROR.Println("Failed to ready request body bytes",err)
+				ERROR.Println("Failed to ready request body bytes", err)
 			}
 		} else {
 			INFO.Println("Json post received with empty body")
@@ -88,7 +90,29 @@ func (p *Params) Bind(dest interface{}, name string) {
 	if !value.CanSet() {
 		panic("revel/params: non-settable variable passed to Bind: " + name)
 	}
+
+	// Remove the json from the Params, this will stop the binder from attempting
+	// to use the json data to populate the destination interface. We do not want
+	// to do this on a named bind directly against the param, it is ok to happen when
+	// the action is invoked.
+	jsonData := p.JSON
+	p.JSON = nil
 	value.Set(Bind(p, name, value.Type()))
+	p.JSON = jsonData
+}
+
+// Bind binds the JSON data to the dest.
+func (p *Params) BindJSON(dest interface{}) error {
+	value := reflect.ValueOf(dest)
+	if value.Kind() != reflect.Ptr {
+		WARN.Println("BindJSON not a pointer")
+		return errors.New("BindJSON not a pointer")
+	}
+	if err := json.Unmarshal(p.JSON, dest); err != nil {
+		WARN.Println("W: bindMap: Unable to unmarshal request:", err)
+		return err
+	}
+	return nil
 }
 
 // calcValues returns a unified view of the component param maps.
diff --git a/validation.go b/validation.go
@@ -187,7 +187,7 @@ func (v *Validation) Check(obj interface{}, checks ...Validator) *ValidationResu
 func ValidationFilter(c *Controller, fc []Filter) {
 	// If json request, we shall assume json response is intended,
 	// as such no validation cookies should be tied response
-	if c.Params != nil && c.Params.Json != nil {
+	if c.Params != nil && c.Params.JSON != nil {
 		c.Validation = &Validation{}
 		fc[0](c, fc[1:])
 	} else {

Original file line number	Diff line number	Diff line change
`@@ -170,24 +170,24 @@ func TestJsonBinder(t *testing.T) {`
`170`	`170`	`// create a structure to be populated`
`171`	`171`	`{`
`172`	`172`	`d, _ := json.Marshal(map[string]int{"a": 1})`
`173`		`- params := &Params{Json: d}`
	`173`	`+ params := &Params{JSON: d}`
`174`	`174`	`foo := struct{ A int }{}`
`175`	`175`	`ParseParams(params, NewRequest(getMultipartRequest()))`
`176`	`176`	`actual := Bind(params, "test", reflect.TypeOf(foo))`
`177`	`177`	`valEq(t, "TestJsonBinder", reflect.ValueOf(actual.Interface().(struct{ A int }).A), reflect.ValueOf(1))`
`178`	`178`	`}`
`179`	`179`	`{`
`180`		`- d, _ := json.Marshal(map[string]interface{}{"a": map[string]int{"b":45}})`
`181`		`- params := &Params{Json: d}`
	`180`	`+ d, _ := json.Marshal(map[string]interface{}{"a": map[string]int{"b": 45}})`
	`181`	`+ params := &Params{JSON: d}`
`182`	`182`	`testMap := map[string]interface{}{}`
`183`	`183`	`actual := Bind(params, "test", reflect.TypeOf(testMap)).Interface().(map[string]interface{})`
`184`		`- if actual["a"].(map[string]interface{})["b"].(float64)!=45 {`
`185`		`- t.Errorf("Failed to fetch map value %#v",actual["a"])`
	`184`	`+ if actual["a"].(map[string]interface{})["b"].(float64) != 45 {`
	`185`	`+ t.Errorf("Failed to fetch map value %#v", actual["a"])`
`186`	`186`	`}`
`187`	`187`	`// Check to see if a named map works`
`188`	`188`	`actualb := Bind(params, "test", reflect.TypeOf(map[string]map[string]float64{})).Interface().(map[string]map[string]float64)`
`189`		`- if actualb["a"]["b"]!=45 {`
`190`		`- t.Errorf("Failed to fetch map value %#v",actual["a"])`
	`189`	`+ if actualb["a"]["b"] != 45 {`
	`190`	`+ t.Errorf("Failed to fetch map value %#v", actual["a"])`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`}`