Milo buildbot builder page: Add pagnation with cursors.

milo/appengine/common/funcs.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package common
 
 import (
         "bytes"
         "fmt"
         "html/template"
+        "net/http"
         "strings"
         "time"
 
         "github.com/luci/luci-go/milo/api/resp"
 )
 
 // A collection of useful templating functions
 
 // funcMap is what gets fed into the template bundle.
 var funcMap = template.FuncMap{
         "humanDuration":  humanDuration,
         "parseRFC3339":   parseRFC3339,
         "linkify":        linkify,
         "linkifySet":     linkifySet,
         "obfuscateEmail": obfuscateEmail,
         "localTime":      localTime,
         "shortHash":      shortHash,
         "startswith":     strings.HasPrefix,
         "sub":            sub,
         "consoleHeader":  consoleHeader,
+        "pagedURL":       pagedURL,
 }
 
 // localTime returns a <span> element with t in human format
 // that will be converted to local timezone in the browser.
 // Recommended usage: {{ .Date | localTime "N/A" }}
 func localTime(ifZero string, t time.Time) template.HTML {
         if t.IsZero() {
                 return template.HTML(template.HTMLEscapeString(ifZero))
         }
         milliseconds := t.UnixNano() / 1e6
@@ skipping 153 matching lines @@
 }
 
 // shortHash abbriviates a git hash into 6 characters.
 func shortHash(s string) string {
         if len(s) > 6 {
                 return s[0:6]
         }
         return s
 }
 
+// pagedURL returns a self URL with the given cursor and limit paging options.
+// if limit is set to 0, then inherit whatever limit is set in request.  If
+// both are unspecified, then limit is omitted.
+func pagedURL(r *http.Request, limit int, cursor string) string {
+        if limit == 0 {
+                var err error
+                limit, err = GetLimit(r)
+                if err != nil {
+                        // This should not happen because the handler should've already validated the
+                        // limit earlier in the process.
+                        panic(err)
+                }
+                if limit < 0 {
+                        limit = 0
+                }
+        }
+        values := r.URL.Query()
+        switch cursor {
+        case "EMPTY":
+                values.Del("cursor")
+        case "":
+                // Do nothing, just leave the cursor in.
+        default:
+                values.Set("cursor", cursor)
+        }
+        switch {
+        case limit < 0:
+                values.Del("limit")
+        case limit > 0:
+                values.Set("limit", fmt.Sprintf("%d", limit))
+        }
+        result := *r.URL
+        result.RawQuery = values.Encode()
+        return result.String()
+}
+
 func init() {
         linkifySetTemplate = template.Must(
                 template.New("linkifySet").
                         Funcs(template.FuncMap{
                                 "linkify": linkify,
                         }).Parse(
                         `{{ range $i, $link := . }}` +
                                 `{{ if gt $i 0 }} {{ end }}` +
                                 `{{ $link | linkify}}` +
                                 `{{ end }}`))
 
         linkifyTemplate = template.Must(
                 template.New("linkify").
                         Parse(
                                 `<a href="{{.URL}}">` +
                                         `{{if .Img}}<img src="{{.Img}}"{{if .Alt}} alt="{{.Alt}}"{{end}}>` +
                                         `{{else if .Alias}}[{{.Label}}]` +
                                         `{{else}}{{.Label}}{{end}}` +
                                         `</a>`))
 }