package main
import (
    "errors"
    "fmt"
+    "html/template"
    "net/http"
    "strconv"
    "snippetbox.alexedwards.net/internal/models"
)
...
func (app *application) snippetView(w http.ResponseWriter, r *http.Request) {
    id, err := strconv.Atoi(r.URL.Query().Get("id"))
    if err != nil || id < 1 {
    	app.notFound(w)
    	return
    }
    snippet, err := app.snippets.Get(id)
    if err != nil {
    	if errors.Is(err, models.ErrNoRecord) {
    	app.notFound(w)
    } else {
        app.serverError(w, err)
    }
    return
    }
    // Initialize a slice containing the paths to the view.tmpl file,
    // plus the base layout and navigation partial that we made earlier.
    files := []string{
        "./ui/html/base.html",
        "./ui/html/partials/nav.html",
        "./ui/html/pages/view.html",
   }
   
    // Parse the template files...
    ts, err := template.ParseFiles(files...)
    if err != nil {
    	app.serverError(w, err)
    	return
    }
    // And then execute them. Notice how we are passing in the snippet
    // data (a models.Snippet struct) as the final parameter?
    err = ts.ExecuteTemplate(w, "base", snippet)
    if err != nil {
    	app.serverError(w, err)
    }
}
...

$ touch ui/html/pages/view.tmpl

{{define "title"}}Snippet #{{.ID}}{{end}}
{{define "main"}}
    <div class='snippet'>
        <div class='metadata'>
            <strong>{{.Title}}</strong>
            <span>#{{.ID}}</span>
        </div>
        <pre><code>{{.Content}}</code></pre>
        <div class='metadata'>
            <time>Created: {{.Created}}</time>
            <time>Expires: {{.Expires}}</time>
        </div>
    </div>
{{end}}

$ touch cmd/web/templates.go

package main
import "snippetbox.alexedwards.net/internal/models"
// Define a templateData type to act as the holding structure for
// any dynamic data that we want to pass to our HTML templates.
// At the moment it only contains one field, but we'll add more
// to it as the build progresses.
type templateData struct {
	Snippet models.Snippet
}

package main
...
func (app *application) snippetView(w http.ResponseWriter, r *http.Request) {
    id, err := strconv.Atoi(r.URL.Query().Get("id"))
    if err != nil || id < 1 {
    app.notFound(w)
    	return
    }
    snippet, err := app.snippets.Get(id)
    if err != nil {
        if errors.Is(err, models.ErrNoRecord) {
        app.notFound(w)
    } else {
    	app.serverError(w, err)
    }
    return
    }
    files := []string{
        "./ui/html/base.html",
        "./ui/html/partials/nav.html",
        "./ui/html/pages/view.html",
    }
    ts, err := template.ParseFiles(files...)
    if err != nil {
    	app.serverError(w, err)
    	return
    }
    // Create an instance of a templateData struct holding the snippet data.
+    data := &templateData{
+    	Snippet: snippet,
+    }
    // Pass in the templateData struct when executing the template.
+    err = ts.ExecuteTemplate(w, "base", data)
    if err != nil {
    	app.serverError(w, err)
    }
}
...

{{define "title"}}Snippet #{{.Snippet.ID}}{{end}}
{{define "main"}}
    <div class='snippet'>
        <div class='metadata'>
            <strong>{{.Snippet.Title}}</strong>
            <span>#{{.Snippet.ID}}</span>
        </div>
        <pre><code>{{.Snippet.Content}}</code></pre>
        <div class='metadata'>
            <time>Created: {{.Snippet.Created}}</time>
            <time>Expires: {{.Snippet.Expires}}</time>
        </div>
    </div>
{{end}}

<span>{{"<script>alert('xss attack')</script>"}}</span>

<span>&lt;script&gt;alert(&#39;xss attack&#39;)&lt;/script&gt;</span>

<span>{{.Snippet.Created.Weekday}}</span>

<span>{{.Snippet.Created.AddDate 0 6 0}}</span>

{{define "title"}}Snippet #{{.Snippet.ID}}{{end}}
{{define "main"}}
    {{with .Snippet}}
        <div class='snippet'>
            <div class='metadata'>
                <strong>{{.Title}}</strong>
                <span>#{{.ID}}</span>
            </div>
            <pre><code>{{.Content}}</code></pre>
            <div class='metadata'>
                <time>Created: {{.Created}}</time>
                <time>Expires: {{.Expires}}</time>
            </div>
        </div>
    {{end}}
{{end}}

package main
import "snippetbox.alexedwards.net/internal/models"
// Include a Snippets field in the templateData struct.
type templateData struct {
    Snippet  models.Snippet
    Snippets []models.Snippet
}

package main
...
func (app *application) home(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/" {
        app.notFound(w)
        return
    }
    snippets, err := app.snippets.Latest()
    if err != nil {
        app.serverError(w, err)
        return
    }
    files := []string{
        "./ui/html/base.html",
        "./ui/html/partials/nav.html",
        "./ui/html/pages/home.html",
    }
    ts, err := template.ParseFiles(files...)
    if err != nil {
    	app.serverError(w, err)
    	return
    }
    // Create an instance of a templateData struct holding the slice of
    // snippets.
    data := &templateData{
    	Snippets: snippets,
    }
    // Pass in the templateData struct when executing the template.
    err = ts.ExecuteTemplate(w, "base", data)
    if err != nil {
    	app.serverError(w, err)
    }
}
...

{{define "title"}}Home{{end}}
{{define "main"}}
    <h2>Latest Snippets</h2>
    {{if .Snippets}}
    <table>
        <tr>
            <th>Title</th>
            <th>Created</th>
            <th>ID</th>
        </tr>
        {{range .Snippets}}
        <tr>
            <td><a href='/snippet/view?id={{.ID}}'>{{.Title}}</a></td>
            <td>{{.Created}}</td>
            <td>#{{.ID}}</td>
        </tr>
        {{end}}
    </table>
    {{else}}
    <p>There's nothing to see here... yet!</p>
    {{end}}
{{end}}

{{if (gt (len .Foo) 99)}} C1 {{end}}

{{range .Foo}}
    // Skip this iteration if the .ID value equals 99.
    {{if eq .ID 99}}
    	{{continue}}
    {{end}}
    // ...
{{end}}

{{range .Foo}}
    // Skip this iteration if the .ID value equals 99.
    {{if eq .ID 99}}
    	{{break}}
    {{end}}
    // ...
{{end}}

package main
import (
"html/template" // New import
"path/filepath" // New import
"github.com/nahueldev23/internal/models"
)
...
func newTemplateCache() (map[string]*template.Template, error) {
// Initialize a new map to act as the cache.
cache := map[string]*template.Template{}
// Use the filepath.Glob() function to get a slice of all filepaths that
// match the pattern "./ui/html/pages/*.tmpl". This will essentially gives
// us a slice of all the filepaths for our application 'page' templates
// like: [ui/html/pages/home.html ui/html/pages/view.html]
pages, err := filepath.Glob("./ui/html/pages/*.html")
if err != nil {
return nil, err
}
// Loop through the page filepaths one-by-one.
for _, page := range pages {
// Extract the file name (like 'home.tmpl') from the full filepath
// and assign it to the name variable.
name := filepath.Base(page)
// Create a slice containing the filepaths for our base template, any
// partials and the page.
files := []string{
"./ui/html/base.html",
"./ui/html/partials/nav.html",
page,
}
// Parse the files into a template set.
ts, err := template.ParseFiles(files...)
if err != nil {
return nil, err
}
// Add the template set to the map, using the name of the page
// (like 'home.tmpl') as the key.
cache[name] = ts
}
// Return the map.
return cache, nil
}

import (
"database/sql"
"flag"
+"html/template" // New import
"log"
"net/http"
"os"
"snippetbox.alexedwards.net/internal/models"
_ "github.com/go-sql-driver/mysql"
)
// Add a templateCache field to the application struct.
type application struct {
        errorLog*log.Logger
        infoLog*log.Logger
        snippets*models.SnippetModel
+        templateCache map[string]*template.Template
    }
    func main() {
        addr := flag.String("addr", ":4000", "HTTP network address")
        dsn := flag.String("dsn", "web:pass@/snippetbox?parseTime=true", "MySQL data source name")
        flag.Parse()
        infoLog := log.New(os.Stdout, "INFO\t", log.Ldate|log.Ltime)
        errorLog := log.New(os.Stderr, "ERROR\t", log.Ldate|log.Ltime|log.Lshortfile)
        db, err := openDB(*dsn)
        if err != nil {
        	errorLog.Fatal(err)
        }
        defer db.Close()
        // Initialize a new template cache...
+       templateCache, err := newTemplateCache()
+       if err != nil {
+       	errorLog.Fatal(err)
+       }
        // And add it to the application dependencies.
        app := &application{
            errorLog:errorLog,
            infoLog:infoLog,
            snippets:&models.SnippetModel{DB: db},
+            templateCache: templateCache,
        }
        srv := &http.Server{
            Addr:*addr,
            ErrorLog: errorLog,
            Handler:
            app.routes(),
        }
        infoLog.Printf("Starting server on %s", *addr)
        err = srv.ListenAndServe()
        errorLog.Fatal(err)
}
...

package main
...
func (app *application) render(w http.ResponseWriter, status int, page string, data *templateData) {
    // Retrieve the appropriate template set from the cache based on the page
    // name (like 'home.html'). If no entry exists in the cache with the
    // provided name, then create a new error and call the serverError() helper
    // method that we made earlier and return.
    ts, ok := app.templateCache[page]
    if !ok {
        err := fmt.Errorf("the template %s does not exist", page)
        app.serverError(w, err)
        return
    }
    // Write out the provided HTTP status code ('200 OK', '400 Bad Request'
    // etc).
    w.WriteHeader(status)
    // Execute the template set and write the response body. Again, if there
    // is any error we call the the serverError() helper.
    err := ts.ExecuteTemplate(w, "base", data)
    if err != nil {
    	app.serverError(w, err)
    }
}

package main
import (
"errors"
"fmt"
"net/http"
"strconv"
"github.com/nahueldev23/internal/models"
)
func (app *application) home(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/" {
        app.notFound(w)
        return
    }
    snippets, err := app.snippets.Latest()
    if err != nil {
        app.serverError(w, err)
        return
    }
-  //Initialize a slice containing the paths to the two files. It's important
-	//to note that the file containing our base template must be the *first*
-	//file in the slice.
-
-	files := []string{
-		"./ui/html/base.html",
-		"./ui/html/partials/nav.html",
-		"./ui/html/pages/home.html",
-	}
-
-	// Use the template.ParseFiles() function to read the files and store the
-	// templates in a template set. Notice that we can pass the slice of file
-	// paths as a variadic parameter?
-	ts, err := template.ParseFiles(files...)
-	if err != nil {
-		app.serverError(w, err)
-		return
-	}
-	data := &templateData{
-		Snippets: snippets,
-	}
-	// Use the ExecuteTemplate() method to write the content of the "base"
-	// template as the response body.
-
-	err = ts.ExecuteTemplate(w, "base", data)
-	if err != nil {
-		app.serverError(w, err)
-	}
    // Use the new render helper.
+    app.render(w, http.StatusOK, "home.html", &templateData{Snippets: snippets,})}

    func (app *application) snippetView(w http.ResponseWriter, r *http.Request) {
    id, err := strconv.Atoi(r.URL.Query().Get("id"))
    if err != nil || id < 1 {
        app.notFound(w)
        return
    }
    snippet, err := app.snippets.Get(id)
    if err != nil {
      if errors.Is(err, models.ErrNoRecord) {
          app.notFound(w)
      } else {
      	app.serverError(w, err)
      }
    return
    }
-    // Initialize a slice containing the paths to the view.tmpl file,
-	// plus the base layout and navigation partial that we made earlier.
-	files := []string{
-		"./ui/html/base.html",
-		"./ui/html/partials/nav.html",
-		"./ui/html/pages/view.html",
-	}
-
-	// Parse the template files...
-	ts, err := template.ParseFiles(files...)
-	if err != nil {
-		app.serverError(w, err)
-		return
-	}
-	data := &templateData{
-		Snippet: snippet,
-	}
-	// And then execute them. Notice how we are passing in the snippet
-	// data (a models.Snippet struct) as the final parameter?
-	err = ts.ExecuteTemplate(w, "base", data)
-	if err != nil {
-		app.serverError(w, err)
-	}
    // Use the new render helper.
+    app.render(w, http.StatusOK, "view.html", &templateData{
    Snippet: snippet,
    })
}
...

func newTemplateCache() (map[string]*template.Template, error) {
    cache := map[string]*template.Template{}
    pages, err := filepath.Glob("./ui/html/pages/*.html")
    if err != nil {
    	return nil, err
    }
    for _, page := range pages {
        name := filepath.Base(page)
-        // Create a slice containing the filepaths for our base template, any
-        // partials and the page.
-        files := []string{
-        "./ui/html/base.html",
-        "./ui/html/partials/nav.html",
-        page,
-        }
-        // Parse the files into a template set.
-		ts, err := template.ParseFiles(files...)
        
+        // Parse the base template file into a template set.
+        ts, err := template.ParseFiles("./ui/html/base.html")
+        if err != nil {
+        	return nil, err
+    	}
        
+       // Call ParseGlob() *on this template set* to add any partials.
+       ts, err = ts.ParseGlob("./ui/html/partials/*.html")
+       if err != nil {
+            return nil, err
+        }
        
        // Add the template set to the map as normal...
        cache[name] = ts
        }
        return cache, nil
}	

{{define "title"}}Snippet #{{.Snippet.ID}}{{end}}
{{define "main"}}
{{with .Snippet}}
    <div class='snippet'>
        <div class='metadata'>
            <strong>{{.Title}}</strong>
            <span>#{{.ID}}</span>
        </div>
        {{len nil}} <!-- Deliberate error -->
        <pre><code>{{.Content}}</code></pre>
        <div class='metadata'>
            <time>Created: {{.Created}}</time>
            <time>Expires: {{.Expires}}</time>
        </div>
    </div>
    {{end}}
{{end}}

$ curl -i "http://localhost:4000/snippet/view?id=1"
HTTP/1.1 200 OK
Date: Tue, 01 Feb 2022 09:20:49 GMT
Content-Length: 762
Content-Type: text/html; charset=utf-8
<!doctype html>
<html lang='en'>
<head>
<meta charset='utf-8'>
<title>Snippet #1 - Snippetbox</title>
<link rel='stylesheet' href='/static/css/main.css'>
<link rel='shortcut icon' href='/static/img/favicon.ico' type='image/x-icon'>
<link rel='stylesheet' href='https://fonts.googleapis.com/css?family=Ubuntu+Mono:400,700'>
</head>
<body>
<header>
<h1><a href='/'>Snippetbox</a></h1>
</header>
<nav>
<a href='/'>Home</a>
</nav>
<main>
<div class='snippet'>
<div class='metadata'>
<strong>An old silent pond</strong>
<span>#1</span>
</div>
Internal Server Error

package main
import (
"bytes" // New import
"fmt"
"net/http"
"runtime/debug"
)
...
func (app *application) render(w http.ResponseWriter, status int, page string, data *templateData) {
    ts, ok := app.templateCache[page]
    if !ok {
        err := fmt.Errorf("the template %s does not exist", page)
        app.serverError(w, err)
        return
    }
    // Initialize a new buffer.
    buf := new(bytes.Buffer)
    // Write the template to the buffer, instead of straight to the
    // http.ResponseWriter. If there's an error, call our serverError() helper
    // and then return.
    err := ts.ExecuteTemplate(buf, "base", data)
    if err != nil {
        app.serverError(w, err)
        return
    }
    // If the template is written to the buffer without any errors, we are safe
    // to go ahead and write the HTTP status code to http.ResponseWriter.
    w.WriteHeader(status)
    // Write the contents of the buffer to the http.ResponseWriter. Note: this
    // is another time where we pass our http.ResponseWriter to a function that
    // takes an io.Writer.
    buf.WriteTo(w)
}

package main
...
// Add a CurrentYear field to the templateData struct.
type templateData struct {
    CurrentYear int
    Snippet models.Snippet
    Snippets []models.Snippet
}
...

package main
import (
    "bytes"
    "fmt"
    "net/http"
    "runtime/debug"
    "time" // New import
)
...
// Create an newTemplateData() helper, which returns a pointer to a templateData
// struct initialized with the current year. Note that we're not using the
// *http.Request parameter here at the moment, but we will do later in the book.
func (app *application) newTemplateData(r *http.Request) *templateData {
    return &templateData{
    	CurrentYear: time.Now().Year(),
    }
}
...

package main
...
func (app *application) home(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/" {
        app.notFound(w)
        return
    }
    
    snippets, err := app.snippets.Latest()
    if err != nil {
        app.serverError(w, err)
        return
    }
+        // Call the newTemplateData() helper to get a templateData struct containing
+        // the 'default' data (which for now is just the current year), and add the
+        // snippets slice to it.
+        data := app.newTemplateData(r)
+        data.Snippets = snippets
+        // Pass the data to the render() helper as normal.
+        app.render(w, http.StatusOK, "home.html", data)
-        app.render(w, http.StatusOK, "home.html", &templateData{Snippets: snippets})
    }

    func (app *application) snippetView(w http.ResponseWriter, r *http.Request) {
    id, err := strconv.Atoi(r.URL.Query().Get("id"))
    if err != nil || id < 1 {
        app.notFound(w)
        return
    }
    snippet, err := app.snippets.Get(id)
    if err != nil {
        if errors.Is(err, models.ErrNoRecord) {
        	app.notFound(w)
        } else {
        	app.serverError(w, err)
        }
        return
    }
    // And do the same thing again here...
+   data := app.newTemplateData(r)
+   data.Snippet = snippet
+   app.render(w, http.StatusOK, "view.html", data)
-   app.render(w, http.StatusOK, "home.html", &templateData{Snippet: snippet})
}
...

 {{define "base"}}
 <!DOCTYPE html>
 <html lang="en">
  <head>
    <meta charset="utf-8" />
    <title>{{template "title" .}} - Snippetbox</title>
    <!-- Link to the CSS stylesheet and favicon -->
    <link rel="stylesheet" href="/static/css/main.css" />
    <link
      rel="shortcut icon"
      href="/static/img/favicon.ico"
      type="image/x-icon"
    />
    <!-- Also link to some fonts hosted by Google -->
    <link
      rel="stylesheet"
      href="https://fonts.googleapis.com/css?		family=Ubuntu+Mono:400,700"
    />
  </head>

  <body>
    <header>
      <h1><a href="/">Snippetbox</a></h1>
    </header>
    {{template "nav" .}}
    <main>{{template "main" .}}</main>
    <footer>
+      Powered by <a href="https://golang.org/">Go</a> in {{.CurrentYear}}
    </footer>
    <!-- And include the JavaScript file -->
    <script src="/static/js/main.js" type="text/javascript"></script>
  </body>
</html>
{{end}}

package main

import (
	"html/template"
	"path/filepath"
	"time"

	"github.com/nahueldev23/snippetbox/internal/models"
)

...

// Initialize a template.FuncMap object and store it in a global variable. This is
// essentially a string-keyed map which acts as a lookup between the names of our
// custom template functions and the functions themselves.
+ var functions = template.FuncMap{
+	"humanDate": humanDate,
+}

func newTemplateCache() (map[string]*template.Template, error) {
	// Initialize a new map to act as the cache.
	cache := map[string]*template.Template{}
	// Use the filepath.Glob() function to get a slice of all filepaths that
	// match the pattern "./ui/html/pages/*.tmpl". This will essentially gives
	// us a slice of all the filepaths for our application 'page' templates
	// like: [ui/html/pages/home.tmpl ui/html/pages/view.tmpl]
	pages, err := filepath.Glob("./ui/html/pages/*.html")
	if err != nil {
		return nil, err
	}
	// Loop through the page filepaths one-by-one.
	for _, page := range pages {
		// Extract the file name (like 'home.tmpl') from the full filepath
		// and assign it to the name variable.
		name := filepath.Base(page)

		// call the ParseFiles() method. This means we have to use template.New() to
		// create an empty template set, use the Funcs() method to register the
		// template.FuncMap, and then parse the file as normal.
+		ts, err := template.New(name).Funcs(functions).ParseFiles("./ui/html/base.html")
        if err != nil {
			return nil, err
		}
        
-       ts, err := template.ParseFiles("./ui/html/base.html")
        
		// Call ParseGlob() *on this template set* to add any partials.
		ts, err = ts.ParseGlob("./ui/html/partials/*.html")
		if err != nil {
			return nil, err
		}

		// Call ParseFiles() *on this template set* to add the
		ts, err = ts.ParseFiles(page)
		if err != nil {
			return nil, err
		}

		// Add the template set to the map, using the name of the page
		// (like 'home.tmpl') as the key.
		cache[name] = ts
	}
	// Return the map.
	return cache, nil
}

{{define "title"}}Home{{end}}
{{define "main"}}
    <h2>Latest Snippets</h2>
    {{if .Snippets}}
    <table>
        <tr>
            <th>Title</th>
            <th>Created</th>
            <th>ID</th>
        </tr>
        {{range .Snippets}}
        <tr>
            <td><a href='/snippet/view?id={{.ID}}'>{{.Title}}</a></td>
            <td>{{humanDate .Created}}</td>
            <td>#{{.ID}}</td>
        </tr>
        {{end}}
    </table>
    {{else}}
    <p>There's nothing to see here... yet!</p>
    {{end}}
{{end}}

{{define "title"}}Snippet #{{.Snippet.ID}}{{end}}]
{{define "main"}}
{{with.Snippet}}
    <div class="snippet">
      <div class="metadata">
        <strong>{{.Title}}</strong>
        <span>#{{.ID}}</span>
      </div>
      <pre><code>{{.Content}}</code></pre>
      <div class="metadata">
        <!-- Use the new template function here -->
        <time>Created: {{humanDate .Created}}</time>
        <time>Expires: {{humanDate .Expires}}</time>
      </div>
    </div>
    {{end}} 
{{end}}

<time>Created: {{humanDate .Created}}</time>

<time>Created: {{.Created | humanDate}}</time>

<time>{{.Created | humanDate | printf "Created: %s"}}</time>