defaults

Documentation

Overview

Package defaults houses default implementations for the very many interfaces that authboss has. It's a goal of the defaults package to provide the core where authboss implements the shell.

It's simultaneously supposed to be possible to take as many or as few of these implementations as you desire, allowing you to reimplement where necessary, but reuse where possible.

Index

• Constants
• func SetCore(config *authboss.Config, readJSON, useUsername bool)
• func URLValuesToMap(form url.Values) map[string]string
• type ConfirmValues
  • func (c ConfirmValues) GetToken() string
• type ErrorHandler
  • func NewErrorHandler(logger authboss.Logger) ErrorHandler
  • func (e ErrorHandler) Wrap(handler func(w http.ResponseWriter, r *http.Request) error) http.Handler
• type FieldError
  • func NewFieldError(name string, err error) FieldError
  • func (f FieldError) Err() error
  • func (f FieldError) Error() string
  • func (f FieldError) Name() string
• type HTTPBodyReader
  • func NewHTTPBodyReader(readJSON, useUsernameNotEmail bool) *HTTPBodyReader
  • func (h HTTPBodyReader) Read(page string, r *http.Request) (authboss.Validator, error)
• type HTTPFormValidator
  • func (h HTTPFormValidator) Validate() []error
• type JSONRenderer
  • func (JSONRenderer) Load(names ...string) error
  • func (JSONRenderer) Render(ctx context.Context, page string, data authboss.HTMLData) (output []byte, contentType string, err error)
• type LogMailer
  • func NewLogMailer(writer io.Writer) *LogMailer
  • func (l LogMailer) Send(ctx context.Context, mail authboss.Email) error
• type Logger
  • func NewLogger(writer io.Writer) Logger
  • func (l Logger) Error(s string)
  • func (l Logger) Info(s string)
• type RecoverEndValues
  • func (r RecoverEndValues) GetPassword() string
  • func (r RecoverEndValues) GetToken() string
• type RecoverMiddleValues
  • func (r RecoverMiddleValues) GetToken() string
• type RecoverStartValues
  • func (r RecoverStartValues) GetPID() string
• type Redirector
  • func NewRedirector(renderer authboss.Renderer, formValueName string) *Redirector
  • func (r *Redirector) Redirect(w http.ResponseWriter, req *http.Request, ro authboss.RedirectOptions) error
• type Responder
  • func NewResponder(renderer authboss.Renderer) *Responder
  • func (r *Responder) Respond(w http.ResponseWriter, req *http.Request, code int, page string, ...) error
• type Router
  • func NewRouter() *Router
  • func (r *Router) Delete(path string, handler http.Handler)
  • func (r *Router) Get(path string, handler http.Handler)
  • func (r *Router) Post(path string, handler http.Handler)
  • func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request)
• type Rules
  • func (r Rules) Errors(toValidate string) authboss.ErrorList
  • func (r Rules) IsValid(toValidate string) bool
  • func (r Rules) Rules() []string
• type SMTPMailer
  • func NewSMTPMailer(server string, auth smtp.Auth) *SMTPMailer
  • func (s SMTPMailer) Send(ctx context.Context, mail authboss.Email) error
• type UserValues
  • func (u UserValues) GetPID() string
  • func (u UserValues) GetPassword() string
  • func (u UserValues) GetValues() map[string]string

Constants

const (
	FormValueEmail    = "email"
	FormValuePassword = "password"
	FormValueUsername = "username"

	FormValueConfirm = "cnf"
	FormValueToken   = "token"
)

FormValue types

const (
	// RedirectFormValueName is the name of the form field
	// in the http request that will be used when redirecting
	RedirectFormValueName = "redir"
)

Functions

func SetCore

func SetCore(config *authboss.Config, readJSON, useUsername bool)

SetCore creates instances of all the default pieces with the exception of ViewRenderer which should be already set before calling this method.

func URLValuesToMap

func URLValuesToMap(form url.Values) map[string]string

URLValuesToMap helps create a map from url.Values

Types

type ConfirmValues

type ConfirmValues struct {
	HTTPFormValidator

	Token string
}

ConfirmValues retrieves values on the confirm page.

func (ConfirmValues) GetToken

func (c ConfirmValues) GetToken() string

GetToken from the confirm values

type ErrorHandler

type ErrorHandler struct {
	LogWriter authboss.Logger
}

ErrorHandler wraps http handlers with errors with itself to provide error handling.

The pieces provided to this struct must be thread-safe since they will be handed to many pointers to themselves.

func NewErrorHandler

func NewErrorHandler(logger authboss.Logger) ErrorHandler

NewErrorHandler constructor

func (ErrorHandler) Wrap

func (e ErrorHandler) Wrap(handler func(w http.ResponseWriter, r *http.Request) error) http.Handler

Wrap an http handler with an error

type FieldError

type FieldError struct {
	FieldName string
	FieldErr  error
}

FieldError represents an error that occurs during validation and is always attached to field on a form.

func NewFieldError

func NewFieldError(name string, err error) FieldError

NewFieldError literally only exists because of poor name planning where name and err can't be exported on the struct due to the method names

func (FieldError) Err

func (f FieldError) Err() error

Err for the field

func (FieldError) Error

func (f FieldError) Error() string

Error in string form

func (FieldError) Name

func (f FieldError) Name() string

Name of the field the error is about

type HTTPBodyReader

type HTTPBodyReader struct {
	// ReadJSON if turned on reads json from the http request
	// instead of a encoded form.
	ReadJSON bool

	// UseUsername instead of e-mail address
	UseUsername bool

	// Rulesets for each page.
	Rulesets map[string][]Rules
	// Confirm fields for each page.
	Confirms map[string][]string
	// Whitelist values for each page through the html forms
	// this is for security so that we can properly protect the
	// arbitrary user API. In reality this really only needs to be set
	// for the register page since everything else is expecting
	// a hardcoded set of values.
	Whitelist map[string][]string
}

HTTPBodyReader reads forms from various pages and decodes them.

func NewHTTPBodyReader

func NewHTTPBodyReader(readJSON, useUsernameNotEmail bool) *HTTPBodyReader

NewHTTPBodyReader creates a form reader with default validation rules and fields for each page. If no defaults are required, simply construct this using the struct members itself for more control.

func (HTTPBodyReader) Read

func (h HTTPBodyReader) Read(page string, r *http.Request) (authboss.Validator, error)

Read the form pages

type HTTPFormValidator

type HTTPFormValidator struct {
	Values map[string]string

	Ruleset       []Rules
	ConfirmFields []string
}

HTTPFormValidator validates HTTP post type inputs

func (HTTPFormValidator) Validate

func (h HTTPFormValidator) Validate() []error

Validate validates a request using the given ruleset.

type JSONRenderer

type JSONRenderer struct {
}

JSONRenderer simply renders the data provided in JSON

func (JSONRenderer) Load

func (JSONRenderer) Load(names ...string) error

Load is a no-op since json doesn't require any templates

func (JSONRenderer) Render

func (JSONRenderer) Render(ctx context.Context, page string, data authboss.HTMLData) (output []byte, contentType string, err error)

Render the data

type LogMailer

type LogMailer struct {
	io.Writer
}

LogMailer logs e-mails instead of sending them.

func NewLogMailer

func NewLogMailer(writer io.Writer) *LogMailer

NewLogMailer creates a mailer that doesn't deliver e-mails but simply logs them.

func (LogMailer) Send

func (l LogMailer) Send(ctx context.Context, mail authboss.Email) error

Send an e-mail

type Logger

type Logger struct {
	Writer io.Writer
}

Logger writes exactly once for each log line to underlying io.Writer that's passed in and ends each message with a newline. It has RFC3339 as a date format, and emits a log level.

func NewLogger

func NewLogger(writer io.Writer) Logger

NewLogger creates a new logger from an io.Writer

func (Logger) Error

func (l Logger) Error(s string)

Error logs go here

func (Logger) Info

func (l Logger) Info(s string)

Info logs go here

type RecoverEndValues

type RecoverEndValues struct {
	HTTPFormValidator

	Token       string
	NewPassword string
}

RecoverEndValues for recover_end page

func (RecoverEndValues) GetPassword

func (r RecoverEndValues) GetPassword() string

GetPassword for recovery

func (RecoverEndValues) GetToken

func (r RecoverEndValues) GetToken() string

GetToken for recovery

type RecoverMiddleValues

type RecoverMiddleValues struct {
	HTTPFormValidator

	Token string
}

RecoverMiddleValues for recover_middle page

func (RecoverMiddleValues) GetToken

func (r RecoverMiddleValues) GetToken() string

GetToken for recovery

type RecoverStartValues

type RecoverStartValues struct {
	HTTPFormValidator

	PID string
}

RecoverStartValues for recover_start page

func (RecoverStartValues) GetPID

func (r RecoverStartValues) GetPID() string

GetPID for recovery

type Redirector

type Redirector struct {
	Renderer authboss.Renderer

	// FormValueName for the redirection
	FormValueName string
}

Redirector for http requests

func NewRedirector

func NewRedirector(renderer authboss.Renderer, formValueName string) *Redirector

NewRedirector constructor

func (*Redirector) Redirect

func (r *Redirector) Redirect(w http.ResponseWriter, req *http.Request, ro authboss.RedirectOptions) error

Redirect the client elsewhere. If it's an API request it will simply render a JSON response with information that should help a client to decide what to do.

type Responder

type Responder struct {
	Renderer authboss.Renderer
}

Responder helps respond to http requests

func NewResponder

func NewResponder(renderer authboss.Renderer) *Responder

NewResponder constructor

func (*Responder) Respond

func (r *Responder) Respond(w http.ResponseWriter, req *http.Request, code int, page string, data authboss.HTMLData) error

Respond to an HTTP request. It's main job is to merge data that comes in from various middlewares via the context with the data sent by the controller and render that.

type Router

type Router struct {
	// contains filtered or unexported fields
}

Router implementation Does not use a dynamic map to hope to be slightly more performant

func NewRouter

func NewRouter() *Router

NewRouter creates a new router

func (*Router) Delete

func (r *Router) Delete(path string, handler http.Handler)

Delete method route

func (*Router) Get

func (r *Router) Get(path string, handler http.Handler)

Get method route

func (*Router) Post

func (r *Router) Post(path string, handler http.Handler)

Post method route

func (*Router) ServeHTTP

func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request)

ServeHTTP for http.Handler Only does get/posts, all other request types are a bad request

type Rules

type Rules struct {
	// FieldName is the name of the field this is intended to validate.
	FieldName string

	// MatchError describes the MustMatch regexp to a user.
	Required             bool
	MatchError           string
	MustMatch            *regexp.Regexp
	MinLength, MaxLength int
	MinLetters           int
	MinLower, MinUpper   int
	MinNumeric           int
	MinSymbols           int
	AllowWhitespace      bool
}

Rules defines a ruleset by which a string can be validated. The errors it produces are english only, with some basic pluralization.

func (Rules) Errors

func (r Rules) Errors(toValidate string) authboss.ErrorList

Errors returns an array of errors for each validation error that is present in the given string. Returns nil if there are no errors.

func (Rules) IsValid

func (r Rules) IsValid(toValidate string) bool

IsValid checks toValidate to make sure it's valid according to the rules.

func (Rules) Rules

func (r Rules) Rules() []string

Rules returns an array of strings describing the rules.

type SMTPMailer

type SMTPMailer struct {
	Server string
	Auth   smtp.Auth
	// contains filtered or unexported fields
}

SMTPMailer uses smtp to actually send e-mails

func NewSMTPMailer

func NewSMTPMailer(server string, auth smtp.Auth) *SMTPMailer

NewSMTPMailer creates an SMTP Mailer to send emails with. An example usage might be something like:

NewSMTPMailer("smtp.gmail.com", smtp.PlainAuth("", "admin@yoursite.com", "password", "smtp.gmail.com"))

func (SMTPMailer) Send

func (s SMTPMailer) Send(ctx context.Context, mail authboss.Email) error

Send an e-mail

type UserValues

type UserValues struct {
	HTTPFormValidator

	PID      string
	Password string

	Arbitrary map[string]string
}

UserValues from the login form

func (UserValues) GetPID

func (u UserValues) GetPID() string

GetPID from the values

func (UserValues) GetPassword

func (u UserValues) GetPassword() string

GetPassword from the values

func (UserValues) GetValues

func (u UserValues) GetValues() map[string]string

GetValues from the form.