You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1318 lines
29 KiB

/*
* Wiki - A wiki with editor
* Copyright (c) 2021 Peter Stuifzand
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package main
import (
"bytes"
"context"
"encoding/json"
"flag"
"fmt"
"html"
"html/template"
"io"
"log"
"net/http"
"net/url"
"os"
"path/filepath"
"regexp"
"strings"
"time"
"github.com/blevesearch/bleve"
"p83.nl/go/ekster/pkg/util"
"p83.nl/go/indieauth"
"p83.nl/go/wiki/link"
)
func init() {
log.SetFlags(log.Lshortfile)
}
type authorizedKey string
var (
authKey = authorizedKey("authorizedKey")
)
var (
mp PagesRepository
port = flag.Int("port", 8080, "listen port")
baseurl = flag.String("baseurl", "", "baseurl")
redirectURI = ""
authToken = os.Getenv("API_TOKEN")
)
2 years ago
type Day struct {
Class string
Text string
URL string
Count string
}
type Backref struct {
Name string
Title string
LineHTML template.HTML
LineEditHTML template.HTML
Line string
}
// Page
type Page struct {
2 years ago
// Name is the filename of the page
Name string
// Title is the human-readable title of the page
Title string
Content string
2 years ago
Refs map[string][]Backref
Blocks BlockResponse
Parent string
}
type DiffPage struct {
Content string
Diff template.HTML
}
type Revision struct {
Version string
Page DiffPage
Summary string
}
type Change struct {
Page string
Date time.Time
EndDate time.Time
Body string
Count int
DateSummary string
TimeSummary string
}
type PagesRepository interface {
Get(p string) Page
Save(p string, page Page, summary, author string) error
Exist(p string) bool
PageHistory(p string) ([]Revision, error)
RecentChanges() ([]Change, error)
AllPages() ([]Page, error)
}
type pageBaseInfo struct {
BaseURL string
RedirectURI string
2 years ago
Days []Day
Month string
Year int
PrevMonth string
NextMonth string
}
type indexPage struct {
pageBaseInfo
Session *Session
Title string
Name string
Content template.HTML
Backrefs map[string][]Backref
ShowGraph bool
TodayPage string
}
type Node struct {
Id int `json:"id"`
Label string `json:"label"`
Color *string `json:"color"`
2 years ago
Opacity float64 `json:"opacity"`
}
type Edge struct {
From int `json:"from"`
To int `json:"to"`
}
type graphPage struct {
pageBaseInfo
Session *Session
Title string
Name string
Nodes template.JS
Edges template.JS
}
type Parent struct {
Text string
ID string
}
type editPage struct {
pageBaseInfo
Session *Session
Title string
TitleHTML template.HTML
Content string
Name string
Editor template.HTML
Backrefs map[string][]Backref
ShowGraph bool
TodayPage string
Parent Parent
Parents []Parent
}
type historyPage struct {
pageBaseInfo
Session *Session
Title string
Name string
History []Revision
}
type recentPage struct {
pageBaseInfo
Session *Session
Title string
Name string
Recent []Change
}
var baseTemplate = []string{"templates/layout.html", "templates/sidebar.html", "templates/sidebar-right.html", "templates/calendar.html"}
2 years ago
type indexHandler struct{}
type graphHandler struct{}
2 years ago
type saveHandler struct {
SearchIndex bleve.Index
}
type editHandler struct{}
type historyHandler struct{}
type recentHandler struct{}
type authHandler struct{}
func (*authHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
sess, err := NewSession(w, r)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
defer func() {
if err := sess.Flush(); err != nil {
log.Println(err)
}
}()
if r.Method == http.MethodGet {
if r.URL.Path == "/auth/login" {
2 years ago
templates := baseTemplate
templates = append(templates, "templates/login.html")
t, err := template.ParseFiles(templates...)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
err = t.Execute(w, nil)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
} else if r.URL.Path == "/auth/callback" {
code := r.URL.Query().Get("code")
state := r.URL.Query().Get("state")
if state != sess.State {
log.Printf("mismatched state: %s != %s", state, sess.State)
http.Error(w, "mismatched state", 500)
return
}
authURL := sess.AuthorizationEndpoint
verified, response, err := indieauth.VerifyAuthCode(*baseurl, code, redirectURI, authURL)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
if !verified {
http.Redirect(w, r, "/auth/login", 302)
return
}
sess.Me = response.Me
sess.LoggedIn = true
sess.State = ""
http.Redirect(w, r, sess.NextURI, 302)
return
} else if r.URL.Path == "/auth/logout" {
2 years ago
templates := baseTemplate
templates = append(templates, "templates/logout.html")
t, err := template.ParseFiles(templates...)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
err = t.Execute(w, nil)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
}
} else if r.Method == http.MethodPost {
if r.URL.Path == "/auth/login" {
r.ParseForm()
urlString := r.PostFormValue("url")
u, err := url.Parse(urlString)
if err != nil {
http.Error(w, err.Error(), 400)
return
}
endpoints, err := indieauth.GetEndpoints(u)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
authURL, err := url.Parse(endpoints.AuthorizationEndpoint)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
state := util.RandStringBytes(32)
sess.AuthorizationEndpoint = authURL.String()
sess.Me = urlString
sess.LoggedIn = false
sess.RedirectURI = redirectURI
sess.NextURI = "/"
sess.State = state
newURL := indieauth.CreateAuthenticationURL(*authURL, urlString, *baseurl, redirectURI, state)
http.Redirect(w, r, newURL, 302)
return
} else if r.URL.Path == "/auth/logout" {
sess.LoggedIn = false
sess.Me = ""
sess.AuthorizationEndpoint = ""
http.Redirect(w, r, "/", 302)
return
}
} else {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}
}
func (h *historyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
sess, err := NewSession(w, r)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
defer func() {
if err := sess.Flush(); err != nil {
log.Println(err)
}
}()
if !sess.LoggedIn {
http.Redirect(w, r, "/", http.StatusFound)
return
}
r.ParseForm()
page := r.URL.Path[9:]
page = resolvePageName(page)
history, err := mp.PageHistory(page)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
funcs := template.FuncMap{
"historyIndex": func(x int, history []Revision) int { return len(history) - x },
}
t, err := template.New("layout.html").Funcs(funcs).ParseFiles("templates/layout.html", "templates/history.html")
if err != nil {
http.Error(w, err.Error(), 500)
return
}
pageBase := getPageBase(mp, time.Now())
pageData := historyPage{
pageBaseInfo: pageBase,
Session: sess,
Title: "History of " + cleanTitle(page),
Name: page,
History: history,
}
err = t.Execute(w, pageData)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
}
2 years ago
func daysInMonth(year int, month time.Month) int {
return time.Date(year, month, 1, 0, 0, 0, 0, time.UTC).AddDate(0, 1, -1).Day()
}
func prepareDays(repo PagesRepository, t time.Time) []Day {
2 years ago
today := time.Now()
var days []Day
curDate := t.AddDate(0, 0, -(t.Day() - 1))
preDays := int(curDate.Weekday())
if preDays == 0 {
preDays = 7
}
preDays -= 1
2 years ago
maxDays := daysInMonth(curDate.Year(), curDate.Month())
endOfMonth := false
for i := 0; i < 6; i++ {
year, week := curDate.ISOWeek()
2 years ago
days = append(days, Day{
Class: "week day",
Text: fmt.Sprintf("%02d", week),
URL: fmt.Sprintf("/edit/%s", formatWeekPageName(year, week)),
2 years ago
Count: "",
})
for d := 0; d < 7; d++ {
day := -preDays + (i * 7) + 1 + d
fday := fmt.Sprintf("%d", day)
if day <= 0 {
fday = ""
}
if day > maxDays {
fday = ""
endOfMonth = true
}
class := "day"
if timeEqual(curDate, today) {
class += " today"
}
if timeEqual(curDate, t) {
class += " current"
}
pageName := formatDatePageName(curDate)
if fday != "" && pageHasContent(mp, pageName) {
class += " has-content"
}
2 years ago
days = append(days, Day{
Class: class,
Text: fday,
URL: fmt.Sprintf("/edit/%s", pageName),
2 years ago
Count: "",
})
if fday != "" {
curDate = curDate.AddDate(0, 0, 1)
}
if day == maxDays {
endOfMonth = true
}
}
if endOfMonth {
break
}
}
return days
}
func pageHasContent(repo PagesRepository, day string) bool {
return repo.Exist(day)
// page := repo.Get(day)
// return page.Blocks.Children != nil
}
func formatWeekPageName(year int, week int) string {
return fmt.Sprintf("%04dW%02d", year, week)
}
2 years ago
func timeEqual(date time.Time, today time.Time) bool {
if date.Year() != today.Year() {
return false
}
if date.Month() != today.Month() {
return false
}
if date.Day() != today.Day() {
return false
}
return true
}
func getPageBase(repo PagesRepository, t time.Time) pageBaseInfo {
clientID := *baseurl
pageBase := pageBaseInfo{
BaseURL: clientID,
RedirectURI: redirectURI,
Days: prepareDays(mp, t),
2 years ago
Month: t.Month().String(),
Year: t.Year(),
}
pageBase.PrevMonth = t.AddDate(0, -1, -t.Day()+1).Format("2006-01-02")
pageBase.NextMonth = t.AddDate(0, 1, -t.Day()+1).Format("2006-01-02")
return pageBase
}
func (h *saveHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
sess, err := NewSession(w, r)
if err != nil {
http.Error(w, err.Error(), 500)
2 years ago
log.Println(err)
return
}
defer func() {
if err := sess.Flush(); err != nil {
log.Println(err)
}
}()
if !sess.LoggedIn {
http.Redirect(w, r, "/", http.StatusFound)
return
}
err = r.ParseForm()
if err != nil {
http.Error(w, err.Error(), 500)
2 years ago
log.Println(err)
return
}
isJson := r.PostForm.Get("json") == "1"
page := r.PostForm.Get("p")
summary := r.PostForm.Get("summary")
pageData := Page{Content: r.PostForm.Get("content")}
err = mp.Save(page, pageData, summary, sess.Me)
if err != nil {
log.Println(err)
}
if isJson {
fmt.Print(w, "{}")
} else {
http.Redirect(w, r, "/"+page, http.StatusFound)
}
}
func (h *editHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
sess, err := NewSession(w, r)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
defer func() {
if err := sess.Flush(); err != nil {
log.Println(err)
}
}()
if !sess.LoggedIn {
http.Redirect(w, r, "/", http.StatusFound)
return
}
page := r.URL.Path[6:]
page = resolvePageName(page)
mpPage := mp.Get(page)
pageText := mpPage.Content
if pageText == "" {
pageText = "[]"
}
var rawMsg json.RawMessage
err = json.NewDecoder(strings.NewReader(pageText)).Decode(&rawMsg)
jsonEditor := pageText != "" && err == nil
var editor template.HTML
if jsonEditor {
2 years ago
editor, err = renderEditor(page, pageText, "json", *baseurl)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
} else {
editor = template.HTML(fmt.Sprintf(`
<textarea name="content" rows="24" style="width:100%%">%s</textarea>
<br>
<div class="field">
<label class="label">Summary</label>
<div class="control">
<input type="text" name="summary" class="input" placeholder="Summary"/>
</div>
</div>
<button class="button is-primary" type="submit">Save</button>
`, html.EscapeString(pageText)))
}
2 years ago
curDate, err := ParseDatePageName(page)
if err != nil {
curDate = time.Now()
}
pageBase := getPageBase(mp, curDate)
title := cleanTitle(mpPage.Title)
if newTitle, err := PageTitle(pageText); err == nil {
title = newTitle
}
var parent Parent
parent.ID = mpPage.Parent
parent.Text = mpPage.Blocks.Texts[parent.ID]
var parents []Parent
for _, p := range mpPage.Blocks.Parents {
var parent Parent
parent.ID = p
parent.Text = mpPage.Blocks.Texts[p]
parents = append(parents, parent)
}
for i, j := 0, len(parents)-1; i < j; i, j = i+1, j-1 {
parents[i], parents[j] = parents[j], parents[i]
}
htmlTitle := link.FormatHtmlTitle(title)
data := editPage{
pageBaseInfo: pageBase,
Session: sess,
Title: title,
TitleHTML: htmlTitle,
Content: pageText,
Editor: editor,
Name: page,
Backrefs: mpPage.Refs,
TodayPage: "Today",
ShowGraph: page != "Daily_Notes",
Parent: parent,
Parents: parents,
}
2 years ago
templates := baseTemplate
templates = append(templates, "templates/edit.html")
2 years ago
t, err := template.ParseFiles(templates...)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("Cache-Control", "public, max-age=600")
err = t.Execute(w, data)
if err != nil {
log.Println(err)
http.Error(w, err.Error(), 500)
return
}
}
func (h *graphHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
sess, err := NewSession(w, r)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
defer func() {
if err := sess.Flush(); err != nil {
log.Println(err)
}
}()
if !sess.LoggedIn {
http.Redirect(w, r, "/", http.StatusFound)
return
}
gb, err := NewGraphBuilder(mp)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
gb.prepareNodeMap()
gb.RemoveNode("DONE")
gb.RemoveNode("TODO")
gb.RemoveNode("Home")
gb.RemoveNode("Projects")
gb.RemoveNode("Notes")
gb.RemoveNode("Books")
gb.RemoveNode("Daily_Notes")
gb.RemoveNode("NewJsonTest")
gb.RemoveNodeWithSuffix("_2020")
err = gb.prepareGraph()
if err != nil {
http.Error(w, err.Error(), 500)
return
}
var nodesBuf bytes.Buffer
var edgesBuf bytes.Buffer
err = json.NewEncoder(&nodesBuf).Encode(&gb.nodes)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
err = json.NewEncoder(&edgesBuf).Encode(&gb.edges)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
pageBase := getPageBase(mp, time.Now())
data := graphPage{
pageBaseInfo: pageBase,
Session: sess,
Title: "Graph",
Name: "Graph",
Nodes: template.JS(nodesBuf.String()),
Edges: template.JS(edgesBuf.String()),
}
2 years ago
templates := baseTemplate
templates = append(templates, "templates/graph.html")
2 years ago
t, err := template.ParseFiles(templates...)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
err = t.Execute(w, data)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
}
func (h *indexHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
metaKV, err := regexp.Compile(`(\w+)::\s+(.*)`)
if err != nil {
log.Fatal(err)
}
sess, err := NewSession(w, r)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
defer func() {
if err := sess.Flush(); err != nil {
log.Println(err)
}
}()
if !sess.LoggedIn {
2 years ago
http.Redirect(w, r, "/auth/login", http.StatusFound)
return
}
format := r.URL.Query().Get("format")
if format == "" {
format = "html"
}
if !(format == "html" || format == "markdown" || format == "hmarkdown" || format == "json" || format == "metakv") {
http.Error(w, "unknown format", http.StatusBadRequest)
}
page := r.URL.Path[1:]
if page == "favicon.ico" {
http.Error(w, "Not Found", 404)
return
}
page = resolvePageName(page)
2 years ago
mpPage := mp.Get(page)
pageText := mpPage.Content
if (format == "" || format == "html") && pageText == "" {
http.Redirect(w, r, "/edit/"+page, 302)
return
}
if pageText == "" {
pageText = "[]"
}
var rawMsg json.RawMessage
err = json.NewDecoder(strings.NewReader(pageText)).Decode(&rawMsg)
title := cleanTitle(mpPage.Title)
jsonPage := pageText != "" && err == nil
if jsonPage {
if format == "json" {
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "no-store")
// Shortcut for json output
_, err := io.WriteString(w, pageText)
if err != nil {
http.Error(w, err.Error(), 500)
}
return
} else if format == "metakv" {
so, err := createStructuredFormat(mpPage)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "no-store")
enc := json.NewEncoder(w)
enc.SetIndent("", " ")
err = enc.Encode(so)
if err != nil {
http.Error(w, err.Error(), 500)
}
return
}
var listItems []struct {
Indented int
Text string
}
err = json.NewDecoder(strings.NewReader(pageText)).Decode(&listItems)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
builder := strings.Builder{}
if format == "markdown" || format == "html" {
for _, item := range listItems {
lines := strings.Split(item.Text, "\n")
if len(lines) > 1 {
first := true
for _, line := range lines {
if first {
builder.WriteString(strings.Repeat(" ", item.Indented))