512 lines
13 KiB
Go
512 lines
13 KiB
Go
package handlers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"path/filepath"
|
|
"runtime/debug"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"git.andreafazzi.eu/andrea/oef/config"
|
|
"git.andreafazzi.eu/andrea/oef/errors"
|
|
"git.andreafazzi.eu/andrea/oef/i18n"
|
|
"git.andreafazzi.eu/andrea/oef/orm"
|
|
"git.andreafazzi.eu/andrea/oef/reflect"
|
|
"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"
|
|
)
|
|
|
|
type handlerFuncWithError func(http.ResponseWriter, *http.Request) error
|
|
|
|
type rootMiddleware struct {
|
|
h *Handlers
|
|
fn handlerFuncWithError
|
|
}
|
|
|
|
func newRootMiddleware(h *Handlers, fn func(http.ResponseWriter, *http.Request) error) *rootMiddleware {
|
|
return &rootMiddleware{h, fn}
|
|
}
|
|
|
|
// type rootHandler func(http.ResponseWriter, *http.Request) error
|
|
|
|
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
|
|
|
|
CookieStore *sessions.CookieStore
|
|
|
|
JWTSigningKey []byte
|
|
JWTCookieMiddleware *jwtmiddleware.JWTMiddleware
|
|
JWTHeaderMiddleware *jwtmiddleware.JWTMiddleware
|
|
|
|
Router *mux.Router
|
|
|
|
permissions map[string]map[string]bool
|
|
}
|
|
|
|
// 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(
|
|
reflect.ModelNameLowerPlural(model),
|
|
),
|
|
h.JWTCookieMiddleware.Handler(
|
|
h.Recover(
|
|
newRootMiddleware(
|
|
h,
|
|
h.modelHandler(
|
|
reflect.ModelNameLowerPlural(model),
|
|
pattern,
|
|
))))).Methods(pattern.Methods...)
|
|
}
|
|
|
|
// Install API paths
|
|
|
|
for _, pattern := range h.Config.Handlers.APIPathPatterns {
|
|
r.Handle(pattern.Path(
|
|
reflect.ModelNameLowerPlural(model),
|
|
),
|
|
h.JWTHeaderMiddleware.Handler(
|
|
h.Recover(
|
|
newRootMiddleware(
|
|
h,
|
|
|
|
h.modelHandler(
|
|
reflect.ModelNameLowerPlural(model),
|
|
pattern,
|
|
))))).Methods(pattern.Methods...)
|
|
}
|
|
|
|
// Set permissions
|
|
|
|
for role, modelPermissions := range h.Config.Handlers.Permissions {
|
|
for m, perm := range modelPermissions {
|
|
if m == reflect.ModelName(model) {
|
|
for _, p := range perm {
|
|
for _, pattern := range h.Config.Handlers.PathPatterns {
|
|
if pattern.Permission == p {
|
|
if h.permissions[role] == nil {
|
|
h.permissions[role] = make(map[string]bool)
|
|
}
|
|
h.permissions[role][pattern.Path(reflect.ModelNameLowerPlural(model))] = true
|
|
}
|
|
}
|
|
|
|
for _, pattern := range DefaultAPIPathPatterns {
|
|
if pattern.Permission == p {
|
|
if h.permissions[role] == nil {
|
|
h.permissions[role] = make(map[string]bool)
|
|
}
|
|
h.permissions[role][pattern.Path(reflect.ModelNameLowerPlural(model))] = true
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func NewHandlers(config *config.ConfigT, renderer map[string]renderer.Renderer, db *orm.Database, models []interface{}) *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.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 []byte(config.Keys.JWTSigningKey), nil
|
|
},
|
|
SigningMethod: jwt.SigningMethodHS256,
|
|
})
|
|
|
|
handlers.permissions = make(map[string]map[string]bool)
|
|
|
|
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{}, path string, format string) (*http.Request, error) {
|
|
return http.NewRequest("GET", h.Config.ReadAllPath(model, path, format), nil)
|
|
}
|
|
|
|
func (h *Handlers) NewReadRequest(model interface{}, path string, format string) (*http.Request, error) {
|
|
return http.NewRequest("GET", h.Config.ReadPath(model, path, format), nil)
|
|
}
|
|
|
|
func (h *Handlers) NewCreateRequest(model interface{}, path string, format string, method string, form url.Values) (*http.Request, error) {
|
|
var (
|
|
request *http.Request
|
|
err error
|
|
)
|
|
switch method {
|
|
case "GET":
|
|
request, err = http.NewRequest("GET", h.Config.CreatePath(model, path, format), nil)
|
|
case "POST":
|
|
request, err = http.NewRequest("POST", h.Config.CreatePath(model, path, format), strings.NewReader(form.Encode()))
|
|
}
|
|
return request, err
|
|
}
|
|
|
|
func (h *Handlers) NewDeleteRequest(model interface{}, path string, format string) (*http.Request, error) {
|
|
return http.NewRequest("DELETE", h.Config.DeletePath(model, path, format), nil)
|
|
}
|
|
|
|
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 (h *Handlers) hasPermission(role, path string) bool {
|
|
if h.permissions[role] == nil {
|
|
return false
|
|
}
|
|
|
|
return h.permissions[role][path]
|
|
}
|
|
|
|
func (h *Handlers) get(w http.ResponseWriter, r *http.Request, model string, pattern config.PathPattern) error {
|
|
format := r.URL.Query().Get("format")
|
|
getFn, err := h.Database.GetFunc(pattern.Path(model))
|
|
if err != nil {
|
|
return err
|
|
} else {
|
|
claims := r.Context().Value("user").(*jwt.Token).Claims.(jwt.MapClaims)
|
|
role := claims["role"].(string)
|
|
if !h.hasPermission(role, pattern.Path(model)) {
|
|
return errors.NotAuthorized
|
|
} 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())
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (h *Handlers) post(w http.ResponseWriter, r *http.Request, model string, pattern config.PathPattern) error {
|
|
var (
|
|
data interface{}
|
|
err error
|
|
)
|
|
|
|
respFormat := renderer.GetContentFormat(r)
|
|
postFn, err := h.Database.GetFunc(pattern.Path(model))
|
|
|
|
if err != nil {
|
|
return err
|
|
} else {
|
|
claims := r.Context().Value("user").(*jwt.Token).Claims.(jwt.MapClaims)
|
|
|
|
role := claims["role"].(string)
|
|
if !h.hasPermission(role, pattern.Path(model)) {
|
|
return errors.NotAuthorized
|
|
} else {
|
|
data, err = postFn(h.Database, mux.Vars(r), w, r)
|
|
if err != nil {
|
|
return 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())
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (h *Handlers) delete(w http.ResponseWriter, r *http.Request, model string, pattern config.PathPattern) error {
|
|
var data interface{}
|
|
|
|
respFormat := renderer.GetContentFormat(r)
|
|
|
|
claims := r.Context().Value("user").(*jwt.Token).Claims.(jwt.MapClaims)
|
|
role := claims["role"].(string)
|
|
if !h.hasPermission(role, pattern.Path(model)) {
|
|
return errors.NotAuthorized
|
|
} else {
|
|
postFn, err := h.Database.GetFunc(pattern.Path(model))
|
|
if err != nil {
|
|
return err
|
|
// 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 {
|
|
return 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())
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func respondWithError(h *Handlers, w http.ResponseWriter, r *http.Request, err error) {
|
|
var format string
|
|
|
|
format = r.URL.Query().Get("format")
|
|
if format == "" {
|
|
format = renderer.GetContentFormat(r)
|
|
}
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
h.Renderer[format].Render(w, r, h.CookieStore, err)
|
|
}
|
|
|
|
func (h *Handlers) Create(model interface{}) http.Handler {
|
|
fn := func(w http.ResponseWriter, r *http.Request) {
|
|
h.post(w, r, reflect.ModelNameLowerPlural(model), h.Config.CreatePattern())
|
|
}
|
|
|
|
return http.HandlerFunc(fn)
|
|
}
|
|
|
|
func (h *Handlers) ReadAll(model interface{}) http.Handler {
|
|
fn := func(w http.ResponseWriter, r *http.Request) {
|
|
h.get(w, r, reflect.ModelNameLowerPlural(model), h.Config.ReadAllPattern())
|
|
}
|
|
|
|
return http.HandlerFunc(fn)
|
|
}
|
|
|
|
func (h *Handlers) Read(model interface{}) http.Handler {
|
|
fn := func(w http.ResponseWriter, r *http.Request) {
|
|
h.get(w, r, reflect.ModelNameLowerPlural(model), h.Config.ReadPattern())
|
|
}
|
|
|
|
return http.HandlerFunc(fn)
|
|
}
|
|
|
|
func (h *Handlers) Delete(model interface{}) http.Handler {
|
|
fn := func(w http.ResponseWriter, r *http.Request) {
|
|
h.delete(w, r, reflect.ModelNameLowerPlural(model), h.Config.DeletePattern())
|
|
}
|
|
|
|
return http.HandlerFunc(fn)
|
|
}
|
|
|
|
func (h *Handlers) modelHandler(model string, pattern config.PathPattern) handlerFuncWithError {
|
|
fn := func(w http.ResponseWriter, r *http.Request) error {
|
|
|
|
var err error
|
|
|
|
// Replace the "api" prefix.
|
|
pattern.PathPattern = strings.Replace(pattern.PathPattern, "/api", "", -1)
|
|
|
|
switch r.Method {
|
|
case "GET":
|
|
err = h.get(w, r, model, pattern)
|
|
|
|
case "POST":
|
|
err = h.post(w, r, model, pattern)
|
|
|
|
case "DELETE":
|
|
err = h.delete(w, r, model, pattern)
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
return handlerFuncWithError(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)
|
|
}
|
|
|
|
func (m *rootMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
err := m.fn(w, r) // Call handler function
|
|
if err == nil {
|
|
return
|
|
}
|
|
// This is where our error handling logic starts.
|
|
log.Printf("An error accured: %v", err) // Log the error.
|
|
|
|
respondWithError(m.h, w, r, err)
|
|
}
|