Move to using HTML templates when filling out the workspace history.

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/json"
         "flag"
         "fmt"
@@ skipping 328 matching lines @@
         match := imageLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         filename := match[1]
         http.ServeFile(w, r, fmt.Sprintf("../../../inout/%s", filename))
 }
 
 type Try struct {
-        Hash     string
-        CreateTS string
+        Hash     string `json:"hash"`
+        CreateTS string `json:"create_ts"`
 }
 
 type Recent struct {
         Tries []Try
 }
 
 // recentHandler shows the last 20 tries.
 func recentHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Recent Handler: %q\n", r.URL.Path)
 
@@ skipping 50 matching lines @@
 }
 
 func workspaceHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Workspace Handler: %q\n", r.URL.Path)
         if r.Method == "GET" {
                 tries := []Try{}
                 match := workspaceLink.FindStringSubmatch(r.URL.Path)
                 name := ""
                 if len(match) == 2 {
                         name = match[1]
-                        rows, err := db.Query("SELECT create_ts, hash FROM workspacetry WHERE name=? ORDER BY create_ts DESC ", name)
+                        rows, err := db.Query("SELECT create_ts, hash FROM workspacetry WHERE name=? ORDER BY create_ts", name)
                         if err != nil {
                                 reportError(w, r, err, "Failed to select.")
                                 return
                         }
                         for rows.Next() {
                                 var hash string
                                 var create_ts time.Time
                                 if err := rows.Scan(&create_ts, &hash); err != nil {
                                         log.Printf("Error: failed to fetch from database: %q", err)
                                         continue
                                 }
                                 tries = append(tries, Try{Hash: hash, CreateTS: create_ts.Format("2006-02-01")})
                         }
                 }
                 var code string
                 if len(tries) == 0 {
                         code = DEFAULT_SAMPLE
                 } else {
-                        code = getCode(tries[0].Hash)
+                        code = getCode(tries[len(tries)-1].Hash)

[mtklein, 2014/04/21 16:19:01]

Undo?

[jcgregorio, 2014/04/21 16:26:24]

This was intentional, the history list is constructed in JS and it works by
appending to the head of history, so the DESC had to be removed from the SELECT
query above, which means the most recent try is now the last try again.

On 2014/04/21 16:19:01, mtklein wrote:

[mtklein, 2014/04/21 16:31:14]

Ah!  Missed the DESC change.  Thanks.

                 }
                 if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name}); err != nil {
                         log.Printf("ERROR: Failed to expand template: %q\n", err)
                 }
         } else if r.Method == "POST" {
                 name, err := newWorkspace()
                 if err != nil {
                         http.Error(w, "Failed to create a new workspace.", 500)
                         return
                 }
@@ skipping 149 matching lines @@
         flag.Parse()
         http.HandleFunc("/i/", imageHandler)
         http.HandleFunc("/w/", workspaceHandler)
         http.HandleFunc("/recent/", recentHandler)
         http.HandleFunc("/iframe/", iframeHandler)
         http.HandleFunc("/css/", cssHandler)
         http.HandleFunc("/js/", jsHandler)
         http.HandleFunc("/", mainHandler)
         log.Fatal(http.ListenAndServe(*port, nil))
 }