$ go get github.com/alexedwards/scs/v2@v2
go: downloading github.com/alexedwards/scs/v2 v2.5.1
go get: added github.com/alexedwards/scs/v2 v2.5.1
$ go get github.com/alexedwards/scs/mysqlstore@latest
go: downloading github.com/alexedwards/scs/mysqlstore v0.0.0-20230902070821-95fa2ac9d520
go get: added github.com/alexedwards/scs/mysqlstore v0.0.0-20230902070821-95fa2ac9d520

USE snippetbox;

CREATE TABLE sessions (
   token CHAR(43) PRIMARY KEY,
   data BLOB NOT NULL,
   expiry TIMESTAMP(6) NOT NULL
);

CREATE INDEX sessions_expiry_idx ON sessions (expiry);

 package main

 import (
	"database/sql"
	"flag"
	"html/template"
	"log"
	"net/http"
	"os"
	"time"

	"log/slog"

+	"github.com/alexedwards/scs/mysqlstore"
+	"github.com/alexedwards/scs/v2"
	"github.com/go-playground/form/v4"
	_ "github.com/go-sql-driver/mysql"
	"github.com/nahueldev23/snippetbox/internal/models"
 )

 type application struct {
	logger         *slog.Logger
	errorLog       *log.Logger
	infoLog        *log.Logger
	snippets       *models.SnippetModel
	templateCache  map[string]*template.Template
	formDecoder    *form.Decoder
+	sessionManager *scs.SessionManager
 }

 func main() {
 	addr := flag.String("addr", ":4000", "HTTP network address")
   
+  //pone tu password
 	dsn := flag.String("dsn", "web:xxxx/snippetbox?parseTime=true", "HTTP network address")
 
 	flag.Parse()
 
 	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
 
 	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()
 	templateCache, err := newTemplateCache()
 	if err != nil {
 		errorLog.Fatal(err)
 	}
 
 	// Initialize a decoder instance...
 	formDecoder := form.NewDecoder()
 
+	// Use the scs.New() function to initialize a new session manager. Then we
+	// configure it to use our MySQL database as the session store, and set a
+	// lifetime of 12 hours (so that sessions automatically expire 12 hours
+	// after first being created).
+	sessionManager := scs.New()
+	sessionManager.Store = mysqlstore.New(db)
+	sessionManager.Lifetime = 12 * time.Hour
 
 	app := &application{
 		logger:         logger,
 		errorLog:       errorLog,
 		infoLog:        infoLog,
 		snippets:       &models.SnippetModel{DB: db},
 		templateCache:  templateCache,
 		formDecoder:    formDecoder,
+		sessionManager: sessionManager,
 	}
 
 	srv := &http.Server{
 		Addr:     *addr,
 		ErrorLog: errorLog,
 		Handler:  app.routes(),
 	}
 
 	logger.Info("Starting server", "addr", *addr)
 
 	err = srv.ListenAndServe()
 	logger.Error(err.Error())
 	os.Exit(1)
 }
 
 func openDB(dsn string) (*sql.DB, error) {
 	db, err := sql.Open("mysql", dsn)
 	if err != nil {
 		return nil, err
 	}
 	if err = db.Ping(); err != nil {
 		return nil, err
 	}
 	return db, nil
 }
 

  package main
  
  import (
  	"net/http"
  
  	"github.com/julienschmidt/httprouter"
  	"github.com/justinas/alice" // New import
  )
  
  func (app *application) routes() http.Handler {
  
  	router := httprouter.New()
  
  	router.NotFound = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  		app.notFound(w)
  	})
  
  	fileServer := http.FileServer(http.Dir("./ui/static/"))
  	router.Handler(http.MethodGet, "/static/*filepath", http.StripPrefix("/static", fileServer))
  
+  	// Create a new middleware chain containing the middleware specific to our
+  	// dynamic application routes. For now, this chain will only contain the
+  	// LoadAndSave session middleware but we'll add more to it later.
+  	dynamic := alice.New(app.sessionManager.LoadAndSave)
  
+  	// Update these routes to use the new dynamic middleware chain followed by
+  	// the appropriate handler function. Note that because the alice ThenFunc()
+  	// method returns a http.Handler (rather than a http.HandlerFunc) we also
+  	// need to switch to registering the route using the router.Handler() method.
+  	router.Handler(http.MethodGet, "/", dynamic.ThenFunc(app.home))
+  	router.Handler(http.MethodGet, "/snippet/view/:id", dynamic.ThenFunc(app.snippetView))
+  	router.Handler(http.MethodGet, "/snippet/create", dynamic.ThenFunc(app.snippetCreate))
+  	router.Handler(http.MethodPost, "/snippet/create", dynamic.ThenFunc(app.snippetCreatePost))

-   router.HandlerFunc(http.MethodGet, "/", app.home)
-  	router.HandlerFunc(http.MethodGet, "/snippet/view/:id", app.snippetView)
-  	router.HandlerFunc(http.MethodGet, "/snippet/create", app.snippetCreate)
-  	router.HandlerFunc(http.MethodPost, "/snippet/create", app.snippetCreatePost)
  	// Create the middleware chain as normal.
  	standard := alice.New(app.recoverPanic, app.logRequest, sercureHeaders)

  	// Wrap the router with the middleware and return it as normal.
  	return standard.Then(router)
}

router := httprouter.New()
router.Handler(http.MethodGet, "/", app.sessionManager.LoadAndSave(http.HandlerFunc(app.home)))
router.Handler(http.MethodGet, "/snippet/view/:id", app.sessionManager.LoadAndSave(http.HandlerFunc(app.snippetView)))
// ... etc

  func (app *application) snippetCreatePost(w http.ResponseWriter, r *http.Request) {
  	var form snippetCreateForm
  
  	err := app.decodePostForm(r, &form)
  	if err != nil {
  		app.clientError(w, http.StatusBadRequest)
  		return
  	}
  
  	form.CheckField(validator.NotBlank(form.Title), "title", "This field cannot be blank")
  	form.CheckField(validator.MaxChars(form.Title, 100), "title", "This field cannot be more than 100 characters long")
  	form.CheckField(validator.NotBlank(form.Content), "content", "This field cannot be blank")
  	form.CheckField(validator.PermittedValue(form.Expires, 1, 7, 365), "expires", "This field must equal 1, 7 or 365")
  
  	if !form.Valid() {
  		data := app.newTemplateData(r)
  		data.Form = form
  		app.render(w, r, http.StatusUnprocessableEntity, "create.html", data)
  		return
  	}
  	id, err := app.snippets.Insert(form.Title, form.Content, form.Expires)
  	if err != nil {
  		app.serverError(w, r, err)
  		return
  	}
  
+	 // Use the Put() method to add a string value ("Snippet successfully
+	 // created!") and the corresponding key ("flash") to the session data.
+	 app.sessionManager.Put(r.Context(), "flash", "Snippet successfully created!")
  
  	// Update the redirect path to use the new clean URL format.
  	http.Redirect(w, r, fmt.Sprintf("/snippet/view/%d", id), http.StatusSeeOther)
  }

  func (app *application) snippetView(w http.ResponseWriter, r *http.Request) {
  
  	params := httprouter.ParamsFromContext(r.Context())
  
  	id, err := strconv.Atoi(params.ByName("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, r, err)
  		}
  		return
  	}
  
+  	// Use the PopString() method to retrieve the value for the "flash" key.
+  	// PopString() also deletes the key and value from the session data, so it
+  	// acts like a one-time fetch. If there is no matching key in the session
+  	// data this will return the empty string.
+  	flash := app.sessionManager.PopString(r.Context(), "flash")
  
  	data := app.newTemplateData(r)
  	data.Snippet = snippet
  
+  	// Pass the flash message to the template.
+  	data.Flash = flash
  
  	app.render(w, r, http.StatusOK, "view.html", data)
}

package main

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

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

type templateData struct {
	CurrentYear int
	Snippet     models.Snippet
	Snippets    []models.Snippet
	Form        any
	Flash       string
}
...

{{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" .}}
+    <!-- Display the flash message if one exists -->
+    {{with .Flash}}
+    <div class="flash">{{.}}</div>
+    {{end}}
    <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

 func (app *application) newTemplateData(r *http.Request) *templateData {
 	return &templateData{
 		CurrentYear: time.Now().Year(),
+ 		// Add the flash message to the template data, if one exists.
+ 		Flash: app.sessionManager.PopString(r.Context(), "flash"),
 	}
 }

  func (app *application) snippetView(w http.ResponseWriter, r *http.Request) {
  
  	params := httprouter.ParamsFromContext(r.Context())
  
  	id, err := strconv.Atoi(params.ByName("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, r, err)
  		}
  		return
  	}
  
-  	// Use the PopString() method to retrieve the value for the "flash" key.
-  	// PopString() also deletes the key and value from the session data, so it
-  	// acts like a one-time fetch. If there is no matching key in the session
-  	// data this will return the empty string.
-  	flash := app.sessionManager.PopString(r.Context(), "flash")
  
  	data := app.newTemplateData(r)
  	data.Snippet = snippet
  
  	// Pass the flash message to the template.
  	data.Flash = flash
  
  	app.render(w, r, http.StatusOK, "view.html", data)
  }

mysql> SELECT * FROM sessions WHERE token = 'y9y1-mXyQUoAM6V5s9lXNjbZ_vXSGkO7jy-KL-di7A4';
+---------------------------------------------+--------------------------------------------------------------------------------------------------
| token
| data
+---------------------------------------------+--------------------------------------------------------------------------------------------------
| y9y1-mXyQUoAM6V5s9lXNjbZ_vXSGkO7jy-KL-di7A4 | 0x26FF81030102FF820001020108446561646C696E6501FF8400010656616C75657301FF8600000010FF8305010104546
+---------------------------------------------+--------------------------------------------------------------------------------------------------
1 row in set (0.00 sec)