Golang Context.App方法代码示例

func ArticleListHandler(ctx *app.Context) {
	data := map[string]interface{}{
		"Articles": getArticles(ctx),
		"Title":    ctx.App().Name(),
	}
	ctx.MustExecute("list.html", data)
}

func decodeResetPayload(ctx *app.Context, payload string) (reflect.Value, error) {
	se, err := ctx.App().EncryptSigner(Salt)
	if err != nil {
		return reflect.Value{}, err
	}
	value, err := se.UnsignDecrypt(payload)
	if err != nil {
		return reflect.Value{}, err
	}
	qs, err := url.ParseQuery(string(value))
	if err != nil {
		return reflect.Value{}, err
	}
	userId, err := strconv.ParseInt(qs.Get("u"), 36, 64)
	if err != nil {
		return reflect.Value{}, err
	}
	ts, err := strconv.ParseInt(qs.Get("t"), 36, 64)
	if err != nil {
		return reflect.Value{}, err
	}
	if time.Since(time.Unix(ts, 0)) > PasswordResetExpiry {
		return reflect.Value{}, errResetExpired
	}
	user, userVal := newEmptyUser(ctx)
	ok := ctx.Orm().MustOne(orm.Eq("User.UserId", userId), userVal)
	if !ok {
		return reflect.Value{}, errNoSuchUser
	}
	return user, nil
}

func printResources(ctx *app.Context) {
	// TODO: Define an interface in package vfs, so this fails
	// if the interface is changed or renamed.
	type rooter interface {
		Root() string
	}
	var assets string
	var templates string
	if mgr := ctx.App().AssetsManager(); mgr != nil {
		if r, ok := mgr.VFS().(rooter); ok {
			assets = r.Root()
		}
	}
	if r, ok := ctx.App().TemplatesFS().(rooter); ok {
		templates = r.Root()
	}
	resources := map[string]string{
		"assets":    assets,
		"templates": templates,
	}
	data, err := json.Marshal(resources)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data))
}

func getGeoIPRecord(ctx *app.Context) *geoip.Record {
	if rec, _ := ctx.Get(recordKey).(*geoip.Record); rec != nil {
		return rec
	}
	g, _ := ctx.App().Get(geoIPKey).(*geoip.GeoIP)
	if g == nil {
		log.Warning("no GeoIP data loaded - did you call geoip.Load()?")
		return nil
	}
	rec, _ := g.Lookup(ctx.RemoteAddress())
	ctx.Set(recordKey, rec)
	return rec
}

func ArticleHandler(ctx *app.Context) {
	slug := ctx.IndexValue(0)
	var art *article.Article
	articles := getArticles(ctx)
	for _, v := range articles {
		if v.Slug() == slug {
			art = v
			break
		}
	}
	if art == nil {
		for _, v := range articles {
			for _, s := range v.AllSlugs() {
				if s == slug {
					ctx.MustRedirectReverse(true, ctx.HandlerName(), s)
					return
				}
			}
		}
		ctx.NotFound("article not found")
		return
	}
	fs := vfs.Memory()
	filename := path.Base(art.Filename)
	if filename == "" {
		filename = "article.html"
	}
	if err := vfs.WriteFile(fs, filename, art.Text, 0644); err != nil {
		panic(err)
	}
	log.Debugf("loading article %s", articleId(art))
	tmpl, err := app.LoadTemplate(ctx.App(), fs, nil, filename)
	if err != nil {
		panic(err)
	}
	var buf bytes.Buffer
	if err := tmpl.ExecuteTo(&buf, ctx, nil); err != nil {
		panic(err)
	}
	body := buf.String()
	data := map[string]interface{}{
		"Article": art,
		"Title":   art.Title(),
		"Body":    template.HTML(body),
	}
	ctx.MustExecute("article.html", data)
}

func makeAssets(ctx *app.Context) {
	a := ctx.App()
	if cfg := a.Config(); cfg != nil {
		cfg.TemplateDebug = false
	}
	err := vfs.Walk(a.TemplatesFS(), "/", func(fs vfs.VFS, p string, info os.FileInfo, err error) error {
		if err != nil || info.IsDir() || p == "" || p[0] == '.' {
			return err
		}
		if _, err := a.LoadTemplate(p); err != nil {
			log.Errorf("error loading template %s: %s", p, err)
		}
		return nil
	})

	if err != nil {
		log.Errorf("error listing templates: %s", err)
	}
}

func renderTemplate(ctx *app.Context) {
	var template string
	ctx.MustParseIndexValue(0, &template)
	tmpl, err := ctx.App().LoadTemplate(template)
	if err != nil {
		panic(err)
	}
	var buf bytes.Buffer
	if err := tmpl.ExecuteTo(&buf, ctx, nil); err != nil {
		panic(err)
	}
	var output string
	ctx.ParseParamValue("o", &output)
	if output == "" || output == "-" {
		fmt.Print(buf.String())
	} else {
		if err := ioutil.WriteFile(output, buf.Bytes(), 0644); err != nil {
			panic(err)
		}
	}
}

func csrfEncryptSigner(ctx *app.Context, salt string) (*cryptoutil.EncryptSigner, error) {
	a := ctx.App()
	signer, err := a.Signer([]byte(salt))
	if err != nil {
		return nil, err
	}
	encrypter, _ := a.Encrypter()
	if encrypter == nil {
		var key []byte
		cfg := a.Config()
		if cfg == nil || cfg.Secret == "" {
			return nil, errors.New("can't generate CSRF tokens, App configuration has no Secret")
		}
		if len(cfg.EncryptionKey) > 0 {
			key = []byte(cfg.EncryptionKey)
		} else {
			s := sha256.New()
			s.Write([]byte(cfg.Secret))
			key = s.Sum(nil)
		}
		encrypter = &cryptoutil.Encrypter{Cipherer: a.Cipherer, Key: key}
	}
	return &cryptoutil.EncryptSigner{Encrypter: encrypter, Signer: signer}, nil
}

// Data is a shorthand for AppData(ctx.App())
func Data(ctx *app.Context) interface{} {
	return AppData(ctx.App())
}

func reverseArticle(ctx *app.Context, article interface{}) (string, error) {
	return reverseAppArticle(ctx.App(), article)
}

func forgotHandler(ctx *app.Context) {
	d := data(ctx)
	if !d.allowDirectSignIn() {
		ctx.NotFound("")
		return
	}
	var user User
	var isEmail bool
	var sent bool
	var fields struct {
		Username         string `form:",singleline,label=Username or Email"`
		ValidateUsername func(*app.Context) error
	}
	fields.ValidateUsername = func(c *app.Context) error {
		username := Normalize(fields.Username)
		isEmail = strings.Contains(username, "@")
		var field string
		if isEmail {
			field = "User.NormalizedEmail"
		} else {
			field = "User.NormalizedUsername"
		}
		userVal, userIface := newEmptyUser(ctx)
		ok := c.Orm().MustOne(orm.Eq(field, username), userIface)
		if !ok {
			if isEmail {
				return i18n.Errorf("address %q does not belong to any registered user", username)
			}
			return i18n.Errorf("username %q does not belong to any registered user", username)
		}
		user = getUserValue(userVal, "User").(User)
		if user.Email == "" {
			return i18n.Errorf("username %q does not have any registered emails", username)
		}
		return nil
	}
	f := form.New(ctx, &fields)
	if f.Submitted() && f.IsValid() {
		se, err := ctx.App().EncryptSigner(Salt)
		if err != nil {
			panic(err)
		}
		values := make(url.Values)
		values.Add("u", strconv.FormatInt(user.Id(), 36))
		values.Add("t", strconv.FormatInt(time.Now().Unix(), 36))
		values.Add("n", stringutil.Random(64))
		payload := values.Encode()
		p, err := se.EncryptSign([]byte(payload))
		if err != nil {
			panic(err)
		}
		abs := ctx.URL()
		reset := fmt.Sprintf("%s://%s%s?p=%s", abs.Scheme, abs.Host, ctx.MustReverse(ResetHandlerName), p)
		data := map[string]interface{}{
			"URL": reset,
		}
		from := mail.DefaultFrom()
		if from == "" {
			from = fmt.Sprintf("[email protected]%s", abs.Host)
		}
		msg := &mail.Message{
			To:      user.Email,
			From:    from,
			Subject: fmt.Sprintf(ctx.T("Reset your %s password"), d.opts.SiteName),
		}
		ctx.MustSendMail("reset_password.txt", data, msg)
		sent = true
	}
	data := map[string]interface{}{
		"ForgotForm": f,
		"IsEmail":    isEmail,
		"Sent":       sent,
		"User":       user,
	}
	ctx.MustExecute(ForgotTemplateName, data)
}

func data(ctx *app.Context) *appData {
	d, _ := reusableapp.AppDataWithKey(ctx.App(), appDataKey).(*appData)
	return d
}

// Execute runs the given handler in a task context. If the handler fails
// with a panic, it will be returned in the error return value.
func Execute(ctx *app.Context, handler app.Handler) error {
	t := &Task{App: ctx.App(), Handler: handler}
	_, err := executeTask(ctx, t)
	return err
}

func SourceHandler(ctx *app.Context) {
	dctx := doc.GetEnvironment(ctx.App())
	rel := ctx.IndexValue(0)
	p := dctx.FromSlash(rel)
	pDir := dctx.Dir(p)
	if pDir == "." {
		pDir = p
	} else {

	}
	dir := packageDir(dctx, pDir)
	filePath := dir
	if pDir+dctx.Separator != p && pDir != p {
		filePath = dctx.Join(dir, dctx.Base(p))
	}
	log.Debugf("Loading source from %s", filePath)
	var breadcrumbs []*breadcrumb
	for ii := 0; ii < len(rel); {
		var end int
		slash := strings.IndexByte(rel[ii:], '/')
		if slash < 0 {
			end = len(rel)
		} else {
			end = ii + slash
		}
		breadcrumbs = append(breadcrumbs, &breadcrumb{
			Title: rel[ii:end],
			Href:  ctx.MustReverse(SourceHandlerName, rel[:end]),
		})
		ii = end + 1
	}
	var tmpl string
	var title string
	var files []string
	var code template.HTML
	var lines []int
	if dctx.IsDir(filePath) {
		if rel != "" && rel[len(rel)-1] != '/' {
			ctx.MustRedirectReverse(true, SourceHandlerName, rel+"/")
			return
		}
		contents, err := dctx.ReadDir(filePath)
		if err != nil {
			panic(err)
		}
		for _, v := range contents {
			if n := v.Name(); len(n) > 0 && n[0] != '.' {
				files = append(files, n)
			}
		}
		title = "Directory " + dctx.Base(rel)
		tmpl = "dir.html"
	} else {
		f, err := dctx.OpenFile(filePath)
		if err != nil {
			ctx.NotFound("File not found")
			return
		}
		defer f.Close()
		contents, err := ioutil.ReadAll(f)
		if err != nil {
			panic(err)
		}
		contentType := http.DetectContentType(contents)
		if !strings.HasPrefix(contentType, "text") {
			ctx.Header().Set("Content-Type", contentType)
			switch contentType {
			case "image/gif", "image/png", "image/jpeg":
			default:
				ctx.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s;", dctx.Base(rel)))
			}
			ctx.Write(contents)
			return
		}
		title = "File " + dctx.Base(rel)
		var buf bytes.Buffer
		buf.WriteString("<span id=\"line-1\">")
		last := 0
		line := 1
		for ii, v := range contents {
			if v == '\n' {
				buf.WriteString(html.Escape(string(contents[last:ii])))
				lines = append(lines, line)
				last = ii
				line++
				buf.WriteString(fmt.Sprintf("</span><span id=\"line-%d\">", line))
			}
		}
		buf.Write(contents[last:])
		buf.WriteString("</span>")
		code = template.HTML(buf.String())
		tmpl = "source.html"
	}
	data := map[string]interface{}{
		"Title":       rel,
		"Header":      title,
		"Breadcrumbs": breadcrumbs,
		"Files":       files,
		"Code":        code,
		"Lines":       lines,
//.........这里部分代码省略.........