go-skeletor/middleware/middleware.go

package middleware

import (
	"html/template"

	"github.com/go-martini/martini"
	"github.com/martini-contrib/render"
	"github.com/martini-contrib/sessions"

	"arno/skeletor/config"
	"arno/skeletor/controller"
	"arno/skeletor/service"

	"net/http"
)

type Middleware struct {
	martini   *martini.ClassicMartini
	templates map[string]*template.Template
	ctn       *service.Container
}

func NewMiddleware(ctn *service.Container) *Middleware {
	var middleware *Middleware = new(Middleware)
	middleware.ctn = ctn
	myconfig := config.Must(ctn)

	// Initialisation du serveur middleware
	middleware.martini = martini.Classic()

	// Initialisation de la session
	store := sessions.NewCookieStore([]byte(myconfig.AppSecret))
	store.Options(sessions.Options{Path: myconfig.AppAlias, MaxAge: int(3600)})

	middleware.martini.Use(sessions.Sessions(myconfig.AppName, store))

	// Definition du répertoire public
	StaticOptions := martini.StaticOptions{Prefix: "public"}
	middleware.martini.Use(martini.Static("public", StaticOptions))

	// Définition du template de base
	middleware.martini.Use(render.Renderer(render.Options{
		Layout: "base",
		Funcs: []template.FuncMap{
			{
				"unescaped": func(args ...interface{}) template.HTML {
					return template.HTML(args[0].(string))
				},
			},
		},
	}))

	// x) Define and set all handlers
	middleware.initHandlers()

	return middleware
}

func (middleware *Middleware) StartMiddleware() {
	myconfig := config.Must(middleware.ctn)
	middleware.martini.RunOnAddr(myconfig.AppServer)
}

func (middleware *Middleware) initHandlers() {
	myconfig := config.Must(middleware.ctn)

	// Route Home
	middleware.martini.Get(myconfig.AppRoutes["home"], middleware.Home)
	middleware.martini.Get(myconfig.AppRoutes["homeconfig"], middleware.HomeConfig)

	// Route Security
	middleware.martini.Get(myconfig.AppRoutes["securitylogin"], middleware.SecurityLogin)
	middleware.martini.Post(myconfig.AppRoutes["securitylogin"], middleware.SecurityLogin)
	middleware.martini.Get(myconfig.AppRoutes["securitylogout"], middleware.SecurityLogout)

	// Route Upload
	middleware.martini.Get(myconfig.AppRoutes["upload"]+":typeupload"+"/:id", middleware.Upload)
	middleware.martini.Post(myconfig.AppRoutes["uploaded"]+":typeupload"+"/:id", middleware.Uploaded)
	middleware.martini.Get(myconfig.AppRoutes["uploadcrop"]+":typeupload"+"/:id", middleware.UploadCrop)
	middleware.martini.Post(myconfig.AppRoutes["uploadcropped"]+":typeupload"+"/:id", middleware.UploadCropped)

	// Route Config
	middleware.martini.Get(myconfig.AppRoutes["configlist"], middleware.ConfigList)
	middleware.martini.Get(myconfig.AppRoutes["configrefresh"], middleware.ConfigRefresh)
	middleware.martini.Get(myconfig.AppRoutes["configupdate"]+":id", middleware.ConfigUpdate)
	middleware.martini.Post(myconfig.AppRoutes["configupdate"]+":id", middleware.ConfigUpdate)
	middleware.martini.Get(myconfig.AppRoutes["configdelete"]+":id", middleware.ConfigDelete)

	// Route User
	middleware.martini.Get(myconfig.AppRoutes["userlist"], middleware.UserList)
	middleware.martini.Get(myconfig.AppRoutes["usersubmit"], middleware.UserSubmit)
	middleware.martini.Post(myconfig.AppRoutes["usersubmit"], middleware.UserSubmit)
	middleware.martini.Get(myconfig.AppRoutes["userupdate"]+":id", middleware.UserUpdate)
	middleware.martini.Post(myconfig.AppRoutes["userupdate"]+":id", middleware.UserUpdate)
	middleware.martini.Get(myconfig.AppRoutes["userdelete"]+":id", middleware.UserDelete)
	middleware.martini.Get(myconfig.AppRoutes["userprofil"], middleware.UserProfil)
	middleware.martini.Post(myconfig.AppRoutes["userprofil"], middleware.UserProfil)

}

// REDIRECT
func (middleware *Middleware) redirect(ctn *service.Container, session sessions.Session, req *http.Request, r render.Render, isperm int) {
	if isperm != 0 {
		controller.SecurityRedirect(middleware.ctn, req, r, isperm)
	}
}

// ROUTE HOME
func (middleware *Middleware) Home(session sessions.Session, req *http.Request, r render.Render) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 100)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.Home(middleware.ctn, session, req, r)
	}
}
func (middleware *Middleware) HomeConfig(session sessions.Session, req *http.Request, r render.Render) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 10)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.HomeConfig(middleware.ctn, session, req, r)
	}
}

// ROUTE SECURITY
func (middleware *Middleware) SecurityLogin(session sessions.Session, req *http.Request, r render.Render) {
	controller.SecurityLogin(middleware.ctn, session, req, r)
}
func (middleware *Middleware) SecurityLogout(session sessions.Session, req *http.Request, r render.Render) {
	controller.SecurityLogout(middleware.ctn, session, req, r)
}

// ROUTE UPLOAD
func (middleware *Middleware) Upload(session sessions.Session, req *http.Request, r render.Render, params martini.Params) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 50)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.Upload(middleware.ctn, session, req, r, params["typeupload"], params["id"])
	}
}
func (middleware *Middleware) Uploaded(session sessions.Session, req *http.Request, r render.Render, params martini.Params) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 50)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.Uploaded(middleware.ctn, session, req, r, params["typeupload"], params["id"])
	}
}
func (middleware *Middleware) UploadCrop(session sessions.Session, req *http.Request, r render.Render, params martini.Params) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 50)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.UploadCrop(middleware.ctn, session, req, r, params["typeupload"], params["id"])
	}
}
func (middleware *Middleware) UploadCropped(session sessions.Session, req *http.Request, r render.Render, params martini.Params) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 50)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.UploadCropped(middleware.ctn, session, req, r, params["typeupload"], params["id"])
	}
}

// ROUTE CONFIG
func (middleware *Middleware) ConfigList(session sessions.Session, req *http.Request, r render.Render) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 10)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.ConfigList(middleware.ctn, session, req, r)
	}
}

func (middleware *Middleware) ConfigRefresh(session sessions.Session, req *http.Request, r render.Render) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 10)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.ConfigRefresh(middleware.ctn, session, req, r)
	}
}

func (middleware *Middleware) ConfigUpdate(session sessions.Session, req *http.Request, r render.Render, params martini.Params) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 10)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.ConfigUpdate(middleware.ctn, session, req, r, params["id"])
	}
}

func (middleware *Middleware) ConfigDelete(session sessions.Session, req *http.Request, r render.Render, params martini.Params) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 10)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.ConfigDelete(middleware.ctn, session, req, r, params["id"])
	}
}

// ROUTE USER
func (middleware *Middleware) UserList(session sessions.Session, req *http.Request, r render.Render) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 10)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.UserList(middleware.ctn, session, req, r)
	}
}

func (middleware *Middleware) UserSubmit(session sessions.Session, req *http.Request, r render.Render) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 10)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.UserSubmit(middleware.ctn, session, req, r)
	}
}

func (middleware *Middleware) UserUpdate(session sessions.Session, req *http.Request, r render.Render, params martini.Params) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 10)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.UserUpdate(middleware.ctn, session, req, r, params["id"], "update")
	}
}

func (middleware *Middleware) UserDelete(session sessions.Session, req *http.Request, r render.Render, params martini.Params) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 10)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.UserDelete(middleware.ctn, session, req, r, params["id"])
	}
}

func (middleware *Middleware) UserProfil(session sessions.Session, req *http.Request, r render.Render, params martini.Params) {
	isperm := controller.SecurityFirewall(middleware.ctn, session, req, r, 50)
	middleware.redirect(middleware.ctn, session, req, r, isperm)
	if isperm == 0 {
		controller.UserUpdate(middleware.ctn, session, req, r, session.Get("Userid").(string), "profil")
	}
}