func NewTemplate(root, path string) *Template { t := &Template{ Url: path, RootDir: filepath.Join(root, path), } // fi, err := ioutil.ReadDir(t.RootDir) // if err != nil { // log.Fatalf("failed to open template dir '%s'", t.RootDir) // } indexPath := filepath.Join(t.RootDir, "index.html") if !fileExists(indexPath) { log.Fatal("template index '%s' not found.") } else if tmpl, err := pongo2.FromFile(indexPath); err != nil { log.Fatal(err) } else { t.Index = tmpl } footerPath := filepath.Join(t.RootDir, "footer.html") if !fileExists(footerPath) { return t } else if tmpl, err := pongo2.FromFile(footerPath); err != nil { log.Fatal(err) } else { t.Footer = tmpl } return t }
func renderTemplate(filepath string, data map[string]interface{}) []byte { var out string var err error var template pongo2.Template // Read the template from the disk every time if ServerConfig.Debug { newTemplate, err := pongo2.FromFile(filepath) if err != nil { panic(err) } template = *newTemplate } else { // Read the template and cache it cached, ok := templateCache[filepath] if ok == false { newTemplate, err := pongo2.FromFile(filepath) if err != nil { panic(err) } templateCache[filepath] = *newTemplate cached = *newTemplate } template = cached } out, err = template.Execute(data) if err != nil { panic(err) } return []byte(out) }
func main() { public_html, err := exists("./public_html/") check(err) if !public_html { os.Mkdir("./public_html/", 0755) os.Mkdir("./public_html/blog/", 0755) os.Mkdir("./public_html/assets/", 0755) ioutil.WriteFile("./public_html/assets/styles.css", []byte(""), 0644) } archive := make([]map[string]string, 0) files, _ := ioutil.ReadDir("./blog/") for _, filename := range files { // Ignore drafts if strings.HasPrefix(filename.Name(), "draft") { continue } filecontent, err := ioutil.ReadFile("./blog/" + filename.Name()) check(err) // Read the metadata r, _ := regexp.Compile("(?m)^Title: (.*)$") title := r.FindStringSubmatch(string(filecontent))[1] filecontent = []byte(r.ReplaceAllString(string(filecontent), "")) r, _ = regexp.Compile("(?m)^Published: (.*)$") published := r.FindStringSubmatch(string(filecontent))[1] filecontent = []byte(r.ReplaceAllString(string(filecontent), "")) tpl, err := pongo2.FromFile("detail.html") check(err) f, err := tpl.Execute(pongo2.Context{"title": title, "published": published, "content": string(blackfriday.MarkdownCommon(filecontent))}) check(err) finalfilename := strings.TrimSuffix(filename.Name(), filepath.Ext(filename.Name())) ioutil.WriteFile("./public_html/blog/" + finalfilename + ".html", []byte(f), 0644) m := make(map[string]string) m["url"] = "./blog/" + finalfilename + ".html" m["title"] = title archive = append(archive, m) } tpl, err := pongo2.FromFile("index.html") check(err) f, err := tpl.Execute(pongo2.Context{"items": archive}) check(err) ioutil.WriteFile("./public_html/index.html", []byte(f), 0644) }
// FromFile - Creates a new template structure from file. func FromFile(fname string) (t Template, err error) { template, err := pongo2.FromFile(fname) if err != nil { return } return &pongoTemplate{Template: template}, nil }
// if err != nil { // http.Error(w, err.Error(), http.StatusInternalServerError) // } // } func (this *ScheduleController) My() { w := this.ResponseWriter r := this.Request r.ParseForm() user := r.FormValue("user") page := u.Page{PageSize: 10, ShowPages: 5} currentPage := r.FormValue("page") log.Println("当前页数", currentPage) page.CurrentPage, _ = strconv.Atoi(currentPage) page.InitSkipRecords() log.Println("过滤多少页", page.SkipRecords) log.Println("总页数", page.TotalPages) order := m.Order{RUser: user} page = order.GetRuserOrders(page) page.InitTotalPages() context := pongo2.Context{"orderlist": page.Data} var tplExample = pongo2.Must(pongo2.FromFile("views/Schedule.my.tpl")) err := tplExample.ExecuteWriter(context, w) if err != nil { log.Println(err) http.Error(w, err.Error(), http.StatusInternalServerError) } }
func (dm *DataManager) WriteRssFile(filename string, pctx pongo2.Context) { tpl, _ := pongo2.FromFile("rss2.j2") pctx["lastBuildDate"] = time.Now().Format(time.RFC1123) context, _ := tpl.ExecuteBytes(pctx) ioutil.WriteFile(filename, context, 0644) dm.Logger.WithFields(SetUpdateLog("rss")).Info("write file " + filename) }
func HomeHandler(rw http.ResponseWriter, r *http.Request) { session, _ := store.Get(r, cfg.SessionName) conf = &oauth2.Config{ ClientID: os.Getenv("GOOGLE_CLIENT_ID"), ClientSecret: os.Getenv("GOOGLE_CLIENT_SECRET"), RedirectURL: os.Getenv("GOOGLE_CLIENT_REDIRECT"), Scopes: []string{ "https://www.googleapis.com/auth/plus.login", "https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile", }, Endpoint: google.Endpoint, } if session.Values["googleId"] != nil { http.Redirect(rw, r, "/dashboard", 301) } // Generate google signin url with xsrf token url := conf.AuthCodeURL(session.Values["xsrf"].(string)) tmpl := pongo2.Must(pongo2.FromFile("./templates/home.html")) err := tmpl.ExecuteWriter(pongo2.Context{"GoogleAuthUrl": url}, rw) if err != nil { http.Error(rw, err.Error(), http.StatusInternalServerError) } }
func TestTemplates(t *testing.T) { // Add a global to the default set pongo2.Globals["this_is_a_global_variable"] = "this is a global text" matches, err := filepath.Glob("./template_tests/*.tpl") if err != nil { t.Fatal(err) } for idx, match := range matches { t.Logf("[Template %3d] Testing '%s'", idx+1, match) tpl, err := pongo2.FromFile(match) if err != nil { t.Fatalf("Error on FromFile('%s'): %s", match, err.Error()) } testFilename := fmt.Sprintf("%s.out", match) testOut, rerr := ioutil.ReadFile(testFilename) if rerr != nil { t.Fatalf("Error on ReadFile('%s'): %s", testFilename, rerr.Error()) } tplOut, err := tpl.ExecuteBytes(tplContext) if err != nil { t.Fatalf("Error on Execute('%s'): %s", match, err.Error()) } if bytes.Compare(testOut, tplOut) != 0 { t.Logf("Template (rendered) '%s': '%s'", match, tplOut) errFilename := filepath.Base(fmt.Sprintf("%s.error", match)) err := ioutil.WriteFile(errFilename, []byte(tplOut), 0600) if err != nil { t.Fatalf(err.Error()) } t.Logf("get a complete diff with command: 'diff -ya %s %s'", testFilename, errFilename) t.Errorf("Failed: test_out != tpl_out for %s", match) } } }
func (m Machine) renderTemplate(templateName string) (string, error) { var tpl = pongo2.Must(pongo2.FromFile(path.Join("templates", templateName))) result, err := tpl.Execute(pongo2.Context{"machine": m}) if err != nil { return "", err } return result, err }
// getFilledTemplate returns the filled template as a slice of bytes. // Initially wanted to use here the stdlib's text/template but ran into issues // with the if instruction. // The template looks quite ugly because of the blank lines left by the tags. // https://code.djangoproject.com/ticket/2594 (WONTFIX) // https://github.com/flosch/pongo2/issues/94 func getFilledTemplate(ctxt pongo2.Context, tplFile string) ([]byte, error) { t := pongo2.Must(pongo2.FromFile(tplFile)) output, err := t.ExecuteBytes(ctxt) if err != nil { log.Fatal(err) } return output, nil }
func (p PongoDebug) Instance(name string, data interface{}) render.Render { t := pongo2.Must(pongo2.FromFile(path.Join(p.Path, name))) return Pongo{ Template: t, Name: name, Data: data, } }
func (cntr Controller) NewFeed(c web.C, w http.ResponseWriter, r *http.Request) { tpl, err := pongo2.FromFile("rss2.j2") if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } items := cntr.GetPageFeedItem(1, c.URLParams["category"], cntr.UserConfig.Site.ItemDays, cntr.UserConfig.Site.PageNewItemCount) tpl.ExecuteWriter(pongo2.Context{"items": items}, w) }
func main() { kingpin.Parse() t := pongo2.Must(pongo2.FromFile(*templatePath)) err := t.ExecuteWriter(getContext(), os.Stdout) if err != nil { panic(err) } }
func viewPage(c *gin.Context, p string, pc pongo2.Context) { tpl, err := pongo2.FromFile(p) if err != nil { c.String(500, "Internal Server Error: cannot found %s", p) } err = tpl.ExecuteWriter(pc, c.Writer) if err != nil { c.String(500, "Internal Server Error: cannot execute %s", p) } }
func (r *Renderer) buildTemplatesCache(name string) (t *pongo2.Template, err error) { r.lock.Lock() defer r.lock.Unlock() t, err = pongo2.FromFile(filepath.Join(r.Directory, name)) if err != nil { return } r.templates[name] = t return }
func DashboardHandler(rw http.ResponseWriter, r *http.Request) { session, _ := store.Get(r, cfg.SessionName) tmpl := pongo2.Must(pongo2.FromFile("./templates/dash.html")) if session.Values["googleId"] != "" { err := tmpl.ExecuteWriter(pongo2.Context{"GoogleId": session.Values["googleId"]}, rw) if err != nil { panic(err) } } }
func index(c web.C, w http.ResponseWriter, r *http.Request) { pongo2.DefaultLoader.SetBaseDir("templates") tpl, err := pongo2.FromFile("index.html") if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } page := &Page{Title: "外部連携"} integrations := conf.Integrations tpl.ExecuteWriter(pongo2.Context{"page": page, "integrations": integrations}, w) }
func BenchmarkExecuteComplexWithSandboxActive(b *testing.B) { tpl, err := pongo2.FromFile("template_tests/complex.tpl") if err != nil { b.Fatal(err) } b.ResetTimer() for i := 0; i < b.N; i++ { err = tpl.ExecuteWriterUnbuffered(tplContext, ioutil.Discard) if err != nil { b.Fatal(err) } } }
func (ctr *UserController) Index(c *gin.Context) { tpl, err := pongo2.FromFile("templates/user/index.html") if err != nil { c.String(500, "can't load template") } err = tpl.ExecuteWriter( pongo2.Context{"hoge": "hogehoge"}, c.Writer, ) if err != nil { c.String(500, "can't write to template") } }
func Pongo2() echo.MiddlewareFunc { return func(h echo.HandlerFunc) echo.HandlerFunc { return func(ctx *echo.Context) error { err := h(ctx) if err != nil { return err } templateName := ctx.Get("template") if templateName == nil { http.Error( ctx.Response().Writer(), "Template in Context not defined.", 500) } var contentType, encoding string var isString bool ct := ctx.Get("ContentType") if ct == nil { contentType = ContentHTML } else { contentType, isString = ct.(string) if !isString { contentType = ContentHTML } } cs := ctx.Get("charset") if cs == nil { encoding = defaultCharset } else { encoding, isString = cs.(string) if !isString { encoding = defaultCharset } } newContentType := contentType + "; charset=" + encoding templateNameValue, isString := templateName.(string) if isString { templateData := ctx.Get("data") var template = pongo2.Must(pongo2.FromFile(path.Join("templates", templateNameValue))) ctx.Response().Header().Set(ContentType, newContentType) err = template.ExecuteWriter( getContext(templateData), ctx.Response().Writer()) if err != nil { http.Error( ctx.Response().Writer(), err.Error(), 500) } } return nil } } }
// Render template among with machine and config struct func (m Machine) renderTemplate(template string, config Config) (string, error) { template = path.Join(config.TemplatePath, template) if _, err := os.Stat(template); err != nil { return "", errors.New("Template does not exist") } var tpl = pongo2.Must(pongo2.FromFile(template)) result, err := tpl.Execute(pongo2.Context{"machine": m, "config": config}) if err != nil { return "", err } return result, err }
func (r *Renderer) getTemplate(name string) (t *pongo2.Template, err error) { if r.Reload { return pongo2.FromFile(filepath.Join(r.Directory, name)) } r.lock.RLock() var ok bool if t, ok = r.templates[name]; !ok { r.lock.RUnlock() t, err = r.buildTemplatesCache(name) } else { r.lock.RUnlock() } return }
func (p PongoProduction) Instance(name string, data interface{}) render.Render { var t *pongo2.Template if tmpl, ok := p.Templates[name]; ok { t = tmpl } else { tmpl := pongo2.Must(pongo2.FromFile(path.Join(p.Path, name))) p.Templates[name] = tmpl t = tmpl } return Pongo{ Template: t, Name: name, Data: data, } }
func (self *PongoTemplate) Load(key string) error { tplPath := fmt.Sprintf("%s/%s.pongo", self.GetTemplateDir(), key) if _, err := os.Stat(tplPath); err == nil { if tpl, err := pongo2.FromFile(tplPath); err == nil { self.template = tpl return nil } else { return err } return nil } else { return err } }
func (p *Render) Render(w http.ResponseWriter, code int, data ...interface{}) error { file := "templates/" + data[0].(string) ctx := data[1].(pongo2.Context) var t *pongo2.Template if tmpl, ok := p.cache[file]; ok { t = tmpl } else { if options.Debug { tmpl, err := pongo2.FromFile(file) if err != nil { return err } t = tmpl } else { buff, err := server.Asset(file) if err == nil { tmpl, err := pongo2.FromString(string(buff)) if err != nil { return err } t = tmpl } else { tmpl, err := pongo2.FromFile(file) if err != nil { return err } t = tmpl } } p.cache[file] = t } writeHeader(w, code, "text/html") return t.ExecuteWriter(ctx, w) }
func BenchmarkParallelExecuteComplexWithSandboxActive(b *testing.B) { tpl, err := pongo2.FromFile("template_tests/complex.tpl") if err != nil { b.Fatal(err) } b.ResetTimer() b.RunParallel(func(pb *testing.PB) { for pb.Next() { err := tpl.ExecuteWriterUnbuffered(tplContext, ioutil.Discard) if err != nil { b.Fatal(err) } } }) }
// Renders a template func (t *Templating) Render(context Context, name string) { var filename = fmt.Sprintf("%s/%s", t.GetViewsDirectory(), name) if _, err := os.Stat(filename); err != nil { if os.IsNotExist(err) { log.Printf("View '%s' does not exists", filename) os.Exit(1) } } var template = pongo2.Must(pongo2.FromFile(filename)) template.ExecuteWriter(pongo2.Context{ "request": context.GetRequest(), "response": context.GetResponse(), }, context.GetResponse()) }
func handleHelpPage(res http.ResponseWriter, r *http.Request) { content, err := ioutil.ReadFile("frontend/help.md") if err != nil { log.WithFields(logrus.Fields{ "error": fmt.Sprintf("%v", err), }).Error("HelpText Load") http.Error(res, "An unknown error occured.", http.StatusInternalServerError) return } template := pongo2.Must(pongo2.FromFile("frontend/help.html")) ctx := getBasicContext(res, r) ctx["helptext"] = string(content) template.ExecuteWriter(ctx, res) }
func Pongo2() HandlerFunc { return func(c *Context) { c.Next() templateName, templateNameError := c.Get("template") templateNameValue, isString := templateName.(string) if templateNameError == nil && isString { templateData, templateDataError := c.Get("data") var template = pongo2.Must(pongo2.FromFile(templateNameValue)) err := template.ExecuteWriter(getContext(templateData, templateDataError), c.Writer) if err != nil { http.Error(c.Writer, err.Error(), http.StatusInternalServerError) } } } }
// Instance should return a new Pongo2Render struct per request and prepare // the template by either loading it from disk or using pongo2's cache. func (p Pongo2Render) Instance(name string, data interface{}) render.Render { var template *pongo2.Template filename := path.Join(p.Options.TemplateDir, name) // always read template files from disk if in debug mode, use cache otherwise. if gin.Mode() == "debug" { template = pongo2.Must(pongo2.FromFile(filename)) } else { template = pongo2.Must(pongo2.FromCache(filename)) } return Pongo2Render{ Template: template, Context: data.(pongo2.Context), Options: p.Options, } }