oef/handlers/handlers.go

package handlers

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"path/filepath"
	"reflect"
	"runtime/debug"
	"strconv"
	"strings"

	"git.andreafazzi.eu/andrea/oef/config"
	"git.andreafazzi.eu/andrea/oef/i18n"
	"git.andreafazzi.eu/andrea/oef/orm"
	"git.andreafazzi.eu/andrea/oef/renderer"

	jwtmiddleware "github.com/auth0/go-jwt-middleware"
	jwt "github.com/dgrijalva/jwt-go"
	"github.com/gorilla/mux"
	"github.com/gorilla/sessions"

	"github.com/jinzhu/inflection"
)

type PathPattern struct {
	PathPattern     string
	RedirectPattern string
	Methods         []string
	Permission      int
}

type Handlers struct {
	Config *config.ConfigT

	Database *orm.Database
	Models   []interface{}

	Renderer map[string]renderer.Renderer

	Login    func(db *orm.Database, store *sessions.CookieStore, signingKey []byte) http.Handler
	Logout   func(store *sessions.CookieStore) http.Handler
	Home     func() http.Handler
	GetToken func(db *orm.Database, signingKey []byte) http.Handler
	Static   func() http.Handler
	Recover  func(next http.Handler) http.Handler

	PathPatterns    []PathPattern
	APIPathPatterns []PathPattern

	RolePermissions map[string]map[string][]int

	CookieStore *sessions.CookieStore

	JWTSigningKey       []byte
	JWTCookieMiddleware *jwtmiddleware.JWTMiddleware
	JWTHeaderMiddleware *jwtmiddleware.JWTMiddleware

	Router *mux.Router
}

var (
	permissions map[string]map[string]bool
)

func init() {
	permissions = make(map[string]map[string]bool, 0)
}

func (pp PathPattern) RedirectPath(model string, id ...uint) string {
	if len(id) > 0 {
		return fmt.Sprintf(pp.RedirectPattern, model, id[0], model)
	}
	return fmt.Sprintf(pp.RedirectPattern, model, model)
}

func (pp PathPattern) Path(model string) string {
	return fmt.Sprintf(pp.PathPattern, model)
}

func modelName(s interface{}) string {
	if t := reflect.TypeOf(s); t.Kind() == reflect.Ptr {
		return t.Elem().Name()
	} else {
		return t.Name()
	}
}

func pluralizedModelName(s interface{}) string {
	return inflection.Plural(strings.ToLower(modelName(s)))
}

// Generate CRUD handlers for models
func (h *Handlers) generateModelHandlers(r *mux.Router, model interface{}) {
	// Install standard paths

	for _, pattern := range DefaultPathPatterns {
		r.Handle(
			pattern.Path(
				pluralizedModelName(model),
			),
			h.JWTCookieMiddleware.Handler(
				h.Recover(
					h.modelHandler(
						pluralizedModelName(model),
						pattern,
					)))).Methods(pattern.Methods...)
	}

	// Install API paths

	for _, pattern := range h.APIPathPatterns {
		r.Handle(pattern.Path(
			pluralizedModelName(model),
		),
			h.JWTHeaderMiddleware.Handler(
				h.Recover(
					h.modelHandler(
						pluralizedModelName(model),
						pattern,
					)))).Methods(pattern.Methods...)
	}

	// Set permissions for HTML patterns

	for role, modelPermissions := range h.RolePermissions {
		for m, perm := range modelPermissions {
			if m == modelName(model) {
				for _, p := range perm {
					for _, pattern := range h.PathPatterns {
						if pattern.Permission == p {
							if permissions[role] == nil {
								permissions[role] = make(map[string]bool)
							}
							permissions[role][pattern.Path(pluralizedModelName(model))] = true
						}
					}

					for _, pattern := range DefaultAPIPathPatterns {
						if pattern.Permission == p {
							if permissions[role] == nil {
								permissions[role] = make(map[string]bool)
							}
							permissions[role][pattern.Path(pluralizedModelName(model))] = true
						}
					}

				}
			}
		}
	}

}

func NewHandlers(
	config *config.ConfigT,
	renderer map[string]renderer.Renderer,
	db *orm.Database,
	models []interface{},
	permissions map[string]map[string][]int,
	pathPatterns []PathPattern,
	apiPathPatterns []PathPattern,
) *Handlers {
	handlers := new(Handlers)

	handlers.Config = config

	handlers.Renderer = renderer
	handlers.Database = db

	handlers.CookieStore = sessions.NewCookieStore([]byte(config.Keys.CookieStoreKey))

	handlers.Login = handlers.DefaultLoginHandler
	handlers.Logout = DefaultLogoutHandler
	handlers.Recover = DefaultRecoverHandler
	handlers.Home = DefaultHomeHandler
	handlers.GetToken = DefaultGetTokenHandler

	handlers.RolePermissions = permissions

	handlers.PathPatterns = pathPatterns
	handlers.APIPathPatterns = apiPathPatterns

	handlers.JWTCookieMiddleware = jwtmiddleware.New(jwtmiddleware.Options{
		ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) {
			return []byte(config.Keys.JWTSigningKey), nil
		},
		SigningMethod: jwt.SigningMethodHS256,
		Extractor:     handlers.cookieExtractor,
		ErrorHandler:  handlers.onError,
	})

	handlers.JWTHeaderMiddleware = jwtmiddleware.New(jwtmiddleware.Options{
		ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) {
			return config.Keys.JWTSigningKey, nil
		},
		SigningMethod: jwt.SigningMethodHS256,
	})

	r := mux.NewRouter()

	// Authentication

	r.Handle("/login", handlers.Login(handlers.Database, handlers.CookieStore, []byte(config.Keys.JWTSigningKey)))
	r.Handle("/logout", handlers.Logout(handlers.CookieStore))

	// School subscription

	r.Handle("/subscribe", handlers.Login(handlers.Database, handlers.CookieStore, []byte(config.Keys.JWTSigningKey)))

	// Home

	r.Handle("/", handlers.JWTCookieMiddleware.Handler(handlers.Recover(handlers.Home())))

	// Generate CRUD handlers

	for _, model := range models {
		handlers.generateModelHandlers(r, model)
	}

	// Token handling

	r.Handle("/get_token", handlers.GetToken(handlers.Database, []byte(config.Keys.JWTSigningKey)))

	// Static file server

	r.PathPrefix("/").Handler(http.FileServer(http.Dir("./dist/")))

	handlers.Router = r

	return handlers
}

func (h *Handlers) NewReadAllRequest(model interface{}) (*http.Request, error) {
	name := inflection.Plural(orm.ModelName(model))
	request, err := http.NewRequest("GET", "/contests?format=html&tpl_layout=base&tpl_content=contests", nil)
	return request, err
}

func (h *Handlers) onError(w http.ResponseWriter, r *http.Request, err string) {
	http.Redirect(w, r, "/login?tpl_layout=login&tpl_content=login", http.StatusTemporaryRedirect)
}

func respondWithStaticFile(w http.ResponseWriter, filename string) error {
	f, err := ioutil.ReadFile(filepath.Join("public/html", filename))
	if err != nil {
		return err
	}
	w.Write(f)
	return nil
}

func (h *Handlers) cookieExtractor(r *http.Request) (string, error) {
	session, err := h.CookieStore.Get(r, "login-session")
	if err != nil {
		return "", nil
	}

	if session.Values["token"] == nil {
		return "", nil
	}

	token := session.Values["token"].([]uint8)

	return string(token), nil
}

func DefaultRecoverHandler(next http.Handler) http.Handler {
	fn := func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if err := recover(); err != nil {
				panicMsg := fmt.Sprintf("PANIC: %v\n\n== STACKTRACE ==\n%s", err, debug.Stack())
				log.Print(panicMsg)
				http.Error(w, panicMsg, http.StatusInternalServerError)
			}
		}()
		next.ServeHTTP(w, r)
	}
	return http.HandlerFunc(fn)
}

func (h *Handlers) setFlashMessage(w http.ResponseWriter, r *http.Request, key string) error {
	session, err := h.CookieStore.Get(r, "flash-session")
	if err != nil {
		return err
	}
	session.AddFlash(i18n.FlashMessages[key][h.Config.Language])
	err = session.Save(r, w)
	if err != nil {
		return err
	}
	return nil
}

func hasPermission(role, path string) bool {
	if permissions[role] == nil {
		return false
	}

	return permissions[role][path]
}

func (h *Handlers) get(w http.ResponseWriter, r *http.Request, model string, pattern PathPattern) {
	format := r.URL.Query().Get("format")
	getFn, err := h.Database.GetFunc(pattern.Path(model))
	if err != nil {
		log.Println("Error:", err)
		respondWithError(h, w, r, err)
	} else {
		claims := r.Context().Value("user").(*jwt.Token).Claims.(jwt.MapClaims)
		role := claims["role"].(string)
		if !hasPermission(role, pattern.Path(model)) {
			h.setFlashMessage(w, r, "notAuthorized")
			h.Renderer[format].Render(w, r, h.CookieStore, fmt.Errorf("%s", "Errore di autorizzazione"))
		} else {

			data, err := getFn(h.Database, mux.Vars(r), w, r)
			if err != nil {
				h.Renderer[format].Render(w, r, h.CookieStore, err)
			} else {
				h.Renderer[format].Render(w, r, h.CookieStore, data, r.URL.Query())
			}
		}
	}

}

func (h *Handlers) post(w http.ResponseWriter, r *http.Request, model string, pattern PathPattern) {
	var (
		data interface{}
		err  error
	)

	respFormat := renderer.GetContentFormat(r)
	postFn, err := h.Database.GetFunc(pattern.Path(model))

	if err != nil {
		respondWithError(h, w, r, err)
	} else {
		claims := r.Context().Value("user").(*jwt.Token).Claims.(jwt.MapClaims)

		role := claims["role"].(string)
		if !hasPermission(role, pattern.Path(model)) {
			h.Renderer[respFormat].Render(w, r, h.CookieStore, fmt.Errorf("%s", "Errore di autorizzazione"))
		} else {
			data, err = postFn(h.Database, mux.Vars(r), w, r)
			if err != nil {
				respondWithError(h, w, r, err)
			} else if pattern.RedirectPattern != "" {
				if id := mux.Vars(r)["id"]; id != "" {
					modelId, _ := strconv.Atoi(id)
					http.Redirect(w, r, pattern.RedirectPath(model, uint(modelId)), http.StatusSeeOther)
				} else {
					http.Redirect(w, r, pattern.RedirectPath(model, data.(orm.IDer).GetID()), http.StatusSeeOther)
				}
			} else {
				h.Renderer[respFormat].Render(w, r, h.CookieStore, data.(orm.IDer).GetID())
			}
		}
	}

}

func (h *Handlers) delete(w http.ResponseWriter, r *http.Request, model string, pattern PathPattern) {
	var data interface{}

	respFormat := renderer.GetContentFormat(r)

	claims := r.Context().Value("user").(*jwt.Token).Claims.(jwt.MapClaims)

	role := claims["role"].(string)
	if !hasPermission(role, pattern.Path(model)) {
		h.Renderer[respFormat].Render(w, r, h.CookieStore, fmt.Errorf("%s", "Errore di autorizzazione"))
	} else {
		postFn, err := h.Database.GetFunc(pattern.Path(model))
		if err != nil {
			h.Renderer[r.URL.Query().Get("format")].Render(w, r, h.CookieStore, err)
		}
		data, err = postFn(h.Database, mux.Vars(r), w, r)
		if err != nil {
			h.Renderer["html"].Render(w, r, h.CookieStore, err)
		} else if pattern.RedirectPattern != "" {
			var data struct {
				RedirectUrl string `json:"redirect_url"`
			}
			data.RedirectUrl = pattern.RedirectPath(model)

			w.Header().Set("Content-Type", "application/json")
			json.NewEncoder(w).Encode(data)
		} else {
			h.Renderer[respFormat].Render(w, r, h.CookieStore, data.(orm.IDer).GetID())
		}
	}
}

func respondWithError(h *Handlers, w http.ResponseWriter, r *http.Request, err error) {
	respFormat := renderer.GetContentFormat(r)
	w.WriteHeader(http.StatusInternalServerError)
	h.Renderer[respFormat].Render(w, r, h.CookieStore, err)
}

func (h *Handlers) modelHandler(model string, pattern PathPattern) http.Handler {
	fn := func(w http.ResponseWriter, r *http.Request) {

		// Replace "api" prefix
		pattern.PathPattern = strings.Replace(pattern.PathPattern, "/api", "", -1)

		switch r.Method {
		case "GET":
			h.get(w, r, model, pattern)

		case "POST":
			h.post(w, r, model, pattern)

		case "DELETE":
			h.delete(w, r, model, pattern)
		}
	}

	return http.HandlerFunc(fn)
}

func DefaultHomeHandler() http.Handler {
	fn := func(w http.ResponseWriter, r *http.Request) {
		claims := r.Context().Value("user").(*jwt.Token).Claims.(jwt.MapClaims)

		switch claims["role"] {

		case "subscriber":
			http.Redirect(
				w,
				r,
				fmt.Sprintf(
					"/schools/create/?format=html&tpl_layout=base&tpl_content=schools_add_update",
				),
				http.StatusSeeOther,
			)

		case "participant":
			http.Redirect(
				w,
				r,
				fmt.Sprintf(
					"/participants/%s?format=html&tpl_layout=base&tpl_content=participants_show",
					claims["user_id"].(string)),
				http.StatusSeeOther,
			)

		case "school":
			http.Redirect(
				w,
				r,
				fmt.Sprintf(
					"/schools/%s?format=html&tpl_layout=base&tpl_content=schools_show",
					claims["user_id"].(string)),
				http.StatusSeeOther,
			)

		default:
			http.Redirect(
				w,
				r,
				"/contests?format=html&tpl_layout=base&tpl_content=contests",
				http.StatusSeeOther,
			)
		}

	}
	return http.HandlerFunc(fn)
}