├── .gitignore
├── LICENSE
├── README.md
├── config.toml.example
├── controllers
    ├── api.go
    └── main.go
├── helpers
    ├── auth.go
    └── template.go
├── models
    └── user.go
├── public
    ├── css
    │   └── style.css
    ├── images
    │   └── favicon.ico
    ├── js
    │   └── .gitkeep
    └── robots.txt
├── server.go
├── system
    ├── configuration.go
    ├── controller.go
    ├── core.go
    ├── gzip.go
    └── middleware.go
├── tmp
    └── .gitkeep
└── views
    ├── auth
        ├── signin.html
        └── signup.html
    ├── footer.html
    ├── header.html
    ├── home.html
    └── main.html


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
 2 | *.o
 3 | *.a
 4 | *.so
 5 | 
 6 | # Folders
 7 | _obj
 8 | _test
 9 | 
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 | 
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 | 
20 | _testmain.go
21 | 
22 | *.exe
23 | *.test
24 | 
25 | /config.toml
26 | *~
27 | .*.swp
28 | tmp/*
29 | golang-goji-sample
30 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Pawel Szymanski (pawel@mikesz.com)
 4 | Copyright (c) HARUYAMA Seigo <hauyama@unixuser.org>
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in all
14 | copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 | SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Golang Goji Sample
 2 | 
 3 | Sample Web Application based on https://github.com/elcct/defaultproject
 4 | 
 5 | - Goji - A web microframework for Golang - http://goji.io/
 6 | - Gorilla web toolkit sessions - cookie (and filesystem) sessions - http://www.gorillatoolkit.org/pkg/sessions
 7 | 
 8 | # Dependencies
 9 | 
10 | Default Project requires `Go`, `MySQL` and few other tools installed.
11 | 
12 | # Project structure
13 | 
14 | `/controllers`
15 | 
16 | All your controllers that serve defined routes.
17 | 
18 | `/helpers`
19 | 
20 | Helper functions.
21 | 
22 | `/models`
23 | 
24 | You database models.
25 | 
26 | `/public`
27 | 
28 | It has all your static files mapped to `/assets/*` path except `robots.txt` and `favicon.ico` that map to `/`.
29 | 
30 | `/system`
31 | 
32 | Core functions and structs.
33 | 
34 | `/views`
35 | 
36 | Your views using standard `Go` template system.
37 | 
38 | `server.go`
39 | 
40 | This file starts your web application and also contains routes definition.
41 | 


--------------------------------------------------------------------------------
/config.toml.example:
--------------------------------------------------------------------------------
 1 | [general]
 2 | public_path   = "public"
 3 | template_path = "views"
 4 | 
 5 | [cookie]
 6 | mac_secret = "secret string which has over 256-bit entropy"
 7 | secure     = false
 8 | 
 9 | [database]
10 | user     = "root"
11 | password = ""
12 | hostname = "localhost"
13 | port     = "3306"
14 | database = "goji"
15 | 
16 | [csrf]
17 | key    = "csrf_token"
18 | cookie = "XSRF-TOKEN"
19 | header = "X-XSRF-TOKEN"
20 | 


--------------------------------------------------------------------------------
/controllers/api.go:
--------------------------------------------------------------------------------
 1 | package controllers
 2 | 
 3 | import (
 4 | 	"github.com/haruyama/golang-goji-sample/system"
 5 | )
 6 | 
 7 | type ApiController struct {
 8 | 	system.Controller
 9 | }
10 | 


--------------------------------------------------------------------------------
/controllers/main.go:
--------------------------------------------------------------------------------
  1 | package controllers
  2 | 
  3 | import (
  4 | 	"net/http"
  5 | 
  6 | 	"github.com/golang/glog"
  7 | 
  8 | 	"html/template"
  9 | 
 10 | 	"github.com/haruyama/golang-goji-sample/helpers"
 11 | 	"github.com/haruyama/golang-goji-sample/models"
 12 | 	"github.com/haruyama/golang-goji-sample/system"
 13 | 	"github.com/zenazn/goji/web"
 14 | )
 15 | 
 16 | type MainController struct {
 17 | 	system.Controller
 18 | }
 19 | 
 20 | // Home page route
 21 | func (controller *MainController) Index(c web.C, r *http.Request) (string, int) {
 22 | 	t := controller.GetTemplate(c)
 23 | 
 24 | 	widgets := helpers.Parse(t, "home", nil)
 25 | 
 26 | 	// With that kind of flags template can "figure out" what route is being rendered
 27 | 	c.Env["IsIndex"] = true
 28 | 
 29 | 	c.Env["Title"] = "Default Project - free Go website project template"
 30 | 	c.Env["Content"] = template.HTML(widgets)
 31 | 
 32 | 	return helpers.Parse(t, "main", c.Env), http.StatusOK
 33 | }
 34 | 
 35 | // Sign in route
 36 | func (controller *MainController) SignIn(c web.C, r *http.Request) (string, int) {
 37 | 	t := controller.GetTemplate(c)
 38 | 	session := controller.GetSession(c)
 39 | 
 40 | 	// With that kind of flags template can "figure out" what route is being rendered
 41 | 	c.Env["IsSignIn"] = true
 42 | 
 43 | 	c.Env["Flash"] = session.Flashes("auth")
 44 | 	var widgets = controller.Parse(t, "auth/signin", c.Env)
 45 | 
 46 | 	c.Env["Title"] = "Default Project - Sign In"
 47 | 	c.Env["Content"] = template.HTML(widgets)
 48 | 
 49 | 	return controller.Parse(t, "main", c.Env), http.StatusOK
 50 | }
 51 | 
 52 | // Sign In form submit route. Logs user in or set appropriate message in session if login was not succesful
 53 | func (controller *MainController) SignInPost(c web.C, r *http.Request) (string, int) {
 54 | 	email, password := r.FormValue("email"), r.FormValue("password")
 55 | 
 56 | 	session := controller.GetSession(c)
 57 | 	dbMap := controller.GetDbMap(c)
 58 | 
 59 | 	user, err := helpers.Login(dbMap, email, password)
 60 | 
 61 | 	if err != nil {
 62 | 		session.AddFlash("Invalid Email or Password", "auth")
 63 | 		return controller.SignIn(c, r)
 64 | 	}
 65 | 
 66 | 	session.Values["UserId"] = user.Id
 67 | 
 68 | 	return "/", http.StatusSeeOther
 69 | }
 70 | 
 71 | // Sign up route
 72 | func (controller *MainController) SignUp(c web.C, r *http.Request) (string, int) {
 73 | 	t := controller.GetTemplate(c)
 74 | 	session := controller.GetSession(c)
 75 | 
 76 | 	// With that kind of flags template can "figure out" what route is being rendered
 77 | 	c.Env["IsSignUp"] = true
 78 | 
 79 | 	c.Env["Flash"] = session.Flashes("auth")
 80 | 
 81 | 	var widgets = controller.Parse(t, "auth/signup", c.Env)
 82 | 
 83 | 	c.Env["Title"] = "Default Project - Sign Up"
 84 | 	c.Env["Content"] = template.HTML(widgets)
 85 | 
 86 | 	return controller.Parse(t, "main", c.Env), http.StatusOK
 87 | }
 88 | 
 89 | // Sign Up form submit route. Registers new user or shows Sign Up route with appropriate messages set in session
 90 | func (controller *MainController) SignUpPost(c web.C, r *http.Request) (string, int) {
 91 | 	email, password := r.FormValue("email"), r.FormValue("password")
 92 | 
 93 | 	session := controller.GetSession(c)
 94 | 	dbMap := controller.GetDbMap(c)
 95 | 
 96 | 	user := models.GetUserByEmail(dbMap, email)
 97 | 
 98 | 	if user != nil {
 99 | 		session.AddFlash("User exists", "auth")
100 | 		return controller.SignUp(c, r)
101 | 	}
102 | 
103 | 	user = &models.User{
104 | 		Username: email,
105 | 		Email:    email,
106 | 	}
107 | 	user.HashPassword(password)
108 | 
109 | 	if err := models.InsertUser(dbMap, user); err != nil {
110 | 		session.AddFlash("Error whilst registering user.")
111 | 		glog.Errorf("Error whilst registering user: %v", err)
112 | 		return controller.SignUp(c, r)
113 | 	}
114 | 
115 | 	session.Values["UserId"] = user.Id
116 | 
117 | 	return "/", http.StatusSeeOther
118 | }
119 | 
120 | // This route logs user out
121 | func (controller *MainController) Logout(c web.C, r *http.Request) (string, int) {
122 | 	session := controller.GetSession(c)
123 | 
124 | 	session.Values["UserId"] = nil
125 | 
126 | 	return "/", http.StatusSeeOther
127 | }
128 | 


--------------------------------------------------------------------------------
/helpers/auth.go:
--------------------------------------------------------------------------------
 1 | package helpers
 2 | 
 3 | import (
 4 | 	"golang.org/x/crypto/bcrypt"
 5 | 	"gopkg.in/gorp.v1"
 6 | 	"github.com/haruyama/golang-goji-sample/models"
 7 | )
 8 | 
 9 | func Login(dbMap *gorp.DbMap, email string, password string) (*models.User, error) {
10 | 	var user models.User
11 | 	err := dbMap.SelectOne(&user, "SELECT * FROM Users WHERE Email = ?", email)
12 | 	if err != nil {
13 | 		return nil, err
14 | 	}
15 | 
16 | 	err = bcrypt.CompareHashAndPassword(user.Password, []byte(password))
17 | 	if err != nil {
18 | 		return nil, err
19 | 	}
20 | 	return &user, err
21 | }
22 | 


--------------------------------------------------------------------------------
/helpers/template.go:
--------------------------------------------------------------------------------
 1 | package helpers
 2 | 
 3 | import (
 4 | 	"html/template"
 5 | 	"bytes"
 6 | )
 7 | 
 8 | func Parse(t *template.Template, name string, data interface{}) string {
 9 | 	var doc bytes.Buffer
10 | 	t.ExecuteTemplate(&doc, name, data)
11 | 	return doc.String()
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/models/user.go:
--------------------------------------------------------------------------------
 1 | package models
 2 | 
 3 | import (
 4 | 	"database/sql"
 5 | 	"fmt"
 6 | 	"log"
 7 | 
 8 | 	"golang.org/x/crypto/bcrypt"
 9 | 	"gopkg.in/gorp.v1"
10 | 	_ "github.com/go-sql-driver/mysql"
11 | 	"github.com/golang/glog"
12 | )
13 | 
14 | type User struct {
15 | 	Id       int64 `db:"UserId"`
16 | 	Email    string
17 | 	Username string
18 | 	Password []byte
19 | }
20 | 
21 | func (user *User) HashPassword(password string) {
22 | 	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
23 | 	if err != nil {
24 | 		glog.Fatalf("Couldn't hash password: %v", err)
25 | 		panic(err)
26 | 	}
27 | 	user.Password = hash
28 | }
29 | 
30 | func GetUserByEmail(dbMap *gorp.DbMap, email string) (user *User) {
31 | 	err := dbMap.SelectOne(&user, "SELECT * FROM Users where Email = ?", email)
32 | 
33 | 	if err != nil {
34 | 		glog.Warningf("Can't get user by email: %v", err)
35 | 	}
36 | 	return
37 | }
38 | 
39 | func InsertUser(dbMap *gorp.DbMap, user *User) error {
40 | 	return dbMap.Insert(user)
41 | }
42 | 
43 | func GetDbMap(user, password, hostname, port, database string) *gorp.DbMap {
44 | 	// connect to db using standard Go database/sql API
45 | 	// use whatever database/sql driver you wish
46 | 	//TODO: Get user, password and database from config.
47 | 	db, err := sql.Open("mysql", fmt.Sprint(user, ":", password, "@(", hostname, ":", port, ")/", database, "?charset=utf8mb4"))
48 | 	checkErr(err, "sql.Open failed")
49 | 
50 | 	// construct a gorp DbMap
51 | 	dbMap := &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{Engine: "InnoDB", Encoding: "UTF8MB4"}}
52 | 
53 | 	// add a table, setting the table name to 'posts' and
54 | 	// specifying that the Id property is an auto incrementing PK
55 | 	dbMap.AddTableWithName(User{}, "Users").SetKeys(true, "Id")
56 | 
57 | 	// create the table. in a production system you'd generally
58 | 	// use a migration tool, or create the tables via scripts
59 | 	err = dbMap.CreateTablesIfNotExists()
60 | 	checkErr(err, "Create tables failed")
61 | 
62 | 	return dbMap
63 | }
64 | 
65 | func checkErr(err error, msg string) {
66 | 	if err != nil {
67 | 		log.Fatalln(msg, err)
68 | 	}
69 | }
70 | 


--------------------------------------------------------------------------------
/public/css/style.css:
--------------------------------------------------------------------------------
 1 | html {
 2 | 	position: relative;
 3 | 	min-height: 100%;
 4 | 	padding-top: 70px;
 5 | }
 6 | 
 7 | body {
 8 | 	margin-bottom: 60px;
 9 | }
10 | 
11 | #footer {
12 | 	position: absolute;
13 | 	bottom: 0;
14 | 	width: 100%;
15 | 	height: 60px;
16 | 	background-color: #f5f5f5;
17 | }
18 | 
19 | input.parsley-success,
20 | select.parsley-success,
21 | textarea.parsley-success {		
22 | 	border: 2px solid #62c462;
23 | }
24 | 
25 | input.parsley-error,
26 | select.parsley-error,
27 | textarea.parsley-error {		
28 | 	border: 2px solid #ee5f5b;
29 | }
30 | 
31 | .parsley-errors-list {
32 | 	margin: 8px 0 3px 0;
33 | 	padding: 0;
34 | 	list-style-type: none;
35 | 	line-height: 0.9em;
36 | 	font-size: 0.9em;
37 | 	opacity: 0;
38 | 	-moz-opacity: 0;
39 | 	-webkit-opacity: 0;
40 | 
41 | 	transition: all .2s ease-in;
42 | 	-o-transition: all .2s ease-in;
43 | 	-ms-transition: all .2s ease-in-;
44 | 	-moz-transition: all .2s ease-in;
45 | 	-webkit-transition: all .2s ease-in;
46 | }
47 | 
48 | .parsley-errors-list.filled {
49 | 	opacity: 1;
50 | }
51 | 
52 | .github {
53 | 	margin-bottom: -5px;
54 | }


--------------------------------------------------------------------------------
/public/images/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haruyama/golang-goji-sample/e66f611b5a79b73736b7ab30057f6983244ef294/public/images/favicon.ico


--------------------------------------------------------------------------------
/public/js/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haruyama/golang-goji-sample/e66f611b5a79b73736b7ab30057f6983244ef294/public/js/.gitkeep


--------------------------------------------------------------------------------
/public/robots.txt:
--------------------------------------------------------------------------------
1 | # hello robots
2 | 
3 | User-agent: *
4 | Disallow: /logout/
5 | 
6 | 


--------------------------------------------------------------------------------
/server.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"net/http"
 6 | 
 7 | 	"github.com/golang/glog"
 8 | 	"github.com/gorilla/context"
 9 | 
10 | 	"github.com/haruyama/golang-goji-sample/controllers"
11 | 	"github.com/haruyama/golang-goji-sample/system"
12 | 
13 | 	"github.com/zenazn/goji"
14 | 	"github.com/zenazn/goji/graceful"
15 | 	"github.com/zenazn/goji/web"
16 | )
17 | 
18 | func main() {
19 | 	filename := flag.String("config", "config.toml", "Path to configuration file")
20 | 
21 | 	flag.Parse()
22 | 	defer glog.Flush()
23 | 
24 | 	var application = &system.Application{}
25 | 
26 | 	application.Init(filename)
27 | 	application.LoadTemplates()
28 | 
29 | 	// Setup static files
30 | 	static := web.New()
31 | 	publicPath := application.Config.Get("general.public_path").(string)
32 | 	static.Get("/assets/*", http.StripPrefix("/assets/", http.FileServer(http.Dir(publicPath))))
33 | 
34 | 	http.Handle("/assets/", static)
35 | 
36 | 	// Apply middleware
37 | 	goji.Use(application.ApplyTemplates)
38 | 	goji.Use(application.ApplySessions)
39 | 	goji.Use(application.ApplyDbMap)
40 | 	goji.Use(application.ApplyAuth)
41 | 	goji.Use(application.ApplyIsXhr)
42 | 	goji.Use(application.ApplyCsrfProtection)
43 | 	goji.Use(context.ClearHandler)
44 | 
45 | 	controller := &controllers.MainController{}
46 | 
47 | 	// Couple of files - in the real world you would use nginx to serve them.
48 | 	goji.Get("/robots.txt", http.FileServer(http.Dir(publicPath)))
49 | 	goji.Get("/favicon.ico", http.FileServer(http.Dir(publicPath+"/images")))
50 | 
51 | 	// Home page
52 | 	goji.Get("/", application.Route(controller, "Index"))
53 | 
54 | 	// Sign In routes
55 | 	goji.Get("/signin", application.Route(controller, "SignIn"))
56 | 	goji.Post("/signin", application.Route(controller, "SignInPost"))
57 | 
58 | 	// Sign Up routes
59 | 	goji.Get("/signup", application.Route(controller, "SignUp"))
60 | 	goji.Post("/signup", application.Route(controller, "SignUpPost"))
61 | 
62 | 	// KTHXBYE
63 | 	goji.Get("/logout", application.Route(controller, "Logout"))
64 | 
65 | 	graceful.PostHook(func() {
66 | 		application.Close()
67 | 	})
68 | 	goji.Serve()
69 | }
70 | 


--------------------------------------------------------------------------------
/system/configuration.go:
--------------------------------------------------------------------------------
 1 | package system
 2 | 
 3 | type ConfigurationDatabase struct {
 4 | 	User     string `json:"user"`
 5 | 	Password string `json:"password"`
 6 | 	Hostname string `json:"hostname"`
 7 | 	Database string `json:"database"`
 8 | }
 9 | 
10 | type Configuration struct {
11 | 	Secret       string `json:"secret"`
12 | 	PublicPath   string `json:"public_path"`
13 | 	TemplatePath string `json:"template_path"`
14 | 	Database     ConfigurationDatabase
15 | }
16 | 


--------------------------------------------------------------------------------
/system/controller.go:
--------------------------------------------------------------------------------
 1 | package system
 2 | 
 3 | import (
 4 | 	"bytes"
 5 | 	"html/template"
 6 | 
 7 | 	"gopkg.in/gorp.v1"
 8 | 	"github.com/gorilla/sessions"
 9 | 	"github.com/zenazn/goji/web"
10 | )
11 | 
12 | type Controller struct {
13 | }
14 | 
15 | func (controller *Controller) GetSession(c web.C) *sessions.Session {
16 | 	return c.Env["Session"].(*sessions.Session)
17 | }
18 | 
19 | func (controller *Controller) GetTemplate(c web.C) *template.Template {
20 | 	return c.Env["Template"].(*template.Template)
21 | }
22 | 
23 | func (controller *Controller) GetDbMap(c web.C) *gorp.DbMap {
24 | 	return c.Env["DbMap"].(*gorp.DbMap)
25 | }
26 | 
27 | func (controller *Controller) IsXhr(c web.C) bool {
28 | 	return c.Env["IsXhr"].(bool)
29 | }
30 | 
31 | func (controller *Controller) Parse(t *template.Template, name string, data interface{}) string {
32 | 	var doc bytes.Buffer
33 | 	t.ExecuteTemplate(&doc, name, data)
34 | 	return doc.String()
35 | }
36 | 


--------------------------------------------------------------------------------
/system/core.go:
--------------------------------------------------------------------------------
  1 | package system
  2 | 
  3 | import (
  4 | 	"html/template"
  5 | 	"io"
  6 | 	"net/http"
  7 | 	"os"
  8 | 	"path/filepath"
  9 | 	"reflect"
 10 | 	"strings"
 11 | 
 12 | 	"crypto/sha256"
 13 | 
 14 | 	"github.com/golang/glog"
 15 | 	"github.com/gorilla/sessions"
 16 | 	"github.com/haruyama/golang-goji-sample/models"
 17 | 	"github.com/pelletier/go-toml"
 18 | 	"github.com/zenazn/goji/web"
 19 | 	"gopkg.in/gorp.v1"
 20 | )
 21 | 
 22 | type CsrfProtection struct {
 23 | 	Key    string
 24 | 	Cookie string
 25 | 	Header string
 26 | 	Secure bool
 27 | }
 28 | 
 29 | type Application struct {
 30 | 	Config         *toml.Tree
 31 | 	Template       *template.Template
 32 | 	Store          *sessions.CookieStore
 33 | 	DbMap          *gorp.DbMap
 34 | 	CsrfProtection *CsrfProtection
 35 | }
 36 | 
 37 | func (application *Application) Init(filename *string) {
 38 | 
 39 | 	config, err := toml.LoadFile(*filename)
 40 | 	if err != nil {
 41 | 		glog.Fatalf("TOML load failed: %s\n", err)
 42 | 	}
 43 | 
 44 | 	hash := sha256.New()
 45 | 	io.WriteString(hash, config.Get("cookie.mac_secret").(string))
 46 | 	application.Store = sessions.NewCookieStore(hash.Sum(nil))
 47 | 	application.Store.Options = &sessions.Options{
 48 | 		Path:     "/",
 49 | 		HttpOnly: true,
 50 | 		Secure:   config.Get("cookie.secure").(bool),
 51 | 	}
 52 | 	dbConfig := config.Get("database").(*toml.Tree)
 53 | 	application.DbMap = models.GetDbMap(
 54 | 		dbConfig.Get("user").(string),
 55 | 		dbConfig.Get("password").(string),
 56 | 		dbConfig.Get("hostname").(string),
 57 | 		dbConfig.Get("port").(string),
 58 | 		dbConfig.Get("database").(string))
 59 | 
 60 | 	application.CsrfProtection = &CsrfProtection{
 61 | 		Key:    config.Get("csrf.key").(string),
 62 | 		Cookie: config.Get("csrf.cookie").(string),
 63 | 		Header: config.Get("csrf.header").(string),
 64 | 		Secure: config.Get("cookie.secure").(bool),
 65 | 	}
 66 | 
 67 | 	application.Config = config
 68 | }
 69 | 
 70 | func (application *Application) LoadTemplates() error {
 71 | 	var templates []string
 72 | 
 73 | 	fn := func(path string, f os.FileInfo, err error) error {
 74 | 		if f.IsDir() != true && strings.HasSuffix(f.Name(), ".html") {
 75 | 			templates = append(templates, path)
 76 | 		}
 77 | 		return nil
 78 | 	}
 79 | 
 80 | 	err := filepath.Walk(application.Config.Get("general.template_path").(string), fn)
 81 | 
 82 | 	if err != nil {
 83 | 		return err
 84 | 	}
 85 | 
 86 | 	application.Template = template.Must(template.ParseFiles(templates...))
 87 | 	return nil
 88 | }
 89 | 
 90 | func (application *Application) Close() {
 91 | 	glog.Info("Bye!")
 92 | }
 93 | 
 94 | func (application *Application) Route(controller interface{}, route string) interface{} {
 95 | 	fn := func(c web.C, w http.ResponseWriter, r *http.Request) {
 96 | 		c.Env["Content-Type"] = "text/html"
 97 | 
 98 | 		methodValue := reflect.ValueOf(controller).MethodByName(route)
 99 | 		methodInterface := methodValue.Interface()
100 | 		method := methodInterface.(func(c web.C, r *http.Request) (string, int))
101 | 
102 | 		body, code := method(c, r)
103 | 
104 | 		if session, exists := c.Env["Session"]; exists {
105 | 			err := session.(*sessions.Session).Save(r, w)
106 | 			if err != nil {
107 | 				glog.Errorf("Can't save session: %v", err)
108 | 			}
109 | 		}
110 | 
111 | 		switch code {
112 | 		case http.StatusOK:
113 | 			if _, exists := c.Env["Content-Type"]; exists {
114 | 				w.Header().Set("Content-Type", c.Env["Content-Type"].(string))
115 | 			}
116 | 			io.WriteString(w, body)
117 | 		case http.StatusSeeOther, http.StatusFound:
118 | 			http.Redirect(w, r, body, code)
119 | 		}
120 | 	}
121 | 	return fn
122 | }
123 | 


--------------------------------------------------------------------------------
/system/gzip.go:
--------------------------------------------------------------------------------
 1 | package system
 2 | 
 3 | import (
 4 | 	"io"
 5 | 	"net/http"
 6 | 	"github.com/zenazn/goji/web"
 7 | 	"strings"
 8 | 	"compress/gzip"
 9 | )
10 | 
11 | type gzipResponseWriter struct {
12 | 	io.Writer
13 | 	http.ResponseWriter
14 | }
15 | 
16 | func (w gzipResponseWriter) Write(b []byte) (int, error) {
17 | 	return w.Writer.Write(b)
18 | }
19 | 
20 | func (application *Application) ApplyGzip(c *web.C, h http.Handler) http.Handler {
21 | 	fn := func(w http.ResponseWriter, r *http.Request) {
22 | 		if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
23 | 			h.ServeHTTP(w, r)
24 | 			return
25 | 		}
26 | 		w.Header().Set("Content-Encoding", "gzip")
27 | 		gz := gzip.NewWriter(w)
28 | 		defer gz.Close()
29 | 		gzr := gzipResponseWriter{Writer: gz, ResponseWriter: w}
30 | 		h.ServeHTTP(gzr, r)
31 | 	}
32 | 	return http.HandlerFunc(fn)
33 | }
34 | 


--------------------------------------------------------------------------------
/system/middleware.go:
--------------------------------------------------------------------------------
  1 | package system
  2 | 
  3 | import (
  4 | 	"crypto/rand"
  5 | 	"crypto/sha256"
  6 | 	"crypto/subtle"
  7 | 	"fmt"
  8 | 	"net/http"
  9 | 	"strings"
 10 | 
 11 | 	"github.com/golang/glog"
 12 | 	"github.com/gorilla/sessions"
 13 | 	"github.com/haruyama/golang-goji-sample/models"
 14 | 	"github.com/zenazn/goji/web"
 15 | 	"gopkg.in/gorp.v1"
 16 | )
 17 | 
 18 | // Makes sure templates are stored in the context
 19 | func (application *Application) ApplyTemplates(c *web.C, h http.Handler) http.Handler {
 20 | 	fn := func(w http.ResponseWriter, r *http.Request) {
 21 | 		c.Env["Template"] = application.Template
 22 | 		h.ServeHTTP(w, r)
 23 | 	}
 24 | 	return http.HandlerFunc(fn)
 25 | }
 26 | 
 27 | // Makes sure controllers can have access to session
 28 | func (application *Application) ApplySessions(c *web.C, h http.Handler) http.Handler {
 29 | 	fn := func(w http.ResponseWriter, r *http.Request) {
 30 | 		session, _ := application.Store.Get(r, "session")
 31 | 		c.Env["Session"] = session
 32 | 		h.ServeHTTP(w, r)
 33 | 	}
 34 | 	return http.HandlerFunc(fn)
 35 | }
 36 | 
 37 | func (application *Application) ApplyDbMap(c *web.C, h http.Handler) http.Handler {
 38 | 	fn := func(w http.ResponseWriter, r *http.Request) {
 39 | 		c.Env["DbMap"] = application.DbMap
 40 | 		h.ServeHTTP(w, r)
 41 | 	}
 42 | 	return http.HandlerFunc(fn)
 43 | }
 44 | 
 45 | func (application *Application) ApplyAuth(c *web.C, h http.Handler) http.Handler {
 46 | 	fn := func(w http.ResponseWriter, r *http.Request) {
 47 | 		session := c.Env["Session"].(*sessions.Session)
 48 | 		if userId, ok := session.Values["UserId"]; ok {
 49 | 			dbMap := c.Env["DbMap"].(*gorp.DbMap)
 50 | 
 51 | 			user, err := dbMap.Get(models.User{}, userId)
 52 | 			if err != nil {
 53 | 				glog.Warningf("Auth error: %v", err)
 54 | 				c.Env["User"] = nil
 55 | 			} else {
 56 | 				c.Env["User"] = user
 57 | 			}
 58 | 		}
 59 | 		h.ServeHTTP(w, r)
 60 | 	}
 61 | 	return http.HandlerFunc(fn)
 62 | }
 63 | 
 64 | func (application *Application) ApplyIsXhr(c *web.C, h http.Handler) http.Handler {
 65 | 	fn := func(w http.ResponseWriter, r *http.Request) {
 66 | 		if r.Header.Get("X-Requested-With") == "XMLHttpRequest" {
 67 | 			c.Env["IsXhr"] = true
 68 | 		} else {
 69 | 			c.Env["IsXhr"] = false
 70 | 		}
 71 | 		h.ServeHTTP(w, r)
 72 | 	}
 73 | 	return http.HandlerFunc(fn)
 74 | }
 75 | 
 76 | func isValidToken(a, b string) bool {
 77 | 	x := []byte(a)
 78 | 	y := []byte(b)
 79 | 	if len(x) != len(y) {
 80 | 		return false
 81 | 	}
 82 | 	return subtle.ConstantTimeCompare(x, y) == 1
 83 | }
 84 | 
 85 | var csrfProtectionMethodForNoXhr = []string{"POST", "PUT", "DELETE"}
 86 | 
 87 | func isCsrfProtectionMethodForNoXhr(method string) bool {
 88 | 	m := strings.ToUpper(method)
 89 | 	for _, mm := range csrfProtectionMethodForNoXhr {
 90 | 		if m == mm {
 91 | 			return true
 92 | 		}
 93 | 	}
 94 | 	return false
 95 | }
 96 | 
 97 | func (application *Application) ApplyCsrfProtection(c *web.C, h http.Handler) http.Handler {
 98 | 	fn := func(w http.ResponseWriter, r *http.Request) {
 99 | 		session := c.Env["Session"].(*sessions.Session)
100 | 		csrfProtection := application.CsrfProtection
101 | 		if _, ok := session.Values["CsrfToken"]; !ok {
102 | 			hash := sha256.New()
103 | 			buffer := make([]byte, 32)
104 | 			_, err := rand.Read(buffer)
105 | 			if err != nil {
106 | 				glog.Fatalf("crypt/rand.Read failed: %s", err)
107 | 			}
108 | 			hash.Write(buffer)
109 | 			session.Values["CsrfToken"] = fmt.Sprintf("%x", hash.Sum(nil))
110 | 			if err = session.Save(r, w); err != nil {
111 | 				glog.Fatal("session.Save() failed")
112 | 			}
113 | 		}
114 | 		c.Env["CsrfKey"] = csrfProtection.Key
115 | 		c.Env["CsrfToken"] = session.Values["CsrfToken"]
116 | 		csrfToken := c.Env["CsrfToken"].(string)
117 | 
118 | 		if c.Env["IsXhr"].(bool) {
119 | 			if !isValidToken(csrfToken, r.Header.Get(csrfProtection.Header)) {
120 | 				http.Error(w, "Invalid Csrf Header", http.StatusBadRequest)
121 | 				return
122 | 			}
123 | 		} else {
124 | 			if isCsrfProtectionMethodForNoXhr(r.Method) {
125 | 				if !isValidToken(csrfToken, r.PostFormValue(csrfProtection.Key)) {
126 | 					http.Error(w, "Invalid Csrf Token", http.StatusBadRequest)
127 | 					return
128 | 				}
129 | 			}
130 | 		}
131 | 		http.SetCookie(w, &http.Cookie{
132 | 			Name:   csrfProtection.Cookie,
133 | 			Value:  csrfToken,
134 | 			Secure: csrfProtection.Secure,
135 | 			Path:   "/",
136 | 		})
137 | 		h.ServeHTTP(w, r)
138 | 	}
139 | 	return http.HandlerFunc(fn)
140 | }
141 | 


--------------------------------------------------------------------------------
/tmp/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haruyama/golang-goji-sample/e66f611b5a79b73736b7ab30057f6983244ef294/tmp/.gitkeep


--------------------------------------------------------------------------------
/views/auth/signin.html:
--------------------------------------------------------------------------------
 1 | {{define "auth/signin"}}
 2 | <div class="panel panel-default">
 3 | 	<div class="panel-body">
 4 | 		<form class="form-horizontal" method="post" data-parsley-validate>
 5 | 		<fieldset>
 6 | 			<legend>Sign In</legend>
 7 | 			{{range .Flash}}
 8 | 				<div class="alert alert-danger">{{.}}</div><p>
 9 | 			{{end}}
10 | 			<div class="form-group">
11 | 				<label class="col-md-4 control-label" for="email">Email</label>  
12 | 				<div class="col-md-6">
13 | 					<input id="email" name="email" type="email" placeholder="Email address" class="form-control input-md" required="" data-parsley-required-message="Please enter your email">    
14 | 				</div>
15 | 			</div>
16 | 
17 | 			<div class="form-group">
18 | 				<label class="col-md-4 control-label" for="password">Password</label>
19 | 				<div class="col-md-6">
20 | 					<input id="password" name="password" type="password" placeholder="Password" class="form-control input-md" required="" data-parsley-required-message="Please enter your password">
21 | 				</div>
22 | 			</div>
23 | 
24 | 			<div class="form-group">
25 | 				<label class="col-md-4 control-label" for="signin"></label>
26 | 				<div class="col-md-4">
27 | 					<button id="signin" name="signin" class="btn btn-primary">Sign In</button>
28 | 				</div>
29 | 			</div>
30 | 		</fieldset>
31 |     <input type="hidden" name="{{.CsrfKey}}" value={{.CsrfToken}}>
32 | 		</form>
33 | 	</div>
34 | </div>
35 | {{end}}
36 | 


--------------------------------------------------------------------------------
/views/auth/signup.html:
--------------------------------------------------------------------------------
 1 | {{define "auth/signup"}}
 2 | <div class="panel panel-default">
 3 | 	<div class="panel-body">
 4 | 		<form method="post" class="form-horizontal" data-parsley-validate>
 5 | 		<fieldset>
 6 | 
 7 | 			<legend>Sign Up</legend>
 8 | 			{{range .Flash}}
 9 | 				<div class="alert alert-danger">{{.}}</div><p>
10 | 			{{end}}
11 | 			<div class="form-group">
12 | 				<label class="col-md-4 control-label" for="email">Email</label>  
13 | 				<div class="col-md-6">
14 | 					<input id="email" name="email" type="email" placeholder="Email address" class="form-control input-md" required="" data-parsley-required-message="Please enter your email">
15 | 				</div>
16 | 			</div>
17 | 
18 | 			<div class="form-group">
19 | 				<label class="col-md-4 control-label" for="password">Password</label>
20 | 				<div class="col-md-6">
21 | 					<input id="password" name="password" type="password" placeholder="Password" class="form-control input-md" required="" data-parsley-required-message="Please enter your password">
22 | 				</div>
23 | 			</div>
24 | 
25 | 			<div class="form-group">
26 | 				<label class="col-md-4 control-label" for="passwordrepear">Repeat password</label>
27 | 				<div class="col-md-6">
28 | 					<input id="passwordrepeat" name="passwordrepeat" type="password" placeholder="Repeat password" class="form-control input-md" required="" data-parsley-required-message="Please repeat your password" data-parsley-equalto="#password" data-parsley-equalto-message="Passwords do not match">
29 | 				</div>
30 | 			</div>
31 | 
32 | 			<div class="form-group">
33 | 				<label class="col-md-4 control-label" for=""></label>
34 | 				<div class="col-md-6">
35 | 					<label class="checkbox-inline" for="terms">
36 | 						<input type="checkbox" name="terms" id="terms" required="" data-parsley-required-message="You can't continue without accepting our Terms and Conditions">
37 | 						I accept terms and conditions
38 | 					</label>
39 | 				</div>
40 | 			</div>
41 | 
42 | 			<div class="form-group">
43 | 				<label class="col-md-4 control-label" for="signup"></label>
44 | 				<div class="col-md-4">
45 | 					<button id="signup" name="signup" class="btn btn-primary">Sign Up</button>
46 | 				</div>
47 | 			</div>
48 | 
49 | 		</fieldset>
50 |     <input type="hidden" name="{{.CsrfKey}}" value={{.CsrfToken}}>
51 | 		</form>
52 | 	</div>
53 | </div>
54 | {{end}}
55 | 


--------------------------------------------------------------------------------
/views/footer.html:
--------------------------------------------------------------------------------
 1 | {{define "footer"}}
 2 | 	<div id="footer">
 3 | 		<div class="container">			
 4 | 			<br>
 5 | 			<p class="text-muted">☮ 2014 Default Project
 6 | 		</div>
 7 | 	</div>
 8 | 
 9 |     <!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
10 |     <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
11 |     <script src="//cdnjs.cloudflare.com/ajax/libs/parsley.js/2.0.0/parsley.min.js"></script>
12 |     <!-- Include all compiled plugins (below), or include individual files as needed -->
13 |     <script src="//maxcdn.bootstrapcdn.com/bootstrap/3.1.1/js/bootstrap.min.js"></script>
14 |   </body>
15 | </html>
16 | {{end}}


--------------------------------------------------------------------------------
/views/header.html:
--------------------------------------------------------------------------------
 1 | {{define "header"}}
 2 | <!DOCTYPE html>
 3 | <html lang="en">
 4 | <head>
 5 | 	<meta charset="utf-8">
 6 | 	<meta http-equiv="X-UA-Compatible" content="IE=edge">
 7 | 	<meta name="viewport" content="width=device-width, initial-scale=1">
 8 | 	<meta name="description" content="Default Project in Go using Goji, Gorilla sessions">
 9 | 	<meta name="keywords" content="go, golang, mongo, goji, microframework, gorilla, sessions, mvc">
10 | 	<title>{{.Title}}</title>
11 | 
12 | 	<!-- Bootstrap -->
13 | 	<link href="//maxcdn.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css" rel="stylesheet">
14 | 	<!-- Custom Style -->
15 | 	<link href="/assets/css/style.css" rel="stylesheet">
16 | 
17 | 	<!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
18 | 	<!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
19 | 	<!--[if lt IE 9]>
20 | 	<script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
21 | 	<script src="https://oss.maxcdn.com/libs/respond.js/1.4.2/respond.min.js"></script>
22 | 	<![endif]-->
23 | </head>
24 | <body>	
25 | {{end}}
26 | 


--------------------------------------------------------------------------------
/views/home.html:
--------------------------------------------------------------------------------
 1 | {{define "home"}}
 2 | <div class="jumbotron">
 3 | <h2>Welcome to Default Project</h2>
 4 | 
 5 | This is a default project created in Go using <a href="http://goji.io/">Goji</a> web microframework, <a href="http://www.gorillatoolkit.org/pkg/sessions">Gorilla web toolkit sessions</a> .
 6 | <br>
 7 | <br>
 8 | It provides essentials that most web applications need - MVC pattern and user authorisation that can be easily extended.
 9 | <br>
10 | <br>
11 | Project's source code can be found here:
12 | <br>
13 | <br>
14 | <div class="well">
15 | 	<a href="https://github.com/haruyama/golang-goji-sample">https://github.com/haruyama/golang-goji-sample</a>
16 | </div>
17 | </div>
18 | {{end}}
19 | 


--------------------------------------------------------------------------------
/views/main.html:
--------------------------------------------------------------------------------
 1 | {{define "main"}}
 2 | 	{{template "header" .}}
 3 | 	<!-- Fixed navbar -->
 4 | 	<div class="navbar navbar-default navbar-fixed-top" role="navigation">
 5 | 		<div class="container">
 6 | 			<div class="navbar-header">
 7 | 				<button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
 8 | 					<span class="sr-only">Toggle navigation</span>
 9 | 					<span class="icon-bar"></span>
10 | 					<span class="icon-bar"></span>
11 | 					<span class="icon-bar"></span>
12 | 				</button>
13 | 				<a class="navbar-brand" href="/">Default Project</a>
14 | 			</div>
15 | 			<div class="navbar-collapse collapse">
16 | 				<ul class="nav navbar-nav">
17 | 					<li {{if .IsIndex }}class="active"{{end}}><a href="/">Home</a></li>
18 | 					<!-- YOU CAN REMOVE THESE ENDORSEMENTS -->
19 | 					<li>
20 | 						<p class="navbar-text github">					
21 | 							<iframe src="http://ghbtns.com/github-btn.html?user=elcct&type=follow&count=true" height="30" width="168" frameborder="0" scrolling="0" style="width:168px; height: 30px;" allowTransparency="true"></iframe>
22 | 						</p>
23 | 					</li>
24 | 					<!-- END OF ENDORSEMENTS -->
25 | 				</ul>
26 | 				{{if .User}}
27 | 				<ul class="nav navbar-nav navbar-right">
28 | 					<li>
29 | 						<p class="navbar-text">
30 | 							Hello, {{ .User.Email}}
31 | 						</p>
32 | 					</li>
33 | 					<li><a href="/logout">Logout</a></li>
34 | 				</ul>
35 | 				{{else}}
36 | 				<ul class="nav navbar-nav navbar-right">
37 | 					<li {{if .IsSignIn }}class="active"{{end}}><a href="/signin">Sign In</a></li>
38 | 					<li {{if .IsSignUp }}class="active"{{end}}><a href="/signup">Sign Up</a></li>
39 | 				</ul>
40 | 				{{end}}				
41 | 			</div><!--/.nav-collapse -->
42 | 		</div>
43 | 	</div>
44 | 	<div class="container" role="main">		
45 | 	{{.Content}}	
46 | 	</div>
47 | 	{{template "footer" .}}
48 | {{end}}
49 | 


--------------------------------------------------------------------------------