view

type AllAuthenticators []Authenticator

type AnyAuthenticator []Authenticator

type Aside struct {
	ViewBaseWithId
	Class   string
	Style   string
	Content View
}

type Authenticator interface {
	// Authenticate returns the auth result in ok,
	// err is used for real errors not negative authentication
	Authenticate(ctx *Context) (ok bool, err error)
}

type BasicAuth struct {
	Realm        string
	UserPassword map[string]string
}

type BoolAuth bool

type Button struct {
	ViewBaseWithId
	Name           string
	Class          string
	Disabled       bool
	TabIndex       int
	OnClick        string
	OnClickConfirm string // Will add a confirmation dialog for onclick
	Content        View   // Only used when Submit is false
}

type CSRFProtector interface {
	ExtraFormField() View
	Validate(ctx *Context) (ok bool, err error)
}

type CachedView struct {
	ViewBaseWithId
	Content  View
	Duration time.Duration
	// contains filtered or unexported fields
}

type Canvas struct {
	ViewBaseWithId
	Class  string
	Width  int
	Height int
}

type Checkbox struct {
	ViewBaseWithId
	Name     string
	Label    string
	Checked  bool
	Disabled bool
	Class    string
}

type Comment string

type Configuration struct {
	ListenAndServeAt           string
	IsProductionServer         bool // IsProductionServer will be set to true if localhost resolves to one of ProductionServerIPs
	ProductionServerIPs        []string
	TemplateSystem             templatesystem.Implementation
	Page                       PageConfiguration
	Form                       FormConfiguration
	LabeledModelViewLabelClass string
	LabeledModelViewValueClass string
	DisableCachedViews         bool
	BaseDirs                   []string
	StaticDirs                 []string
	TemplateDirs               []string
	RedirectSubdomains         []string // Exapmle: "www"
	SiteName                   string
	CookieSecret               string
	SessionTracker             SessionTracker
	SessionDataStore           SessionDataStore
	OnPreAuth                  func(ctx *Context) error
	GlobalAuth                 Authenticator // Will allways be used before all other authenticators
	FallbackAuth               Authenticator // Will be used when no other authenticator is defined for the view
	NamedAuthenticators        map[string]Authenticator
	LoginSignupPage            **Page
	// Middlewares               []Middleware
	Debug struct {
		ListenAndServeAt string
		Mode             bool // Will be set to true if IsProductionServer is false
		LogPaths         bool
		LogRedirects     bool
	}
	// contains filtered or unexported fields
}

type ContactFormModel struct {
	Name    model.String `view:"label=Your name" model:"maxlen=40"`
	Email   model.Email  `view:"label=Your email address" model:"required|maxlen=40"`
	Subject model.String `view:"label=Subject" model:"maxlen=40"`
	Message model.Text   `view:"label=Your message|cols=40|rows=10" model:"required"`
}

type Context struct {
	Request  *Request
	Response *Response
	Session  *Session

	// View that responds to the HTTP request
	RespondingView View

	// Arguments parsed from the URL path
	URLArgs []string

	// Custom response wide data that can be set by the application
	Data      interface{}
	DebugData interface{}
}

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

type CookieSessionTracker struct {
}

type Div struct {
	ViewBaseWithId
	Class   string
	Style   string
	Content View
	OnClick string
}

type DummyImage struct {
	ViewBaseWithId
	Class           string
	Width           int
	Height          int
	BackgroundColor string
	ForegroundColor string
	Text            string
}

type DynamicView func(ctx *Context) (view View, err error)

type EscapeStringsListModel []string

type EscapeStringsTableModel [][]string

type FileInput struct {
	ViewBaseWithId
	Class    string
	Name     string
	Disabled bool
}

type FileUploadFormModel struct {
	File model.File
}

type Forbidden string

type Form struct {
	ViewBaseWithId
	Class  string
	Style  string
	Action string // Default is "." plus any URL params
	Method string // Default is POST
	// If there are multiple forms on one page, then every form
	// needs a unique FormID, because the POST request with the form
	// data is made to the same URL or the page.
	// FormID can be empty if there is only one form on a page,
	// but it's good practice to always assign a FormID, because then
	// forms later added to the page won't lead to conflicts.
	FormID           string
	CSRFProtector    CSRFProtector
	Layout           FormLayout           // Config.Form.DefaultLayout will be used if nil
	FieldControllers FormFieldControllers // Config.Form.DefaultFieldControllers will be used in nil

	// GetModel returns the data-model used to create the form fields
	// and will receive changes from a form submit.
	// Thus, the model must be setable by reflection.
	// Be careful to not return the same model object at every call,
	// because the changed model from a submit will then be re-used
	// at a later form display which is usually not wanted.
	// Use the wrapper function FormModel() only when the form is
	// embedded in a DynamicView and the model argument is dynamically
	// created per View render.
	GetModel GetFormModelFunc

	// ModelFieldAuth maps a field selector to an Authenticator.
	// Fields that match the selector will only be displayed if the
	// Authenticator returns true.
	ModelFieldAuth map[string]Authenticator

	/*
		OnSubmit is called after the form was submitted by the user
		and did not contain any validation errors.
		If the OnSubmit result err is nil and the redirect result or Form.Redirect
		is not nil, then a HTTP redirect will be issued.
		Else if the OnSubmit result message is not empty, it will be displayed
		in the form regardless of the result err.
		If the results message and err are nil, then Form.SuccessMessage
		will be	displayed in the form.
		If the result err is not nil and message is empty, then err will be
		displayed in the form. Else message will be displayed.
		This can be used to return a readable error message for the user
		via message and an internal error for logging via err.
	*/
	OnSubmit OnFormSubmitFunc

	// OnValidationError is called when the form model failed to validate.
	OnValidationError OnFormValidationErrorFunc

	// NewFieldInput is a hook that will be called instead of FieldFactory.NewInput
	// if not nil. Can be used for form specific alterations to the form layout.
	NewFieldInput func(withLabel bool, metaData *model.MetaData, form *Form) (View, error)

	ModelMaxDepth            int      // if zero, no depth limit
	ExcludedFields           []string // Use point notation for nested fields. In case of arrays/slices use wildcards
	HiddenFields             []string // Use point notation for nested fields. In case of arrays/slices use wildcards
	DisabledFields           []string // Use point notation for nested fields
	RequiredFields           []string // Also available as static struct field tag. Use point notation for nested fields
	Labels                   map[string]string
	FieldDescriptions        map[string]string
	InputSizes               map[string]int
	ErrorMessageClass        string // If empty, Config.Form.DefaultErrorMessageClass will be used
	SuccessMessageClass      string // If empty, Config.Form.DefaultSuccessMessageClass will be used
	FieldDescriptionClass    string
	GeneralErrorOnFieldError bool
	RequiredMarker           View // If nil, Config.Form.DefaultRequiredMarker will be used
	SuccessMessage           string
	SubmitButtonText         string
	SubmitButtonClass        string
	SubmitButtonConfirm      string // Will add a confirmation dialog for onclick
	Redirect                 URL    // 302 redirect after successful OnSubmit()
	ShowRefIDs               bool
	Enctype                  string
}

type FormConfiguration struct {
	DefaultLayout                   FormLayout
	DefaultCSRFProtector            CSRFProtector
	DefaultErrorMessageClass        string
	DefaultSuccessMessageClass      string
	DefaultSubmitButtonClass        string
	DefaultFieldDescriptionClass    string
	StandardFormLayoutDivClass      string
	DefaultSubmitButtonText         string
	GeneralErrorMessageOnFieldError string
	DefaultRequiredMarker           View
	DefaultFieldControllers         FormFieldControllers
}

type FormFieldController interface {
	// Supports returns if this controller supports a model with the given metaData.
	Supports(metaData *model.MetaData, form *Form) bool

	// NewInput creates a new form field input view for the model metaData.
	NewInput(withLabel bool, metaData *model.MetaData, form *Form) (input View, err error)

	// SetValue sets the value of the model from HTTP POST form data.
	SetValue(value string, ctx *Context, metaData *model.MetaData, form *Form) error
}

type FormFieldControllers []FormFieldController

type FormLayout interface {
	GetDefaultInputSize(metaData *model.MetaData) int

	BeginFormContent(form *Form, ctx *Context, formContent *Views) error
	// SubmitSuccess will be called before EndFormContent if there were no
	// validation errors of the posted form data and Form.OnSubmit has
	// not returned an error.
	SubmitSuccess(message string, form *Form, ctx *Context, formContent *Views) error
	// SubmitError will be called before EndFormContent if there were no
	// validation errors of the posted form data and Form.OnSubmit has
	// returned an error.
	SubmitError(message string, form *Form, ctx *Context, formContent *Views) error
	EndFormContent(fieldValidationErrs, generalValidationErrs []error, form *Form, ctx *Context, formContent *Views) error

	BeginNamedFields(namedFields *model.MetaData, form *Form, ctx *Context, formContent *Views) error
	NamedField(field *model.MetaData, validationErr error, form *Form, ctx *Context, formContent *Views) error
	EndNamedFields(namedFields *model.MetaData, validationErr error, form *Form, ctx *Context, formContent *Views) error

	BeginIndexedFields(indexedFields *model.MetaData, form *Form, ctx *Context, formContent *Views) error
	IndexedField(field *model.MetaData, validationErr error, form *Form, ctx *Context, formContent *Views) error
	EndIndexedFields(indexedFields *model.MetaData, validationErr error, form *Form, ctx *Context, formContent *Views) error

	NewHiddenInput(metaData *model.MetaData, form *Form) (View, error)
	NewTableHeader(metaData *model.MetaData, form *Form) (View, error)
	NewFieldDescrtiption(description string, form *Form) View
	NewFieldErrorMessage(message string, metaData *model.MetaData, form *Form) View
	NewGeneralErrorMessage(message string, form *Form) View
	NewSuccessMessage(message string, form *Form) View
	NewSubmitButton(text, confirmationMessage string, form *Form) View
	NewAddButton(onclick string, form *Form) View
	NewRemoveButton(onclick string, form *Form) View
	NewUpButton(disabled bool, onclick string, form *Form) View
	NewDownButton(disabled bool, onclick string, form *Form) View
}

type Format struct {
	ViewBase
	Text   string
	Args   []interface{}
	Escape bool
}

type FrontController func(content View) ViewWithURL

type GetFormModelFunc func(form *Form, ctx *Context) (model interface{}, err error)

type GetModelIteratorFunc func(ctx *Context) model.Iterator

type GetModelIteratorViewFunc func(ctx *Context, model interface{}) (view View, err error)

type GetTemplateContextFunc func(ctx *Context) (context interface{}, err error)

type HTML string

type HTMLStringsListModel []string

type HTMLStringsTableModel [][]string

type HiddenInput struct {
	ViewBaseWithId
	Name  string
	Value string
}

type If struct {
	ViewBaseWithId
	Condition   bool
	Content     View
	ElseContent View
}

type Iframe struct {
	ViewBaseWithId
	Class        string
	Width        int
	Height       int
	Border       int
	Scrolling    bool
	MarginWidth  int
	MarginHeight int
	Seamless     bool
	URL          string
}

type Image struct {
	ViewBaseWithId
	Class  string
	URL    URL    // If URL is set, then Src will be ignored
	Src    string // String URL of the image, used when URL is nil
	Width  int
	Height int
	Title  string
}

type IndexedStringsSelectModel struct {
	Options []string
	Index   int
}

type IterateChildrenCallback func(parent View, child View) (next bool)

type JQueryDialog struct {
	Div
	Title     string
	AutoOpen  bool
	CloseText string
}

type Label struct {
	ViewBaseWithId
	Class   string
	For     View
	Content View
}

type LabeledModelView struct {
	ViewBase
	Model          interface{}
	Labels         map[string]string
	ExcludedFields []string
	HideEmpty      bool
}

type Link struct {
	ViewBaseWithId
	Class     string
	Model     LinkModel
	NewWindow bool
}

type LinkModel interface {
	URL
	LinkContent(ctx *Context) View
	LinkTitle(ctx *Context) string
	LinkRel(ctx *Context) string
}

type List struct {
	ViewBaseWithId
	Model       ListModel
	Ordered     bool
	OrderOffset uint
	Class       string
}

type ListModel interface {
	NumItems() int
	ItemView(index int, ctx *Context) (view View, err error)
}

type Menu struct {
	ViewBaseWithId
	Class           string
	ItemClass       string
	ActiveItemClass string
	BetweenItems    string
	Items           []LinkModel
	Reverse         bool
}

type Middleware interface {
	PreRender(ctx *Context) (abort bool)
	PostRender(response *Response, html string, err error) (newHtml string, newErr error)
}

type ModalDialog struct {
	ViewBaseWithId
	Class   string
	Style   string
	Content View
}

type ModelBlobController struct{}

type ModelBoolController struct{}

type ModelChoiceController struct {
	SetModelValueControllerBase
}

type ModelDateController struct {
	SetModelValueControllerBase
}

type ModelDateTimeController struct {
	SetModelValueControllerBase
}

type ModelDynamicChoiceController struct {
	SetModelValueControllerBase
}

type ModelEmailController struct {
	SetModelValueControllerBase
}

type ModelFileController struct{}

type ModelFloatController struct {
	SetModelValueControllerBase
}

type ModelIntController struct {
	SetModelValueControllerBase
}

type ModelIteratorTableView struct {
	ViewBase
	Class             string
	Caption           string
	GetModelIterator  GetModelIteratorFunc
	GetHeaderRowViews func(ctx *Context) (views Views, err error)
	GetRowViews       func(row int, rowModel interface{}, ctx *Context) (views Views, err error)
	// contains filtered or unexported fields
}

type ModelIteratorView struct {
	ViewBase
	GetModelIterator     GetModelIteratorFunc
	GetModelIteratorView GetModelIteratorViewFunc // nil Views will be ignored
}

type ModelMultipleChoiceController struct{}

type ModelPasswordController struct {
	SetModelValueControllerBase
}

type ModelPhoneController struct {
	SetModelValueControllerBase
}

type ModelStringController struct {
	SetModelValueControllerBase
}

type ModelTextController struct {
	SetModelValueControllerBase
}

type ModelUrlController struct {
	SetModelValueControllerBase
}

type MongoRefController struct {
	Selector        string // Empty string matches all selectors
	OptionsIterator model.Iterator
	// GetLabel returns the label of a referenced document.
	// If GetLabel is nil, then the String() method of
	// the doc will be used.
	GetLabel func(doc interface{}) string
}

type MultiViewsListModel []Views

type NotFound string

type NotFoundView struct {
	ViewBase
	Message string
}

type OnFormSubmitFunc func(form *Form, formModel interface{}, ctx *Context) (message string, redirect URL, err error)

type OnFormValidationErrorFunc func(form *Form, formModel interface{}, fieldValidationErrors, generalValidationErrors []error) (revalidate bool)

type Page struct {
	Template

	// Called before any other function when rendering the page
	OnPreRender func(page *Page, ctx *Context) (err error)

	// Writes the head title tag
	Title Renderer

	// Writes the head meta description tag
	MetaDescription Renderer

	// Content of the head meta viewport tag,
	// Config.Page.DefaultMetaViewport will be used if ""
	MetaViewport string

	// Write additional HTML head content
	AdditionalHead Renderer

	// Write head content before the stylesheet link
	PreCSS Renderer

	// stylesheet link URL
	CSS URL

	// Write head content after the stylesheet link
	PostCSS Renderer

	// Write scripts as last element of the HTML head
	HeadScripts Renderer

	// HTML body content. Will be wrapped by a div with class="container"
	Content View

	// Write scripts after body content
	Scripts Renderer

	// That way of linking to favicons my be removed in the future:
	Favicon16x16URL   string
	Favicon57x57URL   string
	Favicon72x72URL   string
	Favicon114x114URL string
	Favicon129x129URL string
	// contains filtered or unexported fields
}

type PageConfiguration struct {
	Template              string
	DefaultAdditionalHead Renderer // will be called after WriteTitle
	DefaultCSS            string
	DefaultMetaViewport   string
	DefaultHeadScripts    Renderer      // write scripts as last element of the HTML head
	DefaultScripts        Renderer      // will be called if Page.WriteScripts is nil
	PostScripts           Renderer      // will always be called after Page.WriteScripts
	DefaultAuth           Authenticator // Will be used for pages with Page.NeedsAuth == true
}

type PageLink struct {
	Page    **Page
	Content View
	Title   string
	Rel     string
}

type Paragraph struct {
	ViewBaseWithId
	Class   string
	Content View
}

type PermanentRedirect string

type Redirect string

type RedirectView struct {
	ViewBase
	URL       string
	Permanent bool
}

type Render func(ctx *Context) error

type RenderView func(ctx *Context) error

type Renderer interface {
	Render(ctx *Context) error
}

type Renderers []Renderer

type Request struct {
	*http.Request

	Params map[string]string
	// contains filtered or unexported fields
}

type Response struct {
	Session *Session

	// XML allowes the Response to be used as utils.XMLWriter
	XML *utils.XMLWriter
	// contains filtered or unexported fields
}

type Select struct {
	ViewBaseWithId
	Model    SelectModel
	Name     string
	Size     int // 0 shows all items, 1 shows a dropdownbox, other values show size items
	Class    string
	Disabled bool
}

type SelectModel interface {
	NumOptions() int
	Value(index int) string
	Selected(index int) bool
	Disabled(index int) bool
	RenderItem(index int, ctx *Context) (err error)
	IterateChildren(parent *Select, callback func(parent View, child View) (next bool))
}

type Session struct {
	Tracker   SessionTracker
	DataStore SessionDataStore
	Ctx       *Context

	/*
		Cached user object of the session.
		User won't be set automatically, use user.OfSession(context) instead.

		Example for setting it automatically for every request:

			import "github.com/ungerik/go-start/user"

			Config.OnPreAuth = func(ctx *Context) error {
				user.OfSession(context) // Sets context.User
				return nil
			}
	*/
	User interface{}
	// contains filtered or unexported fields
}

type SessionDataStore interface {
	Get(ctx *Context, data interface{}) (ok bool, err error)
	Set(ctx *Context, data interface{}) (err error)
	Delete(ctx *Context) (err error)
}

type SessionTracker interface {
	ID(ctx *Context) (id string, ok bool)
	SetID(ctx *Context, id string)
	DeleteID(ctx *Context)
}

type SetModelValueControllerBase struct{}

type ShortTag struct {
	ViewBase
	Tag     string
	Class   string
	Attribs map[string]string
	Content View
}

type Span struct {
	ViewBaseWithId
	Class   string
	Content View
}

type StandardFormLayout struct {
	DefaultInputSize      int
	DefaultTableInputSize int
}

type StaticFile struct {
	ViewBase
	Filename       string // Will set file extension at ContentType
	ContentTypeExt string
	// contains filtered or unexported fields
}

type StringLink struct {
	Url     string
	Content View   // If nil, then self.LinkTitle() will be used
	Title   string // If "", then self.URL will be used
	Rel     string
}

type StringURL string

type StringsSelectModel struct {
	Options        []string
	SelectedOption string
}

type SubmitButton struct {
	ViewBaseWithId
	Name           string
	Value          interface{}
	Class          string
	Disabled       bool
	TabIndex       int
	OnClick        string
	OnClickConfirm string // Will add a confirmation dialog for onclick
}

type Table struct {
	ViewBaseWithId
	Model     TableModel
	Class     string
	Caption   string
	HeaderRow bool
}

type TableModel interface {
	Rows() int
	Columns() int
	CellView(row int, column int, ctx *Context) (view View, err error)
}

type Tag struct {
	ViewBaseWithId
	Tag        string
	Content    View
	Class      string
	Attribs    map[string]string
	ExtraClose bool
}

type Template struct {
	ViewBase
	Filename       string // Will set file extension at ContentType
	Text           string
	ContentTypeExt string
	GetContext     GetTemplateContextFunc
	TemplateSystem templatesystem.Implementation // If nil, self.App.Config.TemplateSystem is used
	// contains filtered or unexported fields
}

type TextArea struct {
	ViewBaseWithId
	Text        string
	Name        string
	Cols        int
	Rows        int
	Readonly    bool
	Disabled    bool
	TabIndex    int
	Class       string
	Placeholder string
}

type TextField struct {
	ViewBaseWithId
	Text        string
	Name        string
	Size        int
	MaxLength   int
	Type        TextFieldType
	Readonly    bool
	Disabled    bool
	TabIndex    int
	Class       string
	Placeholder string
}

type TextFieldType int

type TextPreview struct {
	ViewBase
	PlainText   string
	MaxLength   int
	ShortLength int // Shortened length if len(Text) > MaxLength. If zero, MaxLength will be used
	MoreLink    LinkModel
}

type URL interface {
	URL(ctx *Context) string
}

type URLLink struct {
	Url     URL
	Content View   // If is nil, then self.LinkTitle() will be used
	Title   string // If is "", then self.URL will be used
	Rel     string
}

type URLWithArgs struct {
	Url  URL
	Args []string
}

type Video struct {
	ViewBaseWithId
	Class  string
	URL    string
	Width  int
	Height int
}

type View interface {
	Init(thisView View)
	ID() string
	IterateChildren(callback IterateChildrenCallback)
	// Everything written to out will be discarded if there was an error
	// out.Write() is not expected to return errors like bytes.Buffer
	Render(ctx *Context) (err error)
}

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

type ViewBaseWithId struct {
	ViewBase
	// contains filtered or unexported fields
}

type ViewPath struct {
	Name   string
	Args   int
	View   View
	Auth   Authenticator
	NoAuth URL
	Sub    []ViewPath // Only allowed when View is a Page or nil
}

type ViewURLWrapper struct {
	View View
	// contains filtered or unexported fields
}