fargo

package module
v0.0.0-...-30f4346 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 18, 2015 License: Apache-2.0 Imports: 38 Imported by: 0

README

Beego

Build Status GoDoc

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

######Congratulations! You just built your first beego app. Open your browser and visit http://localhost:8000. 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 is licensed under the Apache Licence, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0.html).

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 infomation: http://beego.me

Index

Constants

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

View Source
const VERSION = "1.5.0"

beego web framework version.

Variables

View Source
var (
	// AccessLogs represent whether output the access logs, default is false
	AccessLogs bool
	// AdminHTTPAddr is address for admin
	AdminHTTPAddr string
	// AdminHTTPPort is listens port for admin
	AdminHTTPPort int
	// AppConfig is the instance of Config, store the config information from file
	AppConfig *beegoAppConfig
	// AppName represent Application name, always the project folder name
	AppName string
	// AppPath is the path to the application
	AppPath string
	// AppConfigPath is the path to the config files
	AppConfigPath string
	// AppConfigProvider is the provider for the config, default is ini
	AppConfigProvider string
	// AutoRender is a flag of render template automatically. It's always turn off in API application
	// default is true
	AutoRender bool
	// BeegoServerName exported in response header.
	BeegoServerName string
	// CopyRequestBody is just useful for raw request body in context. default is false
	CopyRequestBody bool
	// DirectoryIndex wheather display directory index. default is false.
	DirectoryIndex bool
	// EnableAdmin means turn on admin module to log every request info.
	EnableAdmin bool
	// EnableDocs enable generate docs & server docs API Swagger
	EnableDocs bool
	// EnableErrorsShow wheather show errors in page. if true, show error and trace info in page rendered with error template.
	EnableErrorsShow bool
	// EnabelFcgi turn on the fcgi Listen, default is false
	EnabelFcgi bool
	// EnableGzip means gzip the response
	EnableGzip bool
	// EnableHTTPListen represent whether turn on the HTTP, default is true
	EnableHTTPListen bool
	// EnableHTTPTLS represent whether turn on the HTTPS, default is true
	EnableHTTPTLS bool
	// EnableStdIo works with EnabelFcgi Use FCGI via standard I/O
	EnableStdIo bool
	// EnableXSRF whether turn on xsrf. default is false
	EnableXSRF bool
	// FlashName is the name of the flash variable found in response header and cookie
	FlashName string
	// FlashSeperator used to seperate flash key:value, default is BEEGOFLASH
	FlashSeperator string
	// GlobalSessions is the instance for the session manager
	GlobalSessions *session.Manager
	// Graceful means use graceful module to start the server
	Graceful bool

	// ListenTCP4 represent only Listen in TCP4, default is false
	ListenTCP4 bool
	// MaxMemory The whole request body is parsed and up to a total of maxMemory
	// bytes of its file parts are stored in memory, with the remainder stored on disk in temporary files
	MaxMemory int64
	// HTTPAddr is the TCP network address addr for HTTP
	HTTPAddr string
	// HTTPPort is listens port for HTTP
	HTTPPort int
	// HTTPSPort is listens port for HTTPS
	HTTPSPort int
	// HTTPCertFile is the path to certificate file
	HTTPCertFile string
	// HTTPKeyFile is the path to private key file
	HTTPKeyFile string
	// HTTPServerTimeOut HTTP server timeout. default is 0, no timeout
	HTTPServerTimeOut int64
	// RecoverPanic is a flag for auto recover panic, default is true
	RecoverPanic bool
	// RouterCaseSensitive means whether router case sensitive, default is true
	RouterCaseSensitive bool
	// RunMode represent the staging, "dev" or "prod"
	RunMode string
	// SessionOn means whether turn on the session auto when application started. default is false.
	SessionOn bool
	// SessionProvider means session provider, e.q memory, mysql, redis,etc.
	SessionProvider string
	// SessionName is the cookie name when saving session id into cookie.
	SessionName string
	// SessionGCMaxLifetime for auto cleaning expired session.
	SessionGCMaxLifetime int64
	// SessionProviderConfig is for the provider config, define save path or connection info.
	SessionProviderConfig string
	// SessionCookieLifeTime means the life time of session id in cookie.
	SessionCookieLifeTime int
	// SessionAutoSetCookie auto setcookie
	SessionAutoSetCookie bool
	// SessionDomain means the cookie domain default is empty
	SessionDomain string
	// StaticDir store the static path, key is path, value is the folder
	StaticDir map[string]string
	// StaticExtensionsToGzip stores the extensions which need to gzip(.js,.css,etc)
	StaticExtensionsToGzip []string
	// TemplateCache store the caching template
	TemplateCache map[string]*template.Template
	// TemplateLeft left delimiter
	TemplateLeft string
	// TemplateRight right delimiter
	TemplateRight string
	// ViewsPath means the template folder
	ViewsPath string
	// XSRFKEY xsrf hash salt string.
	XSRFKEY string
	// XSRFExpire is the expiry of xsrf value.
	XSRFExpire int
)
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 (

	// BeeTemplates caching map and supported template file extensions.
	BeeTemplates = make(map[string]*template.Template)
	// BeeTemplateExt stores the template extention which will build
	BeeTemplateExt = []string{"tpl", "html"}
)
View Source
var BeeLogger *logs.BeeLogger

BeeLogger references the used application logger.

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

map of http handlers for each error string.

View Source
var FilterMonitorFunc func(string, string, time.Duration) 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) bool {
 	if method == "POST" {
		return false
 	}
 	if t.Nanoseconds() < 100 {
		return false
 	}
 	if strings.HasPrefix(requestPath, "/astaxie") {
		return false
 	}
 	return true
}
beego.FilterMonitorFunc = MyFilterMonitor.
View Source
var GlobalDocAPI map[string]interface{}

GlobalDocAPI store the swagger api documents

Functions

func AddAPPStartHook

func AddAPPStartHook(hf hookfunc)

AddAPPStartHook is used to register the hookfunc The hookfuncs will run in beego.Run() such as sessionInit, middlerware start, buildtemplate, admin start

func AddFuncMap

func AddFuncMap(key string, funname 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 Alert

func Alert(v ...interface{})

Alert logs a message at alert level.

func AssetsCSS

func AssetsCSS(src string) template.HTML

AssetsCSS returns stylesheet link tag with src string.

func AssetsJs

func AssetsJs(src 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 Config

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

Config get the Appconfig

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 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(src string) string

Htmlquote returns quoted html string.

func Htmlunquote

func Htmlunquote(src 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 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 ParseConfig

func ParseConfig() (err error)

ParseConfig parsed default config file. now only support ini, next will support json.

func ParseForm

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

ParseForm will parse form values to struct via tag.

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(":8089") beego.Run("127.0.0.1:8089")

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(apppath 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 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", func(ctx *context.Context){
      ctx.Output.Body("hello world")
})
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 (*App) Run

func (app *App) Run()

Run beego application.

type Controller

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

	TplNames       string
	Layout         string
	LayoutSections map[string]string // the key is the section name and the value is the template name
	TplExt         string

	CruSession    session.Store
	XSRFExpire    int
	AppController interface{}
	EnableRender  bool
	EnableXSRF    bool
	// 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() (controllerName, actionName 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) 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 parse request param and path value 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) SessionRegenerateID

func (c *Controller) SessionRegenerateID()

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

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
}

ControllerComments store the comment for the controller method

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) 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. The bool params is for setting the returnOnOutput value (false allows multiple filters to execute)

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]string{
		"GET":     "GET",
		"POST":    "POST",
		"PUT":     "PUT",
		"DELETE":  "DELETE",
		"PATCH":   "PATCH",
		"OPTIONS": "OPTIONS",
		"HEAD":    "HEAD",
		"TRACE":   "TRACE",
		"CONNECT": "CONNECT",
	}

	// 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) (bool, map[string]string)

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(filiterList ...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(filiterList ...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 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 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 condtion 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 Tree

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

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

func NewTree

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) (runObject interface{}, params map[string]string)

Match router to runObject & params

Directories

Path Synopsis
Package cache provide a Cache interface and some implemetn engine Usage: import( "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("memory", `{"interval":60}`) Use it like this: bm.Put("astaxie", 1, 10) 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 implemetn engine Usage: import( "github.com/astaxie/beego/cache" ) bm, err := cache.NewCache("memory", `{"interval":60}`) Use it like this: bm.Put("astaxie", 1, 10) 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/garyburd/redigo/redis go install github.com/garyburd/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/garyburd/redigo/redis go install github.com/garyburd/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 Usage: import( "github.com/astaxie/beego/config" ) cnf, err := config.NewConfig("ini", "config.conf") cnf APIS: cnf.Set(key, val string) error cnf.String(key string) string cnf.Strings(key string) []string cnf.Int(key string) (int, error) cnf.Int64(key string) (int64, error) cnf.Bool(key string) (bool, error) cnf.Float(key string) (float64, error) cnf.DefaultString(key string, defaultval string) string cnf.DefaultStrings(key string, defaultval []string) []string cnf.DefaultInt(key string, defaultval int) int cnf.DefaultInt64(key string, defaultval int64) int64 cnf.DefaultBool(key string, defaultval bool) bool cnf.DefaultFloat(key string, defaultval float64) float64 cnf.DIY(key string) (interface{}, error) cnf.GetSection(section string) (map[string]string, error) cnf.SaveConfigFile(filename string) error more docs http://beego.me/docs/module/config.md
Package config is used to parse config Usage: import( "github.com/astaxie/beego/config" ) cnf, err := config.NewConfig("ini", "config.conf") cnf APIS: cnf.Set(key, val string) error cnf.String(key string) string cnf.Strings(key string) []string cnf.Int(key string) (int, error) cnf.Int64(key string) (int64, error) cnf.Bool(key string) (bool, error) cnf.Float(key string) (float64, error) cnf.DefaultString(key string, defaultval string) string cnf.DefaultStrings(key string, defaultval []string) []string cnf.DefaultInt(key string, defaultval int) int cnf.DefaultInt64(key string, defaultval int64) int64 cnf.DefaultBool(key string, defaultval bool) bool cnf.DefaultFloat(key string, defaultval float64) float64 cnf.DIY(key string) (interface{}, error) cnf.GetSection(section string) (map[string]string, error) cnf.SaveConfigFile(filename string) error more docs http://beego.me/docs/module/config.md
xml
Package xml for config provider depend on github.com/beego/x2j go install github.com/beego/x2j Usage: import( _ "github.com/astaxie/beego/config/xml" "github.com/astaxie/beego/config" ) cnf, err := config.NewConfig("xml", "config.xml") more docs http://beego.me/docs/module/config.md
Package xml for config provider depend on github.com/beego/x2j go install github.com/beego/x2j Usage: import( _ "github.com/astaxie/beego/config/xml" "github.com/astaxie/beego/config" ) cnf, err := config.NewConfig("xml", "config.xml") more docs http://beego.me/docs/module/config.md
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
es
Package migration is used for migration The table structure is as follow: CREATE TABLE `migrations` ( `id_migration` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'surrogate key', `name` varchar(255) DEFAULT NULL COMMENT 'migration name, unique', `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'date migrated or rolled back', `statements` longtext COMMENT 'SQL statements for this migration', `rollback_statements` longtext, `status` enum('update','rollback') DEFAULT NULL COMMENT 'update indicates it is a normal migration while rollback means this migration is rolled back', PRIMARY KEY (`id_migration`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Package migration is used for migration The table structure is as follow: CREATE TABLE `migrations` ( `id_migration` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'surrogate key', `name` varchar(255) DEFAULT NULL COMMENT 'migration name, unique', `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'date migrated or rolled back', `statements` longtext COMMENT 'SQL statements for this migration', `rollback_statements` longtext, `status` enum('update','rollback') DEFAULT NULL COMMENT 'update indicates it is a normal migration while rollback means this migration is rolled back', PRIMARY KEY (`id_migration`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
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.
cors
Package cors provides handlers to enable CORS support.
Package cors provides handlers to enable CORS support.
jwt
Package jwt provides JWT (Json Web Token) authentication Usage In file main.go import ( "github.com/astaxie/beego" "github.com/astaxie/beego/plugins/jwt" ) func main() { // JWT for Url matching /v1/* // PrivateKeyPath: The path for the private RSA key used by JWT // PublicKeyPath: The path for the public RSA key used by JWT // The list of Urls should be excluded from the JWT Auth beego.InsertFilter("/v1/*", beego.BeforeRouter, jwt.AuthRequest(&jwt.Options{ PrivateKeyPath: "conf/beeblog.rsa", PublicKeyPath: "conf/beeblog.rsa.pub", WhiteList: []string{"/v1/jwt/issue-token", "/docs"}, })) beego.Run() } In file routers/router.go import ( "github.com/astaxie/beego" "github.com/astaxie/beego/plugins/jwt" ) func init() { ns := beego.NSNamespace("/jwt", beego.NSInclude( &jwt.JwtController{}, ), ) beego.AddNamespace(ns) }
Package jwt provides JWT (Json Web Token) authentication Usage In file main.go import ( "github.com/astaxie/beego" "github.com/astaxie/beego/plugins/jwt" ) func main() { // JWT for Url matching /v1/* // PrivateKeyPath: The path for the private RSA key used by JWT // PublicKeyPath: The path for the public RSA key used by JWT // The list of Urls should be excluded from the JWT Auth beego.InsertFilter("/v1/*", beego.BeforeRouter, jwt.AuthRequest(&jwt.Options{ PrivateKeyPath: "conf/beeblog.rsa", PublicKeyPath: "conf/beeblog.rsa.pub", WhiteList: []string{"/v1/jwt/issue-token", "/docs"}, })) beego.Run() } In file routers/router.go import ( "github.com/astaxie/beego" "github.com/astaxie/beego/plugins/jwt" ) func init() { ns := beego.NSNamespace("/jwt", beego.NSInclude( &jwt.JwtController{}, ), ) beego.AddNamespace(ns) }
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, "sessionIDHashFunc": "sha1", "sessionIDHashKey": "", "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, "sessionIDHashFunc": "sha1", "sessionIDHashKey": "", "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/garyburd/redigo/redis go install github.com/garyburd/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/garyburd/redigo/redis go install github.com/garyburd/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 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); !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); !v.Ok { log.Println(v.Error.Key, v.Error.Message) } } more info: http://beego.me/docs/mvc/controller/validation.md

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL