template - load tags django

Ir template.ExecuteTemplate incluye html

Question

He seguido este tutorial: http://golang.org/doc/articles/wiki/final.go y lo he modificado ligeramente para mis necesidades / deseos. El problema es que me gustaría soportar HTML en las plantillas. Me doy cuenta de que esto es un riesgo de seguridad, pero no es una preocupación en este momento.

El resultado de un renderizado de página:

<h1>this<strong>is</strong>a test</h1>

Déjame explicarte un poco del código:

type Page struct {
    Title string
    Body  []byte
}

Los datos que me gustaría tener HTML se almacenan en Page.Body . Este es un []byte tipo []byte que significa que no puedo (o puedo) ejecutar html/template.HTML(Page.Body) ya que esa función espera una cadena.

Tengo esto que pre-renderiza las plantillas:

var (
    templates = template.Must(template.ParseFiles("tmpl/edit.html", "tmpl/view.html"))
)

Y el ExecuteTemplate real se ve así:

err := templates.ExecuteTemplate(w, tmpl+".html", p)

Donde w es w http.ResponseWriter , tmpl es tmpl string , y p es p *Page

Finalmente mi ''view.html'' (plantilla) se parece a lo siguiente:

<h1>{{.Title}}</h1>
<p>[<a href="/edit/{{.Title}}">edit</a>]</p>
<div>{{printf "%s" .Body}}</div>

Cosas que he probado:

• {{printf "%s" .Body | html}} {{printf "%s" .Body | html}} no hace nada
• He incluido github.com/russross/blackfriday (procesador Markdown) y p.Body = blackfriday.MarkdownCommon(p.Body) que convierte Markdown a HTML correctamente, pero el HTML todavía se presenta como entidades.

• EDITAR: He intentado el siguiente bit de código (no sé por qué el formato está desordenado) y sigue siendo el mismo.

  var s template.HTML s = template.HTML(p.Body) p.Body = []byte(s)

Cualquier orientación es muy apreciada. Si estoy siendo confuso por favor pregunte y puedo modificar mi pregunta.

Answer 1

¿Por qué no convertir el []byte a una cadena? Puedes hacerlo así:

str := string(page.Body)

Answer 2

Convierta su []byte o string para escribir template.HTML (documentado here )

p.Body = template.HTML(s) // where s is a string or []byte

Luego, en su plantilla, simplemente:

{{.Body}}

Será impreso sin escape.

EDITAR

Para poder incluir HTML en el cuerpo de su página, necesita cambiar la declaración de tipo de Page :

type Page struct {
    Title string
    Body  template.HTML
}

luego se lo asigna.

Answer 3

Echa un vistazo a la here tipo here . Se puede usar para encapsular un fragmento seguro conocido de HTML (como el resultado de Markdown). El paquete "html / template" no escapará a este tipo.

type Page struct {
    Title string
    Body template.HTML
}

page := &Page{
    Title: "Example",
    Body:  template.HTML(blackfriday.MarkdownCommon([]byte("foo bar")),
}

Normalmente escribo mi propia func Markdown(text string) html.Template método que llama a blackfriday con la configuración apropiada y hace algunas conversiones de tipos. Otra alternativa podría ser también registrar una función "html" en el analizador de plantillas, que le permite generar cualquier valor sin escapar haciendo algo como {{html .MySafeStr}} . El código podría verse como:

var tmpl = template.Must(template.New("").Funcs(template.FuncMap{
    "html": func(value interface{}) template.HTML {
        return template.HTML(fmt.Sprint(value))
    },
}).ParseFiles("file1.html", "file2.html"))

Answer 4

Este es un enfoque que no requiere ningún cambio en sus estructuras existentes, y un cambio mínimo y aditivo en sus plantillas:

Cambia estas lineas:

var (
    templates = template.Must(template.ParseFiles("tmpl/edit.html", "tmpl/view.html"))
)

para esto (incluya un funcmap con una función que generará HTML sin escape):

var templates = template.Must(template.New("main").Funcs(template.FuncMap{
    "safeHTML": func(b []byte) template.HTML {
        return template.HTML(b)
    },
}).ParseFiles("tmpl/edit.html", "tmpl/view.html"))

Y luego simplemente cambia tu plantilla HTML de esto:

<div>{{printf "%s" .Body}}</div>

a esto (usa tu nueva función):

<div>{{ .Body | safeHTML }}</div>

¡Más fácil!

Answer 5

Estoy usando Beego y React.js y luché durante horas intentando que el analizador JSX se ejecutara. Resulta que html / template elimina los comentarios, especialmente el bloque js doc / ** @jsx React.DOM * /.

Logré evitarlo creando un método especial para escribir el comentario como JS y llamarlo desde la plantilla.

// Create a method in your controller (I''m using Beego)
func jsxdoc()(out template.JS) {
    return template.JS(`/** @jsx React.DOM */`)
}

// Add method to your function map available to views
beego.AddFuncMap("jsxdoc", jsxdoc)

// In template
<script type="text/jsx">
    {{ jsxdoc }}
    var CommentBox = React.createClass({
      render: function() {
        return (
          <div class="commentBox">
            Hello, world! I am a CommentBox.
          </div>
        );
      }
    });
    React.renderComponent(
      <CommentBox />,
      document.getElementById(''content'')
    );
</script>

Answer 6

He creado una función personalizada para la plantilla de la siguiente manera:

func noescape(str string) template.HTML {
    return template.HTML(str)
}

var fn = template.FuncMap{
    "noescape": noescape,
}

Luego en tu plantilla:

{{ noescape $x.Body }}

Answer 7

Para aclaraciones y una forma mucho más sencilla de pasar HTML a la plantilla, consulte

https://groups.google.com/forum/#!topic/golang-nuts/8L4eDkr5Q84

Simplemente cree su cadena HTML a través de ir y pásela a su plantilla, por ejemplo:

Sout := ""
.
.

    Sout += fmt.Sprintf(`<tr><td>%s<td align=center>%.2f<td>%s<td>%s<td>%s<td>%s<td align=center>%d<td align=center>%d
                    <td align=center>%d`, AccountID, amount, remissiondetails, created, begins, ends,
                    freePDFs, freeinformants, freeSDQs)

.
.
    render(w, "templates/Waivers.html", map[string]interface{}{ "Body":template.HTML(Sout), })