Add example for #1706 (we already cover that functionality through th…

…e rest of the examples, but make it clear for newcomers that, dependencies can be used for that kind of reasons as well)

_examples/README.md

@@ -253,6 +253,7 @@
     * [Hello world](mvc/hello-world/main.go)
     * [Basic](mvc/basic/main.go)
         * [Wildcard](mvc/basic/wildcard/main.go)
+    * [Default request values](mvc/request-default-values/main.go)
     * [Singleton](mvc/singleton)
     * [Regexp](mvc/regexp/main.go)
     * [Session Controller](mvc/session-controller/main.go)

_examples/mvc/request-default-values/main.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/kataras/iris/v12"
+	"github.com/kataras/iris/v12/mvc"
+)
+
+// https://github.com/kataras/iris/issues/1706
+// When you need that type of logic behind a request input,
+// e.g. set default values, the right way to do that is
+// to register a request-scoped dependency for that type.
+// We have the `Context.ReadQuery(pointer)`
+// which you can use to bind a struct value, that value can have default values.
+// Here is how you could do that:
+func main() {
+	app := iris.New()
+
+	mvcApp := mvc.New(app)
+	{
+		mvcApp.Register(paramsDependency)
+
+		mvcApp.Handle(new(controller))
+	}
+
+	// http://localhost:8080/records?phone=random&order_by=DESC
+	// http://localhost:8080/records?phone=random
+	app.Listen(":8080")
+}
+
+type params struct {
+	CallID     string `url:"phone"`
+	ComDir     int    `url:"dir"`
+	CaseUserID string `url:"on"`
+	StartYear  int    `url:"sy"`
+	EndYear    int    `url:"ey"`
+	OrderBy    string `url:"order_by"`
+	Offset     int    `url:"offset"`
+}
+
+// As we've read in the previous examples, the paramsDependency
+// describes a request-scoped dependency.
+// It should accept the iris context (or any previously registered or builtin dependency)
+// and it should return the value which will be binded to the
+// controller's methods (or fields) - see `GetRecords`.
+var paramsDependency = func(ctx iris.Context) params {
+	p := params{
+		OrderBy: "ASC", // default value.
+	}
+	// Bind the URL values to the "p":
+	ctx.ReadQuery(&p)
+	// Or bind a specific URL value by giving a default value:
+	// p.OrderBy = ctx.URLParamDefault("order_by", "ASC")
+	//
+	// OR make checks for default values after ReadXXX,
+	// e.g. if p.OrderBy == "" {...}
+
+	/* More options to read a request:
+	// Bind the JSON request body to the "p":
+	ctx.ReadJSON(&p)
+	// Bind the Form to the "p":
+	ctx.ReadForm(&p)
+	// Bind any, based on the client's content-type header:
+	ctx.ReadBody(&p)
+	// Bind the http requests to a struct value:
+	ctx.ReadHeader(&h)
+	*/
+
+	return p
+}
+
+type controller struct{}
+
+func (c *controller) GetRecords(stru params) string {
+	return fmt.Sprintf("%#+v\n", stru)
+}

core/host/proxy.go

@@ -17,26 +17,14 @@ import (
 // the target request will be for /base/dir.
 //
 // Relative to httputil.NewSingleHostReverseProxy with some additions.
+//
+// Look `ProxyHandlerRemote` too.
 func ProxyHandler(target *url.URL) *httputil.ReverseProxy {
-	targetQuery := target.RawQuery
 	director := func(req *http.Request) {
-		req.URL.Scheme = target.Scheme
-		req.URL.Host = target.Host
-		req.Host = target.Host
-
+		modifyProxiedRequest(req, target)
 		req.URL.Path = path.Join(target.Path, req.URL.Path)
-
-		if targetQuery == "" || req.URL.RawQuery == "" {
-			req.URL.RawQuery = targetQuery + req.URL.RawQuery
-		} else {
-			req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery
-		}
-
-		if _, ok := req.Header["User-Agent"]; !ok {
-			// explicitly disable User-Agent so it's not set to default value
-			req.Header.Set("User-Agent", "")
-		}
 	}
+
 	p := &httputil.ReverseProxy{Director: director}
 
 	if netutil.IsLoopbackHost(target.Host) {
@@ -49,37 +37,41 @@ func ProxyHandler(target *url.URL) *httputil.ReverseProxy {
 	return p
 }
 
+func modifyProxiedRequest(req *http.Request, target *url.URL) {
+	req.URL.Scheme = target.Scheme
+	req.URL.Host = target.Host
+	req.Host = target.Host
+
+	if target.RawQuery == "" || req.URL.RawQuery == "" {
+		req.URL.RawQuery = target.RawQuery + req.URL.RawQuery
+	} else {
+		req.URL.RawQuery = target.RawQuery + "&" + req.URL.RawQuery
+	}
+
+	if _, ok := req.Header["User-Agent"]; !ok {
+		// explicitly disable User-Agent so it's not set to default value
+		req.Header.Set("User-Agent", "")
+	}
+}
+
 // ProxyHandlerRemote returns a new ReverseProxy that rewrites
 // URLs to the scheme, host, and path provided in target.
 // Case 1: req.Host == target.Host
 // behavior same as ProxyHandler
 // Case 2: req.Host != target.Host
 // the target request will be forwarded to the target's url
-// insecureSkipVerify indicates enable ssl certificate verification or not
+// insecureSkipVerify indicates enable ssl certificate verification or not.
+//
+// Look `ProxyHandler` too.
 func ProxyHandlerRemote(target *url.URL, insecureSkipVerify bool) *httputil.ReverseProxy {
-	targetQuery := target.RawQuery
 	director := func(req *http.Request) {
-		req.URL.Scheme = target.Scheme
+		modifyProxiedRequest(req, target)
 
 		if req.Host != target.Host {
 			req.URL.Path = target.Path
 		} else {
 			req.URL.Path = path.Join(target.Path, req.URL.Path)
 		}
-
-		req.URL.Host = target.Host
-		req.Host = target.Host
-
-		if targetQuery == "" || req.URL.RawQuery == "" {
-			req.URL.RawQuery = targetQuery + req.URL.RawQuery
-		} else {
-			req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery
-		}
-
-		if _, ok := req.Header["User-Agent"]; !ok {
-			// explicitly disable User-Agent so it's not set to default value
-			req.Header.Set("User-Agent", "")
-		}
 	}
 	p := &httputil.ReverseProxy{Director: director}