480 lines
13 KiB
Go
480 lines
13 KiB
Go
package archive
|
|
|
|
import (
|
|
"bufio"
|
|
"errors"
|
|
"fmt"
|
|
"html"
|
|
"io/ioutil"
|
|
"math"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
pageNotSet int = -1
|
|
)
|
|
|
|
type ArchiveState struct {
|
|
svr *ArchiveServer
|
|
log *LogSource
|
|
logBestSlug string
|
|
query string
|
|
queryIsRegex bool
|
|
isStats bool
|
|
ym YearMonth
|
|
page int
|
|
highestPage int
|
|
}
|
|
|
|
func NewArchiveState(svr *ArchiveServer) *ArchiveState {
|
|
return &ArchiveState{
|
|
svr: svr,
|
|
page: pageNotSet,
|
|
}
|
|
}
|
|
|
|
func (this *ArchiveState) showPageURLs() bool {
|
|
return this.log != nil && len(this.query) == 0 && !this.isStats
|
|
}
|
|
|
|
func (this *ArchiveState) URL() string {
|
|
if this.isStats {
|
|
return fmt.Sprintf(`/%s/stats`, this.logBestSlug)
|
|
|
|
} else if len(this.query) > 0 {
|
|
if this.queryIsRegex {
|
|
return fmt.Sprintf(`/%s/rx/%s`, this.logBestSlug, url.QueryEscape(this.query))
|
|
} else {
|
|
return fmt.Sprintf(`/%s/search/%s`, this.logBestSlug, url.QueryEscape(this.query))
|
|
}
|
|
|
|
} else {
|
|
if this.page == pageNotSet {
|
|
return fmt.Sprintf(`/%s/%s/%s`, this.logBestSlug, this.ym.Year, this.ym.Month)
|
|
} else {
|
|
return fmt.Sprintf(`/%s/%s/%s/page-%d`, this.logBestSlug, this.ym.Year, this.ym.Month, this.page)
|
|
}
|
|
}
|
|
}
|
|
|
|
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")
|
|
|
|
// Work around #newpage: if the last line is blank, skip
|
|
if len(lines) > 0 && len(lines[len(lines)-1]) == 0 {
|
|
lines = lines[:len(lines)-1]
|
|
}
|
|
|
|
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 += html.EscapeString(lines[i]) + "\n"
|
|
}
|
|
|
|
this.renderTemplate(w, []byte(output))
|
|
}
|
|
|
|
// parseStatsFor loads user post statistics for a single yearMonth in a single log source.
|
|
func (this *ArchiveState) parseStatsFor(ls *LogSource, ym YearMonth, into map[string]int) error {
|
|
|
|
fname, err := this.svr.LogFile(ls, ym)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fc, err := ioutil.ReadFile(fname)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
rxUser := regexp.MustCompile(`(?ms)^[^<\r\n]*<([^>\r\n]+)>.+?$`)
|
|
matches := rxUser.FindAllSubmatch(fc, -1)
|
|
if matches == nil || len(matches) == 0 {
|
|
return errors.New("No matches")
|
|
}
|
|
|
|
for _, match := range matches {
|
|
username := string(match[1])
|
|
|
|
if ct, ok := into[username]; ok {
|
|
into[username] = ct + 1
|
|
} else {
|
|
into[username] = 1
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (this *ArchiveState) renderStats(w http.ResponseWriter) {
|
|
// Lines per year
|
|
// Users / posts/year
|
|
|
|
startTime := time.Now()
|
|
|
|
yearsToUsersToPostCount := make(map[int]map[string]int, 0)
|
|
|
|
totalErrors := 0
|
|
var lastError error = nil
|
|
|
|
ym := this.log.EarliestDate()
|
|
orderedYears := make([]int, 0)
|
|
for {
|
|
usersToPostCount, ok := yearsToUsersToPostCount[ym.Year]
|
|
if !ok {
|
|
usersToPostCount = make(map[string]int)
|
|
orderedYears = append(orderedYears, ym.Year)
|
|
}
|
|
|
|
err := this.parseStatsFor(this.log, ym, usersToPostCount)
|
|
if err != nil {
|
|
//log.Printf("Stats(%s): %s", this.logBestSlug, err.Error())
|
|
totalErrors += 1
|
|
lastError = err
|
|
}
|
|
|
|
//fmt.Printf("%#v\n", usersToPostCount)
|
|
|
|
yearsToUsersToPostCount[ym.Year] = usersToPostCount
|
|
|
|
if ym.Equals(this.log.LatestDate()) {
|
|
break
|
|
}
|
|
|
|
ym = ym.Next()
|
|
}
|
|
|
|
ret := make([]byte, 0)
|
|
|
|
if lastError != nil {
|
|
ret = append(ret, []byte(fmt.Sprintf("<em>Got %d errors, including: '%s'</em>\n\n", totalErrors, lastError.Error()))...)
|
|
}
|
|
|
|
//
|
|
|
|
allUsersExistence := make(map[string]struct{})
|
|
for _, usersMap := range yearsToUsersToPostCount {
|
|
for username, _ := range usersMap {
|
|
allUsersExistence[username] = struct{}{}
|
|
}
|
|
}
|
|
allUsernames := make([]string, 0, len(allUsersExistence))
|
|
for username, _ := range allUsersExistence {
|
|
allUsernames = append(allUsernames, username)
|
|
}
|
|
sort.Strings(allUsernames)
|
|
|
|
//
|
|
|
|
ret = append(ret, []byte(`<table><thead><tr><th> </th>`)...)
|
|
for _, year := range orderedYears {
|
|
ret = append(ret, []byte(fmt.Sprintf(`<th>%d</th>`, year))...)
|
|
}
|
|
ret = append(ret, []byte("</tr><tbody>\n")...)
|
|
for _, username := range allUsernames {
|
|
|
|
ret = append(ret, []byte(fmt.Sprintf(`<tr><td>%s</td>`, html.EscapeString(username)))...)
|
|
for _, year := range orderedYears {
|
|
usersMap := yearsToUsersToPostCount[year]
|
|
posts, _ /*ok*/ := usersMap[username]
|
|
ret = append(ret, []byte(fmt.Sprintf(`<td>%d</td>`, posts))...)
|
|
}
|
|
ret = append(ret, []byte("</tr>\n")...)
|
|
}
|
|
ret = append(ret, []byte(`</tbody><tfoot><th style="text-align:right;">TOTAL:</th>`)...)
|
|
|
|
for _, year := range orderedYears {
|
|
postsTotalForYear := 0
|
|
for _, userPostCount := range yearsToUsersToPostCount[year] {
|
|
postsTotalForYear += userPostCount
|
|
}
|
|
ret = append(ret, []byte(fmt.Sprintf(`<th>%d</th>`, postsTotalForYear))...)
|
|
}
|
|
|
|
duration := time.Now().Sub(startTime)
|
|
|
|
ret = append(ret, []byte(fmt.Sprintf("</tfoot></table>\n\n<em>%d total users\nStatistics generated in %s</em>", len(allUsernames), duration.String()))...)
|
|
|
|
this.renderTemplate(w, ret)
|
|
}
|
|
|
|
// 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 class="search-results">`))
|
|
|
|
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="` + html.EscapeString(url) + `">»</a> ` + html.EscapeString(scanner.Text()) + `</li>`))
|
|
}
|
|
|
|
}()
|
|
}
|
|
|
|
w.Write([]byte(`</ul>`))
|
|
|
|
if totalResults == 0 {
|
|
w.Write([]byte(`No search results for "<em>` + html.EscapeString(this.query) + `</em>"`))
|
|
} 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(html.EscapeString(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`
|
|
}
|
|
|
|
latestUrl := `/`
|
|
if this.log != nil {
|
|
latestUrl = fmt.Sprintf(`/%s/%d/%d`, url.PathEscape(this.logBestSlug), this.log.LatestDate().Year, this.log.LatestDate().Month)
|
|
}
|
|
statsUrl := fmt.Sprintf(`/%s/stats`, url.PathEscape(this.logBestSlug))
|
|
|
|
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>` + html.EscapeString(title) + `</title>
|
|
<link rel="stylesheet" type="text/css" href="/style.css?nonce=` + fmt.Sprintf("%d", this.svr.startup.Unix()) + `">
|
|
</head>
|
|
<body>
|
|
<div class="layout-top nav">
|
|
|
|
<div id="menu-container" class="noselect">
|
|
<div id="tr1"></div>
|
|
<div id="tr2"></div>
|
|
<div class="ddmenu">
|
|
<a href="` + html.EscapeString(latestUrl) + `">Latest</a>
|
|
<a href="` + html.EscapeString(statsUrl) + `">Statistics</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>
|
|
</div>
|
|
|
|
<div id="logo" class="layout-pushdown"><svg viewBox="0 0 24 24">
|
|
<path fill="#000000" d="M12,17.27L18.18,21L16.54,13.97L22,9.24L14.81,8.62L12,2L9.19,8.62L2,9.24L7.45,13.97L5.82,21L12,17.27Z" />
|
|
</svg></div>
|
|
|
|
<span class="area-nav">
|
|
|
|
<select onchange="window.location.pathname = this.value;">
|
|
`))
|
|
|
|
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])
|
|
|
|
targetUri := `/` + url.PathEscape(slug) + `/`
|
|
if len(this.query) > 0 {
|
|
if this.queryIsRegex {
|
|
targetUri += `rx/` + url.PathEscape(this.query)
|
|
} else {
|
|
targetUri += `search/` + url.PathEscape(this.query)
|
|
}
|
|
} else {
|
|
targetUri += fmt.Sprintf(`%d/%d`, h.LatestDate().Year, h.LatestDate().Month)
|
|
}
|
|
|
|
w.Write([]byte(fmt.Sprintf("\t\t\t\t\t<option value=\"%s\"%s>%s</option>\n", html.EscapeString(targetUri), attr(current, " selected"), html.EscapeString(h.Description))))
|
|
}
|
|
|
|
w.Write([]byte(`
|
|
</select>
|
|
`))
|
|
|
|
if this.showPageURLs() {
|
|
w.Write([]byte(`
|
|
<select onchange="window.location.pathname = this.value;">
|
|
`))
|
|
|
|
// 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("\t\t\t\t\t</optgroup>\n"))
|
|
}
|
|
w.Write([]byte(fmt.Sprintf("\t\t\t\t\t<optgroup label=\"%d\">\n", ympair.Year)))
|
|
lastY = ympair.Year
|
|
}
|
|
|
|
targetUri := fmt.Sprintf(`/%s/%d/%d`, this.logBestSlug, ympair.Year, ympair.Month)
|
|
|
|
w.Write([]byte(fmt.Sprintf("\t\t\t\t\t\t<option value=\"%s\"%s>%s</option>\n", html.EscapeString(targetUri), attr(ympair.Equals(this.ym), " selected"), html.EscapeString(ympair.Month.String()))))
|
|
}
|
|
if lastY != -1 {
|
|
w.Write([]byte("\t\t\t\t\t</optgroup>\n"))
|
|
}
|
|
w.Write([]byte(`
|
|
</select>
|
|
|
|
<div class="mini-separator layout-pushdown"></div>
|
|
`))
|
|
|
|
//
|
|
|
|
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
|
|
}
|
|
|
|
prevMonth := this.ym.Prev() // FIXME check bounds
|
|
prevMonthLink := fmt.Sprintf(`/%s/%d/%d`, this.logBestSlug, prevMonth.Year, prevMonth.Month)
|
|
nextMonth := this.ym.Next() // FIXME check bounds
|
|
nextMonthLink := fmt.Sprintf(`/%s/%d/%d`, this.logBestSlug, nextMonth.Year, nextMonth.Month)
|
|
|
|
w.Write([]byte(`
|
|
<a style="display:none;" id="monthprev" accesskey="j" href="` + html.EscapeString(prevMonthLink) + `">
|
|
<a style="display:none;" id="monthnext" accesskey="k" href="` + html.EscapeString(nextMonthLink) + `">
|
|
|
|
<a class="btn" href="` + pageBase + `/page-0">«</a>
|
|
<a class="btn" accesskey="h" title="Previous page (Alt+H)" href="` + pageBase + `/page-` + fmt.Sprintf("%d", previousPage) + `">‹</a>
|
|
<span class="current-page">` + fmt.Sprintf("%d", this.page) + `</span>
|
|
<a class="btn" accesskey="l" title="Next page (Alt+L)" href="` + pageBase + `/page-` + fmt.Sprintf("%d", nextPage) + `">›</a>
|
|
<a class="btn" href="` + pageBase + `">»</a>
|
|
`))
|
|
}
|
|
|
|
w.Write([]byte(`
|
|
</span>
|
|
|
|
<span class="area-search">
|
|
<form method="GET" id="search-form">
|
|
<input type="hidden" name="h" value="` + html.EscapeString(this.logBestSlug) + `">
|
|
<input type="text" id="searchbox" name="q" value="` + html.EscapeString(this.query) + `" placeholder="Search..." accesskey="m" title="Search (Alt+M)">
|
|
<input type="submit" value="»">
|
|
<input type="checkbox" class="layout-pushdown" name="rx" value="1" title="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>
|
|
`))
|
|
}
|