beego: github.com/astaxie/beego Index | Files | Directories

package beego

import "github.com/astaxie/beego"

Package beego provide a MVC framework beego: an open-source, high-performance, modular, full-stack web framework

It is used for rapid development of RESTful APIs, web apps and backend services in Go. beego is inspired by Tornado, Sinatra and Flask with the added benefit of some Go-specific features such as interfaces and struct embedding.

package main
import "github.com/astaxie/beego"

func main() {
 beego.Run()
}

more information: http://beego.me

Index

Package Files

admin.go adminui.go app.go beego.go config.go controller.go doc.go error.go filter.go flash.go hooks.go log.go mime.go namespace.go parser.go policy.go router.go staticfile.go template.go templatefunc.go tree.go

Constants

const (
    // VERSION represent beego web framework version.
    VERSION = "1.9.0"

    // DEV is for develop
    DEV = "dev"
    // PROD is for production
    PROD = "prod"
)
const (
    LevelEmergency = iota
    LevelAlert
    LevelCritical
    LevelError
    LevelWarning
    LevelNotice
    LevelInformational
    LevelDebug
)

Log levels to control the logging output.

const (
    BeforeStatic = iota
    BeforeRouter
    BeforeExec
    AfterExec
    FinishRouter
)

default filter execution points

Variables

var (
    // BConfig is the default config for Application
    BConfig *Config
    // AppConfig is the instance of Config, store the config information from file
    AppConfig *beegoAppConfig
    // AppPath is the absolute path to the app
    AppPath string
    // GlobalSessions is the instance for the session manager
    GlobalSessions *session.Manager
)
var (
    // ErrAbort custom error when user stop request handler manually.
    ErrAbort = errors.New("User stop run")
    // GlobalControllerRouter store comments with controller. pkgpath+controller:comments
    GlobalControllerRouter = make(map[string][]ControllerComments)
)
var BeeLogger = logs.GetBeeLogger()

BeeLogger references the used application logger.

var ErrorMaps = make(map[string]*errorInfo, 10)

ErrorMaps holds map of http handlers for each error string. there is 10 kinds default error(40x and 50x)

var FilterMonitorFunc func(string, string, time.Duration, string, int) bool

FilterMonitorFunc is default monitor filter when admin module is enable. if this func returns, admin module records qbs for this request by condition of this function logic. usage:

func MyFilterMonitor(method, requestPath string, t time.Duration, pattern string, statusCode int) bool {
 	if method == "POST" {
		return false
 	}
 	if t.Nanoseconds() < 100 {
		return false
 	}
 	if strings.HasPrefix(requestPath, "/astaxie") {
		return false
 	}
 	return true
}
beego.FilterMonitorFunc = MyFilterMonitor.

func AddAPPStartHook Uses

func AddAPPStartHook(hf ...hookfunc)

AddAPPStartHook is used to register the hookfunc The hookfuncs will run in beego.Run() such as initiating session , starting middleware , building template, starting admin control and so on.

func AddFuncMap Uses

func AddFuncMap(key string, fn interface{}) error

AddFuncMap let user to register a func in the template.

func AddNamespace Uses

func AddNamespace(nl ...*Namespace)

AddNamespace register Namespace into beego.Handler support multi Namespace

func AddTemplateExt Uses

func AddTemplateExt(ext string)

AddTemplateExt add new extension for template.

func AddViewPath Uses

func AddViewPath(viewPath string) error

AddViewPath adds a new path to the supported view paths. Can later be used by setting a controller ViewPath to this folder will panic if called after beego.Run()

func Alert Uses

func Alert(v ...interface{})

Alert logs a message at alert level.

func AssetsCSS Uses

func AssetsCSS(text string) template.HTML

AssetsCSS returns stylesheet link tag with src string.

func AssetsJs Uses

func AssetsJs(text string) template.HTML

AssetsJs returns script tag with src string.

func BuildTemplate Uses

func BuildTemplate(dir string, files ...string) error

BuildTemplate will build all template files in a directory. it makes beego can render any template file in view directory.

func Compare Uses

func Compare(a, b interface{}) (equal bool)

Compare is a quick and dirty comparison function. It will convert whatever you give it to strings and see if the two values are equal. Whitespace is trimmed. Used by the template parser as "eq".

func CompareNot Uses

func CompareNot(a, b interface{}) (equal bool)

CompareNot !Compare

func Critical Uses

func Critical(v ...interface{})

Critical logs a message at critical level.

func Date Uses

func Date(t time.Time, format string) string

Date takes a PHP like date func to Go's time format.

func DateFormat Uses

func DateFormat(t time.Time, layout string) (datestring string)

DateFormat takes a time and a layout string and returns a string with the formatted date. Used by the template parser as "dateformat"

func DateParse Uses

func DateParse(dateString, format string) (time.Time, error)

DateParse Parse Date use PHP time format.

func Debug Uses

func Debug(v ...interface{})

Debug logs a message at debug level.

func Emergency Uses

func Emergency(v ...interface{})

Emergency logs a message at emergency level.

func Error Uses

func Error(v ...interface{})

Error logs a message at error level.

func ExceptMethodAppend Uses

func ExceptMethodAppend(action string)

ExceptMethodAppend to append a slice's value into "exceptMethod", for controller's methods shouldn't reflect to AutoRouter

func Exception Uses

func Exception(errCode uint64, ctx *context.Context)

Exception Write HttpStatus with errCode and Exec error handler if exist.

func ExecuteTemplate Uses

func ExecuteTemplate(wr io.Writer, name string, data interface{}) error

ExecuteTemplate applies the template with name to the specified data object, writing the output to wr. A template will be executed safely in parallel.

func ExecuteViewPathTemplate Uses

func ExecuteViewPathTemplate(wr io.Writer, name string, viewPath string, data interface{}) error

ExecuteViewPathTemplate applies the template with name and from specific viewPath to the specified data object, writing the output to wr. A template will be executed safely in parallel.

func GetConfig Uses

func GetConfig(returnType, key string, defaultVal interface{}) (value interface{}, err error)

GetConfig get the Appconfig

func HTML2str Uses

func HTML2str(html string) string

HTML2str returns escaping text convert from html.

func HasTemplateExt Uses

func HasTemplateExt(paths string) bool

HasTemplateExt return this path contains supported template extension of beego or not.

func Htmlquote Uses

func Htmlquote(text string) string

Htmlquote returns quoted html string.

func Htmlunquote Uses

func Htmlunquote(text string) string

Htmlunquote returns unquoted html string.

func Info Uses

func Info(v ...interface{})

Info compatibility alias for Warning()

func Informational Uses

func Informational(v ...interface{})

Informational logs a message at info level.

func InitBeegoBeforeTest Uses

func InitBeegoBeforeTest(appConfigPath string)

InitBeegoBeforeTest is for test package init

func LoadAppConfig Uses

func LoadAppConfig(adapterName, configPath string) error

LoadAppConfig allow developer to apply a config file

func MapGet Uses

func MapGet(arg1 interface{}, arg2 ...interface{}) (interface{}, error)

MapGet getting value from map by keys usage: Data["m"] = map[string]interface{} {

"a": 1,
"1": map[string]float64{
    "c": 4,
},

}

{{ map_get m "a" }} // return 1 {{ map_get m 1 "c" }} // return 4

func NotNil Uses

func NotNil(a interface{}) (isNil bool)

NotNil the same as CompareNot

func Notice Uses

func Notice(v ...interface{})

Notice logs a message at notice level.

func ParseForm Uses

func ParseForm(form url.Values, obj interface{}) error

ParseForm will parse form values to struct via tag.

func Policy Uses

func Policy(pattern, method string, policy ...PolicyFunc)

Policy Register new policy in beego

func PrintTree Uses

func PrintTree() map[string]interface{}

PrintTree prints all registered routers.

func RenderForm Uses

func RenderForm(obj interface{}) template.HTML

RenderForm will render object to form html. obj must be a struct pointer.

func Run Uses

func Run(params ...string)

Run beego application. beego.Run() default run on HttpPort beego.Run("localhost") beego.Run(":8089") beego.Run("127.0.0.1:8089")

func SetLevel Uses

func SetLevel(l int)

SetLevel sets the global log level used by the simple logger.

func SetLogFuncCall Uses

func SetLogFuncCall(b bool)

SetLogFuncCall set the CallDepth, default is 3

func SetLogger Uses

func SetLogger(adaptername string, config string) error

SetLogger sets a new logger.

func Str2html Uses

func Str2html(raw string) template.HTML

Str2html Convert string to template.HTML type.

func Substr Uses

func Substr(s string, start, length int) string

Substr returns the substr from start to length.

func TestBeegoInit Uses

func TestBeegoInit(ap string)

TestBeegoInit is for test package init

func Trace Uses

func Trace(v ...interface{})

Trace logs a message at trace level. compatibility alias for Warning()

func URLFor Uses

func URLFor(endpoint string, values ...interface{}) string

URLFor returns url string with another registered controller handler with params.

	usage:

	URLFor(".index")
	print URLFor("index")
 router /login
	print URLFor("login")
	print URLFor("login", "next","/"")
 router /profile/:username
	print UrlFor("profile", ":username","John Doe")
	result:
	/
	/login
	/login?next=/
	/user/John%20Doe

 more detail http://beego.me/docs/mvc/controller/urlbuilding.md

func Warn Uses

func Warn(v ...interface{})

Warn compatibility alias for Warning()

func Warning Uses

func Warning(v ...interface{})

Warning logs a message at warning level.

type App Uses

type App struct {
    Handlers *ControllerRegister
    Server   *http.Server
}

App defines beego application with a new PatternServeMux.

var (
    // BeeApp is an application instance
    BeeApp *App
)

func AddTemplateEngine Uses

func AddTemplateEngine(extension string, fn templatePreProcessor) *App

AddTemplateEngine add a new templatePreProcessor which support extension

func Any Uses

func Any(rootpath string, f FilterFunc) *App

Any used to register router for all methods usage:

beego.Any("/api", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func AutoPrefix Uses

func AutoPrefix(prefix string, c ControllerInterface) *App

AutoPrefix adds controller handler to BeeApp with prefix. it's same to App.AutoRouterWithPrefix. if beego.AutoPrefix("/admin",&MainContorlller{}) and MainController has methods List and Page, visit the url /admin/main/list to exec List function or /admin/main/page to exec Page function.

func AutoRouter Uses

func AutoRouter(c ControllerInterface) *App

AutoRouter adds defined controller handler to BeeApp. it's same to App.AutoRouter. if beego.AddAuto(&MainContorlller{}) and MainController has methods List and Page, visit the url /main/list to exec List function or /main/page to exec Page function.

func DelStaticPath Uses

func DelStaticPath(url string) *App

DelStaticPath removes the static folder setting in this url pattern in beego application.

func Delete Uses

func Delete(rootpath string, f FilterFunc) *App

Delete used to register router for Delete method usage:

beego.Delete("/api", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func ErrorController Uses

func ErrorController(c ControllerInterface) *App

ErrorController registers ControllerInterface to each http err code string. usage:

beego.ErrorController(&controllers.ErrorController{})

func ErrorHandler Uses

func ErrorHandler(code string, h http.HandlerFunc) *App

ErrorHandler registers http.HandlerFunc to each http err code string. usage:

beego.ErrorHandler("404",NotFound)
beego.ErrorHandler("500",InternalServerError)

func Get Uses

func Get(rootpath string, f FilterFunc) *App

Get used to register router for Get method usage:

beego.Get("/", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func Handler Uses

func Handler(rootpath string, h http.Handler, options ...interface{}) *App

Handler used to register a Handler router usage:

beego.Handler("/api", http.HandlerFunc(func (w http.ResponseWriter, r *http.Request) {
      fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
}))
func Head(rootpath string, f FilterFunc) *App

Head used to register router for Head method usage:

beego.Head("/api", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func Include Uses

func Include(cList ...ControllerInterface) *App

Include will generate router file in the router/xxx.go from the controller's comments usage: beego.Include(&BankAccount{}, &OrderController{},&RefundController{},&ReceiptController{}) type BankAccount struct{

beego.Controller

}

register the function func (b *BankAccount)Mapping(){

b.Mapping("ShowAccount" , b.ShowAccount)
b.Mapping("ModifyAccount", b.ModifyAccount)

}

//@router /account/:id [get] func (b *BankAccount) ShowAccount(){

//logic

}

//@router /account/:id [post] func (b *BankAccount) ModifyAccount(){

//logic

}

the comments @router url methodlist url support all the function Router's pattern methodlist [get post head put delete options *]

func InsertFilter Uses

func InsertFilter(pattern string, pos int, filter FilterFunc, params ...bool) *App

InsertFilter adds a FilterFunc with pattern condition and action constant. The pos means action constant including beego.BeforeStatic, beego.BeforeRouter, beego.BeforeExec, beego.AfterExec and beego.FinishRouter. The bool params is for setting the returnOnOutput value (false allows multiple filters to execute)

func NewApp Uses

func NewApp() *App

NewApp returns a new beego application.

func Options Uses

func Options(rootpath string, f FilterFunc) *App

Options used to register router for Options method usage:

beego.Options("/api", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func Patch Uses

func Patch(rootpath string, f FilterFunc) *App

Patch used to register router for Patch method usage:

beego.Patch("/api", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func Post Uses

func Post(rootpath string, f FilterFunc) *App

Post used to register router for Post method usage:

beego.Post("/api", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func Put Uses

func Put(rootpath string, f FilterFunc) *App

Put used to register router for Put method usage:

beego.Put("/api", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func RESTRouter Uses

func RESTRouter(rootpath string, c ControllerInterface) *App

RESTRouter adds a restful controller handler to BeeApp. its' controller implements beego.ControllerInterface and defines a param "pattern/:objectId" to visit each resource.

func Router Uses

func Router(rootpath string, c ControllerInterface, mappingMethods ...string) *App

Router adds a patterned controller handler to BeeApp. it's an alias method of App.Router. usage:

simple router
beego.Router("/admin", &admin.UserController{})
beego.Router("/admin/index", &admin.ArticleController{})

regex router

beego.Router("/api/:id([0-9]+)", &controllers.RController{})

custom rules
beego.Router("/api/list",&RestController{},"*:ListFood")
beego.Router("/api/create",&RestController{},"post:CreateFood")
beego.Router("/api/update",&RestController{},"put:UpdateFood")
beego.Router("/api/delete",&RestController{},"delete:DeleteFood")

func SetStaticPath Uses

func SetStaticPath(url string, path string) *App

SetStaticPath sets static directory path and proper url pattern in beego application. if beego.SetStaticPath("static","public"), visit /static/* to load static file in folder "public".

func SetViewsPath Uses

func SetViewsPath(path string) *App

SetViewsPath sets view directory path in beego application.

func (*App) Run Uses

func (app *App) Run()

Run beego application.

type Config Uses

type Config struct {
    AppName             string //Application name
    RunMode             string //Running Mode: dev | prod
    RouterCaseSensitive bool
    ServerName          string
    RecoverPanic        bool
    RecoverFunc         func(*context.Context)
    CopyRequestBody     bool
    EnableGzip          bool
    MaxMemory           int64
    EnableErrorsShow    bool
    EnableErrorsRender  bool
    Listen              Listen
    WebConfig           WebConfig
    Log                 LogConfig
}

Config is the main struct for BConfig

type Controller Uses

type Controller struct {
    // context data
    Ctx  *context.Context
    Data map[interface{}]interface{}

    AppController interface{}

    // template data
    TplName        string
    ViewPath       string
    Layout         string
    LayoutSections map[string]string // the key is the section name and the value is the template name
    TplPrefix      string
    TplExt         string
    EnableRender   bool

    XSRFExpire int
    EnableXSRF bool

    // session
    CruSession session.Store
    // contains filtered or unexported fields
}

Controller defines some basic http request handler operations, such as http context, template and view, session and xsrf.

func (*Controller) Abort Uses

func (c *Controller) Abort(code string)

Abort stops controller handler and show the error data if code is defined in ErrorMap or code string.

func (*Controller) CheckXSRFCookie Uses

func (c *Controller) CheckXSRFCookie() bool

CheckXSRFCookie checks xsrf token in this request is valid or not. the token can provided in request header "X-Xsrftoken" and "X-CsrfToken" or in form field value named as "_xsrf".

func (*Controller) CustomAbort Uses

func (c *Controller) CustomAbort(status int, body string)

CustomAbort stops controller handler and show the error data, it's similar Aborts, but support status code and body.

func (*Controller) DelSession Uses

func (c *Controller) DelSession(name interface{})

DelSession removes value from session.

func (*Controller) Delete Uses

func (c *Controller) Delete()

Delete adds a request function to handle DELETE request.

func (*Controller) DestroySession Uses

func (c *Controller) DestroySession()

DestroySession cleans session data and session cookie.

func (*Controller) Finish Uses

func (c *Controller) Finish()

Finish runs after request function execution.

func (*Controller) Get Uses

func (c *Controller) Get()

Get adds a request function to handle GET request.

func (*Controller) GetBool Uses

func (c *Controller) GetBool(key string, def ...bool) (bool, error)

GetBool returns input value as bool or the default value while it's present and input is blank.

func (*Controller) GetControllerAndAction Uses

func (c *Controller) GetControllerAndAction() (string, string)

GetControllerAndAction gets the executing controller name and action name.

func (*Controller) GetFile Uses

func (c *Controller) GetFile(key string) (multipart.File, *multipart.FileHeader, error)

GetFile returns the file data in file upload field named as key. it returns the first one of multi-uploaded files.

func (*Controller) GetFiles Uses

func (c *Controller) GetFiles(key string) ([]*multipart.FileHeader, error)

GetFiles return multi-upload files files, err:=c.GetFiles("myfiles")

if err != nil {
	http.Error(w, err.Error(), http.StatusNoContent)
	return
}

for i, _ := range files {

//for each fileheader, get a handle to the actual file
file, err := files[i].Open()
defer file.Close()
if err != nil {
	http.Error(w, err.Error(), http.StatusInternalServerError)
	return
}
//create destination file making sure the path is writeable.
dst, err := os.Create("upload/" + files[i].Filename)
defer dst.Close()
if err != nil {
	http.Error(w, err.Error(), http.StatusInternalServerError)
	return
}
//copy the uploaded file to the destination file
if _, err := io.Copy(dst, file); err != nil {
	http.Error(w, err.Error(), http.StatusInternalServerError)
	return
}

}

func (*Controller) GetFloat Uses

func (c *Controller) GetFloat(key string, def ...float64) (float64, error)

GetFloat returns input value as float64 or the default value while it's present and input is blank.

func (*Controller) GetInt Uses

func (c *Controller) GetInt(key string, def ...int) (int, error)

GetInt returns input as an int or the default value while it's present and input is blank

func (*Controller) GetInt16 Uses

func (c *Controller) GetInt16(key string, def ...int16) (int16, error)

GetInt16 returns input as an int16 or the default value while it's present and input is blank

func (*Controller) GetInt32 Uses

func (c *Controller) GetInt32(key string, def ...int32) (int32, error)

GetInt32 returns input as an int32 or the default value while it's present and input is blank

func (*Controller) GetInt64 Uses

func (c *Controller) GetInt64(key string, def ...int64) (int64, error)

GetInt64 returns input value as int64 or the default value while it's present and input is blank.

func (*Controller) GetInt8 Uses

func (c *Controller) GetInt8(key string, def ...int8) (int8, error)

GetInt8 return input as an int8 or the default value while it's present and input is blank

func (*Controller) GetSecureCookie Uses

func (c *Controller) GetSecureCookie(Secret, key string) (string, bool)

GetSecureCookie returns decoded cookie value from encoded browser cookie values.

func (*Controller) GetSession Uses

func (c *Controller) GetSession(name interface{}) interface{}

GetSession gets value from session.

func (*Controller) GetString Uses

func (c *Controller) GetString(key string, def ...string) string

GetString returns the input value by key string or the default value while it's present and input is blank

func (*Controller) GetStrings Uses

func (c *Controller) GetStrings(key string, def ...[]string) []string

GetStrings returns the input string slice by key string or the default value while it's present and input is blank it's designed for multi-value input field such as checkbox(input[type=checkbox]), multi-selection.

func (*Controller) GetUint16 Uses

func (c *Controller) GetUint16(key string, def ...uint16) (uint16, error)

GetUint16 returns input as an uint16 or the default value while it's present and input is blank

func (*Controller) GetUint32 Uses

func (c *Controller) GetUint32(key string, def ...uint32) (uint32, error)

GetUint32 returns input as an uint32 or the default value while it's present and input is blank

func (*Controller) GetUint64 Uses

func (c *Controller) GetUint64(key string, def ...uint64) (uint64, error)

GetUint64 returns input value as uint64 or the default value while it's present and input is blank.

func (*Controller) GetUint8 Uses

func (c *Controller) GetUint8(key string, def ...uint8) (uint8, error)

GetUint8 return input as an uint8 or the default value while it's present and input is blank

func (*Controller) HandlerFunc Uses

func (c *Controller) HandlerFunc(fnname string) bool

HandlerFunc call function with the name

func (*Controller) Head Uses

func (c *Controller) Head()

Head adds a request function to handle HEAD request.

func (*Controller) Init Uses

func (c *Controller) Init(ctx *context.Context, controllerName, actionName string, app interface{})

Init generates default values of controller operations.

func (*Controller) Input Uses

func (c *Controller) Input() url.Values

Input returns the input data map from POST or PUT request body and query string.

func (*Controller) IsAjax Uses

func (c *Controller) IsAjax() bool

IsAjax returns this request is ajax or not.

func (*Controller) Mapping Uses

func (c *Controller) Mapping(method string, fn func())

Mapping the method to function

func (*Controller) Options Uses

func (c *Controller) Options()

Options adds a request function to handle OPTIONS request.

func (*Controller) ParseForm Uses

func (c *Controller) ParseForm(obj interface{}) error

ParseForm maps input data map to obj struct.

func (*Controller) Patch Uses

func (c *Controller) Patch()

Patch adds a request function to handle PATCH request.

func (*Controller) Post Uses

func (c *Controller) Post()

Post adds a request function to handle POST request.

func (*Controller) Prepare Uses

func (c *Controller) Prepare()

Prepare runs after Init before request function execution.

func (*Controller) Put Uses

func (c *Controller) Put()

Put adds a request function to handle PUT request.

func (*Controller) Redirect Uses

func (c *Controller) Redirect(url string, code int)

Redirect sends the redirection response to url with status code.

func (*Controller) Render Uses

func (c *Controller) Render() error

Render sends the response with rendered template bytes as text/html type.

func (*Controller) RenderBytes Uses

func (c *Controller) RenderBytes() ([]byte, error)

RenderBytes returns the bytes of rendered template string. Do not send out response.

func (*Controller) RenderString Uses

func (c *Controller) RenderString() (string, error)

RenderString returns the rendered template string. Do not send out response.

func (*Controller) SaveToFile Uses

func (c *Controller) SaveToFile(fromfile, tofile string) error

SaveToFile saves uploaded file to new path. it only operates the first one of mutil-upload form file field.

func (*Controller) ServeFormatted Uses

func (c *Controller) ServeFormatted()

ServeFormatted serve Xml OR Json, depending on the value of the Accept header

func (*Controller) ServeJSON Uses

func (c *Controller) ServeJSON(encoding ...bool)

ServeJSON sends a json response with encoding charset.

func (*Controller) ServeJSONP Uses

func (c *Controller) ServeJSONP()

ServeJSONP sends a jsonp response.

func (*Controller) ServeXML Uses

func (c *Controller) ServeXML()

ServeXML sends xml response.

func (*Controller) SessionRegenerateID Uses

func (c *Controller) SessionRegenerateID()

SessionRegenerateID regenerates session id for this session. the session data have no changes.

func (*Controller) SetSecureCookie Uses

func (c *Controller) SetSecureCookie(Secret, name, value string, others ...interface{})

SetSecureCookie puts value into cookie after encoded the value.

func (*Controller) SetSession Uses

func (c *Controller) SetSession(name interface{}, value interface{})

SetSession puts value into session.

func (*Controller) StartSession Uses

func (c *Controller) StartSession() session.Store

StartSession starts session and load old session data info this controller.

func (*Controller) StopRun Uses

func (c *Controller) StopRun()

StopRun makes panic of USERSTOPRUN error and go to recover function if defined.

func (*Controller) URLFor Uses

func (c *Controller) URLFor(endpoint string, values ...interface{}) string

URLFor does another controller handler in this request function. it goes to this controller method if endpoint is not clear.

func (*Controller) URLMapping Uses

func (c *Controller) URLMapping()

URLMapping register the internal Controller router.

func (*Controller) XSRFFormHTML Uses

func (c *Controller) XSRFFormHTML() string

XSRFFormHTML writes an input field contains xsrf token value.

func (*Controller) XSRFToken Uses

func (c *Controller) XSRFToken() string

XSRFToken creates a CSRF token string and returns.

type ControllerComments Uses

type ControllerComments struct {
    Method           string
    Router           string
    AllowHTTPMethods []string
    Params           []map[string]string
    MethodParams     []*param.MethodParam
}

ControllerComments store the comment for the controller method

type ControllerCommentsSlice Uses

type ControllerCommentsSlice []ControllerComments

ControllerCommentsSlice implements the sort interface

func (ControllerCommentsSlice) Len Uses

func (p ControllerCommentsSlice) Len() int

func (ControllerCommentsSlice) Less Uses

func (p ControllerCommentsSlice) Less(i, j int) bool

func (ControllerCommentsSlice) Swap Uses

func (p ControllerCommentsSlice) Swap(i, j int)

type ControllerInfo Uses

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

ControllerInfo holds information about the controller.

type ControllerInterface Uses

type ControllerInterface interface {
    Init(ct *context.Context, controllerName, actionName string, app interface{})
    Prepare()
    Get()
    Post()
    Delete()
    Put()
    Head()
    Patch()
    Options()
    Finish()
    Render() error
    XSRFToken() string
    CheckXSRFCookie() bool
    HandlerFunc(fn string) bool
    URLMapping()
}

ControllerInterface is an interface to uniform all controller handler.

type ControllerRegister Uses

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

ControllerRegister containers registered router rules, controller handlers and filters.

func NewControllerRegister Uses

func NewControllerRegister() *ControllerRegister

NewControllerRegister returns a new ControllerRegister.

func (*ControllerRegister) Add Uses

func (p *ControllerRegister) Add(pattern string, c ControllerInterface, mappingMethods ...string)

Add controller handler and pattern rules to ControllerRegister. usage:

default methods is the same name as method
Add("/user",&UserController{})
Add("/api/list",&RestController{},"*:ListFood")
Add("/api/create",&RestController{},"post:CreateFood")
Add("/api/update",&RestController{},"put:UpdateFood")
Add("/api/delete",&RestController{},"delete:DeleteFood")
Add("/api",&RestController{},"get,post:ApiFunc"
Add("/simple",&SimpleController{},"get:GetFunc;post:PostFunc")

func (*ControllerRegister) AddAuto Uses

func (p *ControllerRegister) AddAuto(c ControllerInterface)

AddAuto router to ControllerRegister. example beego.AddAuto(&MainContorlller{}), MainController has method List and Page. visit the url /main/list to execute List function /main/page to execute Page function.

func (*ControllerRegister) AddAutoPrefix Uses

func (p *ControllerRegister) AddAutoPrefix(prefix string, c ControllerInterface)

AddAutoPrefix Add auto router to ControllerRegister with prefix. example beego.AddAutoPrefix("/admin",&MainContorlller{}), MainController has method List and Page. visit the url /admin/main/list to execute List function /admin/main/page to execute Page function.

func (*ControllerRegister) AddMethod Uses

func (p *ControllerRegister) AddMethod(method, pattern string, f FilterFunc)

AddMethod add http method router usage:

AddMethod("get","/api/:id", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func (*ControllerRegister) Any Uses

func (p *ControllerRegister) Any(pattern string, f FilterFunc)

Any add all method usage:

Any("/api/:id", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func (*ControllerRegister) Delete Uses

func (p *ControllerRegister) Delete(pattern string, f FilterFunc)

Delete add delete method usage:

Delete("/api/:id", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func (*ControllerRegister) FindPolicy Uses

func (p *ControllerRegister) FindPolicy(cont *context.Context) []PolicyFunc

FindPolicy Find Router info for URL

func (*ControllerRegister) FindRouter Uses

func (p *ControllerRegister) FindRouter(context *beecontext.Context) (routerInfo *ControllerInfo, isFind bool)

FindRouter Find Router info for URL

func (*ControllerRegister) Get Uses

func (p *ControllerRegister) Get(pattern string, f FilterFunc)

Get add get method usage:

Get("/", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func (*ControllerRegister) Handler Uses

func (p *ControllerRegister) Handler(pattern string, h http.Handler, options ...interface{})

Handler add user defined Handler

func (*ControllerRegister) Head Uses

func (p *ControllerRegister) Head(pattern string, f FilterFunc)

Head add head method usage:

Head("/api/:id", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func (*ControllerRegister) Include Uses

func (p *ControllerRegister) Include(cList ...ControllerInterface)

Include only when the Runmode is dev will generate router file in the router/auto.go from the controller Include(&BankAccount{}, &OrderController{},&RefundController{},&ReceiptController{})

func (*ControllerRegister) InsertFilter Uses

func (p *ControllerRegister) InsertFilter(pattern string, pos int, filter FilterFunc, params ...bool) error

InsertFilter Add a FilterFunc with pattern rule and action constant. params is for:

1. setting the returnOnOutput value (false allows multiple filters to execute)
2. determining whether or not params need to be reset.

func (*ControllerRegister) Options Uses

func (p *ControllerRegister) Options(pattern string, f FilterFunc)

Options add options method usage:

Options("/api/:id", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func (*ControllerRegister) Patch Uses

func (p *ControllerRegister) Patch(pattern string, f FilterFunc)

Patch add patch method usage:

Patch("/api/:id", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func (*ControllerRegister) Post Uses

func (p *ControllerRegister) Post(pattern string, f FilterFunc)

Post add post method usage:

Post("/api", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func (*ControllerRegister) Put Uses

func (p *ControllerRegister) Put(pattern string, f FilterFunc)

Put add put method usage:

Put("/api/:id", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})

func (*ControllerRegister) ServeHTTP Uses

func (p *ControllerRegister) ServeHTTP(rw http.ResponseWriter, r *http.Request)

Implement http.Handler interface.

func (*ControllerRegister) URLFor Uses

func (p *ControllerRegister) URLFor(endpoint string, values ...interface{}) string

URLFor does another controller handler in this request function. it can access any controller method.

type FilterFunc Uses

type FilterFunc func(*context.Context)

FilterFunc defines a filter function which is invoked before the controller handler is executed.

type FilterHandler Uses

type FilterHandler interface {
    Filter(*beecontext.Context) bool
}

FilterHandler is an interface for

var (
    // HTTPMETHOD list the supported http methods.
    HTTPMETHOD = map[string]string{
        "GET":       "GET",
        "POST":      "POST",
        "PUT":       "PUT",
        "DELETE":    "DELETE",
        "PATCH":     "PATCH",
        "OPTIONS":   "OPTIONS",
        "HEAD":      "HEAD",
        "TRACE":     "TRACE",
        "CONNECT":   "CONNECT",
        "MKCOL":     "MKCOL",
        "COPY":      "COPY",
        "MOVE":      "MOVE",
        "PROPFIND":  "PROPFIND",
        "PROPPATCH": "PROPPATCH",
        "LOCK":      "LOCK",
        "UNLOCK":    "UNLOCK",
    }

    // DefaultAccessLogFilter will skip the accesslog if return true
    DefaultAccessLogFilter FilterHandler = &logFilter{}
)

type FilterRouter Uses

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

FilterRouter defines a filter operation which is invoked before the controller handler is executed. It can match the URL against a pattern, and execute a filter function when a request with a matching URL arrives.

func (*FilterRouter) ValidRouter Uses

func (f *FilterRouter) ValidRouter(url string, ctx *context.Context) bool

ValidRouter checks if the current request is matched by this filter. If the request is matched, the values of the URL parameters defined by the filter pattern are also returned.

type FlashData Uses

type FlashData struct {
    Data map[string]string
}

FlashData is a tools to maintain data when using across request.

func NewFlash Uses

func NewFlash() *FlashData

NewFlash return a new empty FlashData struct.

func ReadFromRequest Uses

func ReadFromRequest(c *Controller) *FlashData

ReadFromRequest parsed flash data from encoded values in cookie.

func (*FlashData) Error Uses

func (fd *FlashData) Error(msg string, args ...interface{})

Error writes error message to flash.

func (*FlashData) Notice Uses

func (fd *FlashData) Notice(msg string, args ...interface{})

Notice writes notice message to flash.

func (*FlashData) Set Uses

func (fd *FlashData) Set(key string, msg string, args ...interface{})

Set message to flash

func (*FlashData) Store Uses

func (fd *FlashData) Store(c *Controller)

Store does the saving operation of flash data. the data are encoded and saved in cookie.

func (*FlashData) Success Uses

func (fd *FlashData) Success(msg string, args ...interface{})

Success writes success message to flash.

func (*FlashData) Warning Uses

func (fd *FlashData) Warning(msg string, args ...interface{})

Warning writes warning message to flash.

type LinkNamespace Uses

type LinkNamespace func(*Namespace)

LinkNamespace used as link action

func NSAfter Uses

func NSAfter(filterList ...FilterFunc) LinkNamespace

NSAfter add Namespace FinishRouter filter

func NSAny Uses

func NSAny(rootpath string, f FilterFunc) LinkNamespace

NSAny call Namespace Any

func NSAutoPrefix Uses

func NSAutoPrefix(prefix string, c ControllerInterface) LinkNamespace

NSAutoPrefix call Namespace AutoPrefix

func NSAutoRouter Uses

func NSAutoRouter(c ControllerInterface) LinkNamespace

NSAutoRouter call Namespace AutoRouter

func NSBefore Uses

func NSBefore(filterList ...FilterFunc) LinkNamespace

NSBefore Namespace BeforeRouter filter

func NSCond Uses

func NSCond(cond namespaceCond) LinkNamespace

NSCond is Namespace Condition

func NSDelete Uses

func NSDelete(rootpath string, f FilterFunc) LinkNamespace

NSDelete call Namespace Delete

func NSGet Uses

func NSGet(rootpath string, f FilterFunc) LinkNamespace

NSGet call Namespace Get

func NSHandler Uses

func NSHandler(rootpath string, h http.Handler) LinkNamespace

NSHandler add handler

func NSHead Uses

func NSHead(rootpath string, f FilterFunc) LinkNamespace

NSHead call Namespace Head

func NSInclude Uses

func NSInclude(cList ...ControllerInterface) LinkNamespace

NSInclude Namespace Include ControllerInterface

func NSNamespace Uses

func NSNamespace(prefix string, params ...LinkNamespace) LinkNamespace

NSNamespace add sub Namespace

func NSOptions Uses

func NSOptions(rootpath string, f FilterFunc) LinkNamespace

NSOptions call Namespace Options

func NSPatch Uses

func NSPatch(rootpath string, f FilterFunc) LinkNamespace

NSPatch call Namespace Patch

func NSPost Uses

func NSPost(rootpath string, f FilterFunc) LinkNamespace

NSPost call Namespace Post

func NSPut Uses

func NSPut(rootpath string, f FilterFunc) LinkNamespace

NSPut call Namespace Put

func NSRouter Uses

func NSRouter(rootpath string, c ControllerInterface, mappingMethods ...string) LinkNamespace

NSRouter call Namespace Router

type Listen Uses

type Listen struct {
    Graceful      bool // Graceful means use graceful module to start the server
    ServerTimeOut int64
    ListenTCP4    bool
    EnableHTTP    bool
    HTTPAddr      string
    HTTPPort      int
    EnableHTTPS   bool
    HTTPSAddr     string
    HTTPSPort     int
    HTTPSCertFile string
    HTTPSKeyFile  string
    EnableAdmin   bool
    AdminAddr     string
    AdminPort     int
    EnableFcgi    bool
    EnableStdIo   bool // EnableStdIo works with EnableFcgi Use FCGI via standard I/O
}

Listen holds for http and https related config

type LogConfig Uses

type LogConfig struct {
    AccessLogs  bool
    FileLineNum bool
    Outputs     map[string]string // Store Adaptor : config
}

LogConfig holds Log related config

type Namespace Uses

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

Namespace is store all the info

func NewNamespace Uses

func NewNamespace(prefix string, params ...LinkNamespace) *Namespace

NewNamespace get new Namespace

func (*Namespace) Any Uses

func (n *Namespace) Any(rootpath string, f FilterFunc) *Namespace

Any same as beego.Any refer: https://godoc.org/github.com/astaxie/beego#Any

func (*Namespace) AutoPrefix Uses

func (n *Namespace) AutoPrefix(prefix string, c ControllerInterface) *Namespace

AutoPrefix same as beego.AutoPrefix refer: https://godoc.org/github.com/astaxie/beego#AutoPrefix

func (*Namespace) AutoRouter Uses

func (n *Namespace) AutoRouter(c ControllerInterface) *Namespace

AutoRouter same as beego.AutoRouter refer: https://godoc.org/github.com/astaxie/beego#AutoRouter

func (*Namespace) Cond Uses

func (n *Namespace) Cond(cond namespaceCond) *Namespace

Cond set condition function if cond return true can run this namespace, else can't usage: ns.Cond(func (ctx *context.Context) bool{

    if ctx.Input.Domain() == "api.beego.me" {
      return true
    }
    return false
})

Cond as the first filter

func (*Namespace) Delete Uses

func (n *Namespace) Delete(rootpath string, f FilterFunc) *Namespace

Delete same as beego.Delete refer: https://godoc.org/github.com/astaxie/beego#Delete

func (*Namespace) Filter Uses

func (n *Namespace) Filter(action string, filter ...FilterFunc) *Namespace

Filter add filter in the Namespace action has before & after FilterFunc usage: Filter("before", func (ctx *context.Context){

    _, ok := ctx.Input.Session("uid").(int)
    if !ok && ctx.Request.RequestURI != "/login" {
       ctx.Redirect(302, "/login")
     }
})

func (*Namespace) Get Uses

func (n *Namespace) Get(rootpath string, f FilterFunc) *Namespace

Get same as beego.Get refer: https://godoc.org/github.com/astaxie/beego#Get

func (*Namespace) Handler Uses

func (n *Namespace) Handler(rootpath string, h http.Handler) *Namespace

Handler same as beego.Handler refer: https://godoc.org/github.com/astaxie/beego#Handler

func (*Namespace) Head Uses

func (n *Namespace) Head(rootpath string, f FilterFunc) *Namespace

Head same as beego.Head refer: https://godoc.org/github.com/astaxie/beego#Head

func (*Namespace) Include Uses

func (n *Namespace) Include(cList ...ControllerInterface) *Namespace

Include add include class refer: https://godoc.org/github.com/astaxie/beego#Include

func (*Namespace) Namespace Uses

func (n *Namespace) Namespace(ns ...*Namespace) *Namespace

Namespace add nest Namespace usage: ns := beego.NewNamespace(“/v1”). Namespace(

beego.NewNamespace("/shop").
    Get("/:id", func(ctx *context.Context) {
        ctx.Output.Body([]byte("shopinfo"))
}),
beego.NewNamespace("/order").
    Get("/:id", func(ctx *context.Context) {
        ctx.Output.Body([]byte("orderinfo"))
}),
beego.NewNamespace("/crm").
    Get("/:id", func(ctx *context.Context) {
        ctx.Output.Body([]byte("crminfo"))
}),

)

func (*Namespace) Options Uses

func (n *Namespace) Options(rootpath string, f FilterFunc) *Namespace

Options same as beego.Options refer: https://godoc.org/github.com/astaxie/beego#Options

func (*Namespace) Patch Uses

func (n *Namespace) Patch(rootpath string, f FilterFunc) *Namespace

Patch same as beego.Patch refer: https://godoc.org/github.com/astaxie/beego#Patch

func (*Namespace) Post Uses

func (n *Namespace) Post(rootpath string, f FilterFunc) *Namespace

Post same as beego.Post refer: https://godoc.org/github.com/astaxie/beego#Post

func (*Namespace) Put Uses

func (n *Namespace) Put(rootpath string, f FilterFunc) *Namespace

Put same as beego.Put refer: https://godoc.org/github.com/astaxie/beego#Put

func (*Namespace) Router Uses

func (n *Namespace) Router(rootpath string, c ControllerInterface, mappingMethods ...string) *Namespace

Router same as beego.Rourer refer: https://godoc.org/github.com/astaxie/beego#Router

type PolicyFunc Uses

type PolicyFunc func(*context.Context)

PolicyFunc defines a policy function which is invoked before the controller handler is executed.

type SessionConfig Uses

type SessionConfig struct {
    SessionOn                    bool
    SessionProvider              string
    SessionName                  string
    SessionGCMaxLifetime         int64
    SessionProviderConfig        string
    SessionCookieLifeTime        int
    SessionAutoSetCookie         bool
    SessionDomain                string
    SessionDisableHTTPOnly       bool // used to allow for cross domain cookies/javascript cookies.
    SessionEnableSidInHTTPHeader bool //	enable store/get the sessionId into/from http headers
    SessionNameInHTTPHeader      string
    SessionEnableSidInURLQuery   bool //	enable get the sessionId from Url Query params
}

SessionConfig holds session related config

type Tree Uses

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

Tree has three elements: FixRouter/wildcard/leaves fixRouter sotres Fixed Router wildcard stores params leaves store the endpoint information

func NewTree Uses

func NewTree() *Tree

NewTree return a new Tree

func (*Tree) AddRouter Uses

func (t *Tree) AddRouter(pattern string, runObject interface{})

AddRouter call addseg function

func (*Tree) AddTree Uses

func (t *Tree) AddTree(prefix string, tree *Tree)

AddTree will add tree to the exist Tree prefix should has no params

func (*Tree) Match Uses

func (t *Tree) Match(pattern string, ctx *context.Context) (runObject interface{})

Match router to runObject & params

type WebConfig Uses

type WebConfig struct {
    AutoRender             bool
    EnableDocs             bool
    FlashName              string
    FlashSeparator         string
    DirectoryIndex         bool
    StaticDir              map[string]string
    StaticExtensionsToGzip []string
    TemplateLeft           string
    TemplateRight          string
    ViewsPath              string
    EnableXSRF             bool
    XSRFKey                string
    XSRFExpire             int
    Session                SessionConfig
}

WebConfig holds web related config

Directories

PathSynopsis
cachePackage cache provide a Cache interface and some implemetn engine Usage:
cache/memcachePackage memcache for cache provider
cache/redisPackage redis for cache provider
cache/ssdb
configPackage config is used to parse config.
config/envPackage env is used to parse environment.
config/xmlPackage xml for config provider.
config/yamlPackage yaml for config provider
contextPackage context provide the context utils Usage:
context/param
gracePackage grace use to hot reload Description: http://grisha.org/blog/2014/06/03/graceful-restart-in-golang/
httplibPackage httplib is used as http.Client Usage:
logsPackage logs provide a general log interface Usage:
logs/alilsPackage alils implements the SDK(v0.5.0) of Simple Log Service(abbr.
logs/es
migrationPackage migration enables you to generate migrations back and forth.
ormPackage orm provide ORM for MySQL/PostgreSQL/sqlite Simple Usage
plugins/apiauthPackage apiauth provides handlers to enable apiauth support.
plugins/authPackage auth provides handlers to enable basic auth support.
plugins/authzPackage authz provides handlers to enable ACL, RBAC, ABAC authorization support.
plugins/corsPackage cors provides handlers to enable CORS support.
sessionPackage session provider
session/couchbasePackage couchbase for session provider
session/ledisPackage ledis provide session Provider
session/memcachePackage memcache for session provider
session/mysqlPackage mysql for session provider
session/postgresPackage postgres for session provider
session/redisPackage redis for session provider
session/ssdb
swaggerPackage swagger struct definition
testing
toolboxPackage toolbox healthcheck
utils
utils/captchaPackage captcha implements generation and verification of image CAPTCHAs.
utils/paginationPackage pagination provides utilities to setup a paginator within the context of a http request.
validationPackage validation for validations

Package beego imports 37 packages (graph) and is imported by 2415 packages. Updated 2017-07-18. Refresh now. Tools for package owners.