archive/ArchiveState.go

package archive

import (
	"bufio"
	"fmt"
	"html/template"
	"io/ioutil"
	"math"
	"net/http"
	"os"
	"regexp"
	"strings"
)

const (
	pageNotSet int = -1
)

type ArchiveState struct {
	svr          *ArchiveServer
	log          *LogSource
	logBestSlug  string
	query        string
	queryIsRegex bool
	ym           YearMonth
	page         int
	highestPage  int
}

func NewArchiveState(svr *ArchiveServer) *ArchiveState {
	return &ArchiveState{
		svr:  svr,
		page: pageNotSet,
	}
}

func (this *ArchiveState) selectSource(log *LogSource, slug string) {
	this.log = log
	this.logBestSlug = slug
}

// renderView renders a single page of log entries.
// - Mandatory: log, ym
// - Optional:  page
func (this *ArchiveState) renderView(w http.ResponseWriter) {
	fname, err := this.svr.LogFile(this.log, this.ym)
	if err != nil {
		this.renderError(w, err.Error())
		return
	}

	fc, err := ioutil.ReadFile(fname)
	if err != nil {
		this.renderError(w, err.Error())
		return
	}

	lines := strings.Split(string(fc), "\n")

	this.highestPage = int(math.Ceil(float64(len(lines))/float64(this.svr.cfg.LinesPerPage))) - 1
	if this.page == pageNotSet || this.page > this.highestPage {
		this.page = this.highestPage
	}
	if this.page < 0 {
		this.page = 0
	}

	startLine := this.svr.cfg.LinesPerPage * this.page
	endLine := this.svr.cfg.LinesPerPage * (this.page + 1)
	if endLine > len(lines) {
		endLine = len(lines)
	}

	output := ""
	for i := startLine; i < endLine; i += 1 {
		output += template.HTMLEscapeString(lines[i]) + "<br>\n"
	}

	this.renderTemplate(w, []byte(output))
}

// renderSearch renders the search results.
// - Mandatory: log, query, queryIsRegex
func (this *ArchiveState) renderSearch(w http.ResponseWriter) {

	var matcher func(line string) bool
	if this.queryIsRegex {
		rx, err := regexp.Compile(`(?i)` + this.query)
		if err != nil {
			this.renderError(w, "Invalid regular expression "+this.query+" ("+err.Error()+")")
			return
		}

		matcher = rx.MatchString
	} else {
		queryLower := strings.ToLower(this.query)
		matcher = func(line string) bool {
			return strings.Contains(strings.ToLower(line), queryLower)
		}
	}

	this.renderTemplateHead(w)
	totalResults := 0
	w.Write([]byte(`<ul>`))

	limit := this.log.LatestDate().Next() // one off the end
	for ympair := this.log.EarliestDate(); !ympair.Equals(limit); ympair = ympair.Next() {

		fname, err := this.svr.LogFile(this.log, ympair)
		if err != nil {
			continue // no log exists for this ym
		}

		fh, err := os.Open(fname)
		if err != nil {
			continue // can't open this log file
		}

		func() {
			defer fh.Close()

			scanner := bufio.NewScanner(fh)

			for i := 0; scanner.Scan(); i += 1 {
				if !matcher(scanner.Text()) {
					continue
				}
				totalResults += 1

				page := i / this.svr.cfg.LinesPerPage
				lineNo := i % this.svr.cfg.LinesPerPage
				url := fmt.Sprintf(`/%s/%d/%d/page-%d#line-%d`, this.logBestSlug, ympair.Year, ympair.Month, page, lineNo)

				w.Write([]byte(`<li><a href="` + template.HTMLEscapeString(url) + `">&raquo;</a> ` + template.HTMLEscapeString(scanner.Text()) + `</li>`))
			}

		}()
	}

	w.Write([]byte(`</ul>`))

	if totalResults == 0 {
		w.Write([]byte(`No search results for &quot;<em>` + template.HTMLEscapeString(this.query) + `</em>&quot;`))
	} else {
		w.Write([]byte(`<br><em>Found ` + fmt.Sprintf("%d", totalResults) + ` total result(s).</em><br><br>`))
	}

	this.renderTemplateFoot(w)
}

// renderError renders a plain text string, escaping it for HTML use.
func (this *ArchiveState) renderError(w http.ResponseWriter, msg string) {
	this.renderTemplate(w, []byte(template.HTMLEscapeString(msg)))
}

func (this *ArchiveState) renderTemplate(w http.ResponseWriter, body []byte) {
	this.renderTemplateHead(w)
	w.Write(body)
	this.renderTemplateFoot(w)
}

func (this *ArchiveState) renderTemplateHead(w http.ResponseWriter) {
	w.Header().Set(`Content-Type`, `text/html; charset=UTF-8`)
	w.Header().Set(`X-UA-Compatible`, `IE=Edge`)
	w.WriteHeader(200)

	title := `Archives`
	if this.log != nil {
		title = this.log.Description + ` Archives`
	}

	showPageURLs := (this.log != nil && len(this.query) == 0)

	w.Write([]byte(`<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
		<title>` + template.HTMLEscapeString(title) + `</title>
		<link rel="stylesheet" type="text/css" href="/style.css">
	</head>
	<body>
		<div class="layout-top nav">
		
			<div id="tr1" style="display:none;"></div>
			<div id="tr2" style="display:none;"></div>
			<div class="ddmenu" id="spm" style="display:none;">
				<a href="/">Latest</a>
				<a onclick="fontSize(1);">Font increase</a>
				<a onclick="fontSize(-1);">Font decrease</a>
				<a href="/download" onclick="return confirm('Are you sure you want to download a backup?');">Download backup</a>
			</div>
		
			<a onclick="toggleMenu();"><div id="logo" class="layout-pushdown"></div></a>
		
			<span class="area-nav">
			
			<form method="GET" id="frmHub">
				<select name="h" id="selHub">
	`))

	for i, h := range this.svr.cfg.Logs {
		slug, _ := this.svr.bestSlugFor(&this.svr.cfg.Logs[i])
		current := (this.log == &this.svr.cfg.Logs[i])

		w.Write([]byte(`<option value="` + template.HTMLEscapeString(slug) + `" ` + attr(current, "selected") + `>` + template.HTMLEscapeString(h.Description) + `</option>`))
	}

	w.Write([]byte(`
						</select>
					</form>
	`))

	if showPageURLs {
		w.Write([]byte(`

					<form method="GET">
						<input type="hidden" name="h" value="` + template.HTMLEscapeString(this.logBestSlug) + `">
						<select id="seldate" onchange="setYM(this);">
		`))

		// Generate month dropdown options

		lastY := -1
		limit := this.log.LatestDate().Next() // one off the end
		for ympair := this.log.EarliestDate(); !ympair.Equals(limit); ympair = ympair.Next() {
			if ympair.Year != lastY {
				if lastY != -1 {
					w.Write([]byte(`</optgroup>`))
				}
				w.Write([]byte(`<optgroup label="` + fmt.Sprintf("%d", ympair.Year) + `">`))
				lastY = ympair.Year
			}

			w.Write([]byte(fmt.Sprintf(`<option value="%d-%d" %s>%s</option>`, ympair.Year, ympair.Month, attr(ympair.Equals(this.ym), "selected"), template.HTMLEscapeString(ympair.Month.String()))))
		}

		//

		pageBase := fmt.Sprintf(`/%s/%d/%d`, this.logBestSlug, this.ym.Year, this.ym.Month)

		previousPage := this.page - 1
		if previousPage < 0 {
			previousPage = 0
		}

		nextPage := this.page + 1
		if nextPage > this.highestPage {
			nextPage = this.highestPage
		}

		w.Write([]byte(`
							</optgroup>
			
						</select>
						<input type="hidden" name="y" id="f_y" value="">
						<input type="hidden" name="m" id="f_m" value="">
						<input type="hidden" name="p" value="0" >
					</form>

					<div class="mini-separator layout-pushdown"></div>

					<a class="btn" href="` + pageBase + `/page-0">&laquo;</a><a
					   class="btn" id="pgprev" href="` + pageBase + `/page-` + fmt.Sprintf("%d", previousPage) + `">&lsaquo;</a>
					` + fmt.Sprintf("%d", this.page) + `
					<a class="btn" id="pgnext" href="` + pageBase + `/page-` + fmt.Sprintf("%d", nextPage) + `">&rsaquo;</a><a
					   class="btn" href="` + pageBase + `">&raquo;</a>
		`))
	}

	w.Write([]byte(`
						<div class="pad"></div>

					</span>

					<span class="area-search">

					<form method="GET">
						<input type="hidden" name="h" value="` + template.HTMLEscapeString(this.logBestSlug) + `">
						<input type="text" id="searchbox" name="q" value="` + template.HTMLEscapeString(this.query) + `" placeholder="Search...">
						<input type="submit" value="&raquo;">
						<input type="checkbox" class="layout-pushdown" name="rx" value="1" title="PCRE Regular Expression" ` + attr(this.queryIsRegex, "checked") + `>
					</form>

					</span>
				</div>

				<div class="layout-body" id="chatarea">
	`))

	// Header ends
}

func (this *ArchiveState) renderTemplateFoot(w http.ResponseWriter) {
	w.Write([]byte(`
		</div>
		<script type="text/javascript" src="/archive.js?nonce=` + fmt.Sprintf("%d", this.svr.startup.Unix()) + `"></script>
	</body>
</html>
`))
}