dmv

func AuthBasic ¶

func AuthBasic() martini.Handler

AuthBasic attempts to get a username and password from an Authorization header. Basic is mapped to the current request context. BasicFail will be called if there are errors, the header is empty, or a username or password is empty.

m.Get("/protected", AuthBasic(), func(b *dmv.Basic, w http.ResponseWriter) {
    // Lookup user by b.Username
    // Compare password to b.Password
    // If not valid call dmv.FailBasic(w)
})

func AuthFacebook ¶

func AuthFacebook(opts *OAuth2Options) martini.Handler

AuthFacebook authenticates users using Facebook and OAuth2.0. After handling a callback request, a request is made to get the users facebook profile and a Facebook struct will be mapped to the current request context.

This function should be called twice in each application, once on the login handler, and once on the callback handler.

package main

import (
    "github.com/go-martini/martini"
    "github.com/martini-contrib/sessions"
    "net/http"
)

func main() {
    fbOpts := &dmv.OAuth2.0Options{
        ClientID: "oauth_id",
        ClientSecret: "oauth_secret",
        RedirectURL: "http://host:port/auth/callback/facebook",
    }

    m := martini.Classic()
    store := sessions.NewCookieStore([]byte("secret123"))
    m.Use(sessions.Sessions("my_session", store))

    m.Get("/", func(s sessions.Session) string {
        return "hi" + s.Get("userID")
    })
    m.Get("/auth/facebook", dmv.AuthFacebook(fbOpts))
    m.Get("/auth/callback/facebook", dmv.AuthFacebook(fbOpts), func(fb *dmv.Facebook, req *http.Request, w http.ResponseWriter) {
        // Handle any errors.
        if len(fb.Errors) > 0 {
            http.Error(w, "Oauth failure", http.StatusInternalServerError)
            return
        }
        // Do something in a database to create or find the user by the facebook profile id.
        user := findOrCreateByFacebookID(fb.Profile.ID)
        s.Set("userID", user.ID)
        http.Redirect(w, req, "/", http.StatusFound)
    })
}

func AuthGithub ¶

func AuthGithub(opts *OAuth2Options) martini.Handler

AuthGithub authenticates users using Github and OAuth2.0. After handling a callback request, a request is made to get the users Github profile and a Github struct will be mapped to the current request context.

This function should be called twice in each application, once on the login handler and once on the callback handler.

package main

import (
    "github.com/go-martini/martini"
    "github.com/martini-contrib/sessions"
    "net/http"
)

func main() {
    ghOpts := &dmv.OAuth2.0Options{
        ClientID: "oauth_id",
        ClientSecret: "oauth_secret",
        RedirectURL: "http://host:port/auth/callback/github",
    }

    m := martini.Classic()
    store := sessions.NewCookieStore([]byte("secret123"))
    m.Use(sessions.Sessions("my_session", store))

    m.Get("/", func(s sessions.Session) string {
        return "hi" + s.Get("userID")
    })
    m.Get("/auth/github", dmv.AuthGithub(ghOpts))
    m.Get("/auth/callback/github", dmv.AuthGithub(ghOpts), func(gh *dmv.Github, req *http.Request, w http.ResponseWriter) {
        // Handle any errors.
        if len(gh.Errors) > 0 {
            http.Error(w, "Oauth failure", http.StatusInternalServerError)
            return
        }
        // Do something in a database to create or find the user by the Github profile id.
        user := findOrCreateByGithubID(gh.Profile.ID)
        s.Set("userID", user.ID)
        http.Redirect(w, req, "/", http.StatusFound)
    })
}

func AuthGoogle ¶

func AuthGoogle(opts *OAuth2Options) martini.Handler

AuthGoogle authenticates users using Google and OAuth2.0. After handling a callback request, a request is made to get the users Google profile and a Google struct will be mapped to the current request context.

This function should be called twice in each application, once on the login handler and once on the callback handler.

package main

import (
    "github.com/go-martini/martini"
    "github.com/martini-contrib/sessions"
    "github.com/thomasjsteele/dmv"
    "net/http"
)

func main() {
    googleOpts := &dmv.OAuth2Options{
        ClientID: "oauth_id",
        ClientSecret: "oauth_secret",
        RedirectURL: "http://host:port/auth/callback/google",
        Scopes:      []string{"https://www.googleapis.com/auth/userinfo.email",
                              "https://www.googleapis.com/auth/userinfo.profile"},
    }

    m := martini.Classic()
    store := sessions.NewCookieStore([]byte("secret123"))
    m.Use(sessions.Sessions("my_session", store))

    m.Get("/", func(s sessions.Session) string {
        return "hello" + s.Get("userID")
    })
    m.Get("/auth/google", dmv.AuthGoogle(googleOpts))
    m.Get("/auth/callback/google", dmv.AuthGoogle(googleOpts), func(goog *dmv.Google, req *http.Request, w http.ResponseWriter) {
        // Handle any errors.
        if len(goog.Errors) > 0 {
            http.Error(w, "OAuth failure", http.StatusInternalServerError)
            return
        }
        // Do something in a database to create or find the user by the Google profile id.
        s.Set("userID", goog.Profile.ID)
        http.Redirect(w, req, "/", http.StatusFound)
    })
}

func AuthLocal ¶

func AuthLocal(opts *LocalOptions) martini.Handler

AuthLocal attempts to get a username and password from a request.

m.Post("/login", dmv.AuthLocal(), func(l *dmv.Local) {
    if len(l.Errors) > 0 {
        // Return "invalid username or password" message  or perhaps 401.
    }
    // Lookup user by l.Username
    // Compare password of found user to l.Password
})

func FailBasic ¶

func FailBasic(w http.ResponseWriter)

FailBasic writes the required response headers to prompt for basic authentication.

func RedirectRelativeFunc ¶

func RedirectRelativeFunc(path string) func(*http.Request) string