README

Beego Build Status GoDoc Foundation Go Report Card

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

More info at beego.me.

Quick Start

Download and install
go get github.com/astaxie/beego
Create file hello.go
package main

import "github.com/astaxie/beego"

func main(){
    beego.Run()
}
Build and run
go build hello.go
./hello
Go to http://localhost:8080

Congratulations! You've just built your first beego app.

Please see Documentation for more.

Features

  • RESTful support
  • MVC architecture
  • Modularity
  • Auto API documents
  • Annotation router
  • Namespace
  • Powerful development tools
  • Full stack for Web & API

Documentation

Community

License

beego source code is licensed under the Apache Licence, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0.html).

Expand ▾ Collapse ▴

Documentation

Overview

    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

    Constants

    View Source
    const (
    	// VERSION represent beego web framework version.
    	VERSION = "1.10.1"
    
    	// DEV is for develop
    	DEV = "dev"
    	// PROD is for production
    	PROD = "prod"
    )
    View Source
    const (
    	LevelEmergency = iota
    	LevelAlert
    	LevelCritical
    	LevelError
    	LevelWarning
    	LevelNotice
    	LevelInformational
    	LevelDebug
    )

      Log levels to control the logging output.

      View Source
      const (
      	BeforeStatic = iota
      	BeforeRouter
      	BeforeExec
      	AfterExec
      	FinishRouter
      )

        default filter execution points

        Variables

        View Source
        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
        )
        View Source
        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)
        )
        View Source
        var BeeLogger = logs.GetBeeLogger()

          BeeLogger references the used application logger.

          View Source
          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)

            View Source
            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.
              

              Functions

              func AddAPPStartHook

              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

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

                  AddFuncMap let user to register a func in the template.

                  func AddNamespace

                  func AddNamespace(nl ...*Namespace)

                    AddNamespace register Namespace into beego.Handler support multi Namespace

                    func AddTemplateExt

                    func AddTemplateExt(ext string)

                      AddTemplateExt add new extension for template.

                      func AddViewPath

                      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

                        func Alert(v ...interface{})

                          Alert logs a message at alert level.

                          func AssetsCSS

                          func AssetsCSS(text string) template.HTML

                            AssetsCSS returns stylesheet link tag with src string.

                            func AssetsJs

                            func AssetsJs(text string) template.HTML

                              AssetsJs returns script tag with src string.

                              func BuildTemplate

                              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

                                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

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

                                    CompareNot !Compare

                                    func Critical

                                    func Critical(v ...interface{})

                                      Critical logs a message at critical level.

                                      func Date

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

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

                                        func DateFormat

                                        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

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

                                            DateParse Parse Date use PHP time format.

                                            func Debug

                                            func Debug(v ...interface{})

                                              Debug logs a message at debug level.

                                              func Emergency

                                              func Emergency(v ...interface{})

                                                Emergency logs a message at emergency level.

                                                func Error

                                                func Error(v ...interface{})

                                                  Error logs a message at error level.

                                                  func ExceptMethodAppend

                                                  func ExceptMethodAppend(action string)

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

                                                    func Exception

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

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

                                                      func ExecuteTemplate

                                                      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

                                                        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

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

                                                            GetConfig get the Appconfig

                                                            func HTML2str

                                                            func HTML2str(html string) string

                                                              HTML2str returns escaping text convert from html.

                                                              func HasTemplateExt

                                                              func HasTemplateExt(paths string) bool

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

                                                                func Htmlquote

                                                                func Htmlquote(text string) string

                                                                  Htmlquote returns quoted html string.

                                                                  func Htmlunquote

                                                                  func Htmlunquote(text string) string

                                                                    Htmlunquote returns unquoted html string.

                                                                    func Info

                                                                    func Info(v ...interface{})

                                                                      Info compatibility alias for Warning()

                                                                      func Informational

                                                                      func Informational(v ...interface{})

                                                                        Informational logs a message at info level.

                                                                        func InitBeegoBeforeTest

                                                                        func InitBeegoBeforeTest(appConfigPath string)

                                                                          InitBeegoBeforeTest is for test package init

                                                                          func LoadAppConfig

                                                                          func LoadAppConfig(adapterName, configPath string) error

                                                                            LoadAppConfig allow developer to apply a config file

                                                                            func MapGet

                                                                            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

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

                                                                                NotNil the same as CompareNot

                                                                                func Notice

                                                                                func Notice(v ...interface{})

                                                                                  Notice logs a message at notice level.

                                                                                  func ParseForm

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

                                                                                    ParseForm will parse form values to struct via tag.

                                                                                    func Policy

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

                                                                                      Policy Register new policy in beego

                                                                                      func PrintTree

                                                                                      func PrintTree() map[string]interface{}

                                                                                        PrintTree prints all registered routers.

                                                                                        func RenderForm

                                                                                        func RenderForm(obj interface{}) template.HTML

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

                                                                                          func Run

                                                                                          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 RunWithMiddleWares

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

                                                                                              RunWithMiddleWares Run beego application with middlewares.

                                                                                              func SetLevel

                                                                                              func SetLevel(l int)

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

                                                                                                func SetLogFuncCall

                                                                                                func SetLogFuncCall(b bool)

                                                                                                  SetLogFuncCall set the CallDepth, default is 3

                                                                                                  func SetLogger

                                                                                                  func SetLogger(adaptername string, config string) error

                                                                                                    SetLogger sets a new logger.

                                                                                                    func Str2html

                                                                                                    func Str2html(raw string) template.HTML

                                                                                                      Str2html Convert string to template.HTML type.

                                                                                                      func Substr

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

                                                                                                        Substr returns the substr from start to length.

                                                                                                        func TestBeegoInit

                                                                                                        func TestBeegoInit(ap string)

                                                                                                          TestBeegoInit is for test package init

                                                                                                          func Trace

                                                                                                          func Trace(v ...interface{})

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

                                                                                                            func URLFor

                                                                                                            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

                                                                                                              func Warn(v ...interface{})

                                                                                                                Warn compatibility alias for Warning()

                                                                                                                func Warning

                                                                                                                func Warning(v ...interface{})

                                                                                                                  Warning logs a message at warning level.

                                                                                                                  Types

                                                                                                                  type App

                                                                                                                  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

                                                                                                                    func AddTemplateEngine(extension string, fn templatePreProcessor) *App

                                                                                                                      AddTemplateEngine add a new templatePreProcessor which support extension

                                                                                                                      func Any

                                                                                                                      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

                                                                                                                        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

                                                                                                                          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

                                                                                                                            func DelStaticPath(url string) *App

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

                                                                                                                              func Delete

                                                                                                                              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

                                                                                                                                func ErrorController(c ControllerInterface) *App

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

                                                                                                                                  beego.ErrorController(&controllers.ErrorController{})
                                                                                                                                  

                                                                                                                                  func ErrorHandler

                                                                                                                                  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

                                                                                                                                    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

                                                                                                                                      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

                                                                                                                                          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

                                                                                                                                            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

                                                                                                                                              func NewApp() *App

                                                                                                                                                NewApp returns a new beego application.

                                                                                                                                                func Options

                                                                                                                                                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

                                                                                                                                                  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

                                                                                                                                                    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

                                                                                                                                                      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

                                                                                                                                                        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

                                                                                                                                                          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

                                                                                                                                                            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

                                                                                                                                                              func SetViewsPath(path string) *App

                                                                                                                                                                SetViewsPath sets view directory path in beego application.

                                                                                                                                                                func UnregisterFixedRoute

                                                                                                                                                                func UnregisterFixedRoute(fixedRoute string, method string) *App

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

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

                                                                                                                                                                    Run beego application.

                                                                                                                                                                    type Config

                                                                                                                                                                    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

                                                                                                                                                                      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

                                                                                                                                                                        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

                                                                                                                                                                          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

                                                                                                                                                                            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

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

                                                                                                                                                                                DelSession removes value from session.

                                                                                                                                                                                func (*Controller) Delete

                                                                                                                                                                                func (c *Controller) Delete()

                                                                                                                                                                                  Delete adds a request function to handle DELETE request.

                                                                                                                                                                                  func (*Controller) DestroySession

                                                                                                                                                                                  func (c *Controller) DestroySession()

                                                                                                                                                                                    DestroySession cleans session data and session cookie.

                                                                                                                                                                                    func (*Controller) Finish

                                                                                                                                                                                    func (c *Controller) Finish()

                                                                                                                                                                                      Finish runs after request function execution.

                                                                                                                                                                                      func (*Controller) Get

                                                                                                                                                                                      func (c *Controller) Get()

                                                                                                                                                                                        Get adds a request function to handle GET request.

                                                                                                                                                                                        func (*Controller) GetBool

                                                                                                                                                                                        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

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

                                                                                                                                                                                            GetControllerAndAction gets the executing controller name and action name.

                                                                                                                                                                                            func (*Controller) GetFile

                                                                                                                                                                                            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

                                                                                                                                                                                              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

                                                                                                                                                                                                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

                                                                                                                                                                                                  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

                                                                                                                                                                                                    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

                                                                                                                                                                                                      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

                                                                                                                                                                                                        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

                                                                                                                                                                                                          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

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

                                                                                                                                                                                                              GetSecureCookie returns decoded cookie value from encoded browser cookie values.

                                                                                                                                                                                                              func (*Controller) GetSession

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

                                                                                                                                                                                                                GetSession gets value from session.

                                                                                                                                                                                                                func (*Controller) GetString

                                                                                                                                                                                                                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

                                                                                                                                                                                                                  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

                                                                                                                                                                                                                    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

                                                                                                                                                                                                                      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

                                                                                                                                                                                                                        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

                                                                                                                                                                                                                          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

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

                                                                                                                                                                                                                              HandlerFunc call function with the name

                                                                                                                                                                                                                              func (*Controller) Head

                                                                                                                                                                                                                              func (c *Controller) Head()

                                                                                                                                                                                                                                Head adds a request function to handle HEAD request.

                                                                                                                                                                                                                                func (*Controller) Init

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

                                                                                                                                                                                                                                  Init generates default values of controller operations.

                                                                                                                                                                                                                                  func (*Controller) Input

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

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

                                                                                                                                                                                                                                    func (*Controller) IsAjax

                                                                                                                                                                                                                                    func (c *Controller) IsAjax() bool

                                                                                                                                                                                                                                      IsAjax returns this request is ajax or not.

                                                                                                                                                                                                                                      func (*Controller) Mapping

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

                                                                                                                                                                                                                                        Mapping the method to function

                                                                                                                                                                                                                                        func (*Controller) Options

                                                                                                                                                                                                                                        func (c *Controller) Options()

                                                                                                                                                                                                                                          Options adds a request function to handle OPTIONS request.

                                                                                                                                                                                                                                          func (*Controller) ParseForm

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

                                                                                                                                                                                                                                            ParseForm maps input data map to obj struct.

                                                                                                                                                                                                                                            func (*Controller) Patch

                                                                                                                                                                                                                                            func (c *Controller) Patch()

                                                                                                                                                                                                                                              Patch adds a request function to handle PATCH request.

                                                                                                                                                                                                                                              func (*Controller) Post

                                                                                                                                                                                                                                              func (c *Controller) Post()

                                                                                                                                                                                                                                                Post adds a request function to handle POST request.

                                                                                                                                                                                                                                                func (*Controller) Prepare

                                                                                                                                                                                                                                                func (c *Controller) Prepare()

                                                                                                                                                                                                                                                  Prepare runs after Init before request function execution.

                                                                                                                                                                                                                                                  func (*Controller) Put

                                                                                                                                                                                                                                                  func (c *Controller) Put()

                                                                                                                                                                                                                                                    Put adds a request function to handle PUT request.

                                                                                                                                                                                                                                                    func (*Controller) Redirect

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

                                                                                                                                                                                                                                                      Redirect sends the redirection response to url with status code.

                                                                                                                                                                                                                                                      func (*Controller) Render

                                                                                                                                                                                                                                                      func (c *Controller) Render() error

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

                                                                                                                                                                                                                                                        func (*Controller) RenderBytes

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

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

                                                                                                                                                                                                                                                          func (*Controller) RenderString

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

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

                                                                                                                                                                                                                                                            func (*Controller) SaveToFile

                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                              func (c *Controller) ServeFormatted()

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

                                                                                                                                                                                                                                                                func (*Controller) ServeJSON

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

                                                                                                                                                                                                                                                                  ServeJSON sends a json response with encoding charset.

                                                                                                                                                                                                                                                                  func (*Controller) ServeJSONP

                                                                                                                                                                                                                                                                  func (c *Controller) ServeJSONP()

                                                                                                                                                                                                                                                                    ServeJSONP sends a jsonp response.

                                                                                                                                                                                                                                                                    func (*Controller) ServeXML

                                                                                                                                                                                                                                                                    func (c *Controller) ServeXML()

                                                                                                                                                                                                                                                                      ServeXML sends xml response.

                                                                                                                                                                                                                                                                      func (*Controller) ServeYAML

                                                                                                                                                                                                                                                                      func (c *Controller) ServeYAML()

                                                                                                                                                                                                                                                                        ServeXML sends xml response.

                                                                                                                                                                                                                                                                        func (*Controller) SessionRegenerateID

                                                                                                                                                                                                                                                                        func (c *Controller) SessionRegenerateID()

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

                                                                                                                                                                                                                                                                          func (*Controller) SetData

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

                                                                                                                                                                                                                                                                            Set the data depending on the accepted

                                                                                                                                                                                                                                                                            func (*Controller) SetSecureCookie

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

                                                                                                                                                                                                                                                                              SetSecureCookie puts value into cookie after encoded the value.

                                                                                                                                                                                                                                                                              func (*Controller) SetSession

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

                                                                                                                                                                                                                                                                                SetSession puts value into session.

                                                                                                                                                                                                                                                                                func (*Controller) StartSession

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

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

                                                                                                                                                                                                                                                                                  func (*Controller) StopRun

                                                                                                                                                                                                                                                                                  func (c *Controller) StopRun()

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

                                                                                                                                                                                                                                                                                    func (*Controller) URLFor

                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                      func (c *Controller) URLMapping()

                                                                                                                                                                                                                                                                                        URLMapping register the internal Controller router.

                                                                                                                                                                                                                                                                                        func (*Controller) XSRFFormHTML

                                                                                                                                                                                                                                                                                        func (c *Controller) XSRFFormHTML() string

                                                                                                                                                                                                                                                                                          XSRFFormHTML writes an input field contains xsrf token value.

                                                                                                                                                                                                                                                                                          func (*Controller) XSRFToken

                                                                                                                                                                                                                                                                                          func (c *Controller) XSRFToken() string

                                                                                                                                                                                                                                                                                            XSRFToken creates a CSRF token string and returns.

                                                                                                                                                                                                                                                                                            type ControllerComments

                                                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                                                              type ControllerCommentsSlice []ControllerComments

                                                                                                                                                                                                                                                                                                ControllerCommentsSlice implements the sort interface

                                                                                                                                                                                                                                                                                                func (ControllerCommentsSlice) Len

                                                                                                                                                                                                                                                                                                func (p ControllerCommentsSlice) Len() int

                                                                                                                                                                                                                                                                                                func (ControllerCommentsSlice) Less

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

                                                                                                                                                                                                                                                                                                func (ControllerCommentsSlice) Swap

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

                                                                                                                                                                                                                                                                                                type ControllerInfo

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

                                                                                                                                                                                                                                                                                                  ControllerInfo holds information about the controller.

                                                                                                                                                                                                                                                                                                  type ControllerInterface

                                                                                                                                                                                                                                                                                                  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

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

                                                                                                                                                                                                                                                                                                      ControllerRegister containers registered router rules, controller handlers and filters.

                                                                                                                                                                                                                                                                                                      func NewControllerRegister

                                                                                                                                                                                                                                                                                                      func NewControllerRegister() *ControllerRegister

                                                                                                                                                                                                                                                                                                        NewControllerRegister returns a new ControllerRegister.

                                                                                                                                                                                                                                                                                                        func (*ControllerRegister) Add

                                                                                                                                                                                                                                                                                                        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

                                                                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                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

                                                                                                                                                                                                                                                                                                                  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

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

                                                                                                                                                                                                                                                                                                                      FindPolicy Find Router info for URL

                                                                                                                                                                                                                                                                                                                      func (*ControllerRegister) FindRouter

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

                                                                                                                                                                                                                                                                                                                        FindRouter Find Router info for URL

                                                                                                                                                                                                                                                                                                                        func (*ControllerRegister) Get

                                                                                                                                                                                                                                                                                                                        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

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

                                                                                                                                                                                                                                                                                                                            Handler add user defined Handler

                                                                                                                                                                                                                                                                                                                            func (*ControllerRegister) Head

                                                                                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                                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

                                                                                                                                                                                                                                                                                                                                  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

                                                                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                                                      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

                                                                                                                                                                                                                                                                                                                                        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

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

                                                                                                                                                                                                                                                                                                                                            Implement http.Handler interface.

                                                                                                                                                                                                                                                                                                                                            func (*ControllerRegister) URLFor

                                                                                                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                                                                                                              type FilterFunc func(*context.Context)

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

                                                                                                                                                                                                                                                                                                                                                type FilterHandler

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

                                                                                                                                                                                                                                                                                                                                                  FilterHandler is an interface for

                                                                                                                                                                                                                                                                                                                                                  var (
                                                                                                                                                                                                                                                                                                                                                  	// HTTPMETHOD list the supported http methods.
                                                                                                                                                                                                                                                                                                                                                  	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 will skip the accesslog if return true
                                                                                                                                                                                                                                                                                                                                                  	DefaultAccessLogFilter FilterHandler = &logFilter{}
                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                  type FilterRouter

                                                                                                                                                                                                                                                                                                                                                  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

                                                                                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                                                                      type FlashData struct {
                                                                                                                                                                                                                                                                                                                                                      	Data map[string]string
                                                                                                                                                                                                                                                                                                                                                      }

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

                                                                                                                                                                                                                                                                                                                                                        func NewFlash

                                                                                                                                                                                                                                                                                                                                                        func NewFlash() *FlashData

                                                                                                                                                                                                                                                                                                                                                          NewFlash return a new empty FlashData struct.

                                                                                                                                                                                                                                                                                                                                                          func ReadFromRequest

                                                                                                                                                                                                                                                                                                                                                          func ReadFromRequest(c *Controller) *FlashData

                                                                                                                                                                                                                                                                                                                                                            ReadFromRequest parsed flash data from encoded values in cookie.

                                                                                                                                                                                                                                                                                                                                                            func (*FlashData) Error

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

                                                                                                                                                                                                                                                                                                                                                              Error writes error message to flash.

                                                                                                                                                                                                                                                                                                                                                              func (*FlashData) Notice

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

                                                                                                                                                                                                                                                                                                                                                                Notice writes notice message to flash.

                                                                                                                                                                                                                                                                                                                                                                func (*FlashData) Set

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

                                                                                                                                                                                                                                                                                                                                                                  Set message to flash

                                                                                                                                                                                                                                                                                                                                                                  func (*FlashData) Store

                                                                                                                                                                                                                                                                                                                                                                  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

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

                                                                                                                                                                                                                                                                                                                                                                      Success writes success message to flash.

                                                                                                                                                                                                                                                                                                                                                                      func (*FlashData) Warning

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

                                                                                                                                                                                                                                                                                                                                                                        Warning writes warning message to flash.

                                                                                                                                                                                                                                                                                                                                                                        type LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                        type LinkNamespace func(*Namespace)

                                                                                                                                                                                                                                                                                                                                                                          LinkNamespace used as link action

                                                                                                                                                                                                                                                                                                                                                                          func NSAfter

                                                                                                                                                                                                                                                                                                                                                                          func NSAfter(filterList ...FilterFunc) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                            NSAfter add Namespace FinishRouter filter

                                                                                                                                                                                                                                                                                                                                                                            func NSAny

                                                                                                                                                                                                                                                                                                                                                                            func NSAny(rootpath string, f FilterFunc) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                              NSAny call Namespace Any

                                                                                                                                                                                                                                                                                                                                                                              func NSAutoPrefix

                                                                                                                                                                                                                                                                                                                                                                              func NSAutoPrefix(prefix string, c ControllerInterface) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                NSAutoPrefix call Namespace AutoPrefix

                                                                                                                                                                                                                                                                                                                                                                                func NSAutoRouter

                                                                                                                                                                                                                                                                                                                                                                                func NSAutoRouter(c ControllerInterface) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                  NSAutoRouter call Namespace AutoRouter

                                                                                                                                                                                                                                                                                                                                                                                  func NSBefore

                                                                                                                                                                                                                                                                                                                                                                                  func NSBefore(filterList ...FilterFunc) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                    NSBefore Namespace BeforeRouter filter

                                                                                                                                                                                                                                                                                                                                                                                    func NSCond

                                                                                                                                                                                                                                                                                                                                                                                    func NSCond(cond namespaceCond) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                      NSCond is Namespace Condition

                                                                                                                                                                                                                                                                                                                                                                                      func NSDelete

                                                                                                                                                                                                                                                                                                                                                                                      func NSDelete(rootpath string, f FilterFunc) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                        NSDelete call Namespace Delete

                                                                                                                                                                                                                                                                                                                                                                                        func NSGet

                                                                                                                                                                                                                                                                                                                                                                                        func NSGet(rootpath string, f FilterFunc) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                          NSGet call Namespace Get

                                                                                                                                                                                                                                                                                                                                                                                          func NSHandler

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

                                                                                                                                                                                                                                                                                                                                                                                            NSHandler add handler

                                                                                                                                                                                                                                                                                                                                                                                            func NSHead

                                                                                                                                                                                                                                                                                                                                                                                            func NSHead(rootpath string, f FilterFunc) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                              NSHead call Namespace Head

                                                                                                                                                                                                                                                                                                                                                                                              func NSInclude

                                                                                                                                                                                                                                                                                                                                                                                              func NSInclude(cList ...ControllerInterface) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                                NSInclude Namespace Include ControllerInterface

                                                                                                                                                                                                                                                                                                                                                                                                func NSNamespace

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

                                                                                                                                                                                                                                                                                                                                                                                                  NSNamespace add sub Namespace

                                                                                                                                                                                                                                                                                                                                                                                                  func NSOptions

                                                                                                                                                                                                                                                                                                                                                                                                  func NSOptions(rootpath string, f FilterFunc) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                                    NSOptions call Namespace Options

                                                                                                                                                                                                                                                                                                                                                                                                    func NSPatch

                                                                                                                                                                                                                                                                                                                                                                                                    func NSPatch(rootpath string, f FilterFunc) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                                      NSPatch call Namespace Patch

                                                                                                                                                                                                                                                                                                                                                                                                      func NSPost

                                                                                                                                                                                                                                                                                                                                                                                                      func NSPost(rootpath string, f FilterFunc) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                                        NSPost call Namespace Post

                                                                                                                                                                                                                                                                                                                                                                                                        func NSPut

                                                                                                                                                                                                                                                                                                                                                                                                        func NSPut(rootpath string, f FilterFunc) LinkNamespace

                                                                                                                                                                                                                                                                                                                                                                                                          NSPut call Namespace Put

                                                                                                                                                                                                                                                                                                                                                                                                          func NSRouter

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

                                                                                                                                                                                                                                                                                                                                                                                                            NSRouter call Namespace Router

                                                                                                                                                                                                                                                                                                                                                                                                            type Listen

                                                                                                                                                                                                                                                                                                                                                                                                            type Listen struct {
                                                                                                                                                                                                                                                                                                                                                                                                            	Graceful          bool // Graceful means use graceful module to start the server
                                                                                                                                                                                                                                                                                                                                                                                                            	ServerTimeOut     int64
                                                                                                                                                                                                                                                                                                                                                                                                            	ListenTCP4        bool
                                                                                                                                                                                                                                                                                                                                                                                                            	EnableHTTP        bool
                                                                                                                                                                                                                                                                                                                                                                                                            	HTTPAddr          string
                                                                                                                                                                                                                                                                                                                                                                                                            	HTTPPort          int
                                                                                                                                                                                                                                                                                                                                                                                                            	AutoTLS           bool
                                                                                                                                                                                                                                                                                                                                                                                                            	Domains           []string
                                                                                                                                                                                                                                                                                                                                                                                                            	TLSCacheDir       string
                                                                                                                                                                                                                                                                                                                                                                                                            	EnableHTTPS       bool
                                                                                                                                                                                                                                                                                                                                                                                                            	EnableMutualHTTPS bool
                                                                                                                                                                                                                                                                                                                                                                                                            	HTTPSAddr         string
                                                                                                                                                                                                                                                                                                                                                                                                            	HTTPSPort         int
                                                                                                                                                                                                                                                                                                                                                                                                            	HTTPSCertFile     string
                                                                                                                                                                                                                                                                                                                                                                                                            	HTTPSKeyFile      string
                                                                                                                                                                                                                                                                                                                                                                                                            	TrustCaFile       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

                                                                                                                                                                                                                                                                                                                                                                                                              type LogConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                              	AccessLogs       bool
                                                                                                                                                                                                                                                                                                                                                                                                              	EnableStaticLogs bool   //log static files requests default: false
                                                                                                                                                                                                                                                                                                                                                                                                              	AccessLogsFormat string //access log format: JSON_FORMAT, APACHE_FORMAT or empty string
                                                                                                                                                                                                                                                                                                                                                                                                              	FileLineNum      bool
                                                                                                                                                                                                                                                                                                                                                                                                              	Outputs          map[string]string // Store Adaptor : config
                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                LogConfig holds Log related config

                                                                                                                                                                                                                                                                                                                                                                                                                type MiddleWare

                                                                                                                                                                                                                                                                                                                                                                                                                type MiddleWare func(http.Handler) http.Handler

                                                                                                                                                                                                                                                                                                                                                                                                                  MiddleWare function for http.Handler

                                                                                                                                                                                                                                                                                                                                                                                                                  type Namespace

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

                                                                                                                                                                                                                                                                                                                                                                                                                    Namespace is store all the info

                                                                                                                                                                                                                                                                                                                                                                                                                    func NewNamespace

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

                                                                                                                                                                                                                                                                                                                                                                                                                      NewNamespace get new Namespace

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Namespace) Any

                                                                                                                                                                                                                                                                                                                                                                                                                      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

                                                                                                                                                                                                                                                                                                                                                                                                                        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

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Namespace) Cond

                                                                                                                                                                                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                                                                                                                                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

                                                                                                                                                                                                                                                                                                                                                                                                                                  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

                                                                                                                                                                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                                                                                                                                                      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

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Namespace) Namespace

                                                                                                                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                                                                                                                                                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

                                                                                                                                                                                                                                                                                                                                                                                                                                                  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

                                                                                                                                                                                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PolicyFunc func(*context.Context)

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SessionConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                        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

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewTree() *Tree

                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewTree return a new Tree

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Tree) AddRouter

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                AddRouter call addseg function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Tree) AddTree

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Tree) Match

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Match router to runObject & params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WebConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package cache provide a Cache interface and some implement engine Usage: import( "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("memory", `{"interval":60}`) Use it like this: bm.Put("astaxie", 1, 10 * time.Second) bm.Get("astaxie") bm.IsExist("astaxie") bm.Delete("astaxie") more docs http://beego.me/docs/module/cache.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package cache provide a Cache interface and some implement engine Usage: import( "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("memory", `{"interval":60}`) Use it like this: bm.Put("astaxie", 1, 10 * time.Second) bm.Get("astaxie") bm.IsExist("astaxie") bm.Delete("astaxie") more docs http://beego.me/docs/module/cache.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      memcache
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package memcache for cache provider depend on github.com/bradfitz/gomemcache/memcache go install github.com/bradfitz/gomemcache/memcache Usage: import( _ "github.com/astaxie/beego/cache/memcache" "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("memcache", `{"conn":"127.0.0.1:11211"}`) more docs http://beego.me/docs/module/cache.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package memcache for cache provider depend on github.com/bradfitz/gomemcache/memcache go install github.com/bradfitz/gomemcache/memcache Usage: import( _ "github.com/astaxie/beego/cache/memcache" "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("memcache", `{"conn":"127.0.0.1:11211"}`) more docs http://beego.me/docs/module/cache.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      redis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package redis for cache provider depend on github.com/gomodule/redigo/redis go install github.com/gomodule/redigo/redis Usage: import( _ "github.com/astaxie/beego/cache/redis" "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("redis", `{"conn":"127.0.0.1:11211"}`) more docs http://beego.me/docs/module/cache.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package redis for cache provider depend on github.com/gomodule/redigo/redis go install github.com/gomodule/redigo/redis Usage: import( _ "github.com/astaxie/beego/cache/redis" "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("redis", `{"conn":"127.0.0.1:11211"}`) more docs http://beego.me/docs/module/cache.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package config is used to parse config.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package config is used to parse config.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      env
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package env is used to parse environment.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package env is used to parse environment.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package xml for config provider.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package xml for config provider.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      yaml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package yaml for config provider depend on github.com/beego/goyaml2 go install github.com/beego/goyaml2 Usage: import( _ "github.com/astaxie/beego/config/yaml" "github.com/astaxie/beego/config" ) cnf, err := config.NewConfig("yaml", "config.yaml") More docs http://beego.me/docs/module/config.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package yaml for config provider depend on github.com/beego/goyaml2 go install github.com/beego/goyaml2 Usage: import( _ "github.com/astaxie/beego/config/yaml" "github.com/astaxie/beego/config" ) cnf, err := config.NewConfig("yaml", "config.yaml") More docs http://beego.me/docs/module/config.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package context provide the context utils Usage: import "github.com/astaxie/beego/context" ctx := context.Context{Request:req,ResponseWriter:rw} more docs http://beego.me/docs/module/context.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package context provide the context utils Usage: import "github.com/astaxie/beego/context" ctx := context.Context{Request:req,ResponseWriter:rw} more docs http://beego.me/docs/module/context.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package grace use to hot reload Description: http://grisha.org/blog/2014/06/03/graceful-restart-in-golang/ Usage: import( "log" "net/http" "os" "github.com/astaxie/beego/grace" ) func handler(w http.ResponseWriter, r *http.Request) { w.Write([]byte("WORLD!")) } func main() { mux := http.NewServeMux() mux.HandleFunc("/hello", handler) err := grace.ListenAndServe("localhost:8080", mux) if err != nil { log.Println(err) } log.Println("Server on 8080 stopped") os.Exit(0) }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package grace use to hot reload Description: http://grisha.org/blog/2014/06/03/graceful-restart-in-golang/ Usage: import( "log" "net/http" "os" "github.com/astaxie/beego/grace" ) func handler(w http.ResponseWriter, r *http.Request) { w.Write([]byte("WORLD!")) } func main() { mux := http.NewServeMux() mux.HandleFunc("/hello", handler) err := grace.ListenAndServe("localhost:8080", mux) if err != nil { log.Println(err) } log.Println("Server on 8080 stopped") os.Exit(0) }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package httplib is used as http.Client Usage: import "github.com/astaxie/beego/httplib" b := httplib.Post("http://beego.me/") b.Param("username","astaxie") b.Param("password","123456") b.PostFile("uploadfile1", "httplib.pdf") b.PostFile("uploadfile2", "httplib.txt") str, err := b.String() if err != nil { t.Fatal(err) } fmt.Println(str) more docs http://beego.me/docs/module/httplib.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package httplib is used as http.Client Usage: import "github.com/astaxie/beego/httplib" b := httplib.Post("http://beego.me/") b.Param("username","astaxie") b.Param("password","123456") b.PostFile("uploadfile1", "httplib.pdf") b.PostFile("uploadfile2", "httplib.txt") str, err := b.String() if err != nil { t.Fatal(err) } fmt.Println(str) more docs http://beego.me/docs/module/httplib.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package logs provide a general log interface Usage: import "github.com/astaxie/beego/logs" log := NewLogger(10000) log.SetLogger("console", "") > the first params stand for how many channel Use it like this: log.Trace("trace") log.Info("info") log.Warn("warning") log.Debug("debug") log.Critical("critical") more docs http://beego.me/docs/module/logs.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package logs provide a general log interface Usage: import "github.com/astaxie/beego/logs" log := NewLogger(10000) log.SetLogger("console", "") > the first params stand for how many channel Use it like this: log.Trace("trace") log.Info("info") log.Warn("warning") log.Debug("debug") log.Critical("critical") more docs http://beego.me/docs/module/logs.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      alils
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package alils implements the SDK(v0.5.0) of Simple Log Service(abbr.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package alils implements the SDK(v0.5.0) of Simple Log Service(abbr.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      es
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package migration enables you to generate migrations back and forth.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package migration enables you to generate migrations back and forth.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package orm provide ORM for MySQL/PostgreSQL/sqlite Simple Usage package main import ( "fmt" "github.com/astaxie/beego/orm" _ "github.com/go-sql-driver/mysql" // import your used driver ) // Model Struct type User struct { Id int `orm:"auto"` Name string `orm:"size(100)"` } func init() { orm.RegisterDataBase("default", "mysql", "root:root@/my_db?charset=utf8", 30) } func main() { o := orm.NewOrm() user := User{Name: "slene"} // insert id, err := o.Insert(&user) // update user.Name = "astaxie" num, err := o.Update(&user) // read one u := User{Id: user.Id} err = o.Read(&u) // delete num, err = o.Delete(&u) } more docs: http://beego.me/docs/mvc/model/overview.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package orm provide ORM for MySQL/PostgreSQL/sqlite Simple Usage package main import ( "fmt" "github.com/astaxie/beego/orm" _ "github.com/go-sql-driver/mysql" // import your used driver ) // Model Struct type User struct { Id int `orm:"auto"` Name string `orm:"size(100)"` } func init() { orm.RegisterDataBase("default", "mysql", "root:root@/my_db?charset=utf8", 30) } func main() { o := orm.NewOrm() user := User{Name: "slene"} // insert id, err := o.Insert(&user) // update user.Name = "astaxie" num, err := o.Update(&user) // read one u := User{Id: user.Id} err = o.Read(&u) // delete num, err = o.Delete(&u) } more docs: http://beego.me/docs/mvc/model/overview.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      plugins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apiauth
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package apiauth provides handlers to enable apiauth support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package apiauth provides handlers to enable apiauth support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      auth
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package auth provides handlers to enable basic auth support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package auth provides handlers to enable basic auth support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      authz
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package authz provides handlers to enable ACL, RBAC, ABAC authorization support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package authz provides handlers to enable ACL, RBAC, ABAC authorization support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package cors provides handlers to enable CORS support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package cors provides handlers to enable CORS support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package session provider Usage: import( "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("memory", `{"cookieName":"gosessionid", "enableSetCookie,omitempty": true, "gclifetime":3600, "maxLifetime": 3600, "secure": false, "cookieLifeTime": 3600, "providerConfig": ""}`) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package session provider Usage: import( "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("memory", `{"cookieName":"gosessionid", "enableSetCookie,omitempty": true, "gclifetime":3600, "maxLifetime": 3600, "secure": false, "cookieLifeTime": 3600, "providerConfig": ""}`) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      couchbase
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package couchbase for session provider depend on github.com/couchbaselabs/go-couchbasee go install github.com/couchbaselabs/go-couchbase Usage: import( _ "github.com/astaxie/beego/session/couchbase" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("couchbase", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"http://host:port/, Pool, Bucket"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package couchbase for session provider depend on github.com/couchbaselabs/go-couchbasee go install github.com/couchbaselabs/go-couchbase Usage: import( _ "github.com/astaxie/beego/session/couchbase" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("couchbase", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"http://host:port/, Pool, Bucket"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ledis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package ledis provide session Provider
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package ledis provide session Provider
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      memcache
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package memcache for session provider depend on github.com/bradfitz/gomemcache/memcache go install github.com/bradfitz/gomemcache/memcache Usage: import( _ "github.com/astaxie/beego/session/memcache" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("memcache", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"127.0.0.1:11211"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package memcache for session provider depend on github.com/bradfitz/gomemcache/memcache go install github.com/bradfitz/gomemcache/memcache Usage: import( _ "github.com/astaxie/beego/session/memcache" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("memcache", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"127.0.0.1:11211"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mysql
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package mysql for session provider depends on github.com/go-sql-driver/mysql: go install github.com/go-sql-driver/mysql mysql session support need create table as sql: CREATE TABLE `session` ( `session_key` char(64) NOT NULL, `session_data` blob, `session_expiry` int(11) unsigned NOT NULL, PRIMARY KEY (`session_key`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8; Usage: import( _ "github.com/astaxie/beego/session/mysql" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("mysql", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"[username[:password]@][protocol[(address)]]/dbname[?param1=value1&...&paramN=valueN]"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package mysql for session provider depends on github.com/go-sql-driver/mysql: go install github.com/go-sql-driver/mysql mysql session support need create table as sql: CREATE TABLE `session` ( `session_key` char(64) NOT NULL, `session_data` blob, `session_expiry` int(11) unsigned NOT NULL, PRIMARY KEY (`session_key`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8; Usage: import( _ "github.com/astaxie/beego/session/mysql" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("mysql", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"[username[:password]@][protocol[(address)]]/dbname[?param1=value1&...&paramN=valueN]"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      postgres
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package postgres for session provider depends on github.com/lib/pq: go install github.com/lib/pq needs this table in your database: CREATE TABLE session ( session_key char(64) NOT NULL, session_data bytea, session_expiry timestamp NOT NULL, CONSTRAINT session_key PRIMARY KEY(session_key) ); will be activated with these settings in app.conf: SessionOn = true SessionProvider = postgresql SessionSavePath = "user=a password=b dbname=c sslmode=disable" SessionName = session Usage: import( _ "github.com/astaxie/beego/session/postgresql" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("postgresql", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"user=pqgotest dbname=pqgotest sslmode=verify-full"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package postgres for session provider depends on github.com/lib/pq: go install github.com/lib/pq needs this table in your database: CREATE TABLE session ( session_key char(64) NOT NULL, session_data bytea, session_expiry timestamp NOT NULL, CONSTRAINT session_key PRIMARY KEY(session_key) ); will be activated with these settings in app.conf: SessionOn = true SessionProvider = postgresql SessionSavePath = "user=a password=b dbname=c sslmode=disable" SessionName = session Usage: import( _ "github.com/astaxie/beego/session/postgresql" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("postgresql", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"user=pqgotest dbname=pqgotest sslmode=verify-full"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      redis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package redis for session provider depend on github.com/gomodule/redigo/redis go install github.com/gomodule/redigo/redis Usage: import( _ "github.com/astaxie/beego/session/redis" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("redis", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"127.0.0.1:7070"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package redis for session provider depend on github.com/gomodule/redigo/redis go install github.com/gomodule/redigo/redis Usage: import( _ "github.com/astaxie/beego/session/redis" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("redis", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"127.0.0.1:7070"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      redis_cluster
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package redis for session provider depend on github.com/go-redis/redis go install github.com/go-redis/redis Usage: import( _ "github.com/astaxie/beego/session/redis_cluster" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("redis_cluster", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"127.0.0.1:7070;127.0.0.1:7071"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package redis for session provider depend on github.com/go-redis/redis go install github.com/go-redis/redis Usage: import( _ "github.com/astaxie/beego/session/redis_cluster" "github.com/astaxie/beego/session" ) func init() { globalSessions, _ = session.NewManager("redis_cluster", “{"cookieName":"gosessionid","gclifetime":3600,"ProviderConfig":"127.0.0.1:7070;127.0.0.1:7071"}“) go globalSessions.GC() } more docs: http://beego.me/docs/module/session.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package swagger struct definition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package swagger struct definition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package toolbox healthcheck type DatabaseCheck struct { } func (dc *DatabaseCheck) Check() error { if dc.isConnected() { return nil } else { return errors.New("can't connect database") } } AddHealthCheck("database",&DatabaseCheck{}) more docs: http://beego.me/docs/module/toolbox.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package toolbox healthcheck type DatabaseCheck struct { } func (dc *DatabaseCheck) Check() error { if dc.isConnected() { return nil } else { return errors.New("can't connect database") } } AddHealthCheck("database",&DatabaseCheck{}) more docs: http://beego.me/docs/module/toolbox.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      captcha
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package captcha implements generation and verification of image CAPTCHAs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package captcha implements generation and verification of image CAPTCHAs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pagination
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package pagination provides utilities to setup a paginator within the context of a http request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package pagination provides utilities to setup a paginator within the context of a http request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package validation for validations import ( "github.com/astaxie/beego/validation" "log" ) type User struct { Name string Age int } func main() { u := User{"man", 40} valid := validation.Validation{} valid.Required(u.Name, "name") valid.MaxSize(u.Name, 15, "nameMax") valid.Range(u.Age, 0, 140, "age") if valid.HasErrors() { // validation does not pass // print invalid message for _, err := range valid.Errors { log.Println(err.Key, err.Message) } } // or use like this if v := valid.Max(u.Age, 140, "ageMax"); !v.Ok { log.Println(v.Error.Key, v.Error.Message) } } more info: http://beego.me/docs/mvc/controller/validation.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package validation for validations import ( "github.com/astaxie/beego/validation" "log" ) type User struct { Name string Age int } func main() { u := User{"man", 40} valid := validation.Validation{} valid.Required(u.Name, "name") valid.MaxSize(u.Name, 15, "nameMax") valid.Range(u.Age, 0, 140, "age") if valid.HasErrors() { // validation does not pass // print invalid message for _, err := range valid.Errors { log.Println(err.Key, err.Message) } } // or use like this if v := valid.Max(u.Age, 140, "ageMax"); !v.Ok { log.Println(v.Error.Key, v.Error.Message) } } more info: http://beego.me/docs/mvc/controller/validation.md