Convert to go

web/page.go

@@ -0,0 +1,224 @@
+package web
+
+import (
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+
+	"list_app/controllers"
+	"list_app/models"
+)
+
+type mediaView struct {
+	Code     string
+	Title    string
+	Released string
+	WebImg   string
+}
+
+type group struct {
+	Label string
+	Items []mediaView
+}
+
+type pageData struct {
+	ListType string
+	Sort     string
+	Total    int
+	Groups   []group
+	Error    string
+}
+
+func tableFor(listType string) (models.Table, bool) {
+	switch listType {
+	case "movies":
+		return models.Movies, true
+	case "series":
+		return models.Series, true
+	case "games":
+		return models.Games, true
+	}
+	return "", false
+}
+
+// resolveWebImg is decided at render time rather than falling back via
+// client-side JS: if the poster hasn't been downloaded yet (or the file's
+// missing), the fallback image is used directly in the rendered `src`.
+func resolveWebImg(m models.Media) string {
+	if m.WebImg == "" {
+		return "/no_poster.jpg"
+	}
+	if _, err := os.Stat(controllers.PosterDiskPath(m.WebImg)); err != nil {
+		return "/no_poster.jpg"
+	}
+	return m.WebImg
+}
+
+func toView(m models.Media) mediaView {
+	return mediaView{
+		Code:     m.Code,
+		Title:    m.Title,
+		Released: m.Released,
+		WebImg:   resolveWebImg(m),
+	}
+}
+
+func toViews(media []models.Media) []mediaView {
+	views := make([]mediaView, len(media))
+	for i, m := range media {
+		views[i] = toView(m)
+	}
+	return views
+}
+
+func parseReleased(released string) time.Time {
+	t, err := time.Parse("2 Jan 2006", released)
+	if err != nil {
+		return time.Time{}
+	}
+	return t
+}
+
+func groupLetter(title string) string {
+	if title == "" {
+		return "#"
+	}
+	r := []rune(strings.ToUpper(title))[0]
+	if unicode.IsDigit(r) {
+		return "#"
+	}
+	return string(r)
+}
+
+func buildGroups(sortType string, media []models.Media) []group {
+	switch sortType {
+	case "year":
+		sort.SliceStable(media, func(i, j int) bool {
+			return parseReleased(media[i].Released).Before(parseReleased(media[j].Released))
+		})
+
+		byYear := map[string][]models.Media{}
+		for _, m := range media {
+			key := strconv.Itoa(parseReleased(m.Released).Year())
+			byYear[key] = append(byYear[key], m)
+		}
+
+		keys := make([]string, 0, len(byYear))
+		for k := range byYear {
+			keys = append(keys, k)
+		}
+		sort.Sort(sort.Reverse(sort.StringSlice(keys)))
+
+		groups := make([]group, 0, len(keys))
+		for _, k := range keys {
+			groups = append(groups, group{Label: k, Items: toViews(byYear[k])})
+		}
+		return groups
+
+	case "id":
+		sort.SliceStable(media, func(i, j int) bool { return media[i].ID > media[j].ID })
+		return []group{{Label: "added", Items: toViews(media)}}
+
+	default: // title
+		sort.SliceStable(media, func(i, j int) bool {
+			return strings.ToLower(media[i].Title) < strings.ToLower(media[j].Title)
+		})
+
+		byLetter := map[string][]models.Media{}
+		for _, m := range media {
+			key := groupLetter(m.Title)
+			byLetter[key] = append(byLetter[key], m)
+		}
+
+		keys := make([]string, 0, len(byLetter))
+		for k := range byLetter {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys)
+
+		groups := make([]group, 0, len(keys))
+		for _, k := range keys {
+			groups = append(groups, group{Label: k, Items: toViews(byLetter[k])})
+		}
+		return groups
+	}
+}
+
+func Index(w http.ResponseWriter, r *http.Request) {
+	q := r.URL.Query()
+
+	listType := q.Get("listType")
+	table, ok := tableFor(listType)
+	if !ok {
+		listType = "movies"
+		table = models.Movies
+	}
+
+	sortType := q.Get("sortType")
+	if sortType != "title" && sortType != "year" && sortType != "id" {
+		sortType = "title"
+	}
+
+	media := models.Find(table)
+
+	data := pageData{
+		ListType: listType,
+		Sort:     sortType,
+		Total:    len(media),
+		Groups:   buildGroups(sortType, media),
+		Error:    q.Get("error"),
+	}
+
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	if err := pageTemplate.Execute(w, data); err != nil {
+		log.Println(err)
+	}
+}
+
+func redirectToList(w http.ResponseWriter, r *http.Request, listType, sortType, errMsg string) {
+	vals := url.Values{}
+	vals.Set("listType", listType)
+	vals.Set("sortType", sortType)
+	if errMsg != "" {
+		vals.Set("error", errMsg)
+	}
+	http.Redirect(w, r, "/?"+vals.Encode(), http.StatusSeeOther)
+}
+
+// Add handles the plain HTML form submission for adding new media: no JS,
+// so it always ends in a redirect back to the list, with an `error` query
+// param set for the page to render as a flash message on failure.
+func Add(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "bad form", http.StatusBadRequest)
+		return
+	}
+
+	pass := r.FormValue("pass")
+	code := r.FormValue("code")
+	listType := r.FormValue("listType")
+	sortType := r.FormValue("sortType")
+
+	if pass == "" || code == "" {
+		redirectToList(w, r, listType, sortType, "")
+		return
+	}
+
+	if !models.CheckPassword(pass) {
+		redirectToList(w, r, listType, sortType, "Incorrect password")
+		return
+	}
+
+	if _, err := controllers.Create(code); err != nil {
+		redirectToList(w, r, listType, sortType, err.Error())
+		return
+	}
+
+	redirectToList(w, r, listType, sortType, "")
+}