// Generate the static HTML file for the post identified by the index.
func generateFile(td *PostData, idx bool) error {
var w io.Writer
// check if template exists
tplName := td.D["Template"]
var tpl *template.Template
var ex bool
if tpl, ex = postTpls[tplName]; !ex {
return fmt.Errorf("Template not found: %s", tplName)
}
slug := td.D["Slug"]
fw, err := os.Create(filepath.Join(PublicDir, slug))
if err != nil {
return fmt.Errorf("error creating static file %s: %s", slug, err)
}
defer fw.Close()
// If this is the newest file, also save as index.html
w = fw
if idx {
idxw, err := os.Create(filepath.Join(PublicDir, "index.html"))
if err != nil {
return fmt.Errorf("error creating static file index.html: %s", err)
}
defer idxw.Close()
w = io.MultiWriter(fw, idxw)
}
return tpl.ExecuteTemplate(w, tplName+".amber", td)
}
func renderTemplate(w http.ResponseWriter, tName string, tType *template.Template, dataObj interface{}) {
err := tType.ExecuteTemplate(w, tName+".html", dataObj)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
func BulkHandler(Layout *template.Template, Exits *Exits) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
ip := r.URL.Query().Get("ip")
if net.ParseIP(ip) == nil {
if err := Layout.ExecuteTemplate(w, "bulk.html", nil); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
return
}
port_str := r.URL.Query().Get("port")
port, err := strconv.Atoi(port_str)
port_str = "&port=" + port_str
if err != nil {
port = 80
port_str = ""
}
str := fmt.Sprintf("# This is a list of all Tor exit nodes that can contact %s on Port %d #\n", ip, port)
str += fmt.Sprintf("# You can update this list by visiting https://check.torproject.org/cgi-bin/TorBulkExitList.py?ip=%s%s #\n", ip, port_str)
str += fmt.Sprintf("# This file was generated on %v #\n", Exits.UpdateTime.UTC().Format(time.UnixDate))
str += Exits.Dump(ip, port)
fmt.Fprintf(w, str)
}
}
func (h *Handler) Apply(w http.ResponseWriter, t *template.Template, tName string, app interface{}) (err error) {
err = t.ExecuteTemplate(w, tName, app)
if my, bad := mybad.Check(err, "template execution failure", "name", tName); bad {
return my
}
return nil
}
// Render renders the doc to the given writer using the provided template.
func (d *Doc) Render(w io.Writer, t *template.Template) error {
data := struct {
*Doc
Template *template.Template
}{d, t}
return t.ExecuteTemplate(w, "root", data)
}
func RegistroPrendaGET(html *template.Template) gin.HandlerFunc {
return func(c *gin.Context) {
mapa := MapaInfo{}
mapa.ObtenerDatosRegistroPrenda()
html.ExecuteTemplate(c.Writer, "registroPrenda.html", mapa)
}
}
func main() {
var err error
var tpl *template.Template
tpl, err = tpl.ParseGlob("templates/*.gohtml")
if err != nil {
log.Fatalln(err)
}
err = tpl.Execute(os.Stdout, Page{
Title: "My Title 2",
Body: "hello world",
})
if err != nil {
log.Fatalln(err)
}
fmt.Println("\n***************")
err = tpl.ExecuteTemplate(os.Stdout, "tpl.gohtml", Page{
Title: "My Title 2",
Body: "hello world",
})
if err != nil {
log.Fatalln(err)
}
fmt.Println("\n***************")
err = tpl.ExecuteTemplate(os.Stdout, "tpl2.gohtml", Page{
Title: "My Title 2",
Body: "hello world",
})
if err != nil {
log.Fatalln(err)
}
}
// the index page of the chat
func index(indexTemplate *template.Template, w http.ResponseWriter, r *http.Request) {
//disable caching: HTTP/1.1 HTTP/1.0 and proxies
//from http://stackoverflow.com/questions/49547/making-sure-a-web-page-is-not-cached-across-all-browsers
w.Header().Set("Cache-Control", "no-cache,no-store,must-revalidate")
w.Header().Set("Pragma:", "no-cache")
w.Header().Set("Expires", "0")
session, err := sessionStorage.GetSession(w, r)
if err != nil {
log.Fatal(err)
}
if r.Method == "POST" {
user := r.FormValue("username")
session.PutVal("user.name", user)
}
_, err = session.GetVal("user.name")
if err != nil {
err = indexTemplate.ExecuteTemplate(w, "signup", nil)
if err != nil {
log.Fatal(err)
}
return
}
defaultRoom.mutex.Lock()
defer defaultRoom.mutex.Unlock()
err = indexTemplate.ExecuteTemplate(w, "pull_chat", defaultRoom)
if err != nil {
log.Fatal(err)
}
}
func (ts *TemplateStore) Render(w http.ResponseWriter, name string, data Model) {
var tmpl *template.Template
if ts.Development {
includes, err := filepath.Glob(ts.TemplateDir + "includes/*.tmpl")
if err != nil {
log.Fatal(err)
}
files := append(includes, ts.TemplateDir+"layouts/"+name)
tmpl = template.Must(template.New("func").Funcs(ts.funcs).ParseFiles(files...))
} else {
var ok bool
ts.RLock()
tmpl, ok = ts.templates[name]
ts.RUnlock()
if !ok {
http.Error(w, "404. Page not found", 404)
return
}
}
buf := ts.bufpool.get()
defer ts.bufpool.reset(buf)
err := tmpl.ExecuteTemplate(buf, "base", data)
if err != nil {
log.Println(err)
http.Error(w, "500. Internal server error", 500)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
buf.WriteTo(w)
return
}
func respondWithTemplate(
templates *template.Template, templateName string, templateContext interface{}, w http.ResponseWriter,
r *http.Request) error {
// you access the cached templates with the defined name, not the filename
return templates.ExecuteTemplate(w, templateName, templateContext)
}
// pageTitle executes "title" template and returns its result or defaultTitle.
func pageTitle(t *html.Template) string {
b := new(bytes.Buffer)
if err := t.ExecuteTemplate(b, "title", nil); err != nil || b.Len() == 0 {
return defaultTitle
}
return b.String()
}
func RenderDetail(shdarray []*DP, t *template.Template, sh string) error {
var hisName = time.Now().Format("2006-01-02")
dshfilename := homeDir + "/changshi/today/detail_" + sh + ".html"
if _, err := os.Stat(dshfilename); os.IsExist(err) {
os.Remove(dshfilename)
}
dshf, _ := os.Create(dshfilename)
dshfbw := bufio.NewWriter(dshf)
err := t.ExecuteTemplate(dshfbw, "detail.tmpl", shdarray)
if err != nil {
return err
}
dshfbw.Flush()
dshf.Close()
dshhfilename := homeDir + "/changshi/his/d_" + sh + "_" + hisName + ".html"
if _, err := os.Stat(dshhfilename); os.IsExist(err) {
os.Remove(dshhfilename)
}
dshhf, _ := os.Create(dshhfilename)
dshhfbw := bufio.NewWriter(dshhf)
err1 := t.ExecuteTemplate(dshhfbw, "detail.tmpl", shdarray)
if err1 != nil {
return err
}
dshhfbw.Flush()
dshhf.Close()
return nil
}
/*
Builds a post based on the template
*/
func build_post(ps Post, ptype string) string {
var doc bytes.Buffer
var body, name string
var err error
var tml *template.Template
if ptype == "post" {
tml, err = template.ParseFiles("./templates/post.html", "./templates/base.html")
name = "./output/posts/" + ps.Slug + ".html"
} else {
// This should read the pages template
tml, err = template.ParseFiles("./templates/page.html", "./templates/base.html")
name = "./output/pages/" + ps.Slug + ".html"
}
err = tml.ExecuteTemplate(&doc, "base", ps)
if err != nil {
fmt.Println("Error executing template: ", err)
}
body = doc.String()
f, err := os.Create(name)
defer f.Close()
n, err := io.WriteString(f, body)
if err != nil {
fmt.Println("Error while writing output: ", n, err)
}
return body
}
func elemFn(t *htemp.Template, e present.Elem) (htemp.HTML, error) {
var buf bytes.Buffer
if err := t.ExecuteTemplate(&buf, e.TemplateName(), e); err != nil {
return "", err
}
return htemp.HTML(buf.Bytes()), nil
}
func executeTemplate(t *template.Template, p Page) ([]byte, error) {
var out bytes.Buffer
err := t.ExecuteTemplate(&out, "layout", p)
if err != nil {
return []byte{}, err
}
return out.Bytes(), nil
}
func TemplateHTML(writer http.ResponseWriter, tpl *template.Template, name string, params types.M) error {
writer.Header()["Content-Type"] = []string{ghttp.MIMEHTML + "; charset=utf-8"}
if len(name) == 0 {
return tpl.Execute(writer, params)
}
return tpl.ExecuteTemplate(writer, name, params)
}
func Parse(t *template.Template, name string, data interface{}) string {
var doc bytes.Buffer
err := t.ExecuteTemplate(&doc, name, data)
if err != nil {
fmt.Println(err)
}
return doc.String()
}
// Render renders the section to the given writer using the provided template.
func (s *Section) Render(w io.Writer, t *template.Template) error {
data := struct {
*Section
Template *template.Template
PlayEnabled bool
}{s, t, PlayEnabled}
return t.ExecuteTemplate(w, "section", data)
}
func renderTemplate(w http.ResponseWriter, t *template.Template,
data interface{}) error {
// set header?
w.Header().Set("Content-Type", "text/html; charset=utf-8")
return t.ExecuteTemplate(w, "base", data)
}
// execTemplate is a helper to execute a template and return the output as a
// template.HTML value.
func execTemplate(t *template.Template, name string, data interface{}) (template.HTML, error) {
b := new(bytes.Buffer)
err := t.ExecuteTemplate(b, name, data)
if err != nil {
return "", err
}
return template.HTML(b.String()), nil
}
func textTemplateString(tmpl *template.Template, name string, obj interface{}) string {
w := new(bytes.Buffer)
err := tmpl.ExecuteTemplate(w, name, obj)
if err != nil {
panic(err)
}
return w.String()
}
// Render renders the doc to the given writer using the provided template.
func (d *Doc) Render(w io.Writer, t *template.Template) error {
data := struct {
*Doc
Template *template.Template
PlayEnabled bool
}{d, t, PlayEnabled}
return t.ExecuteTemplate(w, "root", data)
}
// Render a named template name to the HTTP channel
func renderTemplate(w io.Writer, tmpl template.Template, context interface{}) {
log.Printf("Rendering %s", tmpl.Name())
err := tmpl.ExecuteTemplate(w, "base.html", context)
if err != nil {
log.Printf("ERROR: %s", err)
w.Write([]byte("Unable to render"))
return
}
}
func process(w http.ResponseWriter, r *http.Request) {
rand.Seed(time.Now().Unix())
var t *template.Template
if rand.Intn(10) > 5 {
t, _ = template.ParseFiles("layout.html", "red_hello.html")
} else {
t, _ = template.ParseFiles("layout.html", "blue_hello.html")
}
t.ExecuteTemplate(w, "layout", "")
}
func executeTemplate(t *template.Template, name string, binding interface{}) (*bytes.Buffer, error) {
buf := new(bytes.Buffer)
err := t.ExecuteTemplate(buf, name, binding)
if err != nil {
return bytes.NewBufferString(err.Error()), err
}
return buf, nil
}
func (r *TemplateRender) Render(w io.Writer, params map[string]interface{}, temps ...string) (err error) {
if nil == params {
params = map[string]interface{}{}
}
var tpl *template.Template
if tpl, err = r.Template(temps...); nil == err {
err = tpl.ExecuteTemplate(w, temps[len(temps)-1], params)
}
return
}
func renderWithLayout(t *template.Template, wr io.Writer, name string, data interface{}) error {
for _, templateName := range []string{"header.html", name, "footer.html"} {
err := t.ExecuteTemplate(wr, templateName, data)
if err != nil {
return err
}
}
return nil
}
func renderIndexPage(t *template.Template) error {
r, w := io.Pipe()
go func() {
err := t.ExecuteTemplate(w, "index.html", VCs)
if err != nil {
fmt.Println("index.html:", err)
}
w.Close()
}()
return Put("index.html", r)
}
func render(t *template.Template, vc *VC) error {
r, w := io.Pipe()
go func() {
err := t.ExecuteTemplate(w, "vc.html", vc)
if err != nil {
fmt.Printf("%s: %s\n", vc.Permalink, err)
}
w.Close()
}()
return Put("firms/"+vc.Permalink+".html", r)
}
func (self *templateEx) execute(tmpl *htmlTpl.Template, data interface{}) string {
buf := new(bytes.Buffer)
err := tmpl.ExecuteTemplate(buf, tmpl.Name(), data)
if err != nil {
return fmt.Sprintf("Parse %v err: %v", tmpl.Name(), err)
}
b, err := ioutil.ReadAll(buf)
if err != nil {
return fmt.Sprintf("Parse %v err: %v", tmpl.Name(), err)
}
return string(b)
}