Example #1
0
func init_templates() {
	root := config.Server["templates"]
	templates["index.html"] = pongo.Must(pongo.FromFile(path.Join(root, "index.html"), nil))
	templates["about.html"] = pongo.Must(pongo.FromFile(path.Join(root, "about.html"), nil))
	templates["history.html"] = pongo.Must(pongo.FromFile(path.Join(root, "history.html"), nil))
	templates["add/page.html"] = pongo.Must(pongo.FromFile(path.Join(root, "add/page.html"), nil))
	templates["add/group.html"] = pongo.Must(pongo.FromFile(path.Join(root, "add/group.html"), nil))
}
Example #2
0
func (w Wrapper) RenderWithVars(p string, vars TemplateVars) {
	w.Res.Header().Add("Content-type", "text/html")

	tplFile := path.Join(w.App.ViewsRoot, p)

	var tpl *pongo.Template
	if val, ok := tplCache[tplFile]; ok {
		tpl = val
	} else {
		tpl = pongo.Must(pongo.FromFile(tplFile, nil))
	}

	var context = pongo.Context{
		"session": w.Session,
	}

	for k, v := range vars {
		context[k] = v
	}

	out, err := tpl.Execute(&context)
	if err != nil {
		panic(err)
	}
	w.Write(*out)
}
Example #3
0
func (tpl *DjangoTpl) Display(template string) {
	var tplExample = pongo.Must(pongo.FromFile(template, nil))
	err := tplExample.ExecuteRW(tpl.w, &tpl.ctx)
	if err != nil {
		http.Error(tpl.w, err.Error(), http.StatusInternalServerError)
	}
}
Example #4
0
/**
 * Handles request for section
 */
func handlePaginatedSection(ctx *web.Context, section string, page string) string {
	config, err := getConfig()
	if err != nil {
		ctx.Abort(500, "Configuration error.")
		return ""
	}
	tpl := pongo.Must(pongo.FromFile(config.TemplateFolder+"/template.html", nil))
	var content, output string
	p, _ := strconv.Atoi(page)
	output, err = getAbstracts(section, p, &config)
	if err != nil {
		ctx.Abort(404, "Page not found. Could not load abstracts")
		return ""
	}
	content = string(blackfriday.MarkdownCommon([]byte(output)))
	menu, err := getMenu(&config)
	if err != nil {
		ctx.Abort(501, "Could not load menu")
		return ""
	}
	var response *string
	response, err = tpl.Execute(&pongo.Context{"content": content, "menu": menu,
		"currentMenu": menu.GetCurrent(section)})
	if err != nil {
		ctx.Abort(501, "")
		return err.Error()
	}
	return *response
}
Example #5
0
func include(cfg *config, vars pongo.Context) func(*string) (*string, error) {
	return func(loc *string) (*string, error) {
		inc := filepath.ToSlash(filepath.Join(cfg.includes, *loc))
		tpl, err := pongo.FromFile(inc, include(cfg, vars))
		if err != nil {
			return nil, err
		}
		return tpl.Execute(&vars)
	}
}
Example #6
0
func (t *Template) CreateTemplate() (string, error) {
	tpl, err := pongo.FromFile(t.Source, nil)
	if err != nil {
		return "", err
	}
	ctx := pongo.Context(t.Context)
	out, err := tpl.Execute(&ctx)
	if err != nil {
		return "", err
	}
	return *out, nil
}
Example #7
0
func renderTemplate(tmpl string, ctx pongo.Context, w http.ResponseWriter) {
	//err := templates[tmpl].ExecuteRW(w, &ctx)
	t, err := pongo.FromFile(path.Join(config.Server["templates"], tmpl), nil)
	//err := templates[tmpl].ExecuteRW(w, &ctx)

	// Add some general items to context from the config
	for k, v := range config.Wiki {
		ctx["_"+k] = v
	}

	ctx["_groups"] = get_all_groups()
	err = t.ExecuteRW(w, &ctx)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}
Example #8
0
func renderTemplate(tmpl string, ctx pongo.Context, w http.ResponseWriter) {
	// When in debug, we will load the templates each time so we can modify them
	// without restarting
	if configuration.App.Debug {
		t, err := pongo.FromFile(path.Join(tpl_root, tmpl), nil)
		err = t.ExecuteRW(w, &ctx)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
		return
	}

	err := templates[tmpl].ExecuteRW(w, &ctx)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}
Example #9
0
func run_server() error {
	tpl_root = path.Join(configuration.Templates.Path, "templates/")
	templates["index.html"] = pongo.Must(pongo.FromFile(path.Join(tpl_root, "index.html"), nil))

	svr := fmt.Sprintf("%s:%d", configuration.Server.Bind, configuration.Server.Port)
	fmt.Printf("Shortly is listening on %s\n", svr)

	http.HandleFunc("/", root_handler)
	http.HandleFunc("/api/", api_handler)
	http.HandleFunc("/app/", app_handler)

	// Static assets
	media := path.Join(configuration.Templates.Path, "assets/")
	http.Handle("/media/",
		http.StripPrefix("/media/", http.FileServer(http.Dir(media))))

	http.ListenAndServe(svr, nil)

	return nil
}
Example #10
0
File: pongo.go Project: murz/ego
func (te *PongoTemplateEngine) Compile(t string) CompiledTemplate {
	return PongoTemplate{
		tmpl: pongo.Must(pongo.FromFile(t, nil)),
	}
}