[milo] Refactor all html knowledge out of backends.

milo/frontend/view_console.go

-// Copyright 2016 The LUCI Authors.
+// Copyright 2017 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package console
+package frontend
 
 import (
         "fmt"
         "net/http"
         "strings"
 
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/common/clock"
+        "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/server/router"
+        "github.com/luci/luci-go/server/templates"
+
         "github.com/luci/luci-go/milo/api/config"
         "github.com/luci/luci-go/milo/api/resp"
         "github.com/luci/luci-go/milo/common"
         "github.com/luci/luci-go/milo/common/gitiles"
         "github.com/luci/luci-go/milo/common/model"
-        "github.com/luci/luci-go/server/router"
 )
 
 // Returns results of build[commit_index][builder_index]
-func GetConsoleBuilds(
+func getConsoleBuilds(
         c context.Context, builders []resp.BuilderRef, commits []string) (
         [][]*model.BuildSummary, error) {
 
         panic("Nothing to see here, check back later.")
 }
 
 // getConsoleDef finds the console definition as defined by any project.
 // If the user is not a reader of the project, this will return a 404.
 // TODO(hinoka): If the user is not a reader of any of of the builders returned,
 // that builder will be removed from list of results.
 func getConsoleDef(c context.Context, project, name string) (*config.Console, error) {
         cs, err := common.GetConsole(c, project, name)
         if err != nil {
                 return nil, err
         }
         // TODO(hinoka): Remove builders that the user does not have access to.
         return cs, nil
 }
 
-// Main is a redirect handler that redirects the user to the main console for a
-// particular project.
-func Main(ctx *router.Context) {
-        w, r, p := ctx.Writer, ctx.Request, ctx.Params
-        proj := p.ByName("project")
-        http.Redirect(w, r, fmt.Sprintf("/console/%s/main", proj), http.StatusMovedPermanently)
-        return
-}
-
 func summaryToConsole(bs []*model.BuildSummary) []*resp.ConsoleBuild {
         cb := make([]*resp.ConsoleBuild, 0, len(bs))
         for _, b := range bs {
                 cb = append(cb, &resp.ConsoleBuild{
                         // TODO(hinoka): This should link to the actual build.
                         Link:   resp.NewLink(b.BuildKey.String(), "#"),
                         Status: b.Summary.Status,
                 })
         }
         return cb
@@ skipping 18 matching lines @@
                 commitLinks[i] = commit.Revision
         }
 
         // HACK(hinoka): This only supports buildbot....
         builders := make([]resp.BuilderRef, len(def.Builders))
         for i, b := range def.Builders {
                 builders[i] = resp.BuilderRef{
                         b.Name, strings.Split(b.Category, "|"), b.ShortName,
                 }
         }
-        cb, err := GetConsoleBuilds(c, builders, commitNames)
+        cb, err := getConsoleBuilds(c, builders, commitNames)
         tConsole := clock.Now(c)
         logging.Debugf(c, "Loading the console took a total of %s.", tConsole.Sub(tGitiles))
         if err != nil {
                 return nil, err
         }
         ccb := make([]resp.CommitBuild, len(commits))
         for i, commit := range commitLinks {
                 // TODO(hinoka): Not like this
                 ccb[i].Commit = resp.Commit{Revision: commit}
                 ccb[i].Build = summaryToConsole(cb[i])
         }
 
         cs := &resp.Console{
                 Name:       def.Name,
                 Commit:     ccb,
                 BuilderRef: builders,
         }
 
         return cs, nil
 }
+
+// ConsoleHandler renders the console page.
+func ConsoleHandler(c *router.Context) {
+        project := c.Params.ByName("project")
+        if project == "" {
+                ErrorHandler(c, errors.New("Missing Project", common.CodeParameterError))
+                return
+        }
+        name := c.Params.ByName("name")
+
+        result, err := console(c.Context, project, name)
+        if err != nil {
+                ErrorHandler(c, err)
+                return
+        }
+
+        templates.MustRender(c.Context, c.Writer, "pages/console.html", templates.Args{
+                "Console": result,
+        })
+}
+
+// ConsoleMainHandler is a redirect handler that redirects the user to the main
+// console for a particular project.
+func ConsoleMainHandler(ctx *router.Context) {
+        w, r, p := ctx.Writer, ctx.Request, ctx.Params
+        proj := p.ByName("project")
+        http.Redirect(w, r, fmt.Sprintf("/console/%s/main", proj), http.StatusMovedPermanently)
+        return
+}