wiki/main.go

package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"html"
	"html/template"
	"log"
	"net/http"
	"net/url"
	"regexp"
	"strings"
	"time"

	"gitlab.com/golang-commonmark/markdown"
	"p83.nl/go/ekster/pkg/util"
	"p83.nl/go/indieauth"
)

func init() {
	log.SetFlags(log.Lshortfile)
}

var (
	mp PagesRepository
)

const (
	ClientID    = "https://wiki.p83.nl/"
	RedirectURI = "https://wiki.p83.nl/auth/callback"
)

type Backref struct {
	Name  string
	Title string
}

// Page
type Page struct {
	// Name is the filename of the page
	Name string

	// Title is the human-readable title of the page
	Title string

	Content string

	Refs []Backref
}

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)
}

type indexPage struct {
	Session  *Session
	Title    string
	Name     string
	Content  template.HTML
	Backrefs []Backref
}

type editPage struct {
	Session  *Session
	Title    string
	Content  string
	Name     string
	Editor   template.HTML
	Backrefs []Backref
}

type historyPage struct {
	Session *Session
	Title   string
	Name    string
	History []Revision
}

type recentPage struct {
	Session *Session
	Title   string
	Name    string
	Recent  []Change
}

type indexHandler struct{}
type saveHandler struct{}
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" {
			t, err := template.ParseFiles("templates/layout.html", "templates/login.html")
			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" {
			log.Printf("%+v\n", sess)
			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(ClientID, 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" {
			t, err := template.ParseFiles("templates/layout.html", "templates/logout.html")
			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, ClientID, 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:]
	if page == "" {
		page = "Home"
	}

	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
	}

	err = t.Execute(w, historyPage{
		Session: sess,
		Title:   "History of " + cleanTitle(page),
		Name:    page,
		History: history,
	})
	if err != nil {
		http.Error(w, err.Error(), 500)
		return
	}
}

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)
		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)
		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:]
	if page == "" {
		page = "Home"
	}

	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 {
		editor, err = renderEditor(page, pageText, "json")
		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)))
	}

	data := editPage{
		Session:  sess,
		Title:    cleanTitle(page),
		Content:  pageText,
		Editor:   editor,
		Name:     page,
		Backrefs: mpPage.Refs,
	}

	t, err := template.ParseFiles("templates/layout.html", "templates/edit.html")
	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()

	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)
		}
	}()

	page := r.URL.Path[1:]
	if page == "" {
		page = "Home"
	}

	mpPage := mp.Get(page)
	pageText := mpPage.Content
	if pageText == "" {
		http.Redirect(w, r, "/edit/"+page, 302)
		return
	}

	if pageText == "" {
		pageText = "[]"
	}

	var rawMsg json.RawMessage
	err = json.NewDecoder(strings.NewReader(pageText)).Decode(&rawMsg)

	jsonPage := pageText != "" && err == nil
	if jsonPage {
		var listItems []struct {
			Id       int
			Indented int
			Text     string
		}

		err = json.NewDecoder(strings.NewReader(pageText)).Decode(&listItems)
		if err != nil {
			http.Error(w, err.Error(), 500)
			return
		}

		pageText = ""
		for _, item := range listItems {
			pageText += strings.Repeat("  ", item.Indented) + "* " + item.Text + "\n"
		}
	}

	hrefRE, err := regexp.Compile(`#?\[\[\s*([^\]]+)\s*\]\]`)
	if err != nil {
		log.Fatal(err)
	}

	pageText = hrefRE.ReplaceAllStringFunc(pageText, func(s string) string {
		tag := false
		if s[0] == '#' {
			s = strings.TrimPrefix(s, "#[[")
			tag = true
		} else {
			s = strings.TrimPrefix(s, "[[")
		}
		s = strings.TrimSuffix(s, "]]")
		s = strings.TrimSpace(s)
		if tag {
			return fmt.Sprintf(`<a href=%q class="tag">%s</a>`, cleanNameURL(s), s)
		}
		return fmt.Sprintf("[%s](/%s)", s, cleanNameURL(s))
	})

	md := markdown.New(
		markdown.HTML(true),
		markdown.XHTMLOutput(true),
	)
	pageText = md.RenderToString([]byte(pageText))

	data := indexPage{
		Session:  sess,
		Title:    cleanTitle(page),
		Content:  template.HTML(pageText),
		Name:     page,
		Backrefs: mpPage.Refs,
	}

	t, err := template.ParseFiles("templates/layout.html", "templates/view.html")
	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 *recentHandler) 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()

	changes, err := mp.RecentChanges()
	if err != nil {
		http.Error(w, err.Error(), 500)
		return
	}

	// group recentchanges on Page
	if len(changes) > 0 {
		f := groupRecentChanges(changes)
		changes = changes[f:]
	}

	for i, c := range changes {
		if c.Count <= 1 {
			changes[i].DateSummary = c.Date.Format("Mon, 2 Jan 2006")
			changes[i].TimeSummary = c.Date.Format("15:04")
		} else {
			changes[i].DateSummary = c.Date.Format("Mon, 2 Jan 2006")
			changes[i].TimeSummary = fmt.Sprintf("%s - %s", c.Date.Format("15:04"), c.EndDate.Format("15:04"))
		}
	}

	t, err := template.New("layout.html").ParseFiles("templates/layout.html", "templates/recent.html")
	if err != nil {
		http.Error(w, err.Error(), 500)
		return
	}

	err = t.Execute(w, recentPage{
		Session: sess,
		Title:   "Recent changes",
		Name:    "Recent changes",
		Recent:  changes,
	})
	if err != nil {
		http.Error(w, err.Error(), 500)
		return
	}
}

type LinkResponseMetaImage struct {
	Url string `json:"url"`
}

type LinkResponseMeta struct {
	Title       string                `json:"title"`
	Description string                `json:"description"`
	Image       LinkResponseMetaImage `json:"image"`
}

type LinkResponse struct {
	Success int              `json:"success"`
	Link    string           `json:"link"`
	Meta    LinkResponseMeta `json:"meta"`
}

func main() {
	var port int
	flag.IntVar(&port, "port", 8080, "http port")
	flag.Parse()

	mp = NewFilePages("data")

	http.Handle("/auth/", &authHandler{})
	http.HandleFunc("/fetchLink", func(w http.ResponseWriter, r *http.Request) {
		link := r.URL.Query().Get("url")
		u, err := url.Parse(link)
		if err != nil {
			http.Error(w, err.Error(), 400)
			return
		}
		var response LinkResponse
		response.Success = 1
		response.Link = u.String()
		response.Meta.Title = "Test"
		json.NewEncoder(w).Encode(response)
	})
	http.Handle("/public/", http.StripPrefix("/public/", http.FileServer(http.Dir("./dist"))))
	http.Handle("/save/", &saveHandler{})
	http.Handle("/edit/", &editHandler{})
	http.Handle("/history/", &historyHandler{})
	http.Handle("/recent/", &recentHandler{})
	http.Handle("/", &indexHandler{})

	fmt.Printf("Running on port %d\n", port)
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), nil))
}