no submod

2023-04-17 11:20:05 -06:00
parent 026e7718ed
commit 8970da11e5
60 changed files with 4326 additions and 1 deletions
--- a/work/notea/server/server.go
+++ b/work/notea/server/server.go
@@ -0,0 +1,582 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"html/template"
+	"io"
+	"io/ioutil"
+	"local/gziphttp"
+	"local/router"
+	"local/simpleserve/simpleserve"
+	"log"
+	"net/http"
+	"os"
+	"path"
+	"regexp"
+	"strings"
+
+	"github.com/gomarkdown/markdown"
+	"github.com/gomarkdown/markdown/html"
+	"github.com/gomarkdown/markdown/parser"
+
+	"github.com/google/uuid"
+)
+
+type Server struct {
+	router *router.Router
+	root   string
+	auth   auth
+	user   *User
+}
+
+func NewServer(root string, auth auth) *Server {
+	return &Server{
+		root: root,
+		auth: auth,
+	}
+}
+
+func (server *Server) WithUser(user, group string, groups []string) *Server {
+	s2 := *server
+	s2.user = &User{
+		User:   user,
+		Group:  group,
+		Groups: groups,
+	}
+	return &s2
+}
+
+func (server *Server) Routes() error {
+	server.router = router.New()
+	wildcard := func(s string) string {
+		return strings.TrimSuffix(s, "/") + "/" + router.Wildcard
+	}
+	wildcards := func(s string) string {
+		return wildcard(s) + router.Wildcard
+	}
+	_ = wildcards
+	for path, handler := range map[string]func(http.ResponseWriter, *http.Request) error{
+		"/":                        server.rootHandler,
+		"/api/v0/tree":             server.apiV0TreeHandler,
+		"/api/v0/media":            server.apiV0MediaHandler,
+		wildcard("/api/v0/media"):  server.apiV0MediaIDHandler,
+		wildcards("/api/v0/files"): server.apiV0FilesHandler,
+		"/api/v0/search":           server.apiV0SearchHandler,
+		"/ui":                      server.rootHandler,
+		"/ui/search":               server.uiSearchHandler,
+		wildcards("/ui/files"):     server.uiFilesHandler,
+	} {
+		if err := server.router.Add(path, server.tryCatchHttpHandler(handler)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (server *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if server.auth != nil {
+		s2, done, err := server.authenticate(w, r)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if done {
+			return
+		}
+		if s2 != nil {
+			server = s2
+		}
+	}
+	if err := server.Routes(); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+	server.router.ServeHTTP(w, r)
+}
+
+func (server *Server) tryCatchHttpHandler(handler func(http.ResponseWriter, *http.Request) error) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if gziphttp.Can(r) {
+			w2 := gziphttp.New(w)
+			defer w2.Close()
+			w = w2
+		}
+		if err := handler(w, r); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			log.Printf("failed handling %s: %v", r.URL.String(), err)
+		}
+	}
+}
+
+func (server *Server) apiV0TreeHandler(w http.ResponseWriter, r *http.Request) error {
+	tree := server.tree()
+	branches, err := tree.GetRootMeta()
+	if err != nil {
+		return err
+	}
+	return json.NewEncoder(w).Encode(branches)
+}
+
+func ensureAndWrite(p string, b []byte) error {
+	if err := os.MkdirAll(path.Dir(p), os.ModePerm); err != nil {
+		return err
+	}
+	return ioutil.WriteFile(p, b, os.ModePerm)
+}
+
+func (server *Server) apiV0MediaHandler(w http.ResponseWriter, r *http.Request) error {
+	id := uuid.New().String()
+	filePath, err := server.postContentHandler(server.diskMediaPath(id), w, r)
+	if err != nil {
+		return err
+	}
+	return json.NewEncoder(w).Encode(map[string]map[string]string{
+		"data": map[string]string{
+			"filePath": path.Join("/api/v0/media", path.Base(filePath)),
+		},
+	})
+}
+
+func (server *Server) apiV0MediaIDHandler(w http.ResponseWriter, r *http.Request) error {
+	switch r.Method {
+	case http.MethodGet:
+		return server.apiV0MediaIDGetHandler(w, r)
+	case http.MethodPut:
+		return server.apiV0MediaIDPutHandler(w, r)
+	case http.MethodDelete:
+		return server.apiV0MediaIDDelHandler(w, r)
+	}
+	http.NotFound(w, r)
+	return nil
+}
+
+func (server *Server) apiV0MediaIDPutHandler(w http.ResponseWriter, r *http.Request) error {
+	panic("not impl")
+}
+
+func (server *Server) apiV0MediaIDDelHandler(w http.ResponseWriter, r *http.Request) error {
+	id := path.Base(r.URL.Path)
+	os.Remove(server.diskMediaPath(id))
+	return nil
+}
+
+func (server *Server) apiV0MediaIDGetHandler(w http.ResponseWriter, r *http.Request) error {
+	id := path.Base(r.URL.Path)
+	return server.getContentHandler(server.diskMediaPath(id), w, r)
+}
+
+func (server *Server) getContentHandler(filePath string, w http.ResponseWriter, r *http.Request) error {
+	if r.Method != http.MethodGet {
+		return errors.New("not found")
+	}
+	f, err := os.Open(filePath)
+	if os.IsNotExist(err) {
+		http.NotFound(w, r)
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	simpleserve.SetContentTypeIfMedia(w, r)
+	io.Copy(w, f)
+	return nil
+}
+
+func (server *Server) postContentHandler(filePath string, w http.ResponseWriter, r *http.Request) (string, error) {
+	if r.Method != http.MethodPost {
+		return "", errors.New("not found")
+	}
+	if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data") {
+		kb := int64(1 << 10)
+		mb := kb << 10
+		if err := r.ParseMultipartForm(10 * mb); err != nil {
+			return "", err
+		}
+		if len(r.MultipartForm.File) != 1 {
+			return "", errors.New("not exactly 1 file found in request")
+		}
+		for _, infos := range r.MultipartForm.File {
+			if len(infos) != 1 {
+				return "", errors.New("not exactly 1 file info found in request")
+			}
+			ext := path.Ext(infos[0].Filename)
+			if h, ok := infos[0].Header["Content-Type"]; ok {
+				ext = path.Base(h[0])
+			}
+			filePath += "." + ext
+			f, err := infos[0].Open()
+			if err != nil {
+				return "", err
+			}
+			defer f.Close()
+			r.Body = f
+		}
+	} else if strings.HasPrefix(r.Header.Get("Content-Type"), "application/x-www-form-urlencoded") {
+		if err := r.ParseForm(); err != nil {
+			return "", err
+		}
+		return "", fmt.Errorf("parse form: %+v", r.PostForm)
+	}
+	return filePath, server.putContentHandler(filePath, w, r)
+}
+
+func (server *Server) putContentHandler(filePath string, w http.ResponseWriter, r *http.Request) error {
+	defer r.Body.Close()
+	b, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return err
+	}
+	return ensureAndWrite(filePath, b)
+}
+
+func (server *Server) uiSearchHandler(w http.ResponseWriter, r *http.Request) error {
+	t, err := server.uiSubTemplates()
+	if err != nil {
+		return err
+	}
+	t, err = t.ParseFiles(path.Join(server.root, "ui", "search.ctmpl"))
+	if err != nil {
+		return err
+	}
+	idsTitles, err := server._apiV0SearchHandler(r.URL.Query().Get("q"))
+	if err != nil {
+		return err
+	}
+	data := make([]struct {
+		Title string
+		ID    ID
+	}, len(idsTitles))
+	for i := range idsTitles {
+		data[i].ID = NewID(idsTitles[i][0])
+		data[i].Title = idsTitles[i][1]
+	}
+	tree := server.tree()
+	branches, err := tree.GetRootMeta()
+	if err != nil {
+		return err
+	}
+	branchesJSON, err := json.Marshal(branches)
+	if err != nil {
+		return err
+	}
+	return t.Lookup("search").Execute(w, map[string]interface{}{
+		"Results":    data,
+		"Tree":       string(branchesJSON),
+		"Namespaces": server.getUser().Groups,
+		"Namespace":  server.getUser().Group,
+	})
+}
+
+func (server *Server) getUser() User {
+	if server.user != nil {
+		return *server.user
+	}
+	return User{}
+}
+
+func (server *Server) uiFilesHandler(w http.ResponseWriter, r *http.Request) error {
+	id := NewID(strings.TrimPrefix(r.URL.Path, "/ui/files"))
+	t, err := server.uiSubTemplates()
+	if err != nil {
+		return err
+	}
+	t, err = t.ParseFiles(path.Join(server.root, "ui", "files.ctmpl"))
+	if err != nil {
+		return err
+	}
+	tree := server.tree()
+	branches, err := tree.GetRootMeta()
+	if err != nil {
+		return err
+	}
+	branchesJSON, err := json.Marshal(branches)
+	if err != nil {
+		return err
+	}
+	var parent Leaf
+	var leaf Leaf
+	if id != "" {
+		if id.Pop() != "" {
+			parent, err = tree.Get(id.Pop())
+			if err != nil {
+				return fmt.Errorf("failed to get pid %q: %v", id.Pop(), err)
+			}
+		}
+		leaf, err = tree.Get(id)
+		if err != nil {
+			leaf.Meta.Title = "My New File"
+		}
+	}
+	if leaf.Meta.ReadOnly {
+		if _, ok := r.URL.Query()["edit"]; !ok {
+			leaf.Content = Gomarkdown([]byte(leaf.Content))
+		} else {
+			leaf.Meta.ReadOnly = false
+		}
+	}
+	data := map[string]interface{}{
+		"This": map[string]interface{}{
+			"Title":    leaf.Meta.Title,
+			"ReadOnly": leaf.Meta.ReadOnly,
+			"Content":  leaf.Content,
+			"ID":       id.String(),
+			"PID":      id.Pop().String(),
+			"PTitle":   parent.Meta.Title,
+		},
+		"Tree":       string(branchesJSON),
+		"Namespaces": server.getUser().Groups,
+		"Namespace":  server.getUser().Group,
+	}
+	return t.Lookup("files").Execute(w, data)
+}
+
+func (server *Server) uiSubTemplates() (*template.Template, error) {
+	templateFiles := []string{}
+	var loadTemplateFilesFromDir func(string) error
+	loadTemplateFilesFromDir = func(root string) error {
+		entries, err := os.ReadDir(root)
+		if err != nil {
+			return err
+		}
+		for _, entry := range entries {
+			entryPath := path.Join(root, entry.Name())
+			if entry.IsDir() {
+				if err := loadTemplateFilesFromDir(entryPath); err != nil {
+					return err
+				}
+			} else if !strings.HasPrefix(path.Base(entryPath), "_") {
+			} else if strings.HasSuffix(entryPath, ".ctmpl") {
+				templateFiles = append(templateFiles, entryPath)
+			}
+		}
+		return nil
+	}
+	if err := loadTemplateFilesFromDir(path.Join(server.root, "ui")); err != nil {
+		return nil, err
+	}
+	return template.ParseFiles(templateFiles...)
+}
+
+func (server *Server) rootHandler(w http.ResponseWriter, r *http.Request) error {
+	http.Redirect(w, r, "/ui/files", 302)
+	return nil
+}
+
+func (server *Server) tree() Tree {
+	return NewTree(path.Join(server.root, "files", server.getUser().Group))
+}
+
+func (server *Server) diskMediaPath(id string) string {
+	return path.Join(server.root, "media", id)
+}
+
+func (server *Server) apiV0FilesHandler(w http.ResponseWriter, r *http.Request) error {
+	switch r.Method {
+	case http.MethodPost:
+		return server.apiV0FilesPostHandler(w, r)
+	case http.MethodGet:
+		return server.apiV0FilesIDGetHandler(w, r)
+	case http.MethodPut:
+		return server.apiV0FilesIDPutHandler(w, r)
+	case http.MethodDelete:
+		return server.apiV0FilesIDDelHandler(w, r)
+	}
+	http.NotFound(w, r)
+	return nil
+}
+
+func (server *Server) apiV0FilesPostHandler(w http.ResponseWriter, r *http.Request) error {
+	f, err := ioutil.TempFile(os.TempDir(), "filesPost*")
+	if err != nil {
+		return err
+	}
+	f.Close()
+	defer os.Remove(f.Name())
+
+	filePath, err := server.postContentHandler(f.Name(), w, r)
+	if err != nil {
+		return err
+	}
+	defer os.Remove(filePath)
+
+	b, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return err
+	}
+	r.Body = io.NopCloser(bytes.NewReader(b))
+
+	pid := server.fileId(r)
+	id := NewID(pid).Push(strings.Split(uuid.New().String(), "-")[0])
+	leaf, err := NewHTTPRequestLeaf(r)
+	if err != nil {
+		return err
+	}
+	if err := server.tree().Put(id, leaf); err != nil {
+		return err
+	}
+	return json.NewEncoder(w).Encode(map[string]map[string]string{
+		"data": map[string]string{
+			"filePath": path.Join("/api/v0/files/", id.URLSafeString()),
+		},
+	})
+}
+
+func (server *Server) apiV0FilesIDGetHandler(w http.ResponseWriter, r *http.Request) error {
+	id := NewID(server.fileId(r))
+	if id.String() == "" {
+		return fmt.Errorf("no id found: %+v", id)
+	}
+
+	leaf, err := server.tree().Get(id)
+	if os.IsNotExist(err) {
+		http.NotFound(w, r)
+		return nil
+	} else if err != nil {
+		return err
+	}
+
+	return leaf.WriteHTTP(w)
+}
+
+func (server *Server) apiV0FilesIDDelHandler(w http.ResponseWriter, r *http.Request) error {
+	id := NewID(server.fileId(r))
+	if id.String() == "" {
+		return fmt.Errorf("no id found: %+v", id)
+	}
+
+	leaf, err := server.tree().Get(id)
+	if os.IsNotExist(err) {
+		return nil
+	} else if err != nil {
+		return err
+	}
+	leaf.Meta.Deleted = true
+
+	return server.tree().Put(id, leaf)
+}
+
+func (server *Server) fileId(r *http.Request) string {
+	return strings.Trim(
+		strings.TrimPrefix(
+			strings.Trim(r.URL.Path, "/"),
+			"api/v0/files",
+		),
+		"/",
+	)
+}
+
+func (server *Server) apiV0FilesIDPutHandler(w http.ResponseWriter, r *http.Request) error {
+	id := NewID(server.fileId(r))
+	if id.String() == "" {
+		return fmt.Errorf("no id found: %+v", id)
+	}
+
+	leaf, err := server.tree().Get(id)
+	if os.IsNotExist(err) {
+	} else if err != nil {
+		return err
+	}
+
+	updatedLeaf, err := NewHTTPRequestLeaf(r)
+	if err != nil {
+		return err
+	}
+	leaf = leaf.Merge(updatedLeaf)
+
+	if err := server.tree().Put(id, leaf); err != nil {
+		return err
+	}
+	return json.NewEncoder(w).Encode(map[string]map[string]string{
+		"data": map[string]string{
+			"filePath": path.Join("/api/v0/files/", id.URLSafeString()),
+		},
+	})
+}
+
+func (server *Server) apiV0SearchHandler(w http.ResponseWriter, r *http.Request) error {
+	query := r.URL.Query().Get("q")
+	idsTitles, err := server._apiV0SearchHandler(query)
+	if err != nil {
+		return err
+	}
+	result := make([]string, len(idsTitles))
+	for i := range idsTitles {
+		result[i] = idsTitles[i][0]
+	}
+	return json.NewEncoder(w).Encode(result)
+}
+
+func (server *Server) _apiV0SearchHandler(query string) ([][2]string, error) {
+	queries := strings.Split(query, " ")
+	if len(queries) == 0 {
+		return [][2]string{}, nil
+	}
+	patterns := []*regexp.Regexp{}
+	unsafepattern := regexp.MustCompile(`[^a-zA-Z0-9]`)
+	for _, query := range queries {
+		if len(query) > 0 {
+			query = unsafepattern.ReplaceAllString(query, ".")
+			patterns = append(patterns, regexp.MustCompile("(?i)"+query))
+		}
+	}
+	if len(patterns) == 0 {
+		return [][2]string{}, nil
+	}
+	tree, err := server.tree().GetRoot()
+	if err != nil {
+		return nil, err
+	}
+	result := [][2]string{}
+	if err := tree.ForEach(func(id ID, leaf Leaf) error {
+		for _, pattern := range patterns {
+			if !pattern.MatchString(leaf.Content) && !pattern.MatchString(leaf.Meta.Title) {
+				return nil
+			}
+		}
+		title := leaf.Meta.Title
+		pid := id.Pop()
+		for pid != "" {
+			parent, err := server.tree().Get(pid)
+			if err != nil {
+				return err
+			}
+			title = path.Join(parent.Meta.Title, title)
+			pid = pid.Pop()
+		}
+		result = append(result, [2]string{id.URLSafeString(), title})
+		return nil
+	}); err != nil {
+		return nil, fmt.Errorf("failed for each: %v", err)
+	}
+	return result, nil
+}
+
+func Gomarkdown(b []byte) string {
+	renderer := html.NewRenderer(html.RendererOptions{
+		Flags: html.CommonFlags | html.TOC,
+	})
+	ext := parser.NoExtensions
+	for _, extension := range []parser.Extensions{
+		parser.NoIntraEmphasis,
+		parser.Tables,
+		parser.FencedCode,
+		parser.Autolink,
+		parser.Strikethrough,
+		parser.SpaceHeadings,
+		parser.HeadingIDs,
+		parser.BackslashLineBreak,
+		parser.DefinitionLists,
+		parser.MathJax,
+		parser.Titleblock,
+		parser.AutoHeadingIDs,
+		parser.Includes,
+	} {
+		ext |= extension
+	}
+	parser := parser.NewWithExtensions(ext)
+	content := markdown.ToHTML(b, parser, renderer)
+	return string(content) + "\n"
+}