Пример #1
0
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
}
Пример #2
0
// 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
}
Пример #3
0
// 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
}
Пример #4
0
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,
	)
}
Пример #5
0
// 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 {
								matched = true
								break
							}
						}
						if !matched {
							return nil
						}
					}

					ctx.Write([]byte(`<li>&nbsp; &nbsp; <a href="/` + path.Join(opt.Prefix, rPath) + `">` + filepath.Base(p) + `</a></li>`))
				}
				return nil
			})
			ctx.Write([]byte("</ul>"))
			return
		}
	}

}