func AddAPPStartHook(hf ...hookfunc)

func AddNamespace(nl ...*Namespace)

func AddTemplateExt(ext string)

func Alert(v ...interface{})

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

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

func Critical(v ...interface{})

func Debug(v ...interface{})

func Emergency(v ...interface{})

func Error(v ...interface{})

func ExceptMethodAppend(action string)

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

func Info(v ...interface{})

func Informational(v ...interface{})

func InitBeegoBeforeTest(appConfigPath string)

func LoadAppConfig(adapterName, configPath string) error

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

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

func Notice(v ...interface{})

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

func RunWithMiddleWares(addr string, mws ...MiddleWare)

func SetLogFuncCall(b bool)

func SetTemplateFSFunc(fnt templateFSFunc)

func Trace(v ...interface{})

func Warn(v ...interface{})

func Warning(v ...interface{})

func AddTemplateEngine(extension string, fn templatePreProcessor) *App

AddTemplateEngine add a new templatePreProcessor which support extension

Any used to register router for all methods usage:

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

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(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(url string) *App

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

Delete used to register router for Delete method usage:

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

func ErrorController(c ControllerInterface) *App

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

beego.ErrorController(&controllers.ErrorController{})

func ErrorHandler ¶ added in v1.6.0

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

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

Get used to register router for Get method usage:

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

func Handler ¶

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))
}))

Head used to register router for Head method usage:

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

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 *]

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)

NewApp returns a new beego application.

Options used to register router for Options method usage:

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

Patch used to register router for Patch method usage:

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

Post used to register router for Post method usage:

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

Put used to register router for Put method usage:

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

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

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")

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(path string) *App

SetViewsPath sets view directory path in beego application.

UnregisterFixedRoute unregisters the route with the specified fixedRoute. It is particularly useful in web applications that inherit most routes from a base webapp via the underscore import, and aim to overwrite only certain paths. The method parameter can be empty or "*" for all HTTP methods, or a particular method type (e.g. "GET" or "POST") for selective removal.

Usage (replace "GET" with "*" for all methods):

beego.UnregisterFixedRoute("/yourpreviouspath", "GET")
beego.Router("/yourpreviouspath", yourControllerAddress, "get:GetNewPage")

func (app *App) Run(mws ...MiddleWare)

Run beego application.

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

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".

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

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

DelSession removes value from session.

func (c *Controller) Delete()

Delete adds a request function to handle DELETE request.

func (c *Controller) DestroySession()

DestroySession cleans session data and session cookie.

func (c *Controller) Finish()

Finish runs after request function execution.

func (c *Controller) Get()

Get adds a request function to handle GET request.

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

func (*Controller) GetControllerAndAction ¶

GetControllerAndAction gets the executing controller name and action name.

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

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
	}
}

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

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

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

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

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

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

GetSecureCookie returns decoded cookie value from encoded browser cookie values.

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

GetSession gets value from session.

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

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.

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

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

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

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

func (*Controller) HandlerFunc ¶ added in v1.3.0

HandlerFunc call function with the name

func (c *Controller) Head()

Head adds a request function to handle HEAD request.

Init generates default values of controller operations.

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

IsAjax returns this request is ajax or not.

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

Mapping the method to function

func (c *Controller) Options()

Options adds a request function to handle OPTIONS request.

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

ParseForm maps input data map to obj struct.

func (c *Controller) Patch()

Patch adds a request function to handle PATCH request.

func (c *Controller) Post()

Post adds a request function to handle POST request.

func (c *Controller) Prepare()

Prepare runs after Init before request function execution.

func (c *Controller) Put()

Put adds a request function to handle PUT request.

Redirect sends the redirection response to url with status code.

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

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

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

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

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

ServeFormatted serve YAML, XML OR JSON, depending on the value of the Accept header

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

ServeJSON sends a json response with encoding charset.

func (c *Controller) ServeJSONP()

ServeJSONP sends a jsonp response.

func (c *Controller) ServeXML()

ServeXML sends xml response.

func (c *Controller) ServeYAML()

ServeYAML sends yaml response.

func (c *Controller) SessionRegenerateID()

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

func (c *Controller) SetData(data interface{})

SetData set the data depending on the accepted

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

SetSecureCookie puts value into cookie after encoded the value.

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

SetSession puts value into session.

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

func (c *Controller) StopRun()

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

func (c *Controller) Trace()

Trace adds a request function to handle Trace request. this method SHOULD NOT be overridden. https://tools.ietf.org/html/rfc7231#section-4.3.8 The TRACE method requests a remote, application-level loop-back of the request message. The final recipient of the request SHOULD reflect the message received, excluding some fields described below, back to the client as the message body of a 200 (OK) response with a Content-Type of "message/http" (Section 8.3.1 of [RFC7230]).

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

func (c *Controller) URLMapping()

URLMapping register the internal Controller router.

XSRFFormHTML writes an input field contains xsrf token value.

XSRFToken creates a CSRF token string and returns.

type ControllerComments struct {
}

type ControllerCommentsSlice []ControllerComments

type ControllerFilter struct {
	Pattern        string
	Pos            int
	Filter         FilterFunc
	ReturnOnOutput bool
	ResetParams    bool
}

type ControllerFilterComments struct {
}

type ControllerImportComments struct {
}

type ControllerInfo struct {
}

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

type ControllerRegister struct {
}

func NewControllerRegister() *ControllerRegister

NewControllerRegister returns a new ControllerRegister.

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 (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.

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 (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")
})

Any add all method usage:

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

Delete add delete method usage:

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

FindPolicy Find Router info for URL

FindRouter Find Router info for URL

Get add get method usage:

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

GetContext returns a context from pool, so usually you should remember to call Reset function to clean the context And don't forget to give back context to pool example:

ctx := p.GetContext()
ctx.Reset(w, q)
defer p.GiveBackContext(ctx)

GiveBackContext put the ctx into pool so that it could be reuse

func (*ControllerRegister) Handler ¶ added in v1.6.0

Handler add user defined Handler

Head add head method usage:

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

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{})

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.

Options add options method usage:

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

Patch add patch method usage:

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

Post add post method usage:

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

Put add put method usage:

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

Implement http.Handler interface.

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

var (

	HTTPMETHOD = map[string]bool{
		"GET":       true,
		"POST":      true,
		"PUT":       true,
		"DELETE":    true,
		"PATCH":     true,
		"OPTIONS":   true,
		"HEAD":      true,
		"TRACE":     true,
		"CONNECT":   true,
		"MKCOL":     true,
		"COPY":      true,
		"MOVE":      true,
		"PROPFIND":  true,
		"PROPPATCH": true,
		"LOCK":      true,
		"UNLOCK":    true,
	}

	DefaultAccessLogFilter FilterHandler = &logFilter{}
)

type FilterRouter struct {
}

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.

func NewFlash() *FlashData

NewFlash return a new empty FlashData struct.

func ReadFromRequest(c *Controller) *FlashData

ReadFromRequest parsed flash data from encoded values in cookie.

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

Error writes error message to flash.

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

Notice writes notice message to flash.

Set message to flash

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

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

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

Success writes success message to flash.

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

Warning writes warning message to flash.

type LinkNamespace func(*Namespace)

func NSAfter(filterList ...FilterFunc) LinkNamespace

NSAfter add Namespace FinishRouter filter

NSAny call Namespace Any

NSAutoPrefix call Namespace AutoPrefix

func NSAutoRouter(c ControllerInterface) LinkNamespace

NSAutoRouter call Namespace AutoRouter

func NSBefore(filterList ...FilterFunc) LinkNamespace

NSBefore Namespace BeforeRouter filter

func NSCond(cond namespaceCond) LinkNamespace

NSCond is Namespace Condition

NSDelete call Namespace Delete

NSGet call Namespace Get

func NSHandler ¶ added in v1.6.1

NSHandler add handler

NSHead call Namespace Head

func NSInclude(cList ...ControllerInterface) LinkNamespace

NSInclude Namespace Include ControllerInterface

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

NSNamespace add sub Namespace

NSOptions call Namespace Options

NSPatch call Namespace Patch

NSPost call Namespace Post

NSPut call Namespace Put

NSRouter call Namespace Router

PrintTree prints all registered routers.

type Namespace struct {
}

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

NewNamespace get new Namespace

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 (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 (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"))
}),

)

type SessionConfig struct {
	SessionOn                    bool
	SessionProvider              string
	SessionName                  string
	SessionGCMaxLifetime         int64
	SessionProviderConfig        string
	SessionCookieLifeTime        int
	SessionAutoSetCookie         bool
	SessionDomain                string
	SessionDisableHTTPOnly       bool
	SessionEnableSidInURLQuery   bool
	SessionCookieSameSite        http.SameSite
}

type Tree struct {
}

NewTree return a new Tree

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

AddRouter call addseg function

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

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

Match router to runObject & params