Upgrade: v11.2.0

HISTORY.md

@@ -17,6 +17,10 @@ Developers are not forced to upgrade if they don't really need it. Upgrade whene
 
 **How to upgrade**: Open your command-line and execute this command: `go get -u github.com/kataras/iris` or let the automatic updater do that for you.
 
+# Soon
+
+Coming soon, stay tuned by reading the [PR](https://github.com/kataras/iris/pull/1175) progress.
+
 # Fr, 11 January 2019 | v11.1.1
 
 Happy new year! This is a minor release, contains mostly bug fixes.

README.md

@@ -1020,7 +1020,7 @@ Iris, unlike others, is 100% compatible with the standards and that's why the ma
 
 ## Support
 
-- [HISTORY](HISTORY.md#fr-11-january-2019--v1111) file is your best friend, it contains information about the latest features and changes
+- [HISTORY](HISTORY.md#soon) file is your best friend, it contains information about the latest features and changes
 - Did you happen to find a bug? Post it at [github issues](https://github.com/kataras/iris/issues)
 - Do you have any questions or need to speak with someone experienced to solve a problem at real-time? Join us to the [community chat](https://chat.iris-go.com)
 - Complete our form-based user experience report by clicking [here](https://docs.google.com/forms/d/e/1FAIpQLSdCxZXPANg_xHWil4kVAdhmh7EBBHQZ_4_xSZVDL-oCC_z5pA/viewform?usp=sf_link)

VERSION

@@ -1 +1 @@
-11.1.1:https://github.com/kataras/iris/blob/master/HISTORY.md#fr-11-january-2019--v1111
+11.2.0:https://github.com/kataras/iris/blob/master/HISTORY.md#soon

_examples/miscellaneous/i18n/main.go

@@ -59,6 +59,19 @@ func newApp() *iris.Application {
 			"key2", fromSecondFileValue)
 	})
 
+	// using in inside your templates:
+	view := iris.HTML("./templates", ".html")
+	app.RegisterView(view)
+
+	app.Get("/templates", func(ctx iris.Context) {
+		ctx.View("index.html", iris.Map{
+			"tr": ctx.Translate,
+		})
+		// it will return "hello, iris"
+		// when {{call .tr "hi" "iris"}}
+	})
+	//
+
 	return app
 }
 

_examples/miscellaneous/i18n/templates/index.html

@@ -0,0 +1 @@
+{{call .tr "hi" "iris"}}

_examples/mvc/basic/main.go

@@ -4,13 +4,15 @@ import (
 	"fmt"
 
 	"github.com/kataras/iris"
+	"github.com/kataras/iris/middleware/recover"
 	"github.com/kataras/iris/sessions"
 
 	"github.com/kataras/iris/mvc"
 )
 
 func main() {
 	app := iris.New()
+	app.Use(recover.New())
 	app.Logger().SetLevel("debug")
 	mvc.Configure(app.Party("/basic"), basicMVC)
 

_examples/routing/conditional-chain/main.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"github.com/kataras/iris"
+)
+
+func main() {
+	app := iris.New()
+	v1 := app.Party("/api/v1")
+
+	myFilter := func(ctx iris.Context) bool {
+		// don't do that on production, use session or/and database calls and etc.
+		ok, _ := ctx.URLParamBool("admin")
+		return ok
+	}
+
+	onlyWhenFilter1 := func(ctx iris.Context) {
+		ctx.Application().Logger().Infof("admin: %s", ctx.Params())
+		ctx.Next()
+	}
+
+	onlyWhenFilter2 := func(ctx iris.Context) {
+		// You can always use the per-request storage
+		// to perform actions like this ofc.
+		//
+		// this handler: ctx.Values().Set("is_admin", true)
+		// next handler: isAdmin := ctx.Values().GetBoolDefault("is_admin", false)
+		//
+		// but, let's simplify it:
+		ctx.HTML("<h1>Hello Admin</h1><br>")
+		ctx.Next()
+	}
+
+	// HERE:
+	// It can be registered anywhere, as a middleware.
+	// It will fire the `onlyWhenFilter1` and `onlyWhenFilter2` as middlewares (with ctx.Next())
+	// if myFilter pass otherwise it will just continue the handler chain with ctx.Next() by ignoring
+	// the `onlyWhenFilter1` and `onlyWhenFilter2`.
+	myMiddleware := iris.NewConditionalHandler(myFilter, onlyWhenFilter1, onlyWhenFilter2)
+
+	v1UsersRouter := v1.Party("/users", myMiddleware)
+	v1UsersRouter.Get("/", func(ctx iris.Context) {
+		ctx.HTML("requested: <b>/api/v1/users</b>")
+	})
+
+	// http://localhost:8080/api/v1/users
+	// http://localhost:8080/api/v1/users?admin=true
+	app.Run(iris.Addr(":8080"))
+}

_examples/tutorial/mongodb/.env

@@ -0,0 +1,2 @@
+PORT=8080
+DSN=mongodb://localhost:27017

_examples/tutorial/mongodb/README.md

@@ -0,0 +1,58 @@
+# Build RESTful API with the official MongoDB Go Driver and Iris 
+
+Article is coming soon, follow and stay tuned
+
+- <https://medium.com/@kataras>
+- <https://dev.to/kataras>
+
+Read [the fully functional example](main.go).
+
+```sh
+$ go get -u github.com/mongodb/mongo-go-driver
+$ go get -u github.com/joho/godotenv
+```
+
+
+```sh
+# .env file contents
+PORT=8080
+DSN=mongodb://localhost:27017
+```
+
+```sh
+$ go run main.go
+> 2019/01/28 05:17:59 Loading environment variables from file: .env
+> 2019/01/28 05:17:59 ◽ PORT=8080
+> 2019/01/28 05:17:59 ◽ DSN=mongodb://localhost:27017
+> Now listening on: http://localhost:8080
+```
+
+```sh
+GET    :  http://localhost:8080/api/store/movies
+POST   :  http://localhost:8080/api/store/movies
+GET    :  http://localhost:8080/api/store/movies/{id}
+PUT    :  http://localhost:8080/api/store/movies/{id}
+DELETE :  http://localhost:8080/api/store/movies/{id}
+```
+
+## Screens
+
+### Add a Movie
+![](0_create_movie.png)
+
+### Update a Movie
+
+![](1_update_movie.png)
+
+### Get all Movies
+
+![](2_get_all_movies.png)
+
+### Get a Movie by its ID
+
+![](3_get_movie.png)
+
+### Delete a Movie by its ID
+
+![](4_delete_movie.png)
+

_examples/tutorial/mongodb/api/store/movie.go

@@ -0,0 +1,101 @@
+package storeapi
+
+import (
+	"github.com/kataras/iris/_examples/tutorial/mongodb/httputil"
+	"github.com/kataras/iris/_examples/tutorial/mongodb/store"
+
+	"github.com/kataras/iris"
+)
+
+type MovieHandler struct {
+	service store.MovieService
+}
+
+func NewMovieHandler(service store.MovieService) *MovieHandler {
+	return &MovieHandler{service: service}
+}
+
+func (h *MovieHandler) GetAll(ctx iris.Context) {
+	movies, err := h.service.GetAll(nil)
+	if err != nil {
+		httputil.InternalServerErrorJSON(ctx, err, "Server was unable to retrieve all movies")
+		return
+	}
+
+	if movies == nil {
+		// will return "null" if empty, with this "trick" we return "[]" json.
+		movies = make([]store.Movie, 0)
+	}
+
+	ctx.JSON(movies)
+}
+
+func (h *MovieHandler) Get(ctx iris.Context) {
+	id := ctx.Params().Get("id")
+
+	m, err := h.service.GetByID(nil, id)
+	if err != nil {
+		if err == store.ErrNotFound {
+			ctx.NotFound()
+		} else {
+			httputil.InternalServerErrorJSON(ctx, err, "Server was unable to retrieve movie [%s]", id)
+		}
+		return
+	}
+
+	ctx.JSON(m)
+}
+
+func (h *MovieHandler) Add(ctx iris.Context) {
+	m := new(store.Movie)
+
+	err := ctx.ReadJSON(m)
+	if err != nil {
+		httputil.FailJSON(ctx, iris.StatusBadRequest, err, "Malformed request payload")
+		return
+	}
+
+	err = h.service.Create(nil, m)
+	if err != nil {
+		httputil.InternalServerErrorJSON(ctx, err, "Server was unable to create a movie")
+		return
+	}
+
+	ctx.StatusCode(iris.StatusCreated)
+	ctx.JSON(m)
+}
+
+func (h *MovieHandler) Update(ctx iris.Context) {
+	id := ctx.Params().Get("id")
+
+	var m store.Movie
+	err := ctx.ReadJSON(&m)
+	if err != nil {
+		httputil.FailJSON(ctx, iris.StatusBadRequest, err, "Malformed request payload")
+		return
+	}
+
+	err = h.service.Update(nil, id, m)
+	if err != nil {
+		if err == store.ErrNotFound {
+			ctx.NotFound()
+			return
+		}
+		httputil.InternalServerErrorJSON(ctx, err, "Server was unable to update movie [%s]", id)
+		return
+	}
+}
+
+func (h *MovieHandler) Delete(ctx iris.Context) {
+	id := ctx.Params().Get("id")
+
+	err := h.service.Delete(nil, id)
+	if err != nil {
+		if err == store.ErrNotFound {
+			ctx.NotFound()
+			return
+		}
+		httputil.InternalServerErrorJSON(ctx, err, "Server was unable to delete movie [%s]", id)
+		return
+	}
+}

_examples/tutorial/mongodb/env/env.go

@@ -0,0 +1,71 @@
+package env
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/joho/godotenv"
+)
+
+var (
+	// Port is the PORT environment variable or 8080 if missing.
+	// Used to open the tcp listener for our web server.
+	Port string
+	// DSN is the DSN environment variable or mongodb://localhost:27017 if missing.
+	// Used to connect to the mongodb.
+	DSN string
+)
+
+func parse() {
+	Port = getDefault("PORT", "8080")
+	DSN = getDefault("DSN", "mongodb://localhost:27017")
+}
+
+// Load loads environment variables that are being used across the whole app.
+// Loading from file(s), i.e .env or dev.env
+//
+// Example of a 'dev.env':
+// PORT=8080
+// DSN=mongodb://localhost:27017
+//
+// After `Load` the callers can get an environment variable via `os.Getenv`.
+func Load(envFileName string) {
+	if args := os.Args; len(args) > 1 && args[1] == "help" {
+		fmt.Fprintln(os.Stderr, "https://github.com/kataras/iris/blob/master/_examples/tutorials/mongodb/README.md")
+		os.Exit(-1)
+	}
+
+	log.Printf("Loading environment variables from file: %s\n", envFileName)
+	// If more than one filename passed with comma separated then load from all
+	// of these, a env file can be a partial too.
+	envFiles := strings.Split(envFileName, ",")
+	for i := range envFiles {
+		if filepath.Ext(envFiles[i]) == "" {
+			envFiles[i] += ".env"
+		}
+	}
+
+	if err := godotenv.Load(envFiles...); err != nil {
+		panic(fmt.Sprintf("error loading environment variables from [%s]: %v", envFileName, err))
+	}
+
+	envMap, _ := godotenv.Read(envFiles...)
+	for k, v := range envMap {
+		log.Printf("◽ %s=%s\n", k, v)
+	}
+
+	parse()
+}
+
+func getDefault(key string, def string) string {
+	value := os.Getenv(key)
+	if value == "" {
+		os.Setenv(key, def)
+		value = def
+	}
+
+	return value
+}