Golang tango.Context类代码示例

func (s *Server) serveFile(ctx *tango.Context, file string) bool {
	if com.IsFile(file) {
		ctx.ServeFile(file)
		return true
	}
	return false
}

func LoginUserFromRememberCookie(user *models.User, ctx *tango.Context, session *session.Session) (success bool) {
	userName := GetCookie(ctx.Req(), setting.CookieUserName)
	if len(userName) == 0 {
		return false
	}

	defer func() {
		if !success {
			DeleteRememberCookie(ctx)
		}
	}()

	var err error
	if user, err = models.GetUserByName(userName); err != nil {
		return false
	}

	secret := utils.EncodeMd5(user.Rands + user.Password)
	value, _ := GetSecureCookie(ctx.Req(), secret, setting.CookieRememberName)
	if value != userName {
		return false
	}

	LoginUser(user, ctx, session, true)

	return true
}

func (s *Server) serveFile(ctx *tango.Context, file string) bool {
	log15.Debug("Dest.File." + file)
	if com.IsFile(file) {
		ctx.ServeFile(file)
		return true
	}
	return false
}

// Handle implement tango.Handle
func (c *Caches) Handle(ctx *tango.Context) {
	if action := ctx.Action(); ctx != nil {
		if s, ok := action.(Cacher); ok {
			s.SetCaches(c)
		}
	}

	ctx.Next()
}

// get login redirect url from cookie
func GetLoginRedirect(ctx *tango.Context) string {
	loginRedirect := strings.TrimSpace(GetCookie(ctx.Req(), "login_to"))
	if utils.IsMatchHost(loginRedirect) == false {
		loginRedirect = "/"
	} else {
		SetCookie(ctx, "login_to", "", -1, "/")
	}
	return loginRedirect
}

func Image(ctx *tango.Context) {
	token := ctx.Params().Get(":path")

	// split token and file ext
	var filePath string
	if i := strings.IndexRune(token, '.'); i == -1 {
		return
	} else {
		filePath = token[i+1:]
		token = token[:i]
	}

	// decode token to file path
	var image models.Image
	if err := image.DecodeToken(token); err != nil {
		log.Info(err)
		return
	}

	// file real path
	filePath = attachment.GenImagePath(&image) + filePath

	// if x-send on then set header and http status
	// fall back use proxy serve file
	if setting.ImageXSend {
		//ext := filepath.Ext(filePath)
		// TODO:
		//ctx.Header().ContentType(ext)
		ctx.Header().Set(setting.ImageXSendHeader, "/"+filePath)
		ctx.WriteHeader(http.StatusOK)
	} else {
		// direct serve file use go
		ctx.ServeFile(filePath)
	}
}

func (h *TimeHandler) Handle(ctx *tango.Context) {
	t1 := time.Now()
	ctx.Next()
	ctx.Logger.Infof("Completed %v %v %v in %v for %v",
		ctx.Req().Method,
		ctx.Req().URL.Path,
		ctx.Status(),
		time.Since(t1),
		ctx.Req().RemoteAddr,
	)
}

func (s *Server) globalHandler(ctx *tango.Context) {
	param := ctx.Param("*name")
	if path.Ext(param) == "" {
		if s.serveFile(ctx, path.Join(s.dstDir, param, "index.html")) {
			return
		}
	}
	if !strings.HasSuffix(param, "/") {
		if s.serveFile(ctx, path.Join(s.dstDir, param, ".html")) {
			return
		}
	}
	if s.serveFile(ctx, path.Join(s.dstDir, param)) {
		return
	}
	ctx.Redirect("/")
}

func QiniuImage(ctx *tango.Context) {
	var imageName = ctx.Params().Get(":path")
	var imageKey string
	var imageSize string
	if i := strings.IndexRune(imageName, '.'); i == -1 {
		return
	} else {
		imageSize = imageName[i+1:]
		if j := strings.IndexRune(imageSize, '.'); j == -1 {
			imageSize = "full"
		} else {
			imageSize = imageSize[:j]
		}
		imageKey = imageName[:i]
	}

	var image = models.Image{
		Token: imageKey,
	}
	err := models.GetByExample(&image)
	if err != nil {
		return
	}
	var imageWidth = image.Width
	var imageHeight = image.Height
	var zoomRatio = setting.ImageSizeMiddle / imageWidth
	if imageWidth > setting.ImageSizeMiddle {
		imageWidth = setting.ImageSizeMiddle
	}
	imageHeight *= zoomRatio

	var imageUrl = utils.GetQiniuPublicDownloadUrl(setting.QiniuPostDomain, imageKey)
	var zoomImageUrl = utils.GetQiniuZoomViewUrl(imageUrl, imageWidth, imageHeight)
	resp, err := http.Get(zoomImageUrl)
	if err != nil {
		return
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return
	}
	ctx.ResponseWriter.Write(body)
}

func (rh *RecoveryHandler) Handle(ctx *tango.Context) {
	// capture render-controller error
	if render, ok := ctx.Action().(ITheme); ok {
		if err, ok := ctx.Result.(tango.AbortError); ok {
			render.RenderError(err.Code(), err)
			return
		}
		if err, ok := ctx.Result.(error); ok {
			ctx.WriteHeader(500)
			render.RenderError(ctx.Status(), err)
			return
		}
	}

	// capture abort error
	/*
		if err, ok := ctx.Result.(tango.AbortError); ok {
			ctx.WriteHeader(err.Code())
			theme := new(ThemeRender)
			theme.SetTheme(nil)
			theme.RenderError(err.Code(), err)
			return
		}*/

	// unexpected error
	tango.Errors()(ctx)
}

// get language from context
func getContextLanguage(ctx *tango.Context) string {
	// get from cookie
	lang := ctx.Cookie(langCookieName)

	// get from header
	if lang == "" {
		al := ctx.Req().Header.Get("Accept-Language")
		if len(al) > 4 {
			lang = al[:5] // Only compare first 5 letters.
		}
	}

	// get from query param
	if lang == "" {
		lang = ctx.Param(langParamName)
	}

	// get default if not find in context
	lang = strings.ToLower(lang)
	if !i18n.IsExist(lang) {
		lang = i18n.GetLangByIndex(0)
	}

	return lang
}

// get auth token via http header, cookie or form value
func (ar *AuthRouter) GetAuthToken(ctx *tango.Context) string {
	var token string
	if token = ctx.Header().Get("X-Token"); token != "" {
		return token
	}
	if token = ctx.Cookie("x-token"); token != "" {
		return token
	}
	return ctx.Form("x-token")
}

func (s *Server) globalHandler(ctx *tango.Context) {
	param := ctx.Param("*name")
	if param == "favicon.ico" || param == "robots.txt" {
		if !s.serveFiles(ctx, param) {
			ctx.NotFound()
		}
		return
	}

	if !strings.HasPrefix("/"+param, s.prefix) {
		ctx.Redirect(s.prefix)
		return
	}
	param = strings.TrimPrefix("/"+param, s.prefix)
	s.serveFiles(ctx, param)
}

//Tango
func tangoHandler(ctx *tango.Context) {
	if sleepTime > 0 {
		time.Sleep(sleepTimeDuration)
	}
	ctx.Write(message)
}

// Handle implements tango handler,
// copy from tango static.go
func (s *Static) Handle(ctx *tango.Context) {
	if ctx.Req().Method != "GET" && ctx.Req().Method != "HEAD" {
		ctx.Next()
		return
	}

	opt := prepareStaticOptions(s.Options)

	var rPath = ctx.Req().URL.Path
	// if defined prefix, then only check prefix
	if opt.Prefix != "" {
		if !strings.HasPrefix(ctx.Req().URL.Path, opt.Prefix) {
			ctx.Next()
			return
		} else {
			if len(opt.Prefix) == len(ctx.Req().URL.Path) {
				rPath = ""
			} else {
				rPath = ctx.Req().URL.Path[len(opt.Prefix):]
			}
		}
	}

	fPath, _ := filepath.Abs(filepath.Join(opt.RootPath, rPath))
	finfo, err := os.Stat(fPath)
	if err != nil {
		if !os.IsNotExist(err) {
			ctx.Result = tango.InternalServerError(err.Error())
			ctx.HandleError()
			return
		}
	} else if !finfo.IsDir() {
		if len(opt.FilterExts) > 0 {
			var matched bool
			for _, ext := range opt.FilterExts {
				if filepath.Ext(fPath) == ext {
					matched = true
					break
				}
			}
			if !matched {
				ctx.Next()
				return
			}
		}

		err := ctx.ServeFile(fPath)
		if err != nil {
			ctx.Result = tango.InternalServerError(err.Error())
			ctx.HandleError()
		}
		return
	} else {
		// try serving index.html or index.htm
		if len(opt.IndexFiles) > 0 {
			for _, index := range opt.IndexFiles {
				nPath := filepath.Join(fPath, index)
				finfo, err = os.Stat(nPath)
				if err != nil {
					if !os.IsNotExist(err) {
						ctx.Result = tango.InternalServerError(err.Error())
						ctx.HandleError()
						return
					}
				} else if !finfo.IsDir() {
					err = ctx.ServeFile(nPath)
					if err != nil {
						ctx.Result = tango.InternalServerError(err.Error())
						ctx.HandleError()
					}
					return
				}
			}
		}

		// list dir files
		if opt.ListDir {
			ctx.Header().Set("Content-Type", "text/html; charset=UTF-8")
			ctx.Write([]byte(`<ul style="list-style-type:none;line-height:32px;">`))
			rootPath, _ := filepath.Abs(opt.RootPath)
			rPath, _ := filepath.Rel(rootPath, fPath)
			if fPath != rootPath {
				ctx.Write([]byte(`<li>&nbsp; &nbsp; <a href="/` + path.Join(opt.Prefix, filepath.Dir(rPath)) + `">..</a></li>`))
			}
			err = filepath.Walk(fPath, func(p string, fi os.FileInfo, err error) error {
				rPath, _ := filepath.Rel(fPath, p)
				if rPath == "." || len(strings.Split(rPath, string(filepath.Separator))) > 1 {
					return nil
				}
				rPath, _ = filepath.Rel(rootPath, p)
				ps, _ := os.Stat(p)
				if ps.IsDir() {
					ctx.Write([]byte(`<li>┖ <a href="/` + path.Join(opt.Prefix, rPath) + `">` + filepath.Base(p) + `</a></li>`))
				} else {
					if len(opt.FilterExts) > 0 {
						var matched bool
						for _, ext := range opt.FilterExts {
							if filepath.Ext(p) == ext {
//.........这里部分代码省略.........