Merge pull request revel#1173 from notzippy/json-params

notzippy · web-flow · commit fa40869ad2d7 · 2017-06-05T20:29:31.000-07:00
JSON Parameter binding
diff --git a/binder.go b/binder.go
@@ -5,6 +5,7 @@
 package revel
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -290,7 +291,15 @@ func unbindSlice(output map[string]string, name string, val interface{}) {
 }
 
 func bindStruct(params *Params, name string, typ reflect.Type) reflect.Value {
-	result := reflect.New(typ).Elem()
+	resultPointer := reflect.New(typ)
+	result := resultPointer.Elem()
+	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 {
+			WARN.Println("W: bindStruct: Unable to unmarshal request:", name, err)
+		}
+		return result
+	}
 	fieldValues := make(map[string]reflect.Value)
 	for key := range params.Values {
 		if !strings.HasPrefix(key, name+".") {
@@ -407,10 +416,20 @@ func bindReadSeeker(params *Params, name string, typ reflect.Type) reflect.Value
 //   params["a[5]"]=foo, name="a", typ=map[int]string => map[int]string{5: "foo"}
 func bindMap(params *Params, name string, typ reflect.Type) reflect.Value {
 	var (
-		result    = reflect.MakeMap(typ)
 		keyType   = typ.Key()
 		valueType = typ.Elem()
+		resultPtr = reflect.New(reflect.MapOf(keyType, valueType))
+		result    = resultPtr.Elem()
 	)
+	result.Set(reflect.MakeMap(typ))
+	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 {
+			WARN.Println("W: bindMap: Unable to unmarshal request:", name, err)
+		}
+		return result
+	}
+
 	for paramName, values := range params.Values {
 		if !strings.HasPrefix(paramName, name+"[") || paramName[len(paramName)-1] != ']' {
 			continue
diff --git a/binder_test.go b/binder_test.go
@@ -5,6 +5,7 @@
 package revel
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -165,6 +166,33 @@ var fileBindings = []struct{ val, arrval, f interface{} }{
 	{(*io.ReadSeeker)(nil), []io.ReadSeeker{}, ioutil.ReadAll},
 }
 
+func TestJsonBinder(t *testing.T) {
+	// create a structure to be populated
+	{
+		d, _ := json.Marshal(map[string]int{"a": 1})
+		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}
+		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"])
+		}
+		// 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"])
+		}
+
+	}
+}
+
 func TestBinder(t *testing.T) {
 	// Reuse the mvc_test.go multipart request to test the binder.
 	params := &Params{}
diff --git a/params.go b/params.go
@@ -5,10 +5,13 @@
 package revel
 
 import (
+	"encoding/json"
+	"io/ioutil"
 	"mime/multipart"
 	"net/url"
 	"os"
 	"reflect"
+	"errors"
 )
 
 // Params provides a unified view of the request params.
@@ -31,6 +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
 }
 
 // ParseParams parses the `http.Request` params into `revel.Controller.Params`
@@ -56,6 +60,19 @@ func ParseParams(params *Params, req *Request) {
 			params.Form = req.MultipartForm.Value
 			params.Files = req.MultipartForm.File
 		}
+	case "application/json":
+		fallthrough
+	case "text/json":
+		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
+			} else {
+				ERROR.Println("Failed to ready request body bytes", err)
+			}
+		} else {
+			INFO.Println("Json post received with empty body")
+		}
 	}
 
 	params.Values = params.calcValues()
@@ -73,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
@@ -185,49 +185,56 @@ func (v *Validation) Check(obj interface{}, checks ...Validator) *ValidationResu
 
 // ValidationFilter revel Filter function to be hooked into the filter chain.
 func ValidationFilter(c *Controller, fc []Filter) {
-	errors, err := restoreValidationErrors(c.Request.Request)
-	c.Validation = &Validation{
-		Errors: errors,
-		keep:   false,
-	}
-	hasCookie := (err != http.ErrNoCookie)
+	// 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 {
+		c.Validation = &Validation{}
+		fc[0](c, fc[1:])
+	} else {
+		errors, err := restoreValidationErrors(c.Request.Request)
+		c.Validation = &Validation{
+			Errors: errors,
+			keep:   false,
+		}
+		hasCookie := (err != http.ErrNoCookie)
 
-	fc[0](c, fc[1:])
+		fc[0](c, fc[1:])
 
-	// Add Validation errors to ViewArgs.
-	c.ViewArgs["errors"] = c.Validation.ErrorMap()
+		// Add Validation errors to ViewArgs.
+		c.ViewArgs["errors"] = c.Validation.ErrorMap()
 
-	// Store the Validation errors
-	var errorsValue string
-	if c.Validation.keep {
-		for _, error := range c.Validation.Errors {
-			if error.Message != "" {
-				errorsValue += "\x00" + error.Key + ":" + error.Message + "\x00"
+		// Store the Validation errors
+		var errorsValue string
+		if c.Validation.keep {
+			for _, err := range c.Validation.Errors {
+				if err.Message != "" {
+					errorsValue += "\x00" + err.Key + ":" + err.Message + "\x00"
+				}
 			}
 		}
-	}
 
-	// When there are errors from Validation and Keep() has been called, store the
-	// values in a cookie. If there previously was a cookie but no errors, remove
-	// the cookie.
-	if errorsValue != "" {
-		c.SetCookie(&http.Cookie{
-			Name:     CookiePrefix + "_ERRORS",
-			Value:    url.QueryEscape(errorsValue),
-			Domain:   CookieDomain,
-			Path:     "/",
-			HttpOnly: true,
-			Secure:   CookieSecure,
-		})
-	} else if hasCookie {
-		c.SetCookie(&http.Cookie{
-			Name:     CookiePrefix + "_ERRORS",
-			MaxAge:   -1,
-			Domain:   CookieDomain,
-			Path:     "/",
-			HttpOnly: true,
-			Secure:   CookieSecure,
-		})
+		// When there are errors from Validation and Keep() has been called, store the
+		// values in a cookie. If there previously was a cookie but no errors, remove
+		// the cookie.
+		if errorsValue != "" {
+			c.SetCookie(&http.Cookie{
+				Name:     CookiePrefix + "_ERRORS",
+				Value:    url.QueryEscape(errorsValue),
+				Domain:   CookieDomain,
+				Path:     "/",
+				HttpOnly: true,
+				Secure:   CookieSecure,
+			})
+		} else if hasCookie {
+			c.SetCookie(&http.Cookie{
+				Name:     CookiePrefix + "_ERRORS",
+				MaxAge:   -1,
+				Domain:   CookieDomain,
+				Path:     "/",
+				HttpOnly: true,
+				Secure:   CookieSecure,
+			})
+		}
 	}
 }
 
