| Request Method: | {{.RequestMethod}} | +
| Request URL: | {{.RequestURL}} | +
| RemoteAddr: | {{.RemoteAddr }} | +
+ Stack
+
+ {{.Stack}}
+ %s", + taskname, res.Content.(string)))} + + } else { + data["Message"] = []string{"error", template.HTMLEscapeString(fmt.Sprintf("%s", res.Error))} + } + } + + // List Tasks + content := make(M) + resultList := admin.GetCommand("task", "list").Execute().Content.([][]string) + var fields = []string{ + "Task Name", + "Task Spec", + "Task Status", + "Last Time", + "", + } + + content["Fields"] = fields + content["Data"] = resultList + data["Content"] = content + data["Title"] = "Tasks" + writeTemplate(rw, data, tasksTpl, defaultScriptsTpl) +} + +func (a *adminController) AdminIndex() { + // AdminIndex is the default http.Handler for admin module. + // it matches url pattern "/". + writeTemplate(a.Ctx.ResponseWriter, map[interface{}]interface{}{}, indexTpl, defaultScriptsTpl) +} + +// Healthcheck is a http.Handler calling health checking and showing the result. +// it's in "/healthcheck" pattern in admin module. +func (a *adminController) Healthcheck() { + heathCheck(a.Ctx.ResponseWriter, a.Ctx.Request) +} + +func heathCheck(rw http.ResponseWriter, r *http.Request) { + var ( + result []string + data = make(map[interface{}]interface{}) + resultList = new([][]string) + content = M{ + "Fields": []string{"Name", "Message", "Status"}, + } + ) + + for name, h := range admin.AdminCheckList { + if err := h.Check(); err != nil { + result = []string{ + "error", + template.HTMLEscapeString(name), + template.HTMLEscapeString(err.Error()), + } + } else { + result = []string{ + "success", + template.HTMLEscapeString(name), + "OK", + } + } + *resultList = append(*resultList, result) + } + + queryParams := r.URL.Query() + jsonFlag := queryParams.Get("json") + shouldReturnJSON, _ := strconv.ParseBool(jsonFlag) + + if shouldReturnJSON { + response := buildHealthCheckResponseList(resultList) + jsonResponse, err := json.Marshal(response) + + if err != nil { + http.Error(rw, err.Error(), http.StatusInternalServerError) + } else { + writeJSON(rw, jsonResponse) + } + return + } + + content["Data"] = resultList + data["Content"] = content + data["Title"] = "Health Check" + + writeTemplate(rw, data, healthCheckTpl, defaultScriptsTpl) +} + +// QpsIndex is the http.Handler for writing qps statistics map result info in http.ResponseWriter. +// it's registered with url pattern "/qps" in admin module. +func (a *adminController) QpsIndex() { + data := make(map[interface{}]interface{}) + data["Content"] = StatisticsMap.GetMap() + + // do html escape before display path, avoid xss + if content, ok := (data["Content"]).(M); ok { + if resultLists, ok := (content["Data"]).([][]string); ok { + for i := range resultLists { + if len(resultLists[i]) > 0 { + resultLists[i][0] = template.HTMLEscapeString(resultLists[i][0]) + } + } + } + } + writeTemplate(a.Ctx.ResponseWriter, data, qpsTpl, defaultScriptsTpl) +} + +// ListConf is the http.Handler of displaying all beego configuration values as key/value pair. +// it's registered with url pattern "/listconf" in admin module. +func (a *adminController) ListConf() { + rw := a.Ctx.ResponseWriter + r := a.Ctx.Request + r.ParseForm() + command := r.Form.Get("command") + if command == "" { + rw.Write([]byte("command not support")) + return + } + + data := make(map[interface{}]interface{}) + switch command { + case "conf": + m := make(M) + list("BConfig", BConfig, m) + m["appConfigPath"] = template.HTMLEscapeString(appConfigPath) + m["appConfigProvider"] = template.HTMLEscapeString(appConfigProvider) + tmpl := template.Must(template.New("dashboard").Parse(dashboardTpl)) + tmpl = template.Must(tmpl.Parse(configTpl)) + tmpl = template.Must(tmpl.Parse(defaultScriptsTpl)) + + data["Content"] = m + + tmpl.Execute(rw, data) + + case "router": + content := BeeApp.PrintTree() + content["Fields"] = []string{ + "Router Pattern", + "Methods", + "Controller", + } + data["Content"] = content + data["Title"] = "Routers" + writeTemplate(rw, data, routerAndFilterTpl, defaultScriptsTpl) + case "filter": + var ( + content = M{ + "Fields": []string{ + "Router Pattern", + "Filter Function", + }, + } + ) + + filterTypeData := BeeApp.reportFilter() + + filterTypes := make([]string, 0, len(filterTypeData)) + for k := range filterTypeData { + filterTypes = append(filterTypes, k) + } + + content["Data"] = filterTypeData + content["Methods"] = filterTypes + + data["Content"] = content + data["Title"] = "Filters" + writeTemplate(rw, data, routerAndFilterTpl, defaultScriptsTpl) + default: + rw.Write([]byte("command not support")) + } +} + +func writeTemplate(rw http.ResponseWriter, data map[interface{}]interface{}, tpls ...string) { + tmpl := template.Must(template.New("dashboard").Parse(dashboardTpl)) + for _, tpl := range tpls { + tmpl = template.Must(tmpl.Parse(tpl)) + } + tmpl.Execute(rw, data) +} + +func buildHealthCheckResponseList(healthCheckResults *[][]string) []map[string]interface{} { + response := make([]map[string]interface{}, len(*healthCheckResults)) + + for i, healthCheckResult := range *healthCheckResults { + currentResultMap := make(map[string]interface{}) + + currentResultMap["name"] = healthCheckResult[0] + currentResultMap["message"] = healthCheckResult[1] + currentResultMap["status"] = healthCheckResult[2] + + response[i] = currentResultMap + } + + return response + +} + +// PrintTree print all routers +// Deprecated using BeeApp directly +func PrintTree() M { + return BeeApp.PrintTree() +} diff --git a/vendor/github.com/beego/beego/v2/server/web/adminui.go b/vendor/github.com/beego/beego/v2/server/web/adminui.go new file mode 100644 index 0000000000000000000000000000000000000000..54d67354017e04c8af90d5fc49ea7c6245f9f73f --- /dev/null +++ b/vendor/github.com/beego/beego/v2/server/web/adminui.go @@ -0,0 +1,356 @@ +// Copyright 2014 beego Author. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package web + +var indexTpl = ` +{{define "content"}} +
Beego Admin Dashboard
++For detail usage please check our document: +
++Toolbox +
++Live Monitor +
+{{.Content}} +{{end}}` + +var profillingTpl = ` +{{define "content"}} +{{.Title}}
+++{{end}}` + +var defaultScriptsTpl = `` + +var gcAjaxTpl = ` +{{define "scripts"}} + +{{end}} +` + +var qpsTpl = `{{define "content"}} +{{.Content}}+
Requests statistics
+| + {{.}} + | + {{end}} +||||||
|---|---|---|---|---|---|---|
| {{index $elem 0}} | +{{index $elem 1}} | +{{index $elem 2}} | +{{index $elem 4}} | +{{index $elem 6}} | +{{index $elem 8}} | +{{index $elem 10}} | +
Configurations
+
+{{range $index, $elem := .Content}}
+{{$index}}={{$elem}}
+{{end}}
+
+{{end}}
+`
+
+var routerAndFilterTpl = `{{define "content"}}
+
+
+{{.Title}}
+ +{{range .Content.Methods}} + +
+
+{{end}}
+
+
+{{end}}`
+
+var tasksTpl = `{{define "content"}}
+
+{{.}}
+
+
+
+
+
+| + {{.}} + | + {{end}} +
|---|
| + {{.}} + | + {{end}} +
{{.Title}}
+ +{{if .Message }} +{{ $messageType := index .Message 0}} + +{{end}} + + +| +{{.}} + | +{{end}} +|
|---|---|
| + {{.}} + | + {{end}} ++ Run + | +
{{.Title}}
+| + {{.}} + | +{{end}} +|
|---|---|
| + {{$elem}} + | + {{end}} + {{end}} ++ {{$header}} + | +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{{template "content" .}}
+
+
+
+
+
+
+
+
+{{template "scripts" .}}
+
+
+`
diff --git a/vendor/github.com/beego/beego/v2/server/web/beego.go b/vendor/github.com/beego/beego/v2/server/web/beego.go
new file mode 100644
index 0000000000000000000000000000000000000000..14e51a942959318cf200cecd9af57180485db573
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/beego.go
@@ -0,0 +1,103 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package web
+
+import (
+ "os"
+ "path/filepath"
+ "sync"
+)
+
+const (
+ // DEV is for develop
+ DEV = "dev"
+ // PROD is for production
+ PROD = "prod"
+)
+
+// M is Map shortcut
+type M map[string]interface{}
+
+// Hook function to run
+type hookfunc func() error
+
+var (
+ hooks = make([]hookfunc, 0) // hook function slice to store the 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 AddAPPStartHook(hf ...hookfunc) {
+ hooks = append(hooks, hf...)
+}
+
+// Run beego application.
+// beego.Run() default run on HttpPort
+// beego.Run("localhost")
+// beego.Run(":8089")
+// beego.Run("127.0.0.1:8089")
+func Run(params ...string) {
+
+ if len(params) > 0 && params[0] != "" {
+ BeeApp.Run(params[0])
+ }
+ BeeApp.Run("")
+}
+
+// RunWithMiddleWares Run beego application with middlewares.
+func RunWithMiddleWares(addr string, mws ...MiddleWare) {
+ BeeApp.Run(addr, mws...)
+}
+
+var initHttpOnce sync.Once
+
+// TODO move to module init function
+func initBeforeHTTPRun() {
+ initHttpOnce.Do(func() {
+ // init hooks
+ AddAPPStartHook(
+ registerMime,
+ registerDefaultErrorHandler,
+ registerSession,
+ registerTemplate,
+ registerAdmin,
+ registerGzip,
+ registerCommentRouter,
+ )
+
+ for _, hk := range hooks {
+ if err := hk(); err != nil {
+ panic(err)
+ }
+ }
+ })
+}
+
+// TestBeegoInit is for test package init
+func TestBeegoInit(ap string) {
+ path := filepath.Join(ap, "conf", "app.conf")
+ os.Chdir(ap)
+ InitBeegoBeforeTest(path)
+}
+
+// InitBeegoBeforeTest is for test package init
+func InitBeegoBeforeTest(appConfigPath string) {
+ if err := LoadAppConfig(appConfigProvider, appConfigPath); err != nil {
+ panic(err)
+ }
+ BConfig.RunMode = "test"
+ initBeforeHTTPRun()
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/config.go b/vendor/github.com/beego/beego/v2/server/web/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..d89c59cba17ab786429aafa683e7db4d6b209688
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/config.go
@@ -0,0 +1,561 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package web
+
+import (
+ "crypto/tls"
+ "fmt"
+ "os"
+ "path/filepath"
+ "reflect"
+ "runtime"
+ "strings"
+
+ "github.com/beego/beego/v2"
+ "github.com/beego/beego/v2/core/config"
+ "github.com/beego/beego/v2/core/logs"
+ "github.com/beego/beego/v2/server/web/session"
+
+ "github.com/beego/beego/v2/core/utils"
+ "github.com/beego/beego/v2/server/web/context"
+)
+
+// Config is the main struct for BConfig
+// TODO after supporting multiple servers, remove common config to somewhere else
+type Config struct {
+ AppName string // Application name
+ RunMode string // Running Mode: dev | prod
+ RouterCaseSensitive bool
+ ServerName string
+ RecoverPanic bool
+ RecoverFunc func(*context.Context, *Config)
+ CopyRequestBody bool
+ EnableGzip bool
+ // MaxMemory and MaxUploadSize are used to limit the request body
+ // if the request is not uploading file, MaxMemory is the max size of request body
+ // if the request is uploading file, MaxUploadSize is the max size of request body
+ MaxMemory int64
+ MaxUploadSize int64
+ EnableErrorsShow bool
+ EnableErrorsRender bool
+ Listen Listen
+ WebConfig WebConfig
+ Log LogConfig
+}
+
+// Listen holds for http and https related config
+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
+ ClientAuth int
+}
+
+// WebConfig holds web related config
+type WebConfig struct {
+ AutoRender bool
+ EnableDocs bool
+ FlashName string
+ FlashSeparator string
+ DirectoryIndex bool
+ StaticDir map[string]string
+ StaticExtensionsToGzip []string
+ StaticCacheFileSize int
+ StaticCacheFileNum int
+ TemplateLeft string
+ TemplateRight string
+ ViewsPath string
+ CommentRouterPath string
+ EnableXSRF bool
+ XSRFKey string
+ XSRFExpire int
+ Session SessionConfig
+}
+
+// SessionConfig holds session related config
+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
+}
+
+// LogConfig holds Log related config
+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
+}
+
+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
+
+ // appConfigPath is the path to the config files
+ appConfigPath string
+ // appConfigProvider is the provider for the config, default is ini
+ appConfigProvider = "ini"
+ // WorkPath is the absolute path to project root directory
+ WorkPath string
+)
+
+func init() {
+ BConfig = newBConfig()
+ var err error
+ if AppPath, err = filepath.Abs(filepath.Dir(os.Args[0])); err != nil {
+ panic(err)
+ }
+ WorkPath, err = os.Getwd()
+ if err != nil {
+ panic(err)
+ }
+ var filename = "app.conf"
+ if os.Getenv("BEEGO_RUNMODE") != "" {
+ filename = os.Getenv("BEEGO_RUNMODE") + ".app.conf"
+ }
+ appConfigPath = filepath.Join(WorkPath, "conf", filename)
+ if !utils.FileExists(appConfigPath) {
+ appConfigPath = filepath.Join(AppPath, "conf", filename)
+ if !utils.FileExists(appConfigPath) {
+ AppConfig = &beegoAppConfig{innerConfig: config.NewFakeConfig()}
+ return
+ }
+ }
+ if err = parseConfig(appConfigPath); err != nil {
+ panic(err)
+ }
+}
+
+func defaultRecoverPanic(ctx *context.Context, cfg *Config) {
+ if err := recover(); err != nil {
+ if err == ErrAbort {
+ return
+ }
+ if !cfg.RecoverPanic {
+ panic(err)
+ }
+ if cfg.EnableErrorsShow {
+ if _, ok := ErrorMaps[fmt.Sprint(err)]; ok {
+ exception(fmt.Sprint(err), ctx)
+ return
+ }
+ }
+ var stack string
+ logs.Critical("the request url is ", ctx.Input.URL())
+ logs.Critical("Handler crashed with error", err)
+ for i := 1; ; i++ {
+ _, file, line, ok := runtime.Caller(i)
+ if !ok {
+ break
+ }
+ logs.Critical(fmt.Sprintf("%s:%d", file, line))
+ stack = stack + fmt.Sprintln(fmt.Sprintf("%s:%d", file, line))
+ }
+ if cfg.RunMode == DEV && cfg.EnableErrorsRender {
+ showErr(err, ctx, stack)
+ }
+ if ctx.Output.Status != 0 {
+ ctx.ResponseWriter.WriteHeader(ctx.Output.Status)
+ } else {
+ ctx.ResponseWriter.WriteHeader(500)
+ }
+ }
+}
+
+func newBConfig() *Config {
+ res := &Config{
+ AppName: "beego",
+ RunMode: PROD,
+ RouterCaseSensitive: true,
+ ServerName: "beegoServer:" + beego.VERSION,
+ RecoverPanic: true,
+
+ CopyRequestBody: false,
+ EnableGzip: false,
+ MaxMemory: 1 << 26, // 64MB
+ MaxUploadSize: 1 << 30, // 1GB
+ EnableErrorsShow: true,
+ EnableErrorsRender: true,
+ Listen: Listen{
+ Graceful: false,
+ ServerTimeOut: 0,
+ ListenTCP4: false,
+ EnableHTTP: true,
+ AutoTLS: false,
+ Domains: []string{},
+ TLSCacheDir: ".",
+ HTTPAddr: "",
+ HTTPPort: 8080,
+ EnableHTTPS: false,
+ HTTPSAddr: "",
+ HTTPSPort: 10443,
+ HTTPSCertFile: "",
+ HTTPSKeyFile: "",
+ EnableAdmin: false,
+ AdminAddr: "",
+ AdminPort: 8088,
+ EnableFcgi: false,
+ EnableStdIo: false,
+ ClientAuth: int(tls.RequireAndVerifyClientCert),
+ },
+ WebConfig: WebConfig{
+ AutoRender: true,
+ EnableDocs: false,
+ FlashName: "BEEGO_FLASH",
+ FlashSeparator: "BEEGOFLASH",
+ DirectoryIndex: false,
+ StaticDir: map[string]string{"/static": "static"},
+ StaticExtensionsToGzip: []string{".css", ".js"},
+ StaticCacheFileSize: 1024 * 100,
+ StaticCacheFileNum: 1000,
+ TemplateLeft: "{{",
+ TemplateRight: "}}",
+ ViewsPath: "views",
+ CommentRouterPath: "controllers",
+ EnableXSRF: false,
+ XSRFKey: "beegoxsrf",
+ XSRFExpire: 0,
+ Session: SessionConfig{
+ SessionOn: false,
+ SessionProvider: "memory",
+ SessionName: "beegosessionID",
+ SessionGCMaxLifetime: 3600,
+ SessionProviderConfig: "",
+ SessionDisableHTTPOnly: false,
+ SessionCookieLifeTime: 0, // set cookie default is the browser life
+ SessionAutoSetCookie: true,
+ SessionDomain: "",
+ SessionEnableSidInHTTPHeader: false, // enable store/get the sessionId into/from http headers
+ SessionNameInHTTPHeader: "Beegosessionid",
+ SessionEnableSidInURLQuery: false, // enable get the sessionId from Url Query params
+ },
+ },
+ Log: LogConfig{
+ AccessLogs: false,
+ EnableStaticLogs: false,
+ AccessLogsFormat: "APACHE_FORMAT",
+ FileLineNum: true,
+ Outputs: map[string]string{"console": ""},
+ },
+ }
+
+ res.RecoverFunc = defaultRecoverPanic
+ return res
+}
+
+// now only support ini, next will support json.
+func parseConfig(appConfigPath string) (err error) {
+ AppConfig, err = newAppConfig(appConfigProvider, appConfigPath)
+ if err != nil {
+ return err
+ }
+ return assignConfig(AppConfig)
+}
+
+// assignConfig is tricky.
+// For 1.x, it use assignSingleConfig to parse the file
+// but for 2.x, we use Unmarshaler method
+func assignConfig(ac config.Configer) error {
+
+ parseConfigForV1(ac)
+
+ err := ac.Unmarshaler("", BConfig)
+ if err != nil {
+ _, _ = fmt.Fprintln(os.Stderr, fmt.Sprintf("Unmarshaler config file to BConfig failed. "+
+ "And if you are working on v1.x config file, please ignore this, err: %s", err))
+ return err
+ }
+
+ // init log
+ logs.Reset()
+ for adaptor, cfg := range BConfig.Log.Outputs {
+ err := logs.SetLogger(adaptor, cfg)
+ if err != nil {
+ fmt.Fprintln(os.Stderr, fmt.Sprintf("%s with the config %q got err:%s", adaptor, cfg, err.Error()))
+ return err
+ }
+ }
+ logs.SetLogFuncCall(BConfig.Log.FileLineNum)
+ return nil
+}
+
+func parseConfigForV1(ac config.Configer) {
+ for _, i := range []interface{}{BConfig, &BConfig.Listen, &BConfig.WebConfig, &BConfig.Log, &BConfig.WebConfig.Session} {
+ assignSingleConfig(i, ac)
+ }
+
+ // set the run mode first
+ if envRunMode := os.Getenv("BEEGO_RUNMODE"); envRunMode != "" {
+ BConfig.RunMode = envRunMode
+ } else if runMode, err := ac.String("RunMode"); runMode != "" && err == nil {
+ BConfig.RunMode = runMode
+ }
+
+ if sd, err := ac.String("StaticDir"); sd != "" && err == nil {
+ BConfig.WebConfig.StaticDir = map[string]string{}
+ sds := strings.Fields(sd)
+ for _, v := range sds {
+ if url2fsmap := strings.SplitN(v, ":", 2); len(url2fsmap) == 2 {
+ BConfig.WebConfig.StaticDir["/"+strings.Trim(url2fsmap[0], "/")] = url2fsmap[1]
+ } else {
+ BConfig.WebConfig.StaticDir["/"+strings.Trim(url2fsmap[0], "/")] = url2fsmap[0]
+ }
+ }
+ }
+
+ if sgz, err := ac.String("StaticExtensionsToGzip"); sgz != "" && err == nil {
+ extensions := strings.Split(sgz, ",")
+ fileExts := []string{}
+ for _, ext := range extensions {
+ ext = strings.TrimSpace(ext)
+ if ext == "" {
+ continue
+ }
+ if !strings.HasPrefix(ext, ".") {
+ ext = "." + ext
+ }
+ fileExts = append(fileExts, ext)
+ }
+ if len(fileExts) > 0 {
+ BConfig.WebConfig.StaticExtensionsToGzip = fileExts
+ }
+ }
+
+ if sfs, err := ac.Int("StaticCacheFileSize"); err == nil {
+ BConfig.WebConfig.StaticCacheFileSize = sfs
+ }
+
+ if sfn, err := ac.Int("StaticCacheFileNum"); err == nil {
+ BConfig.WebConfig.StaticCacheFileNum = sfn
+ }
+
+ if lo, err := ac.String("LogOutputs"); lo != "" && err == nil {
+ // if lo is not nil or empty
+ // means user has set his own LogOutputs
+ // clear the default setting to BConfig.Log.Outputs
+ BConfig.Log.Outputs = make(map[string]string)
+ los := strings.Split(lo, ";")
+ for _, v := range los {
+ if logType2Config := strings.SplitN(v, ",", 2); len(logType2Config) == 2 {
+ BConfig.Log.Outputs[logType2Config[0]] = logType2Config[1]
+ } else {
+ continue
+ }
+ }
+ }
+}
+
+func assignSingleConfig(p interface{}, ac config.Configer) {
+ pt := reflect.TypeOf(p)
+ if pt.Kind() != reflect.Ptr {
+ return
+ }
+ pt = pt.Elem()
+ if pt.Kind() != reflect.Struct {
+ return
+ }
+ pv := reflect.ValueOf(p).Elem()
+
+ for i := 0; i < pt.NumField(); i++ {
+ pf := pv.Field(i)
+ if !pf.CanSet() {
+ continue
+ }
+ name := pt.Field(i).Name
+ switch pf.Kind() {
+ case reflect.String:
+ pf.SetString(ac.DefaultString(name, pf.String()))
+ case reflect.Int, reflect.Int64:
+ pf.SetInt(ac.DefaultInt64(name, pf.Int()))
+ case reflect.Bool:
+ pf.SetBool(ac.DefaultBool(name, pf.Bool()))
+ case reflect.Struct:
+ default:
+ // do nothing here
+ }
+ }
+
+}
+
+// LoadAppConfig allow developer to apply a config file
+func LoadAppConfig(adapterName, configPath string) error {
+ absConfigPath, err := filepath.Abs(configPath)
+ if err != nil {
+ return err
+ }
+
+ if !utils.FileExists(absConfigPath) {
+ return fmt.Errorf("the target config file: %s don't exist", configPath)
+ }
+
+ appConfigPath = absConfigPath
+ appConfigProvider = adapterName
+
+ return parseConfig(appConfigPath)
+}
+
+type beegoAppConfig struct {
+ config.BaseConfiger
+ innerConfig config.Configer
+}
+
+func newAppConfig(appConfigProvider, appConfigPath string) (*beegoAppConfig, error) {
+ ac, err := config.NewConfig(appConfigProvider, appConfigPath)
+ if err != nil {
+ return nil, err
+ }
+ return &beegoAppConfig{innerConfig: ac}, nil
+}
+
+func (b *beegoAppConfig) Unmarshaler(prefix string, obj interface{}, opt ...config.DecodeOption) error {
+ return b.innerConfig.Unmarshaler(prefix, obj, opt...)
+}
+
+func (b *beegoAppConfig) Set(key, val string) error {
+ if err := b.innerConfig.Set(BConfig.RunMode+"::"+key, val); err != nil {
+ return b.innerConfig.Set(key, val)
+ }
+ return nil
+}
+
+func (b *beegoAppConfig) String(key string) (string, error) {
+ if v, err := b.innerConfig.String(BConfig.RunMode + "::" + key); v != "" && err == nil {
+ return v, nil
+ }
+ return b.innerConfig.String(key)
+}
+
+func (b *beegoAppConfig) Strings(key string) ([]string, error) {
+ if v, err := b.innerConfig.Strings(BConfig.RunMode + "::" + key); len(v) > 0 && err == nil {
+ return v, nil
+ }
+ return b.innerConfig.Strings(key)
+}
+
+func (b *beegoAppConfig) Int(key string) (int, error) {
+ if v, err := b.innerConfig.Int(BConfig.RunMode + "::" + key); err == nil {
+ return v, nil
+ }
+ return b.innerConfig.Int(key)
+}
+
+func (b *beegoAppConfig) Int64(key string) (int64, error) {
+ if v, err := b.innerConfig.Int64(BConfig.RunMode + "::" + key); err == nil {
+ return v, nil
+ }
+ return b.innerConfig.Int64(key)
+}
+
+func (b *beegoAppConfig) Bool(key string) (bool, error) {
+ if v, err := b.innerConfig.Bool(BConfig.RunMode + "::" + key); err == nil {
+ return v, nil
+ }
+ return b.innerConfig.Bool(key)
+}
+
+func (b *beegoAppConfig) Float(key string) (float64, error) {
+ if v, err := b.innerConfig.Float(BConfig.RunMode + "::" + key); err == nil {
+ return v, nil
+ }
+ return b.innerConfig.Float(key)
+}
+
+func (b *beegoAppConfig) DefaultString(key string, defaultVal string) string {
+ if v, err := b.String(key); v != "" && err == nil {
+ return v
+ }
+ return defaultVal
+}
+
+func (b *beegoAppConfig) DefaultStrings(key string, defaultVal []string) []string {
+ if v, err := b.Strings(key); len(v) != 0 && err == nil {
+ return v
+ }
+ return defaultVal
+}
+
+func (b *beegoAppConfig) DefaultInt(key string, defaultVal int) int {
+ if v, err := b.Int(key); err == nil {
+ return v
+ }
+ return defaultVal
+}
+
+func (b *beegoAppConfig) DefaultInt64(key string, defaultVal int64) int64 {
+ if v, err := b.Int64(key); err == nil {
+ return v
+ }
+ return defaultVal
+}
+
+func (b *beegoAppConfig) DefaultBool(key string, defaultVal bool) bool {
+ if v, err := b.Bool(key); err == nil {
+ return v
+ }
+ return defaultVal
+}
+
+func (b *beegoAppConfig) DefaultFloat(key string, defaultVal float64) float64 {
+ if v, err := b.Float(key); err == nil {
+ return v
+ }
+ return defaultVal
+}
+
+func (b *beegoAppConfig) DIY(key string) (interface{}, error) {
+ return b.innerConfig.DIY(key)
+}
+
+func (b *beegoAppConfig) GetSection(section string) (map[string]string, error) {
+ return b.innerConfig.GetSection(section)
+}
+
+func (b *beegoAppConfig) SaveConfigFile(filename string) error {
+ return b.innerConfig.SaveConfigFile(filename)
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/context/acceptencoder.go b/vendor/github.com/beego/beego/v2/server/web/context/acceptencoder.go
new file mode 100644
index 0000000000000000000000000000000000000000..312e50de249dd33d6a1937a864e77bbe6dd3a8a4
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/context/acceptencoder.go
@@ -0,0 +1,232 @@
+// Copyright 2015 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package context
+
+import (
+ "bytes"
+ "compress/flate"
+ "compress/gzip"
+ "compress/zlib"
+ "io"
+ "net/http"
+ "os"
+ "strconv"
+ "strings"
+ "sync"
+)
+
+var (
+ // Default size==20B same as nginx
+ defaultGzipMinLength = 20
+ // Content will only be compressed if content length is either unknown or greater than gzipMinLength.
+ gzipMinLength = defaultGzipMinLength
+ // Compression level used for deflate compression. (0-9).
+ gzipCompressLevel int
+ // List of HTTP methods to compress. If not set, only GET requests are compressed.
+ includedMethods map[string]bool
+ getMethodOnly bool
+)
+
+// InitGzip initializes the gzipcompress
+func InitGzip(minLength, compressLevel int, methods []string) {
+ if minLength >= 0 {
+ gzipMinLength = minLength
+ }
+ gzipCompressLevel = compressLevel
+ if gzipCompressLevel < flate.NoCompression || gzipCompressLevel > flate.BestCompression {
+ gzipCompressLevel = flate.BestSpeed
+ }
+ getMethodOnly = (len(methods) == 0) || (len(methods) == 1 && strings.ToUpper(methods[0]) == "GET")
+ includedMethods = make(map[string]bool, len(methods))
+ for _, v := range methods {
+ includedMethods[strings.ToUpper(v)] = true
+ }
+}
+
+type resetWriter interface {
+ io.Writer
+ Reset(w io.Writer)
+}
+
+type nopResetWriter struct {
+ io.Writer
+}
+
+func (n nopResetWriter) Reset(w io.Writer) {
+ // do nothing
+}
+
+type acceptEncoder struct {
+ name string
+ levelEncode func(int) resetWriter
+ customCompressLevelPool *sync.Pool
+ bestCompressionPool *sync.Pool
+}
+
+func (ac acceptEncoder) encode(wr io.Writer, level int) resetWriter {
+ if ac.customCompressLevelPool == nil || ac.bestCompressionPool == nil {
+ return nopResetWriter{wr}
+ }
+ var rwr resetWriter
+ switch level {
+ case flate.BestSpeed:
+ rwr = ac.customCompressLevelPool.Get().(resetWriter)
+ case flate.BestCompression:
+ rwr = ac.bestCompressionPool.Get().(resetWriter)
+ default:
+ rwr = ac.levelEncode(level)
+ }
+ rwr.Reset(wr)
+ return rwr
+}
+
+func (ac acceptEncoder) put(wr resetWriter, level int) {
+ if ac.customCompressLevelPool == nil || ac.bestCompressionPool == nil {
+ return
+ }
+ wr.Reset(nil)
+
+ // notice
+ // compressionLevel==BestCompression DOES NOT MATTER
+ // sync.Pool will not memory leak
+
+ switch level {
+ case gzipCompressLevel:
+ ac.customCompressLevelPool.Put(wr)
+ case flate.BestCompression:
+ ac.bestCompressionPool.Put(wr)
+ }
+}
+
+var (
+ noneCompressEncoder = acceptEncoder{"", nil, nil, nil}
+ gzipCompressEncoder = acceptEncoder{
+ name: "gzip",
+ levelEncode: func(level int) resetWriter { wr, _ := gzip.NewWriterLevel(nil, level); return wr },
+ customCompressLevelPool: &sync.Pool{New: func() interface{} { wr, _ := gzip.NewWriterLevel(nil, gzipCompressLevel); return wr }},
+ bestCompressionPool: &sync.Pool{New: func() interface{} { wr, _ := gzip.NewWriterLevel(nil, flate.BestCompression); return wr }},
+ }
+
+ // According to: http://tools.ietf.org/html/rfc2616#section-3.5 the deflate compress in http is zlib indeed
+ // deflate
+ // The "zlib" format defined in RFC 1950 [31] in combination with
+ // the "deflate" compression mechanism described in RFC 1951 [29].
+ deflateCompressEncoder = acceptEncoder{
+ name: "deflate",
+ levelEncode: func(level int) resetWriter { wr, _ := zlib.NewWriterLevel(nil, level); return wr },
+ customCompressLevelPool: &sync.Pool{New: func() interface{} { wr, _ := zlib.NewWriterLevel(nil, gzipCompressLevel); return wr }},
+ bestCompressionPool: &sync.Pool{New: func() interface{} { wr, _ := zlib.NewWriterLevel(nil, flate.BestCompression); return wr }},
+ }
+)
+
+var (
+ encoderMap = map[string]acceptEncoder{ // all the other compress methods will ignore
+ "gzip": gzipCompressEncoder,
+ "deflate": deflateCompressEncoder,
+ "*": gzipCompressEncoder, // * means any compress will accept,we prefer gzip
+ "identity": noneCompressEncoder, // identity means none-compress
+ }
+)
+
+// WriteFile reads from file and writes to writer by the specific encoding(gzip/deflate)
+func WriteFile(encoding string, writer io.Writer, file *os.File) (bool, string, error) {
+ return writeLevel(encoding, writer, file, flate.BestCompression)
+}
+
+// WriteBody reads writes content to writer by the specific encoding(gzip/deflate)
+func WriteBody(encoding string, writer io.Writer, content []byte) (bool, string, error) {
+ if encoding == "" || len(content) < gzipMinLength {
+ _, err := writer.Write(content)
+ return false, "", err
+ }
+ return writeLevel(encoding, writer, bytes.NewReader(content), gzipCompressLevel)
+}
+
+// writeLevel reads from reader and writes to writer by specific encoding and compress level.
+// The compress level is defined by deflate package
+func writeLevel(encoding string, writer io.Writer, reader io.Reader, level int) (bool, string, error) {
+ var outputWriter resetWriter
+ var err error
+ var ce = noneCompressEncoder
+
+ if cf, ok := encoderMap[encoding]; ok {
+ ce = cf
+ }
+ encoding = ce.name
+ outputWriter = ce.encode(writer, level)
+ defer ce.put(outputWriter, level)
+
+ _, err = io.Copy(outputWriter, reader)
+ if err != nil {
+ return false, "", err
+ }
+
+ switch outputWriter.(type) {
+ case io.WriteCloser:
+ outputWriter.(io.WriteCloser).Close()
+ }
+ return encoding != "", encoding, nil
+}
+
+// ParseEncoding will extract the right encoding for response
+// the Accept-Encoding's sec is here:
+// http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3
+func ParseEncoding(r *http.Request) string {
+ if r == nil {
+ return ""
+ }
+ if (getMethodOnly && r.Method == "GET") || includedMethods[r.Method] {
+ return parseEncoding(r)
+ }
+ return ""
+}
+
+type q struct {
+ name string
+ value float64
+}
+
+func parseEncoding(r *http.Request) string {
+ acceptEncoding := r.Header.Get("Accept-Encoding")
+ if acceptEncoding == "" {
+ return ""
+ }
+ var lastQ q
+ for _, v := range strings.Split(acceptEncoding, ",") {
+ v = strings.TrimSpace(v)
+ if v == "" {
+ continue
+ }
+ vs := strings.Split(v, ";")
+ var cf acceptEncoder
+ var ok bool
+ if cf, ok = encoderMap[vs[0]]; !ok {
+ continue
+ }
+ if len(vs) == 1 {
+ return cf.name
+ }
+ if len(vs) == 2 {
+ f, _ := strconv.ParseFloat(strings.Replace(vs[1], "q=", "", -1), 64)
+ if f == 0 {
+ continue
+ }
+ if f > lastQ.value {
+ lastQ = q{cf.name, f}
+ }
+ }
+ }
+ return lastQ.name
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/context/context.go b/vendor/github.com/beego/beego/v2/server/web/context/context.go
new file mode 100644
index 0000000000000000000000000000000000000000..6070c99606cfddc6ae02cd86674fe30f9c2d4769
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/context/context.go
@@ -0,0 +1,263 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package context provide the context utils
+// Usage:
+//
+// import "github.com/beego/beego/v2/context"
+//
+// ctx := context.Context{Request:req,ResponseWriter:rw}
+//
+// more docs http://beego.me/docs/module/context.md
+package context
+
+import (
+ "bufio"
+ "crypto/hmac"
+ "crypto/sha256"
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "net"
+ "net/http"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/beego/beego/v2/core/utils"
+)
+
+// Commonly used mime-types
+const (
+ ApplicationJSON = "application/json"
+ ApplicationXML = "application/xml"
+ ApplicationYAML = "application/x-yaml"
+ TextXML = "text/xml"
+)
+
+// NewContext return the Context with Input and Output
+func NewContext() *Context {
+ return &Context{
+ Input: NewInput(),
+ Output: NewOutput(),
+ }
+}
+
+// Context Http request context struct including BeegoInput, BeegoOutput, http.Request and http.ResponseWriter.
+// BeegoInput and BeegoOutput provides an api to operate request and response more easily.
+type Context struct {
+ Input *BeegoInput
+ Output *BeegoOutput
+ Request *http.Request
+ ResponseWriter *Response
+ _xsrfToken string
+}
+
+// Reset initializes Context, BeegoInput and BeegoOutput
+func (ctx *Context) Reset(rw http.ResponseWriter, r *http.Request) {
+ ctx.Request = r
+ if ctx.ResponseWriter == nil {
+ ctx.ResponseWriter = &Response{}
+ }
+ ctx.ResponseWriter.reset(rw)
+ ctx.Input.Reset(ctx)
+ ctx.Output.Reset(ctx)
+ ctx._xsrfToken = ""
+}
+
+// Redirect redirects to localurl with http header status code.
+func (ctx *Context) Redirect(status int, localurl string) {
+ http.Redirect(ctx.ResponseWriter, ctx.Request, localurl, status)
+}
+
+// Abort stops the request.
+// If beego.ErrorMaps exists, panic body.
+func (ctx *Context) Abort(status int, body string) {
+ ctx.Output.SetStatus(status)
+ panic(body)
+}
+
+// WriteString writes a string to response body.
+func (ctx *Context) WriteString(content string) {
+ ctx.ResponseWriter.Write([]byte(content))
+}
+
+// GetCookie gets a cookie from a request for a given key.
+// (Alias of BeegoInput.Cookie)
+func (ctx *Context) GetCookie(key string) string {
+ return ctx.Input.Cookie(key)
+}
+
+// SetCookie sets a cookie for a response.
+// (Alias of BeegoOutput.Cookie)
+func (ctx *Context) SetCookie(name string, value string, others ...interface{}) {
+ ctx.Output.Cookie(name, value, others...)
+}
+
+// GetSecureCookie gets a secure cookie from a request for a given key.
+func (ctx *Context) GetSecureCookie(Secret, key string) (string, bool) {
+ val := ctx.Input.Cookie(key)
+ if val == "" {
+ return "", false
+ }
+
+ parts := strings.SplitN(val, "|", 3)
+
+ if len(parts) != 3 {
+ return "", false
+ }
+
+ vs := parts[0]
+ timestamp := parts[1]
+ sig := parts[2]
+
+ h := hmac.New(sha256.New, []byte(Secret))
+ fmt.Fprintf(h, "%s%s", vs, timestamp)
+
+ if fmt.Sprintf("%02x", h.Sum(nil)) != sig {
+ return "", false
+ }
+ res, _ := base64.URLEncoding.DecodeString(vs)
+ return string(res), true
+}
+
+// SetSecureCookie sets a secure cookie for a response.
+func (ctx *Context) SetSecureCookie(Secret, name, value string, others ...interface{}) {
+ vs := base64.URLEncoding.EncodeToString([]byte(value))
+ timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+ h := hmac.New(sha256.New, []byte(Secret))
+ fmt.Fprintf(h, "%s%s", vs, timestamp)
+ sig := fmt.Sprintf("%02x", h.Sum(nil))
+ cookie := strings.Join([]string{vs, timestamp, sig}, "|")
+ ctx.Output.Cookie(name, cookie, others...)
+}
+
+// XSRFToken creates and returns an xsrf token string
+func (ctx *Context) XSRFToken(key string, expire int64) string {
+ if ctx._xsrfToken == "" {
+ token, ok := ctx.GetSecureCookie(key, "_xsrf")
+ if !ok {
+ token = string(utils.RandomCreateBytes(32))
+ // TODO make it configurable
+ ctx.SetSecureCookie(key, "_xsrf", token, expire, "", "")
+ }
+ ctx._xsrfToken = token
+ }
+ return ctx._xsrfToken
+}
+
+// CheckXSRFCookie checks if the XSRF token in this request is valid or not.
+// The token can be provided in the request header in the form "X-Xsrftoken" or "X-CsrfToken"
+// or in form field value named as "_xsrf".
+func (ctx *Context) CheckXSRFCookie() bool {
+ token := ctx.Input.Query("_xsrf")
+ if token == "" {
+ token = ctx.Request.Header.Get("X-Xsrftoken")
+ }
+ if token == "" {
+ token = ctx.Request.Header.Get("X-Csrftoken")
+ }
+ if token == "" {
+ ctx.Abort(422, "422")
+ return false
+ }
+ if ctx._xsrfToken != token {
+ ctx.Abort(417, "417")
+ return false
+ }
+ return true
+}
+
+// RenderMethodResult renders the return value of a controller method to the output
+func (ctx *Context) RenderMethodResult(result interface{}) {
+ if result != nil {
+ renderer, ok := result.(Renderer)
+ if !ok {
+ err, ok := result.(error)
+ if ok {
+ renderer = errorRenderer(err)
+ } else {
+ renderer = jsonRenderer(result)
+ }
+ }
+ renderer.Render(ctx)
+ }
+}
+
+// Response is a wrapper for the http.ResponseWriter
+// Started: if true, response was already written to so the other handler will not be executed
+type Response struct {
+ http.ResponseWriter
+ Started bool
+ Status int
+ Elapsed time.Duration
+}
+
+func (r *Response) reset(rw http.ResponseWriter) {
+ r.ResponseWriter = rw
+ r.Status = 0
+ r.Started = false
+}
+
+// Write writes the data to the connection as part of a HTTP reply,
+// and sets `Started` to true.
+// Started: if true, the response was already sent
+func (r *Response) Write(p []byte) (int, error) {
+ r.Started = true
+ return r.ResponseWriter.Write(p)
+}
+
+// WriteHeader sends a HTTP response header with status code,
+// and sets `Started` to true.
+func (r *Response) WriteHeader(code int) {
+ if r.Status > 0 {
+ // prevent multiple response.WriteHeader calls
+ return
+ }
+ r.Status = code
+ r.Started = true
+ r.ResponseWriter.WriteHeader(code)
+}
+
+// Hijack hijacker for http
+func (r *Response) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+ hj, ok := r.ResponseWriter.(http.Hijacker)
+ if !ok {
+ return nil, nil, errors.New("webserver doesn't support hijacking")
+ }
+ return hj.Hijack()
+}
+
+// Flush http.Flusher
+func (r *Response) Flush() {
+ if f, ok := r.ResponseWriter.(http.Flusher); ok {
+ f.Flush()
+ }
+}
+
+// CloseNotify http.CloseNotifier
+func (r *Response) CloseNotify() <-chan bool {
+ if cn, ok := r.ResponseWriter.(http.CloseNotifier); ok {
+ return cn.CloseNotify()
+ }
+ return nil
+}
+
+// Pusher http.Pusher
+func (r *Response) Pusher() (pusher http.Pusher) {
+ if pusher, ok := r.ResponseWriter.(http.Pusher); ok {
+ return pusher
+ }
+ return nil
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/context/input.go b/vendor/github.com/beego/beego/v2/server/web/context/input.go
new file mode 100644
index 0000000000000000000000000000000000000000..241ef8bc80afb5b380a38295668912ddc0ed4559
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/context/input.go
@@ -0,0 +1,687 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package context
+
+import (
+ "bytes"
+ "compress/gzip"
+ "errors"
+ "io"
+ "io/ioutil"
+ "net"
+ "net/http"
+ "net/url"
+ "reflect"
+ "regexp"
+ "strconv"
+ "strings"
+ "sync"
+
+ "github.com/beego/beego/v2/server/web/session"
+)
+
+// Regexes for checking the accept headers
+// TODO make sure these are correct
+var (
+ acceptsHTMLRegex = regexp.MustCompile(`(text/html|application/xhtml\+xml)(?:,|$)`)
+ acceptsXMLRegex = regexp.MustCompile(`(application/xml|text/xml)(?:,|$)`)
+ acceptsJSONRegex = regexp.MustCompile(`(application/json)(?:,|$)`)
+ acceptsYAMLRegex = regexp.MustCompile(`(application/x-yaml)(?:,|$)`)
+ maxParam = 50
+)
+
+// BeegoInput operates the http request header, data, cookie and body.
+// Contains router params and current session.
+type BeegoInput struct {
+ Context *Context
+ CruSession session.Store
+ pnames []string
+ pvalues []string
+ data map[interface{}]interface{} // store some values in this context when calling context in filter or controller.
+ dataLock sync.RWMutex
+ RequestBody []byte
+ RunMethod string
+ RunController reflect.Type
+}
+
+// NewInput returns the BeegoInput generated by context.
+func NewInput() *BeegoInput {
+ return &BeegoInput{
+ pnames: make([]string, 0, maxParam),
+ pvalues: make([]string, 0, maxParam),
+ data: make(map[interface{}]interface{}),
+ }
+}
+
+// Reset initializes the BeegoInput
+func (input *BeegoInput) Reset(ctx *Context) {
+ input.Context = ctx
+ input.CruSession = nil
+ input.pnames = input.pnames[:0]
+ input.pvalues = input.pvalues[:0]
+ input.dataLock.Lock()
+ input.data = nil
+ input.dataLock.Unlock()
+ input.RequestBody = []byte{}
+}
+
+// Protocol returns the request protocol name, such as HTTP/1.1 .
+func (input *BeegoInput) Protocol() string {
+ return input.Context.Request.Proto
+}
+
+// URI returns the full request url with query, string and fragment.
+func (input *BeegoInput) URI() string {
+ return input.Context.Request.RequestURI
+}
+
+// URL returns the request url path (without query, string and fragment).
+func (input *BeegoInput) URL() string {
+ return input.Context.Request.URL.Path
+}
+
+// Site returns the base site url as scheme://domain type.
+func (input *BeegoInput) Site() string {
+ return input.Scheme() + "://" + input.Domain()
+}
+
+// Scheme returns the request scheme as "http" or "https".
+func (input *BeegoInput) Scheme() string {
+ if scheme := input.Header("X-Forwarded-Proto"); scheme != "" {
+ return scheme
+ }
+ if input.Context.Request.URL.Scheme != "" {
+ return input.Context.Request.URL.Scheme
+ }
+ if input.Context.Request.TLS == nil {
+ return "http"
+ }
+ return "https"
+}
+
+// Domain returns the host name (alias of host method)
+func (input *BeegoInput) Domain() string {
+ return input.Host()
+}
+
+// Host returns the host name.
+// If no host info in request, return localhost.
+func (input *BeegoInput) Host() string {
+ if input.Context.Request.Host != "" {
+ if hostPart, _, err := net.SplitHostPort(input.Context.Request.Host); err == nil {
+ return hostPart
+ }
+ return input.Context.Request.Host
+ }
+ return "localhost"
+}
+
+// Method returns http request method.
+func (input *BeegoInput) Method() string {
+ return input.Context.Request.Method
+}
+
+// Is returns the boolean value of this request is on given method, such as Is("POST").
+func (input *BeegoInput) Is(method string) bool {
+ return input.Method() == method
+}
+
+// IsGet Is this a GET method request?
+func (input *BeegoInput) IsGet() bool {
+ return input.Is("GET")
+}
+
+// IsPost Is this a POST method request?
+func (input *BeegoInput) IsPost() bool {
+ return input.Is("POST")
+}
+
+// IsHead Is this a Head method request?
+func (input *BeegoInput) IsHead() bool {
+ return input.Is("HEAD")
+}
+
+// IsOptions Is this a OPTIONS method request?
+func (input *BeegoInput) IsOptions() bool {
+ return input.Is("OPTIONS")
+}
+
+// IsPut Is this a PUT method request?
+func (input *BeegoInput) IsPut() bool {
+ return input.Is("PUT")
+}
+
+// IsDelete Is this a DELETE method request?
+func (input *BeegoInput) IsDelete() bool {
+ return input.Is("DELETE")
+}
+
+// IsPatch Is this a PATCH method request?
+func (input *BeegoInput) IsPatch() bool {
+ return input.Is("PATCH")
+}
+
+// IsAjax returns boolean of is this request generated by ajax.
+func (input *BeegoInput) IsAjax() bool {
+ return input.Header("X-Requested-With") == "XMLHttpRequest"
+}
+
+// IsSecure returns boolean of this request is in https.
+func (input *BeegoInput) IsSecure() bool {
+ return input.Scheme() == "https"
+}
+
+// IsWebsocket returns boolean of this request is in webSocket.
+func (input *BeegoInput) IsWebsocket() bool {
+ return input.Header("Upgrade") == "websocket"
+}
+
+// IsUpload returns boolean of whether file uploads in this request or not..
+func (input *BeegoInput) IsUpload() bool {
+ return strings.Contains(input.Header("Content-Type"), "multipart/form-data")
+}
+
+// AcceptsHTML Checks if request accepts html response
+func (input *BeegoInput) AcceptsHTML() bool {
+ return acceptsHTMLRegex.MatchString(input.Header("Accept"))
+}
+
+// AcceptsXML Checks if request accepts xml response
+func (input *BeegoInput) AcceptsXML() bool {
+ return acceptsXMLRegex.MatchString(input.Header("Accept"))
+}
+
+// AcceptsJSON Checks if request accepts json response
+func (input *BeegoInput) AcceptsJSON() bool {
+ return acceptsJSONRegex.MatchString(input.Header("Accept"))
+}
+
+// AcceptsYAML Checks if request accepts json response
+func (input *BeegoInput) AcceptsYAML() bool {
+ return acceptsYAMLRegex.MatchString(input.Header("Accept"))
+}
+
+// IP returns request client ip.
+// if in proxy, return first proxy id.
+// if error, return RemoteAddr.
+func (input *BeegoInput) IP() string {
+ ips := input.Proxy()
+ if len(ips) > 0 && ips[0] != "" {
+ rip, _, err := net.SplitHostPort(ips[0])
+ if err != nil {
+ rip = ips[0]
+ }
+ return rip
+ }
+ if ip, _, err := net.SplitHostPort(input.Context.Request.RemoteAddr); err == nil {
+ return ip
+ }
+ return input.Context.Request.RemoteAddr
+}
+
+// Proxy returns proxy client ips slice.
+func (input *BeegoInput) Proxy() []string {
+ if ips := input.Header("X-Forwarded-For"); ips != "" {
+ return strings.Split(ips, ",")
+ }
+ return []string{}
+}
+
+// Referer returns http referer header.
+func (input *BeegoInput) Referer() string {
+ return input.Header("Referer")
+}
+
+// Refer returns http referer header.
+func (input *BeegoInput) Refer() string {
+ return input.Referer()
+}
+
+// SubDomains returns sub domain string.
+// if aa.bb.domain.com, returns aa.bb
+func (input *BeegoInput) SubDomains() string {
+ parts := strings.Split(input.Host(), ".")
+ if len(parts) >= 3 {
+ return strings.Join(parts[:len(parts)-2], ".")
+ }
+ return ""
+}
+
+// Port returns request client port.
+// when error or empty, return 80.
+func (input *BeegoInput) Port() int {
+ if _, portPart, err := net.SplitHostPort(input.Context.Request.Host); err == nil {
+ port, _ := strconv.Atoi(portPart)
+ return port
+ }
+ return 80
+}
+
+// UserAgent returns request client user agent string.
+func (input *BeegoInput) UserAgent() string {
+ return input.Header("User-Agent")
+}
+
+// ParamsLen return the length of the params
+func (input *BeegoInput) ParamsLen() int {
+ return len(input.pnames)
+}
+
+// Param returns router param by a given key.
+func (input *BeegoInput) Param(key string) string {
+ for i, v := range input.pnames {
+ if v == key && i <= len(input.pvalues) {
+ // we cannot use url.PathEscape(input.pvalues[i])
+ // for example, if the value is /a/b
+ // after url.PathEscape(input.pvalues[i]), the value is %2Fa%2Fb
+ // However, the value is used in ControllerRegister.ServeHTTP
+ // and split by "/", so function crash...
+ return input.pvalues[i]
+ }
+ }
+ return ""
+}
+
+// Params returns the map[key]value.
+func (input *BeegoInput) Params() map[string]string {
+ m := make(map[string]string)
+ for i, v := range input.pnames {
+ if i <= len(input.pvalues) {
+ m[v] = input.pvalues[i]
+ }
+ }
+ return m
+}
+
+// SetParam sets the param with key and value
+func (input *BeegoInput) SetParam(key, val string) {
+ // check if already exists
+ for i, v := range input.pnames {
+ if v == key && i <= len(input.pvalues) {
+ input.pvalues[i] = val
+ return
+ }
+ }
+ input.pvalues = append(input.pvalues, val)
+ input.pnames = append(input.pnames, key)
+}
+
+// ResetParams clears any of the input's params
+// Used to clear parameters so they may be reset between filter passes.
+func (input *BeegoInput) ResetParams() {
+ input.pnames = input.pnames[:0]
+ input.pvalues = input.pvalues[:0]
+}
+
+// Query returns input data item string by a given string.
+func (input *BeegoInput) Query(key string) string {
+ if val := input.Param(key); val != "" {
+ return val
+ }
+ if input.Context.Request.Form == nil {
+ input.dataLock.Lock()
+ if input.Context.Request.Form == nil {
+ input.Context.Request.ParseForm()
+ }
+ input.dataLock.Unlock()
+ }
+ input.dataLock.RLock()
+ defer input.dataLock.RUnlock()
+ return input.Context.Request.Form.Get(key)
+}
+
+// Header returns request header item string by a given string.
+// if non-existed, return empty string.
+func (input *BeegoInput) Header(key string) string {
+ return input.Context.Request.Header.Get(key)
+}
+
+// Cookie returns request cookie item string by a given key.
+// if non-existed, return empty string.
+func (input *BeegoInput) Cookie(key string) string {
+ ck, err := input.Context.Request.Cookie(key)
+ if err != nil {
+ return ""
+ }
+ return ck.Value
+}
+
+// Session returns current session item value by a given key.
+// if non-existed, return nil.
+func (input *BeegoInput) Session(key interface{}) interface{} {
+ return input.CruSession.Get(nil, key)
+}
+
+// CopyBody returns the raw request body data as bytes.
+func (input *BeegoInput) CopyBody(MaxMemory int64) []byte {
+ if input.Context.Request.Body == nil {
+ return []byte{}
+ }
+
+ var requestbody []byte
+ safe := &io.LimitedReader{R: input.Context.Request.Body, N: MaxMemory}
+ if input.Header("Content-Encoding") == "gzip" {
+ reader, err := gzip.NewReader(safe)
+ if err != nil {
+ return nil
+ }
+ requestbody, _ = ioutil.ReadAll(reader)
+ } else {
+ requestbody, _ = ioutil.ReadAll(safe)
+ }
+
+ input.Context.Request.Body.Close()
+ bf := bytes.NewBuffer(requestbody)
+ input.Context.Request.Body = http.MaxBytesReader(input.Context.ResponseWriter, ioutil.NopCloser(bf), MaxMemory)
+ input.RequestBody = requestbody
+ return requestbody
+}
+
+// Data returns the implicit data in the input
+func (input *BeegoInput) Data() map[interface{}]interface{} {
+ input.dataLock.Lock()
+ defer input.dataLock.Unlock()
+ if input.data == nil {
+ input.data = make(map[interface{}]interface{})
+ }
+ return input.data
+}
+
+// GetData returns the stored data in this context.
+func (input *BeegoInput) GetData(key interface{}) interface{} {
+ input.dataLock.Lock()
+ defer input.dataLock.Unlock()
+ if v, ok := input.data[key]; ok {
+ return v
+ }
+ return nil
+}
+
+// SetData stores data with given key in this context.
+// This data is only available in this context.
+func (input *BeegoInput) SetData(key, val interface{}) {
+ input.dataLock.Lock()
+ defer input.dataLock.Unlock()
+ if input.data == nil {
+ input.data = make(map[interface{}]interface{})
+ }
+ input.data[key] = val
+}
+
+// ParseFormOrMultiForm parseForm or parseMultiForm based on Content-type
+func (input *BeegoInput) ParseFormOrMultiForm(maxMemory int64) error {
+ // Parse the body depending on the content type.
+ if input.IsUpload() {
+ if err := input.Context.Request.ParseMultipartForm(maxMemory); err != nil {
+ return errors.New("Error parsing request body:" + err.Error())
+ }
+ } else if err := input.Context.Request.ParseForm(); err != nil {
+ return errors.New("Error parsing request body:" + err.Error())
+ }
+ return nil
+}
+
+// Bind data from request.Form[key] to dest
+// like /?id=123&isok=true&ft=1.2&ol[0]=1&ol[1]=2&ul[]=str&ul[]=array&user.Name=astaxie
+// var id int beegoInput.Bind(&id, "id") id ==123
+// var isok bool beegoInput.Bind(&isok, "isok") isok ==true
+// var ft float64 beegoInput.Bind(&ft, "ft") ft ==1.2
+// ol := make([]int, 0, 2) beegoInput.Bind(&ol, "ol") ol ==[1 2]
+// ul := make([]string, 0, 2) beegoInput.Bind(&ul, "ul") ul ==[str array]
+// user struct{Name} beegoInput.Bind(&user, "user") user == {Name:"astaxie"}
+func (input *BeegoInput) Bind(dest interface{}, key string) error {
+ value := reflect.ValueOf(dest)
+ if value.Kind() != reflect.Ptr {
+ return errors.New("beego: non-pointer passed to Bind: " + key)
+ }
+ value = value.Elem()
+ if !value.CanSet() {
+ return errors.New("beego: non-settable variable passed to Bind: " + key)
+ }
+ typ := value.Type()
+ // Get real type if dest define with interface{}.
+ // e.g var dest interface{} dest=1.0
+ if value.Kind() == reflect.Interface {
+ typ = value.Elem().Type()
+ }
+ rv := input.bind(key, typ)
+ if !rv.IsValid() {
+ return errors.New("beego: reflect value is empty")
+ }
+ value.Set(rv)
+ return nil
+}
+
+func (input *BeegoInput) bind(key string, typ reflect.Type) reflect.Value {
+ if input.Context.Request.Form == nil {
+ input.Context.Request.ParseForm()
+ }
+ rv := reflect.Zero(typ)
+ switch typ.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ val := input.Query(key)
+ if len(val) == 0 {
+ return rv
+ }
+ rv = input.bindInt(val, typ)
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ val := input.Query(key)
+ if len(val) == 0 {
+ return rv
+ }
+ rv = input.bindUint(val, typ)
+ case reflect.Float32, reflect.Float64:
+ val := input.Query(key)
+ if len(val) == 0 {
+ return rv
+ }
+ rv = input.bindFloat(val, typ)
+ case reflect.String:
+ val := input.Query(key)
+ if len(val) == 0 {
+ return rv
+ }
+ rv = input.bindString(val, typ)
+ case reflect.Bool:
+ val := input.Query(key)
+ if len(val) == 0 {
+ return rv
+ }
+ rv = input.bindBool(val, typ)
+ case reflect.Slice:
+ rv = input.bindSlice(&input.Context.Request.Form, key, typ)
+ case reflect.Struct:
+ rv = input.bindStruct(&input.Context.Request.Form, key, typ)
+ case reflect.Ptr:
+ rv = input.bindPoint(key, typ)
+ case reflect.Map:
+ rv = input.bindMap(&input.Context.Request.Form, key, typ)
+ }
+ return rv
+}
+
+func (input *BeegoInput) bindValue(val string, typ reflect.Type) reflect.Value {
+ rv := reflect.Zero(typ)
+ switch typ.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ rv = input.bindInt(val, typ)
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ rv = input.bindUint(val, typ)
+ case reflect.Float32, reflect.Float64:
+ rv = input.bindFloat(val, typ)
+ case reflect.String:
+ rv = input.bindString(val, typ)
+ case reflect.Bool:
+ rv = input.bindBool(val, typ)
+ case reflect.Slice:
+ rv = input.bindSlice(&url.Values{"": {val}}, "", typ)
+ case reflect.Struct:
+ rv = input.bindStruct(&url.Values{"": {val}}, "", typ)
+ case reflect.Ptr:
+ rv = input.bindPoint(val, typ)
+ case reflect.Map:
+ rv = input.bindMap(&url.Values{"": {val}}, "", typ)
+ }
+ return rv
+}
+
+func (input *BeegoInput) bindInt(val string, typ reflect.Type) reflect.Value {
+ intValue, err := strconv.ParseInt(val, 10, 64)
+ if err != nil {
+ return reflect.Zero(typ)
+ }
+ pValue := reflect.New(typ)
+ pValue.Elem().SetInt(intValue)
+ return pValue.Elem()
+}
+
+func (input *BeegoInput) bindUint(val string, typ reflect.Type) reflect.Value {
+ uintValue, err := strconv.ParseUint(val, 10, 64)
+ if err != nil {
+ return reflect.Zero(typ)
+ }
+ pValue := reflect.New(typ)
+ pValue.Elem().SetUint(uintValue)
+ return pValue.Elem()
+}
+
+func (input *BeegoInput) bindFloat(val string, typ reflect.Type) reflect.Value {
+ floatValue, err := strconv.ParseFloat(val, 64)
+ if err != nil {
+ return reflect.Zero(typ)
+ }
+ pValue := reflect.New(typ)
+ pValue.Elem().SetFloat(floatValue)
+ return pValue.Elem()
+}
+
+func (input *BeegoInput) bindString(val string, typ reflect.Type) reflect.Value {
+ return reflect.ValueOf(val)
+}
+
+func (input *BeegoInput) bindBool(val string, typ reflect.Type) reflect.Value {
+ val = strings.TrimSpace(strings.ToLower(val))
+ switch val {
+ case "true", "on", "1":
+ return reflect.ValueOf(true)
+ }
+ return reflect.ValueOf(false)
+}
+
+type sliceValue struct {
+ index int // Index extracted from brackets. If -1, no index was provided.
+ value reflect.Value // the bound value for this slice element.
+}
+
+func (input *BeegoInput) bindSlice(params *url.Values, key string, typ reflect.Type) reflect.Value {
+ maxIndex := -1
+ numNoIndex := 0
+ sliceValues := []sliceValue{}
+ for reqKey, vals := range *params {
+ if !strings.HasPrefix(reqKey, key+"[") {
+ continue
+ }
+ // Extract the index, and the index where a sub-key starts. (e.g. field[0].subkey)
+ index := -1
+ leftBracket, rightBracket := len(key), strings.Index(reqKey[len(key):], "]")+len(key)
+ if rightBracket > leftBracket+1 {
+ index, _ = strconv.Atoi(reqKey[leftBracket+1 : rightBracket])
+ }
+ subKeyIndex := rightBracket + 1
+
+ // Handle the indexed case.
+ if index > -1 {
+ if index > maxIndex {
+ maxIndex = index
+ }
+ sliceValues = append(sliceValues, sliceValue{
+ index: index,
+ value: input.bind(reqKey[:subKeyIndex], typ.Elem()),
+ })
+ continue
+ }
+
+ // It's an un-indexed element. (e.g. element[])
+ numNoIndex += len(vals)
+ for _, val := range vals {
+ // Unindexed values can only be direct-bound.
+ sliceValues = append(sliceValues, sliceValue{
+ index: -1,
+ value: input.bindValue(val, typ.Elem()),
+ })
+ }
+ }
+ resultArray := reflect.MakeSlice(typ, maxIndex+1, maxIndex+1+numNoIndex)
+ for _, sv := range sliceValues {
+ if sv.index != -1 {
+ resultArray.Index(sv.index).Set(sv.value)
+ } else {
+ resultArray = reflect.Append(resultArray, sv.value)
+ }
+ }
+ return resultArray
+}
+
+func (input *BeegoInput) bindStruct(params *url.Values, key string, typ reflect.Type) reflect.Value {
+ result := reflect.New(typ).Elem()
+ fieldValues := make(map[string]reflect.Value)
+ for reqKey, val := range *params {
+ var fieldName string
+ if strings.HasPrefix(reqKey, key+".") {
+ fieldName = reqKey[len(key)+1:]
+ } else if strings.HasPrefix(reqKey, key+"[") && reqKey[len(reqKey)-1] == ']' {
+ fieldName = reqKey[len(key)+1 : len(reqKey)-1]
+ } else {
+ continue
+ }
+
+ if _, ok := fieldValues[fieldName]; !ok {
+ // Time to bind this field. Get it and make sure we can set it.
+ fieldValue := result.FieldByName(fieldName)
+ if !fieldValue.IsValid() {
+ continue
+ }
+ if !fieldValue.CanSet() {
+ continue
+ }
+ boundVal := input.bindValue(val[0], fieldValue.Type())
+ fieldValue.Set(boundVal)
+ fieldValues[fieldName] = boundVal
+ }
+ }
+
+ return result
+}
+
+func (input *BeegoInput) bindPoint(key string, typ reflect.Type) reflect.Value {
+ return input.bind(key, typ.Elem()).Addr()
+}
+
+func (input *BeegoInput) bindMap(params *url.Values, key string, typ reflect.Type) reflect.Value {
+ var (
+ result = reflect.MakeMap(typ)
+ keyType = typ.Key()
+ valueType = typ.Elem()
+ )
+ for paramName, values := range *params {
+ if !strings.HasPrefix(paramName, key+"[") || paramName[len(paramName)-1] != ']' {
+ continue
+ }
+
+ key := paramName[len(key)+1 : len(paramName)-1]
+ result.SetMapIndex(input.bindValue(key, keyType), input.bindValue(values[0], valueType))
+ }
+ return result
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/context/output.go b/vendor/github.com/beego/beego/v2/server/web/context/output.go
new file mode 100644
index 0000000000000000000000000000000000000000..aba5e56036111bf46513f9f80c04eae52cbd34fe
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/context/output.go
@@ -0,0 +1,408 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package context
+
+import (
+ "bytes"
+ "encoding/json"
+ "encoding/xml"
+ "errors"
+ "fmt"
+ "html/template"
+ "io"
+ "mime"
+ "net/http"
+ "net/url"
+ "os"
+ "path/filepath"
+ "strconv"
+ "strings"
+ "time"
+
+ yaml "gopkg.in/yaml.v2"
+)
+
+// BeegoOutput does work for sending response header.
+type BeegoOutput struct {
+ Context *Context
+ Status int
+ EnableGzip bool
+}
+
+// NewOutput returns new BeegoOutput.
+// Empty when initialized
+func NewOutput() *BeegoOutput {
+ return &BeegoOutput{}
+}
+
+// Reset initializes BeegoOutput
+func (output *BeegoOutput) Reset(ctx *Context) {
+ output.Context = ctx
+ output.Status = 0
+}
+
+// Header sets response header item string via given key.
+func (output *BeegoOutput) Header(key, val string) {
+ output.Context.ResponseWriter.Header().Set(key, val)
+}
+
+// Body sets the response body content.
+// if EnableGzip, content is compressed.
+// Sends out response body directly.
+func (output *BeegoOutput) Body(content []byte) error {
+ var encoding string
+ var buf = &bytes.Buffer{}
+ if output.EnableGzip {
+ encoding = ParseEncoding(output.Context.Request)
+ }
+ if b, n, _ := WriteBody(encoding, buf, content); b {
+ output.Header("Content-Encoding", n)
+ output.Header("Content-Length", strconv.Itoa(buf.Len()))
+ } else {
+ output.Header("Content-Length", strconv.Itoa(len(content)))
+ }
+ // Write status code if it has been set manually
+ // Set it to 0 afterwards to prevent "multiple response.WriteHeader calls"
+ if output.Status != 0 {
+ output.Context.ResponseWriter.WriteHeader(output.Status)
+ output.Status = 0
+ } else {
+ output.Context.ResponseWriter.Started = true
+ }
+ io.Copy(output.Context.ResponseWriter, buf)
+ return nil
+}
+
+// Cookie sets a cookie value via given key.
+// others: used to set a cookie's max age time, path,domain, secure and httponly.
+func (output *BeegoOutput) Cookie(name string, value string, others ...interface{}) {
+ var b bytes.Buffer
+ fmt.Fprintf(&b, "%s=%s", sanitizeName(name), sanitizeValue(value))
+
+ // fix cookie not work in IE
+ if len(others) > 0 {
+ var maxAge int64
+
+ switch v := others[0].(type) {
+ case int:
+ maxAge = int64(v)
+ case int32:
+ maxAge = int64(v)
+ case int64:
+ maxAge = v
+ }
+
+ switch {
+ case maxAge > 0:
+ fmt.Fprintf(&b, "; Expires=%s; Max-Age=%d", time.Now().Add(time.Duration(maxAge)*time.Second).UTC().Format(time.RFC1123), maxAge)
+ case maxAge < 0:
+ fmt.Fprintf(&b, "; Max-Age=0")
+ }
+ }
+
+ // the settings below
+ // Path, Domain, Secure, HttpOnly
+ // can use nil skip set
+
+ // default "/"
+ if len(others) > 1 {
+ if v, ok := others[1].(string); ok && len(v) > 0 {
+ fmt.Fprintf(&b, "; Path=%s", sanitizeValue(v))
+ }
+ } else {
+ fmt.Fprintf(&b, "; Path=%s", "/")
+ }
+
+ // default empty
+ if len(others) > 2 {
+ if v, ok := others[2].(string); ok && len(v) > 0 {
+ fmt.Fprintf(&b, "; Domain=%s", sanitizeValue(v))
+ }
+ }
+
+ // default empty
+ if len(others) > 3 {
+ var secure bool
+ switch v := others[3].(type) {
+ case bool:
+ secure = v
+ default:
+ if others[3] != nil {
+ secure = true
+ }
+ }
+ if secure {
+ fmt.Fprintf(&b, "; Secure")
+ }
+ }
+
+ // default false. for session cookie default true
+ if len(others) > 4 {
+ if v, ok := others[4].(bool); ok && v {
+ fmt.Fprintf(&b, "; HttpOnly")
+ }
+ }
+
+ output.Context.ResponseWriter.Header().Add("Set-Cookie", b.String())
+}
+
+var cookieNameSanitizer = strings.NewReplacer("\n", "-", "\r", "-")
+
+func sanitizeName(n string) string {
+ return cookieNameSanitizer.Replace(n)
+}
+
+var cookieValueSanitizer = strings.NewReplacer("\n", " ", "\r", " ", ";", " ")
+
+func sanitizeValue(v string) string {
+ return cookieValueSanitizer.Replace(v)
+}
+
+func jsonRenderer(value interface{}) Renderer {
+ return rendererFunc(func(ctx *Context) {
+ ctx.Output.JSON(value, false, false)
+ })
+}
+
+func errorRenderer(err error) Renderer {
+ return rendererFunc(func(ctx *Context) {
+ ctx.Output.SetStatus(500)
+ ctx.Output.Body([]byte(err.Error()))
+ })
+}
+
+// JSON writes json to the response body.
+// if encoding is true, it converts utf-8 to \u0000 type.
+func (output *BeegoOutput) JSON(data interface{}, hasIndent bool, encoding bool) error {
+ output.Header("Content-Type", "application/json; charset=utf-8")
+ var content []byte
+ var err error
+ if hasIndent {
+ content, err = json.MarshalIndent(data, "", " ")
+ } else {
+ content, err = json.Marshal(data)
+ }
+ if err != nil {
+ http.Error(output.Context.ResponseWriter, err.Error(), http.StatusInternalServerError)
+ return err
+ }
+ if encoding {
+ content = []byte(stringsToJSON(string(content)))
+ }
+ return output.Body(content)
+}
+
+// YAML writes yaml to the response body.
+func (output *BeegoOutput) YAML(data interface{}) error {
+ output.Header("Content-Type", "application/x-yaml; charset=utf-8")
+ var content []byte
+ var err error
+ content, err = yaml.Marshal(data)
+ if err != nil {
+ http.Error(output.Context.ResponseWriter, err.Error(), http.StatusInternalServerError)
+ return err
+ }
+ return output.Body(content)
+}
+
+// JSONP writes jsonp to the response body.
+func (output *BeegoOutput) JSONP(data interface{}, hasIndent bool) error {
+ output.Header("Content-Type", "application/javascript; charset=utf-8")
+ var content []byte
+ var err error
+ if hasIndent {
+ content, err = json.MarshalIndent(data, "", " ")
+ } else {
+ content, err = json.Marshal(data)
+ }
+ if err != nil {
+ http.Error(output.Context.ResponseWriter, err.Error(), http.StatusInternalServerError)
+ return err
+ }
+ callback := output.Context.Input.Query("callback")
+ if callback == "" {
+ return errors.New(`"callback" parameter required`)
+ }
+ callback = template.JSEscapeString(callback)
+ callbackContent := bytes.NewBufferString(" if(window." + callback + ")" + callback)
+ callbackContent.WriteString("(")
+ callbackContent.Write(content)
+ callbackContent.WriteString(");\r\n")
+ return output.Body(callbackContent.Bytes())
+}
+
+// XML writes xml string to the response body.
+func (output *BeegoOutput) XML(data interface{}, hasIndent bool) error {
+ output.Header("Content-Type", "application/xml; charset=utf-8")
+ var content []byte
+ var err error
+ if hasIndent {
+ content, err = xml.MarshalIndent(data, "", " ")
+ } else {
+ content, err = xml.Marshal(data)
+ }
+ if err != nil {
+ http.Error(output.Context.ResponseWriter, err.Error(), http.StatusInternalServerError)
+ return err
+ }
+ return output.Body(content)
+}
+
+// ServeFormatted serves YAML, XML or JSON, depending on the value of the Accept header
+func (output *BeegoOutput) ServeFormatted(data interface{}, hasIndent bool, hasEncode ...bool) error {
+ accept := output.Context.Input.Header("Accept")
+ switch accept {
+ case ApplicationYAML:
+ return output.YAML(data)
+ case ApplicationXML, TextXML:
+ return output.XML(data, hasIndent)
+ default:
+ return output.JSON(data, hasIndent, len(hasEncode) > 0 && hasEncode[0])
+ }
+}
+
+// Download forces response for download file.
+// Prepares the download response header automatically.
+func (output *BeegoOutput) Download(file string, filename ...string) {
+ // check get file error, file not found or other error.
+ if _, err := os.Stat(file); err != nil {
+ http.ServeFile(output.Context.ResponseWriter, output.Context.Request, file)
+ return
+ }
+
+ var fName string
+ if len(filename) > 0 && filename[0] != "" {
+ fName = filename[0]
+ } else {
+ fName = filepath.Base(file)
+ }
+ // https://tools.ietf.org/html/rfc6266#section-4.3
+ fn := url.PathEscape(fName)
+ if fName == fn {
+ fn = "filename=" + fn
+ } else {
+ /**
+ The parameters "filename" and "filename*" differ only in that
+ "filename*" uses the encoding defined in [RFC5987], allowing the use
+ of characters not present in the ISO-8859-1 character set
+ ([ISO-8859-1]).
+ */
+ fn = "filename=" + fName + "; filename*=utf-8''" + fn
+ }
+ output.Header("Content-Disposition", "attachment; "+fn)
+ output.Header("Content-Description", "File Transfer")
+ output.Header("Content-Type", "application/octet-stream")
+ output.Header("Content-Transfer-Encoding", "binary")
+ output.Header("Expires", "0")
+ output.Header("Cache-Control", "must-revalidate")
+ output.Header("Pragma", "public")
+ http.ServeFile(output.Context.ResponseWriter, output.Context.Request, file)
+}
+
+// ContentType sets the content type from ext string.
+// MIME type is given in mime package.
+func (output *BeegoOutput) ContentType(ext string) {
+ if !strings.HasPrefix(ext, ".") {
+ ext = "." + ext
+ }
+ ctype := mime.TypeByExtension(ext)
+ if ctype != "" {
+ output.Header("Content-Type", ctype)
+ }
+}
+
+// SetStatus sets the response status code.
+// Writes response header directly.
+func (output *BeegoOutput) SetStatus(status int) {
+ output.Status = status
+}
+
+// IsCachable returns boolean of if this request is cached.
+// HTTP 304 means cached.
+func (output *BeegoOutput) IsCachable() bool {
+ return output.Status >= 200 && output.Status < 300 || output.Status == 304
+}
+
+// IsEmpty returns boolean of if this request is empty.
+// HTTP 201，204 and 304 means empty.
+func (output *BeegoOutput) IsEmpty() bool {
+ return output.Status == 201 || output.Status == 204 || output.Status == 304
+}
+
+// IsOk returns boolean of if this request was ok.
+// HTTP 200 means ok.
+func (output *BeegoOutput) IsOk() bool {
+ return output.Status == 200
+}
+
+// IsSuccessful returns boolean of this request was successful.
+// HTTP 2xx means ok.
+func (output *BeegoOutput) IsSuccessful() bool {
+ return output.Status >= 200 && output.Status < 300
+}
+
+// IsRedirect returns boolean of if this request is redirected.
+// HTTP 301,302,307 means redirection.
+func (output *BeegoOutput) IsRedirect() bool {
+ return output.Status == 301 || output.Status == 302 || output.Status == 303 || output.Status == 307
+}
+
+// IsForbidden returns boolean of if this request is forbidden.
+// HTTP 403 means forbidden.
+func (output *BeegoOutput) IsForbidden() bool {
+ return output.Status == 403
+}
+
+// IsNotFound returns boolean of if this request is not found.
+// HTTP 404 means not found.
+func (output *BeegoOutput) IsNotFound() bool {
+ return output.Status == 404
+}
+
+// IsClientError returns boolean of if this request client sends error data.
+// HTTP 4xx means client error.
+func (output *BeegoOutput) IsClientError() bool {
+ return output.Status >= 400 && output.Status < 500
+}
+
+// IsServerError returns boolean of if this server handler errors.
+// HTTP 5xx means server internal error.
+func (output *BeegoOutput) IsServerError() bool {
+ return output.Status >= 500 && output.Status < 600
+}
+
+func stringsToJSON(str string) string {
+ var jsons bytes.Buffer
+ for _, r := range str {
+ rint := int(r)
+ if rint < 128 {
+ jsons.WriteRune(r)
+ } else {
+ jsons.WriteString("\\u")
+ if rint < 0x100 {
+ jsons.WriteString("00")
+ } else if rint < 0x1000 {
+ jsons.WriteString("0")
+ }
+ jsons.WriteString(strconv.FormatInt(int64(rint), 16))
+ }
+ }
+ return jsons.String()
+}
+
+// Session sets session item value with given key.
+func (output *BeegoOutput) Session(name interface{}, value interface{}) {
+ output.Context.Input.CruSession.Set(nil, name, value)
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/context/param/conv.go b/vendor/github.com/beego/beego/v2/server/web/context/param/conv.go
new file mode 100644
index 0000000000000000000000000000000000000000..eecb6acbd9e9f5e0f8b1afdb1200e2dbe4416612
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/context/param/conv.go
@@ -0,0 +1,78 @@
+package param
+
+import (
+ "fmt"
+ "reflect"
+
+ "github.com/beego/beego/v2/core/logs"
+ beecontext "github.com/beego/beego/v2/server/web/context"
+)
+
+// ConvertParams converts http method params to values that will be passed to the method controller as arguments
+func ConvertParams(methodParams []*MethodParam, methodType reflect.Type, ctx *beecontext.Context) (result []reflect.Value) {
+ result = make([]reflect.Value, 0, len(methodParams))
+ for i := 0; i < len(methodParams); i++ {
+ reflectValue := convertParam(methodParams[i], methodType.In(i), ctx)
+ result = append(result, reflectValue)
+ }
+ return
+}
+
+func convertParam(param *MethodParam, paramType reflect.Type, ctx *beecontext.Context) (result reflect.Value) {
+ paramValue := getParamValue(param, ctx)
+ if paramValue == "" {
+ if param.required {
+ ctx.Abort(400, fmt.Sprintf("Missing parameter %s", param.name))
+ } else {
+ paramValue = param.defaultValue
+ }
+ }
+
+ reflectValue, err := parseValue(param, paramValue, paramType)
+ if err != nil {
+ logs.Debug(fmt.Sprintf("Error converting param %s to type %s. Value: %v, Error: %s", param.name, paramType, paramValue, err))
+ ctx.Abort(400, fmt.Sprintf("Invalid parameter %s. Can not convert %v to type %s", param.name, paramValue, paramType))
+ }
+
+ return reflectValue
+}
+
+func getParamValue(param *MethodParam, ctx *beecontext.Context) string {
+ switch param.in {
+ case body:
+ return string(ctx.Input.RequestBody)
+ case header:
+ return ctx.Input.Header(param.name)
+ case path:
+ return ctx.Input.Query(":" + param.name)
+ default:
+ return ctx.Input.Query(param.name)
+ }
+}
+
+func parseValue(param *MethodParam, paramValue string, paramType reflect.Type) (result reflect.Value, err error) {
+ if paramValue == "" {
+ return reflect.Zero(paramType), nil
+ }
+ parser := getParser(param, paramType)
+ value, err := parser.parse(paramValue, paramType)
+ if err != nil {
+ return result, err
+ }
+
+ return safeConvert(reflect.ValueOf(value), paramType)
+}
+
+func safeConvert(value reflect.Value, t reflect.Type) (result reflect.Value, err error) {
+ defer func() {
+ if r := recover(); r != nil {
+ var ok bool
+ err, ok = r.(error)
+ if !ok {
+ err = fmt.Errorf("%v", r)
+ }
+ }
+ }()
+ result = value.Convert(t)
+ return
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/context/param/methodparams.go b/vendor/github.com/beego/beego/v2/server/web/context/param/methodparams.go
new file mode 100644
index 0000000000000000000000000000000000000000..22ff0e4369b9138ef315063430966dbe9588bc3a
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/context/param/methodparams.go
@@ -0,0 +1,69 @@
+package param
+
+import (
+ "fmt"
+ "strings"
+)
+
+// MethodParam keeps param information to be auto passed to controller methods
+type MethodParam struct {
+ name string
+ in paramType
+ required bool
+ defaultValue string
+}
+
+type paramType byte
+
+const (
+ param paramType = iota
+ path
+ body
+ header
+)
+
+// New creates a new MethodParam with name and specific options
+func New(name string, opts ...MethodParamOption) *MethodParam {
+ return newParam(name, nil, opts)
+}
+
+func newParam(name string, parser paramParser, opts []MethodParamOption) (param *MethodParam) {
+ param = &MethodParam{name: name}
+ for _, option := range opts {
+ option(param)
+ }
+ return
+}
+
+// Make creates an array of MethodParmas or an empty array
+func Make(list ...*MethodParam) []*MethodParam {
+ if len(list) > 0 {
+ return list
+ }
+ return nil
+}
+
+func (mp *MethodParam) String() string {
+ options := []string{}
+ result := "param.New(\"" + mp.name + "\""
+ if mp.required {
+ options = append(options, "param.IsRequired")
+ }
+ switch mp.in {
+ case path:
+ options = append(options, "param.InPath")
+ case body:
+ options = append(options, "param.InBody")
+ case header:
+ options = append(options, "param.InHeader")
+ }
+ if mp.defaultValue != "" {
+ options = append(options, fmt.Sprintf(`param.Default("%s")`, mp.defaultValue))
+ }
+ if len(options) > 0 {
+ result += ", "
+ }
+ result += strings.Join(options, ", ")
+ result += ")"
+ return result
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/context/param/options.go b/vendor/github.com/beego/beego/v2/server/web/context/param/options.go
new file mode 100644
index 0000000000000000000000000000000000000000..3d5ba013e1ca7831dd7dc0acaac328d87d7ec6a9
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/context/param/options.go
@@ -0,0 +1,37 @@
+package param
+
+import (
+ "fmt"
+)
+
+// MethodParamOption defines a func which apply options on a MethodParam
+type MethodParamOption func(*MethodParam)
+
+// IsRequired indicates that this param is required and can not be omitted from the http request
+var IsRequired MethodParamOption = func(p *MethodParam) {
+ p.required = true
+}
+
+// InHeader indicates that this param is passed via an http header
+var InHeader MethodParamOption = func(p *MethodParam) {
+ p.in = header
+}
+
+// InPath indicates that this param is part of the URL path
+var InPath MethodParamOption = func(p *MethodParam) {
+ p.in = path
+}
+
+// InBody indicates that this param is passed as an http request body
+var InBody MethodParamOption = func(p *MethodParam) {
+ p.in = body
+}
+
+// Default provides a default value for the http param
+func Default(defaultValue interface{}) MethodParamOption {
+ return func(p *MethodParam) {
+ if defaultValue != nil {
+ p.defaultValue = fmt.Sprint(defaultValue)
+ }
+ }
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/context/param/parsers.go b/vendor/github.com/beego/beego/v2/server/web/context/param/parsers.go
new file mode 100644
index 0000000000000000000000000000000000000000..fb4099f5e31cd4b6b6bfcefb20a3fec37084d645
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/context/param/parsers.go
@@ -0,0 +1,149 @@
+package param
+
+import (
+ "encoding/json"
+ "reflect"
+ "strconv"
+ "strings"
+ "time"
+)
+
+type paramParser interface {
+ parse(value string, toType reflect.Type) (interface{}, error)
+}
+
+func getParser(param *MethodParam, t reflect.Type) paramParser {
+ switch t.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+ reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ return intParser{}
+ case reflect.Slice:
+ if t.Elem().Kind() == reflect.Uint8 { // treat []byte as string
+ return stringParser{}
+ }
+ if param.in == body {
+ return jsonParser{}
+ }
+ elemParser := getParser(param, t.Elem())
+ if elemParser == (jsonParser{}) {
+ return elemParser
+ }
+ return sliceParser(elemParser)
+ case reflect.Bool:
+ return boolParser{}
+ case reflect.String:
+ return stringParser{}
+ case reflect.Float32, reflect.Float64:
+ return floatParser{}
+ case reflect.Ptr:
+ elemParser := getParser(param, t.Elem())
+ if elemParser == (jsonParser{}) {
+ return elemParser
+ }
+ return ptrParser(elemParser)
+ default:
+ if t.PkgPath() == "time" && t.Name() == "Time" {
+ return timeParser{}
+ }
+ return jsonParser{}
+ }
+}
+
+type parserFunc func(value string, toType reflect.Type) (interface{}, error)
+
+func (f parserFunc) parse(value string, toType reflect.Type) (interface{}, error) {
+ return f(value, toType)
+}
+
+type boolParser struct {
+}
+
+func (p boolParser) parse(value string, toType reflect.Type) (interface{}, error) {
+ return strconv.ParseBool(value)
+}
+
+type stringParser struct {
+}
+
+func (p stringParser) parse(value string, toType reflect.Type) (interface{}, error) {
+ return value, nil
+}
+
+type intParser struct {
+}
+
+func (p intParser) parse(value string, toType reflect.Type) (interface{}, error) {
+ return strconv.Atoi(value)
+}
+
+type floatParser struct {
+}
+
+func (p floatParser) parse(value string, toType reflect.Type) (interface{}, error) {
+ if toType.Kind() == reflect.Float32 {
+ res, err := strconv.ParseFloat(value, 32)
+ if err != nil {
+ return nil, err
+ }
+ return float32(res), nil
+ }
+ return strconv.ParseFloat(value, 64)
+}
+
+type timeParser struct {
+}
+
+func (p timeParser) parse(value string, toType reflect.Type) (result interface{}, err error) {
+ result, err = time.Parse(time.RFC3339, value)
+ if err != nil {
+ result, err = time.Parse("2006-01-02", value)
+ }
+ return
+}
+
+type jsonParser struct {
+}
+
+func (p jsonParser) parse(value string, toType reflect.Type) (interface{}, error) {
+ pResult := reflect.New(toType)
+ v := pResult.Interface()
+ err := json.Unmarshal([]byte(value), v)
+ if err != nil {
+ return nil, err
+ }
+ return pResult.Elem().Interface(), nil
+}
+
+func sliceParser(elemParser paramParser) paramParser {
+ return parserFunc(func(value string, toType reflect.Type) (interface{}, error) {
+ values := strings.Split(value, ",")
+ result := reflect.MakeSlice(toType, 0, len(values))
+ elemType := toType.Elem()
+ for _, v := range values {
+ parsedValue, err := elemParser.parse(v, elemType)
+ if err != nil {
+ return nil, err
+ }
+ result = reflect.Append(result, reflect.ValueOf(parsedValue))
+ }
+ return result.Interface(), nil
+ })
+}
+
+func ptrParser(elemParser paramParser) paramParser {
+ return parserFunc(func(value string, toType reflect.Type) (interface{}, error) {
+ parsedValue, err := elemParser.parse(value, toType.Elem())
+ if err != nil {
+ return nil, err
+ }
+ newValPtr := reflect.New(toType.Elem())
+ newVal := reflect.Indirect(newValPtr)
+ convertedVal, err := safeConvert(reflect.ValueOf(parsedValue), toType.Elem())
+ if err != nil {
+ return nil, err
+ }
+
+ newVal.Set(convertedVal)
+ return newValPtr.Interface(), nil
+ })
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/context/renderer.go b/vendor/github.com/beego/beego/v2/server/web/context/renderer.go
new file mode 100644
index 0000000000000000000000000000000000000000..5a0783324f5b9428cafa055318a67b5bd85f356c
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/context/renderer.go
@@ -0,0 +1,12 @@
+package context
+
+// Renderer defines a http response renderer
+type Renderer interface {
+ Render(ctx *Context)
+}
+
+type rendererFunc func(ctx *Context)
+
+func (f rendererFunc) Render(ctx *Context) {
+ f(ctx)
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/context/response.go b/vendor/github.com/beego/beego/v2/server/web/context/response.go
new file mode 100644
index 0000000000000000000000000000000000000000..86b2c0b8870cf560dbaa39409d3dd34e97427743
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/context/response.go
@@ -0,0 +1,26 @@
+package context
+
+import (
+ "net/http"
+ "strconv"
+)
+
+const (
+ // BadRequest indicates HTTP error 400
+ BadRequest StatusCode = http.StatusBadRequest
+
+ // NotFound indicates HTTP error 404
+ NotFound StatusCode = http.StatusNotFound
+)
+
+// StatusCode sets the HTTP response status code
+type StatusCode int
+
+func (s StatusCode) Error() string {
+ return strconv.Itoa(int(s))
+}
+
+// Render sets the HTTP status code
+func (s StatusCode) Render(ctx *Context) {
+ ctx.Output.SetStatus(int(s))
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/controller.go b/vendor/github.com/beego/beego/v2/server/web/controller.go
new file mode 100644
index 0000000000000000000000000000000000000000..5983cfbd411f7acfec3ba33bd63354778fb19a42
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/controller.go
@@ -0,0 +1,724 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package web
+
+import (
+ "bytes"
+ context2 "context"
+ "errors"
+ "fmt"
+ "html/template"
+ "io"
+ "mime/multipart"
+ "net/http"
+ "net/url"
+ "os"
+ "reflect"
+ "strconv"
+ "strings"
+
+ "github.com/beego/beego/v2/server/web/session"
+
+ "github.com/beego/beego/v2/server/web/context"
+ "github.com/beego/beego/v2/server/web/context/param"
+)
+
+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)
+)
+
+// ControllerFilter store the filter for controller
+type ControllerFilter struct {
+ Pattern string
+ Pos int
+ Filter FilterFunc
+ ReturnOnOutput bool
+ ResetParams bool
+}
+
+// ControllerFilterComments store the comment for controller level filter
+type ControllerFilterComments struct {
+ Pattern string
+ Pos int
+ Filter string // NOQA
+ ReturnOnOutput bool
+ ResetParams bool
+}
+
+// ControllerImportComments store the import comment for controller needed
+type ControllerImportComments struct {
+ ImportPath string
+ ImportAlias string
+}
+
+// ControllerComments store the comment for the controller method
+type ControllerComments struct {
+ Method string
+ Router string
+ Filters []*ControllerFilter
+ ImportComments []*ControllerImportComments
+ FilterComments []*ControllerFilterComments
+ AllowHTTPMethods []string
+ Params []map[string]string
+ MethodParams []*param.MethodParam
+}
+
+// ControllerCommentsSlice implements the sort interface
+type ControllerCommentsSlice []ControllerComments
+
+func (p ControllerCommentsSlice) Len() int { return len(p) }
+func (p ControllerCommentsSlice) Less(i, j int) bool { return p[i].Router < p[j].Router }
+func (p ControllerCommentsSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+
+// Controller defines some basic http request handler operations, such as
+// http context, template and view, session and xsrf.
+type Controller struct {
+ // context data
+ Ctx *context.Context
+ Data map[interface{}]interface{}
+
+ // route controller info
+ controllerName string
+ actionName string
+ methodMapping map[string]func() //method:routertree
+ 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
+
+ // xsrf data
+ _xsrfToken string
+ XSRFExpire int
+ EnableXSRF bool
+
+ // session
+ CruSession session.Store
+}
+
+// ControllerInterface is an interface to uniform all controller handler.
+type ControllerInterface interface {
+ Init(ct *context.Context, controllerName, actionName string, app interface{})
+ Prepare()
+ Get()
+ Post()
+ Delete()
+ Put()
+ Head()
+ Patch()
+ Options()
+ Trace()
+ Finish()
+ Render() error
+ XSRFToken() string
+ CheckXSRFCookie() bool
+ HandlerFunc(fn string) bool
+ URLMapping()
+}
+
+// Init generates default values of controller operations.
+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())
+}
+
+// Prepare runs after Init before request function execution.
+func (c *Controller) Prepare() {}
+
+// Finish runs after request function execution.
+func (c *Controller) Finish() {}
+
+// Get adds a request function to handle GET request.
+func (c *Controller) Get() {
+ http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", http.StatusMethodNotAllowed)
+}
+
+// Post adds a request function to handle POST request.
+func (c *Controller) Post() {
+ http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", http.StatusMethodNotAllowed)
+}
+
+// Delete adds a request function to handle DELETE request.
+func (c *Controller) Delete() {
+ http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", http.StatusMethodNotAllowed)
+}
+
+// Put adds a request function to handle PUT request.
+func (c *Controller) Put() {
+ http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", http.StatusMethodNotAllowed)
+}
+
+// Head adds a request function to handle HEAD request.
+func (c *Controller) Head() {
+ http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", http.StatusMethodNotAllowed)
+}
+
+// Patch adds a request function to handle PATCH request.
+func (c *Controller) Patch() {
+ http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", http.StatusMethodNotAllowed)
+}
+
+// Options adds a request function to handle OPTIONS request.
+func (c *Controller) Options() {
+ http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", http.StatusMethodNotAllowed)
+}
+
+// Trace adds a request function to handle Trace request.
+// this method SHOULD NOT be overridden.
+// https://tools.ietf.org/html/rfc7231#section-4.3.8
+// The TRACE method requests a remote, application-level loop-back of
+// the request message. The final recipient of the request SHOULD
+// reflect the message received, excluding some fields described below,
+// back to the client as the message body of a 200 (OK) response with a
+// Content-Type of "message/http" (Section 8.3.1 of [RFC7230]).
+func (c *Controller) Trace() {
+ ts := func(h http.Header) (hs string) {
+ for k, v := range h {
+ hs += fmt.Sprintf("\r\n%s: %s", k, v)
+ }
+ return
+ }
+ hs := fmt.Sprintf("\r\nTRACE %s %s%s\r\n", c.Ctx.Request.RequestURI, c.Ctx.Request.Proto, ts(c.Ctx.Request.Header))
+ c.Ctx.Output.Header("Content-Type", "message/http")
+ c.Ctx.Output.Header("Content-Length", fmt.Sprint(len(hs)))
+ c.Ctx.Output.Header("Cache-Control", "no-cache, no-store, must-revalidate")
+ c.Ctx.WriteString(hs)
+}
+
+// HandlerFunc call function with the name
+func (c *Controller) HandlerFunc(fnname string) bool {
+ if v, ok := c.methodMapping[fnname]; ok {
+ v()
+ return true
+ }
+ return false
+}
+
+// URLMapping register the internal Controller router.
+func (c *Controller) URLMapping() {}
+
+// Mapping the method to function
+func (c *Controller) Mapping(method string, fn func()) {
+ c.methodMapping[method] = fn
+}
+
+// Render sends the response with rendered template bytes as text/html type.
+func (c *Controller) Render() error {
+ if !c.EnableRender {
+ return nil
+ }
+ rb, err := c.RenderBytes()
+ if err != nil {
+ return err
+ }
+
+ if c.Ctx.ResponseWriter.Header().Get("Content-Type") == "" {
+ c.Ctx.Output.Header("Content-Type", "text/html; charset=utf-8")
+ }
+
+ return c.Ctx.Output.Body(rb)
+}
+
+// RenderString returns the rendered template string. Do not send out response.
+func (c *Controller) RenderString() (string, error) {
+ b, e := c.RenderBytes()
+ if e != nil {
+ return "", e
+ }
+ return string(b), e
+}
+
+// RenderBytes returns the bytes of rendered template string. Do not send out response.
+func (c *Controller) RenderBytes() ([]byte, error) {
+ buf, err := c.renderTemplate()
+ // if the controller has set layout, then first get the tplName's content set the content to the layout
+ 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 = ExecuteViewPathTemplate(&buf, sectionTpl, c.viewPath(), c.Data)
+ if err != nil {
+ return nil, err
+ }
+ c.Data[sectionName] = template.HTML(buf.String())
+ }
+ }
+
+ buf.Reset()
+ err = ExecuteViewPathTemplate(&buf, c.Layout, c.viewPath(), 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(c.viewPath(), buildFiles...)
+ }
+ return buf, ExecuteViewPathTemplate(&buf, c.TplName, c.viewPath(), c.Data)
+}
+
+func (c *Controller) viewPath() string {
+ if c.ViewPath == "" {
+ return BConfig.WebConfig.ViewsPath
+ }
+ return c.ViewPath
+}
+
+// Redirect sends the redirection response to url with status code.
+func (c *Controller) Redirect(url string, code int) {
+ LogAccess(c.Ctx, nil, code)
+ c.Ctx.Redirect(code, url)
+}
+
+// SetData set the data depending on the accepted
+func (c *Controller) SetData(data interface{}) {
+ accept := c.Ctx.Input.Header("Accept")
+ switch accept {
+ case context.ApplicationYAML:
+ c.Data["yaml"] = data
+ case context.ApplicationXML, context.TextXML:
+ c.Data["xml"] = data
+ default:
+ c.Data["json"] = data
+ }
+}
+
+// Abort stops controller handler and show the error data if code is defined in ErrorMap or code string.
+func (c *Controller) Abort(code string) {
+ status, err := strconv.Atoi(code)
+ if err != nil {
+ status = 200
+ }
+ c.CustomAbort(status, code)
+}
+
+// CustomAbort stops controller handler and show the error data, it's similar Aborts, but support status code and body.
+func (c *Controller) CustomAbort(status int, body string) {
+ // first panic from ErrorMaps, it is user defined error functions.
+ if _, ok := ErrorMaps[body]; ok {
+ c.Ctx.Output.Status = status
+ panic(body)
+ }
+ // last panic user string
+ c.Ctx.ResponseWriter.WriteHeader(status)
+ c.Ctx.ResponseWriter.Write([]byte(body))
+ panic(ErrAbort)
+}
+
+// StopRun makes panic of USERSTOPRUN error and go to recover function if defined.
+func (c *Controller) StopRun() {
+ panic(ErrAbort)
+}
+
+// URLFor does another controller handler in this request function.
+// it goes to this controller method if endpoint is not clear.
+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...)
+}
+
+// ServeJSON sends a json response with encoding charset.
+func (c *Controller) ServeJSON(encoding ...bool) error {
+ var (
+ hasIndent = BConfig.RunMode != PROD
+ hasEncoding = len(encoding) > 0 && encoding[0]
+ )
+
+ return c.Ctx.Output.JSON(c.Data["json"], hasIndent, hasEncoding)
+}
+
+// ServeJSONP sends a jsonp response.
+func (c *Controller) ServeJSONP() error {
+ hasIndent := BConfig.RunMode != PROD
+ return c.Ctx.Output.JSONP(c.Data["jsonp"], hasIndent)
+}
+
+// ServeXML sends xml response.
+func (c *Controller) ServeXML() error {
+ hasIndent := BConfig.RunMode != PROD
+ return c.Ctx.Output.XML(c.Data["xml"], hasIndent)
+}
+
+// ServeYAML sends yaml response.
+func (c *Controller) ServeYAML() error {
+ return c.Ctx.Output.YAML(c.Data["yaml"])
+}
+
+// ServeFormatted serve YAML, XML OR JSON, depending on the value of the Accept header
+func (c *Controller) ServeFormatted(encoding ...bool) error {
+ hasIndent := BConfig.RunMode != PROD
+ hasEncoding := len(encoding) > 0 && encoding[0]
+ return c.Ctx.Output.ServeFormatted(c.Data, hasIndent, hasEncoding)
+}
+
+// Input returns the input data map from POST or PUT request body and query string.
+func (c *Controller) Input() (url.Values, error) {
+ if c.Ctx.Request.Form == nil {
+ err := c.Ctx.Request.ParseForm()
+ if err != nil {
+ return nil, err
+ }
+ }
+ return c.Ctx.Request.Form, nil
+}
+
+// ParseForm maps input data map to obj struct.
+func (c *Controller) ParseForm(obj interface{}) error {
+ form, err := c.Input()
+ if err != nil {
+ return err
+ }
+ return ParseForm(form, obj)
+}
+
+// GetString returns the input value by key string or the default value while it's present and input is blank
+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 ""
+}
+
+// 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 (c *Controller) GetStrings(key string, def ...[]string) []string {
+ var defv []string
+ if len(def) > 0 {
+ defv = def[0]
+ }
+
+ if f, err := c.Input(); f == nil || err != nil {
+ return defv
+ } else if vs := f[key]; len(vs) > 0 {
+ return vs
+ }
+
+ return defv
+}
+
+// GetInt returns input as an int or the default value while it's present and input is blank
+func (c *Controller) GetInt(key string, def ...int) (int, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ return strconv.Atoi(strv)
+}
+
+// GetInt8 return input as an int8 or the default value while it's present and input is blank
+func (c *Controller) GetInt8(key string, def ...int8) (int8, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ i64, err := strconv.ParseInt(strv, 10, 8)
+ return int8(i64), err
+}
+
+// GetUint8 return input as an uint8 or the default value while it's present and input is blank
+func (c *Controller) GetUint8(key string, def ...uint8) (uint8, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ u64, err := strconv.ParseUint(strv, 10, 8)
+ return uint8(u64), err
+}
+
+// GetInt16 returns input as an int16 or the default value while it's present and input is blank
+func (c *Controller) GetInt16(key string, def ...int16) (int16, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ i64, err := strconv.ParseInt(strv, 10, 16)
+ return int16(i64), err
+}
+
+// GetUint16 returns input as an uint16 or the default value while it's present and input is blank
+func (c *Controller) GetUint16(key string, def ...uint16) (uint16, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ u64, err := strconv.ParseUint(strv, 10, 16)
+ return uint16(u64), err
+}
+
+// GetInt32 returns input as an int32 or the default value while it's present and input is blank
+func (c *Controller) GetInt32(key string, def ...int32) (int32, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ i64, err := strconv.ParseInt(strv, 10, 32)
+ return int32(i64), err
+}
+
+// GetUint32 returns input as an uint32 or the default value while it's present and input is blank
+func (c *Controller) GetUint32(key string, def ...uint32) (uint32, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ u64, err := strconv.ParseUint(strv, 10, 32)
+ return uint32(u64), err
+}
+
+// GetInt64 returns input value as int64 or the default value while it's present and input is blank.
+func (c *Controller) GetInt64(key string, def ...int64) (int64, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ return strconv.ParseInt(strv, 10, 64)
+}
+
+// GetUint64 returns input value as uint64 or the default value while it's present and input is blank.
+func (c *Controller) GetUint64(key string, def ...uint64) (uint64, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ return strconv.ParseUint(strv, 10, 64)
+}
+
+// GetBool returns input value as bool or the default value while it's present and input is blank.
+func (c *Controller) GetBool(key string, def ...bool) (bool, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ return strconv.ParseBool(strv)
+}
+
+// GetFloat returns input value as float64 or the default value while it's present and input is blank.
+func (c *Controller) GetFloat(key string, def ...float64) (float64, error) {
+ strv := c.Ctx.Input.Query(key)
+ if len(strv) == 0 && len(def) > 0 {
+ return def[0], nil
+ }
+ return strconv.ParseFloat(strv, 64)
+}
+
+// GetFile returns the file data in file upload field named as key.
+// it returns the first one of multi-uploaded files.
+func (c *Controller) GetFile(key string) (multipart.File, *multipart.FileHeader, error) {
+ return c.Ctx.Request.FormFile(key)
+}
+
+// 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 (c *Controller) GetFiles(key string) ([]*multipart.FileHeader, error) {
+ if files, ok := c.Ctx.Request.MultipartForm.File[key]; ok {
+ return files, nil
+ }
+ return nil, http.ErrMissingFile
+}
+
+// SaveToFile saves uploaded file to new path.
+// it only operates the first one of mutil-upload form file field.
+func (c *Controller) SaveToFile(fromfile, tofile string) error {
+ file, _, err := c.Ctx.Request.FormFile(fromfile)
+ if err != nil {
+ return err
+ }
+ defer file.Close()
+ f, err := os.OpenFile(tofile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+ io.Copy(f, file)
+ return nil
+}
+
+// StartSession starts session and load old session data info this controller.
+func (c *Controller) StartSession() session.Store {
+ if c.CruSession == nil {
+ c.CruSession = c.Ctx.Input.CruSession
+ }
+ return c.CruSession
+}
+
+// SetSession puts value into session.
+func (c *Controller) SetSession(name interface{}, value interface{}) error {
+ if c.CruSession == nil {
+ c.StartSession()
+ }
+ return c.CruSession.Set(context2.Background(), name, value)
+}
+
+// GetSession gets value from session.
+func (c *Controller) GetSession(name interface{}) interface{} {
+ if c.CruSession == nil {
+ c.StartSession()
+ }
+ return c.CruSession.Get(context2.Background(), name)
+}
+
+// DelSession removes value from session.
+func (c *Controller) DelSession(name interface{}) error {
+ if c.CruSession == nil {
+ c.StartSession()
+ }
+ return c.CruSession.Delete(context2.Background(), name)
+}
+
+// SessionRegenerateID regenerates session id for this session.
+// the session data have no changes.
+func (c *Controller) SessionRegenerateID() error {
+ if c.CruSession != nil {
+ c.CruSession.SessionRelease(context2.Background(), c.Ctx.ResponseWriter)
+ }
+ var err error
+ c.CruSession, err = GlobalSessions.SessionRegenerateID(c.Ctx.ResponseWriter, c.Ctx.Request)
+ c.Ctx.Input.CruSession = c.CruSession
+ return err
+}
+
+// DestroySession cleans session data and session cookie.
+func (c *Controller) DestroySession() error {
+ err := c.Ctx.Input.CruSession.Flush(nil)
+ if err != nil {
+ return err
+ }
+ c.Ctx.Input.CruSession = nil
+ GlobalSessions.SessionDestroy(c.Ctx.ResponseWriter, c.Ctx.Request)
+ return nil
+}
+
+// IsAjax returns this request is ajax or not.
+func (c *Controller) IsAjax() bool {
+ return c.Ctx.Input.IsAjax()
+}
+
+// GetSecureCookie returns decoded cookie value from encoded browser cookie values.
+func (c *Controller) GetSecureCookie(Secret, key string) (string, bool) {
+ return c.Ctx.GetSecureCookie(Secret, key)
+}
+
+// SetSecureCookie puts value into cookie after encoded the value.
+func (c *Controller) SetSecureCookie(Secret, name, value string, others ...interface{}) {
+ c.Ctx.SetSecureCookie(Secret, name, value, others...)
+}
+
+// XSRFToken creates a CSRF token string and returns.
+func (c *Controller) XSRFToken() string {
+ if c._xsrfToken == "" {
+ expire := int64(BConfig.WebConfig.XSRFExpire)
+ if c.XSRFExpire > 0 {
+ expire = int64(c.XSRFExpire)
+ }
+ c._xsrfToken = c.Ctx.XSRFToken(BConfig.WebConfig.XSRFKey, expire)
+ }
+ return c._xsrfToken
+}
+
+// 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 (c *Controller) CheckXSRFCookie() bool {
+ if !c.EnableXSRF {
+ return true
+ }
+ return c.Ctx.CheckXSRFCookie()
+}
+
+// XSRFFormHTML writes an input field contains xsrf token value.
+func (c *Controller) XSRFFormHTML() string {
+ return ``
+}
+
+// GetControllerAndAction gets the executing controller name and action name.
+func (c *Controller) GetControllerAndAction() (string, string) {
+ return c.controllerName, c.actionName
+}
diff --git a/vendor/github.com/beego/beego/v2/server/web/doc.go b/vendor/github.com/beego/beego/v2/server/web/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..48c2134204c2597c0f8991375b1f17f7cd0f8479
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/doc.go
@@ -0,0 +1,17 @@
+/*
+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/beego/beego/v2"
+
+ func main() {
+ beego.Run()
+ }
+
+more information: http://beego.me
+*/
+package web
diff --git a/vendor/github.com/beego/beego/v2/server/web/error.go b/vendor/github.com/beego/beego/v2/server/web/error.go
new file mode 100644
index 0000000000000000000000000000000000000000..85ae5c8c6b764ae4e5a0214e65a224243026d6fe
--- /dev/null
+++ b/vendor/github.com/beego/beego/v2/server/web/error.go
@@ -0,0 +1,490 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package web
+
+import (
+ "fmt"
+ "html/template"
+ "net/http"
+ "reflect"
+ "runtime"
+ "strconv"
+ "strings"
+
+ "github.com/beego/beego/v2"
+ "github.com/beego/beego/v2/core/utils"
+
+ "github.com/beego/beego/v2/server/web/context"
+)
+
+const (
+ errorTypeHandler = iota
+ errorTypeController
+)
+
+var tpl = `
+
+
+
+
+
+
+ {{.AppError}}
+
+
+
+
+
+
+
+`
+
+// render default application error page with error and stack string.
+func showErr(err interface{}, ctx *context.Context, stack string) {
+ t, _ := template.New("beegoerrortemp").Parse(tpl)
+ data := map[string]string{
+ "AppError": fmt.Sprintf("%s:%v", BConfig.AppName, err),
+ "RequestMethod": ctx.Input.Method(),
+ "RequestURL": ctx.Input.URI(),
+ "RemoteAddr": ctx.Input.IP(),
+ "Stack": stack,
+ "BeegoVersion": beego.VERSION,
+ "GoVersion": runtime.Version(),
+ }
+ t.Execute(ctx.ResponseWriter, data)
+}
+
+var errtpl = `
+
+
+
+
+
+
+
+
+`
+
+type errorInfo struct {
+ controllerType reflect.Type
+ handler http.HandlerFunc
+ method string
+ errorType int
+}
+
+// ErrorMaps holds map of http handlers for each error string.
+// there is 10 kinds default error(40x and 50x)
+var ErrorMaps = make(map[string]*errorInfo, 10)
+
+// show 401 unauthorized error.
+func unauthorized(rw http.ResponseWriter, r *http.Request) {
+ responseError(rw, r,
+ 401,
+ "
+
+
+
+ The page you have requested can't be authorized."+ + "
Perhaps you are here because:"+ + "
- "+
+ "
The credentials you supplied are incorrect"+ + "
There are errors in the website address"+ + "
The page you have requested Payment Required."+ + "
Perhaps you are here because:"+ + "
- "+
+ "
The credentials you supplied are incorrect"+ + "
There are errors in the website address"+ + "
The page you have requested is forbidden."+ + "
Perhaps you are here because:"+ + "
- "+
+ "
Your address may be blocked"+ + "
The site may be disabled"+ + "
You need to log in"+ + "
The page you have requested is forbidden."+ + "
Perhaps you are here because:"+ + "
- "+
+ "
'_xsrf' argument missing from POST"+ + "
The page you have requested is forbidden."+ + "
Perhaps you are here because:"+ + "
- "+
+ "
expected XSRF not found"+ + "
The page you have requested has flown the coop."+ + "
Perhaps you are here because:"+ + "
- "+
+ "
The page has moved"+ + "
The page no longer exists"+ + "
You were looking for your puppy and got lost"+ + "
You like 404 pages"+ + "
The method you have requested Not Allowed."+ + "
Perhaps you are here because:"+ + "
- "+
+ "
The method specified in the Request-Line is not allowed for the resource identified by the Request-URI"+ + "
The response MUST include an Allow header containing a list of valid methods for the requested resource."+ + "
The page you have requested is down right now."+ + "
- "+
+ "
Please try again later and report the error to the website administrator"+ + "
The page you have requested is Not Implemented."+ + "
- "+
+ "
Please try again later and report the error to the website administrator"+ + "
The page you have requested is down right now."+ + "
- "+
+ "
The server, while acting as a gateway or proxy, received an invalid response from the upstream server it accessed in attempting to fulfill the request."+ + "
Please try again later and report the error to the website administrator"+ + "
The page you have requested is unavailable."+ + "
Perhaps you are here because:"+ + "
- "+
+ "
The page is overloaded"+ + "
Please try again later."+ + "
The page you have requested is unavailable"+ + "
Perhaps you are here because:"+ + "
- "+
+ "
The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URI."+ + "
Please try again later."+ + "
The page you have requested is unavailable. +
Perhaps you are here because:
+
-
+
The request entity is larger than limits defined by server. +
Please change the request entity and try again. +