name: Controller funcs

sort: 3

Introduction to controller

Note: From version 1.6: this.ServeJson() has been changed to this.ServeJSON() and this.TplNames has been changed to this.TplName

Beego’s controller needs to be embeded as beego.Controller:

  1. type xxxController struct {
  2.     beego.Controller
  3. }

beego.Controller implements interface beego.ControllerInterface. beego.ControllerInterface defines these functions:

  • Init(ct *context.Context, controllerName, actionName string, app interface{})

    This function will initialize Context, Controller name, template name, template variable container Data. app is the executing Controller’s reflecttype. This can be used to execute the subclass’s methods.

  • Prepare()

    This function is used for extension and will execute before the methods below. It can be overwritten to implement functions such as user validation.

  • Get()

    This method will be executed if the HTTP request method is GET. It returns 403 by default. This can be used to handle GET requests by overwriting them in the struct of subclass.

  • Post()

    This method will be executed if the HTTP request method is POST. It returns 403 by default. This can be used to handle POST requests by overwriting them in the struct of subclass.

  • Delete()

    This method will be executed if the HTTP request method is DELETE. It returns 403 by default. This can be used to handle DELETE requests by overwriting them in the struct of subclass.

  • Put()

    This method will be executed if the HTTP request method is PUT. It returns 403 by default. This can be used to handle PUT requests by overwriting them in the struct of subclass.

  • Head()

    This method will be executed if the HTTP request method is HEAD. It return 403 by default. This can be used to handle HEAD requests by overwriting them in the struct of subclass.

  • Patch()

    This method will be executed if the HTTP request method is PATCH. It returns 403 by default. This can be used to handle PATCH requests by overwriting them in the struct of subclass.

  • Options()

    This method will be executed if the HTTP request method is OPTIONS. It returns 403 by default. This can be used to handle OPTIONS requests by overwriting them in the struct of subclass.

  • Finish()

    This method will be executed after finishing the related HTTP method. It is empty by default. This can be implemented by overwriting it in the struct of subclass. It is used for database closing, data cleaning and so on.

  • Render() error

    This method is used to render templates. It is only executed if beego.AutoRender is set to true.

Custom logica can be implemented by overwriting functions in struct. For example:

  1. type AddController struct {
  2.     beego.Controller
  3. }
  5. func (this *AddController) Prepare() {
  7. }
  9. func (this *AddController) Get() {
  10.     this.Data["content"] = "value"
  11.     this.Layout = "admin/layout.html"
  12.     this.TplName = "admin/add.tpl"
  13. }
  15. func (this *AddController) Post() {
  16.     pkgname := this.GetString("pkgname")
  17.     content := this.GetString("content")
  18.     pk := models.GetCruPkg(pkgname)
  19.     if pk.Id == 0 {
  20.         var pp models.PkgEntity
  21.         pp.Pid = 0
  22.         pp.Pathname = pkgname
  23.         pp.Intro = pkgname
  24.         models.InsertPkg(pp)
  25.         pk = models.GetCruPkg(pkgname)
  26.     }
  27.     var at models.Article
  28.     at.Pkgid = pk.Id
  29.     at.Content = content
  30.     models.InsertArticle(at)
  31.     this.Ctx.Redirect(302, "/admin/index")
  32. }

In the example above a RESTful structure has been implemented by overwriting functions.

The following example implements a baseController and other initialization methods that will be inherited by other controllers:

  1. type NestPreparer interface {
  2.         NestPrepare()
  3. }
  5. // baseRouter implements global settings for all other routers.
  6. type baseRouter struct {
  7.         beego.Controller
  8.         i18n.Locale
  9.         user    models.User
  10.         isLogin bool
  11. }
  12. // Prepare implements Prepare method for baseRouter.
  13. func (this *baseRouter) Prepare() {
  15.         // page start time
  16.         this.Data["PageStartTime"] = time.Now()
  18.         // Setting properties.
  19.         this.Data["AppDescription"] = utils.AppDescription
  20.         this.Data["AppKeywords"] = utils.AppKeywords
  21.         this.Data["AppName"] = utils.AppName
  22.         this.Data["AppVer"] = utils.AppVer
  23.         this.Data["AppUrl"] = utils.AppUrl
  24.         this.Data["AppLogo"] = utils.AppLogo
  25.         this.Data["AvatarURL"] = utils.AvatarURL
  26.         this.Data["IsProMode"] = utils.IsProMode
  28.         if app, ok := this.AppController.(NestPreparer); ok {
  29.                 app.NestPrepare()
  30.         }
  31. }

The above example defines a base class and initializes some variables. It will test if the executing Controller is an implementation of NestPreparer. If it is it calls the method of subclass.

The example below shows an implementation of NestPreparer:

  1. type BaseAdminRouter struct {
  2.     baseRouter
  3. }
  5. func (this *BaseAdminRouter) NestPrepare() {
  6.     if this.CheckActiveRedirect() {
  7.             return
  8.     }
  10.     // if user isn't admin, then logout user
  11.     if !this.user.IsAdmin {
  12.             models.LogoutUser(&this.Controller)
  14.             // write flash message
  15.             this.FlashWrite("NotPermit", "true")
  17.             this.Redirect("/login", 302)
  18.             return
  19.     }
  21.     // current in admin page
  22.     this.Data["IsAdmin"] = true
  24.     if app, ok := this.AppController.(ModelPreparer); ok {
  25.             app.ModelPrepare()
  26.             return
  27.     }
  28. }
  30. func (this *BaseAdminRouter) Get(){
  31.     this.TplName = "Get.tpl"
  32. }
  34. func (this *BaseAdminRouter) Post(){
  35.     this.TplName = "Post.tpl"
  36. }

The above example first executes Prepare. Go will search for methods in the struct by looking in the parent classes. BaseAdminRouter will execute and checks whether there is a Prepare method. If not it keeps searching baseRouter. If there is it will execute the logic. this.AppController in baseRouter is the currently executing Controller BaseAdminRouter. Next, it will execute BaseAdminRouter.NestPrepare method. Finally, it will start executing the related GET or POST method.

Stop controller executing immediately

To stop the execution logic of a request and return the response immediately use StopRun(). For example, when a user authentication fails in Prepare method a response will be returned immediately. 

  1. type RController struct {
  2.     beego.Controller
  3. }
  5. func (this *RController) Prepare() {
  6.     this.Data["json"] = map[string]interface{}{"name": "astaxie"}
  7.     this.ServeJSON()
  8.     this.StopRun()
  9. }

If you call StopRun the Finish method won’t be run. To free resources call Finish manually before calling StopRun.

Using PUT method in HTTP form

Since XHTML 1.x forms only support GET and POST these are the only allowed values for the “method” attribute. Optionally, this can be extended as follows:

Add a hidden input in the post form:

  1. <form method="post" ...>
  2.   <input type="hidden" name="_method" value="put" />

Then add a filter in Beego to check if the requests should be treated as a put request:

  1. var FilterMethod = func(ctx *context.Context) {
  2.     if ctx.Input.Query("_method")!="" && ctx.Input.IsPost(){
  3.           ctx.Request.Method = ctx.Input.Query("_method")
  4.     }
  5. }
  7. beego.InsertFilter("*", beego.BeforeRouter, FilterMethod)