func (s Server) initTemplates() { server.Templates = make(map[string]Template) if !fileExist(getTemplateName("error")) { tmp, _ := template.Parse(htmlError, nil) server.Templates["error"] = tmp } if !fileExist(getTemplateName("notfound")) { tmp, _ := template.Parse(htmlNotFound, nil) server.Templates["notfound"] = tmp } }
func analytics(a urlshortener.AnalyticsInfo) { var b bytes.Buffer tmpl, _ := template.Parse(` Kind: {Kind} Id: {Id} LongUrl: {LongUrl} Status: {Status} Created: {Created} AllTime: {.section Analytics.AllTime} ShortUrlClicks: {ShortUrlClicks} LongUrlClicks: {LongUrlClicks} Referrers: {.repeated section Referrers} {Id} ({Count}) {.end} Countries: {.repeated section Countries} {Id} ({Count}) {.end} Browsers: {.repeated section Browsers} {Id} ({Count}) {.end} Platforms: {.repeated section Platforms} {Id} ({Count}) {.end} {.end} `, nil) tmpl.Execute(a, &b) println(b.String()) }
func myWidgets(w http.ResponseWriter, r *http.Request) { var err os.Error ctx := appengine.NewContext(r) page, err := template.Parse(myWidgetTemplate, nil) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } data := myWidgetData{ CSS: commonCSS(), Header: header(ctx), } data.Widget, err = LoadWidgets(ctx) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } if len(r.FormValue("ids_only")) > 0 { w.Header().Set("Content-Type", "text/plain") for _, widget := range data.Widget { fmt.Fprintln(w, widget.ID) } return } page.Execute(w, data) }
func template_load(backend uintptr, request uintptr) (tpl *template.Template, err string) { var tpl_str []byte // request size q_count := f.Hash([]f.Hskel{ f.Hitem(f.HK_action, f.TYPE_UINT32T, f.ACTION_COUNT), f.Hitem(f.HK_buffer, f.TYPE_SIZET, 0), f.Hnext(request)}) f.Backend_pass(backend, q_count) str_len, ok := f.Hget(q_count, f.HK_buffer).(uint) if !ok || str_len == 0 { tpl_str = []byte("") } else { tpl_str = make([]byte, str_len) // read all q_read := f.Hash([]f.Hskel{ f.Hitem(f.HK_action, f.TYPE_UINT32T, f.ACTION_READ), f.Hitem(f.HK_buffer, f.TYPE_RAWT, tpl_str), f.Hnext(request)}) f.Backend_pass(backend, q_read) } tpl, e := template.Parse(string(tpl_str), nil) // TODO BAD BAD BAD if e != nil { err := fmt.Sprintf("templateLoad_handler template parse error: %v", e) return nil, err } return tpl, "" }
func handleFriendList(writer http.ResponseWriter, request *http.Request) { if request.RawURL == "/favicon.ico" { return } var ( friends []friend err os.Error ) authorizeUrl := AUTHORIZE_URL_BASE + config["client_id"] parts := strings.Split(request.RawURL, "?code=", -1) if 2 <= len(parts) { if err = authorizeCode(parts[1]); err != nil { redirect(writer, request, authorizeUrl) } else { redirect(writer, request, "/") } return } else if currentTokens == nil { redirect(writer, request, authorizeUrl) return } if friends, err = getFriendList(); err != nil { redirect(writer, request, authorizeUrl) } else { params := new(struct{ Friends []friend }) params.Friends = friends tmpl, _ := template.Parse(TEMPLATE, nil) tmpl.Execute(writer, params) } }
func Dispatch(w http.ResponseWriter) os.Error { t := View.Themes.Current() if t == nil { se := &ServerError{404, "Not Found"} se.Write(w) return os.ENOENT } w.SetHeader("Content-Type", "text/html; charset=utf-8") w.SetHeader("Content-Encoding", "gzip") templ, err := template.Parse(t.Index, nil) if err != nil { return err } gz, err := gzip.NewWriter(w) if err != nil { return err } err = templ.Execute(gz, View) if err != nil { return err } gz.Close() return nil }
func loadTmpl(tdir, name string) (tmpl *template.Template, err os.Error) { path := gopath.Join(tdir, name) data, err := ioutil.ReadFile(path) if err != nil { return } return template.Parse(string(data), nil) }
func ReadTemplate(templateDir, name string) *template.Template { log.Println(" Reading template ", name) templatePath := path.Join(templateDir, name) templateText := readFile(templatePath) template, err := template.Parse(templateText, nil) if err != nil { panic(err) } return template }
func readTemplate(name string) *template.Template { path := pathutil.Join(*tmplroot, name) data, err := ioutil.ReadFile(path) if err != nil { log.Exitf("ReadFile %s: %v", path, err) } t, err := template.Parse(string(data), fmap) if err != nil { log.Exitf("%s: %v", name, err) } return t }
func readTemplate(name string) *template.Template { fileName := path.Join(*root, "tmpl", name) data, err := ioutil.ReadFile(fileName) if err != nil { log.Exitf("ReadFile %s: %v", fileName, err) } t, err := template.Parse(string(data), fmap) if err != nil { log.Exitf("%s: %v", fileName, err) } return t }
func Update(b []byte) (f *bytes.Buffer) { templ, _ := template.Parse(templatestr, fmap) /* templ.rdelim = []byte{ '}', '}'} templ.ldelim = []byte{ '{', '{'} */ var table mytable f = bytes.NewBuffer(nil) table.v = b templ.Execute(table, f) return }
func render(tmplString string, context interface{}) (string, os.Error) { var tmpl *template.Template var err os.Error if tmpl, err = template.Parse(tmplString, nil); err != nil { return "", err } var buf bytes.Buffer tmpl.Execute(context, &buf) return buf.String(), nil }
func header(ctx appengine.Context) string { page, err := template.Parse(headerTemplate, nil) if err != nil { return fmt.Sprintf("<b>Error</b>: %s<br/>", err) } data := &headerData{ User: user.Current(ctx), } buf := bytes.NewBuffer(nil) err = page.Execute(buf, data) if err != nil { return fmt.Sprintf("<b>Error</b>: %s<br/>", err) } return buf.String() }
func readTemplate(name string) *template.Template { path := filepath.Join(*goroot, "lib", "godoc", name) if *templateDir != "" { defaultpath := path path = filepath.Join(*templateDir, name) if _, err := fs.Stat(path); err != nil { log.Print("readTemplate:", err) path = defaultpath } } data, err := fs.ReadFile(path) if err != nil { log.Fatalf("ReadFile %s: %v", path, err) } t, err := template.Parse(string(data), fmap) if err != nil { log.Fatalf("%s: %v", name, err) } return t }