func (c *Controller) GetString(key string, def ...string) string {
	if v := c.Ctx.Input.Query(key); v != "" {
		return v
	}
	if len(def) > 0 {
		return def[0]
	}
	return ""
}
GetString returns the input value by key string or the default value while it's present and input is blank
package beego
import (
	"bytes"
	"errors"
	"html/template"
	"io"
	"mime/multipart"
	"net/http"
	"net/url"
	"os"
	"reflect"
	"strconv"
	"strings"
	"github.com/astaxie/beego/context"
	"github.com/astaxie/beego/session"
)
const (
	applicationJSON = "application/json"
	applicationXML  = "application/xml"
	textXML         = "text/xml"
)
var (
	ErrAbort = errors.New("User stop run")
	GlobalControllerRouter = make(map[string][]ControllerComments)
)
type ControllerComments struct {
	Method           string
	Router           string
	AllowHTTPMethods []string
	Params           []map[string]string
}
type Controller struct {
	Ctx  *context.Context
	Data map[interface{}]interface{}
	controllerName string
	actionName     string
	methodMapping  map[string]func()  
	gotofunc       string
	AppController  interface{}
	TplName        string
	Layout         string
	LayoutSections map[string]string  
	TplPrefix      string
	TplExt         string
	EnableRender   bool
	_xsrfToken string
	XSRFExpire int
	EnableXSRF bool
	CruSession session.Store
}
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()
}
func (c *Controller) Init(ctx *context.Context, controllerName, actionName string, app interface{}) {
	c.Layout = ""
	c.TplName = ""
	c.controllerName = controllerName
	c.actionName = actionName
	c.Ctx = ctx
	c.TplExt = "tpl"
	c.AppController = app
	c.EnableRender = true
	c.EnableXSRF = true
	c.Data = ctx.Input.Data()
	c.methodMapping = make(map[string]func())
}
func (c *Controller) Prepare() {}
func (c *Controller) Finish() {}
func (c *Controller) Get() {
	http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", 405)
}
func (c *Controller) Post() {
	http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", 405)
}
func (c *Controller) Delete() {
	http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", 405)
}
func (c *Controller) Put() {
	http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", 405)
}
func (c *Controller) Head() {
	http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", 405)
}
func (c *Controller) Patch() {
	http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", 405)
}
func (c *Controller) Options() {
	http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", 405)
}
func (c *Controller) HandlerFunc(fnname string) bool {
	if v, ok := c.methodMapping[fnname]; ok {
		v()
		return true
	}
	return false
}
func (c *Controller) URLMapping() {}
func (c *Controller) Mapping(method string, fn func()) {
	c.methodMapping[method] = fn
}
func (c *Controller) Render() error {
	if !c.EnableRender {
		return nil
	}
	rb, err := c.RenderBytes()
	if err != nil {
		return err
	}
	c.Ctx.Output.Header("Content-Type", "text/html; charset=utf-8")
	return c.Ctx.Output.Body(rb)
}
func (c *Controller) RenderString() (string, error) {
	b, e := c.RenderBytes()
	return string(b), e
}
func (c *Controller) RenderBytes() ([]byte, error) {
	buf, err := c.renderTemplate()
	if err == nil && c.Layout != "" {
		c.Data["LayoutContent"] = template.HTML(buf.String())
		if c.LayoutSections != nil {
			for sectionName, sectionTpl := range c.LayoutSections {
				if sectionTpl == "" {
					c.Data[sectionName] = ""
					continue
				}
				buf.Reset()
				err = ExecuteTemplate(&buf, sectionTpl, c.Data)
				if err != nil {
					return nil, err
				}
				c.Data[sectionName] = template.HTML(buf.String())
			}
		}
		buf.Reset()
		ExecuteTemplate(&buf, c.Layout, c.Data)
	}
	return buf.Bytes(), err
}
func (c *Controller) renderTemplate() (bytes.Buffer, error) {
	var buf bytes.Buffer
	if c.TplName == "" {
		c.TplName = strings.ToLower(c.controllerName) + "/" + strings.ToLower(c.actionName) + "." + c.TplExt
	}
	if c.TplPrefix != "" {
		c.TplName = c.TplPrefix + c.TplName
	}
	if BConfig.RunMode == DEV {
		buildFiles := []string{c.TplName}
		if c.Layout != "" {
			buildFiles = append(buildFiles, c.Layout)
			if c.LayoutSections != nil {
				for _, sectionTpl := range c.LayoutSections {
					if sectionTpl == "" {
						continue
					}
					buildFiles = append(buildFiles, sectionTpl)
				}
			}
		}
		BuildTemplate(BConfig.WebConfig.ViewsPath, buildFiles...)
	}
	return buf, ExecuteTemplate(&buf, c.TplName, c.Data)
}
func (c *Controller) Redirect(url string, code int) {
	c.Ctx.Redirect(code, url)
}
func (c *Controller) Abort(code string) {
	status, err := strconv.Atoi(code)
	if err != nil {
		status = 200
	}
	c.CustomAbort(status, code)
}
func (c *Controller) CustomAbort(status int, body string) {
	if _, ok := ErrorMaps[body]; ok {
		c.Ctx.Output.Status = status
		panic(body)
	}
	c.Ctx.ResponseWriter.WriteHeader(status)
	c.Ctx.ResponseWriter.Write([]byte(body))
	panic(ErrAbort)
}
func (c *Controller) StopRun() {
	panic(ErrAbort)
}
func (c *Controller) URLFor(endpoint string, values ...interface{}) string {
	if len(endpoint) == 0 {
		return ""
	}
	if endpoint[0] == '.' {
		return URLFor(reflect.Indirect(reflect.ValueOf(c.AppController)).Type().Name()+endpoint, values...)
	}
	return URLFor(endpoint, values...)
}
func (c *Controller) ServeJSON(encoding ...bool) {
	var (
		hasIndent   = true
		hasEncoding = false
	)
	if BConfig.RunMode == PROD {
		hasIndent = false
	}
	if len(encoding) > 0 && encoding[0] == true {
		hasEncoding = true
	}
	c.Ctx.Output.JSON(c.Data["json"], hasIndent, hasEncoding)
}
func (c *Controller) ServeJSONP() {
	hasIndent := true
	if BConfig.RunMode == PROD {
		hasIndent = false
	}
	c.Ctx.Output.JSONP(c.Data["jsonp"], hasIndent)
}
func (c *Controller) ServeXML() {
	hasIndent := true
	if BConfig.RunMode == PROD {
		hasIndent = false
	}
	c.Ctx.Output.XML(c.Data["xml"], hasIndent)
}
func (c *Controller) ServeFormatted() {
	accept := c.Ctx.Input.Header("Accept")
	switch accept {
	case applicationJSON:
		c.ServeJSON()
	case applicationXML, textXML:
		c.ServeXML()
	default:
		c.ServeJSON()
	}
}
func (c *Controller) Input() url.Values {
	if c.Ctx.Request.Form == nil {
		c.Ctx.Request.ParseForm()
	}
	return c.Ctx.Request.Form
}
func (c *Controller) ParseForm(obj interface{}) error {
	return ParseForm(c.Input(), obj)
}