gonotes/internal/notes/views/views.go

package views

import (
	"log"
	"net/http"
	"strconv"

	urls "forgejo.gwairfelin.com/max/gispatcho"
	"forgejo.gwairfelin.com/max/gonotes/internal/middleware"
	"forgejo.gwairfelin.com/max/gonotes/internal/notes"
	"forgejo.gwairfelin.com/max/gonotes/internal/templ"
)

var myurls urls.URLs

func addRequestContext(r *http.Request, ctx templ.Ctx) templ.Ctx {
	return ctx
}

func GetRoutes(prefix string) *http.ServeMux {
	myurls = urls.URLs{
		Prefix: prefix,
		URLs: map[string]urls.URL{
			"list":      {Path: "/", Protocol: "GET", Handler: list},
			"new":       {Path: "/new", Protocol: "GET", Handler: new},
			"view_":     {Path: "/{note}", Protocol: "GET", Handler: view},
			"view":      {Path: "/{note}/", Protocol: "GET", Handler: view},
			"delete":    {Path: "/{note}/delete/", Protocol: "GET", Handler: delete},
			"edit":      {Path: "/{note}/edit/", Protocol: "GET", Handler: edit},
			"save":      {Path: "/{note}/edit/save/", Protocol: "POST", Handler: save},
			"togglebox": {Path: "/{note}/togglebox/", Protocol: "POST", Handler: togglebox},
		},
	}
	return myurls.GetRouter()
}

func view(w http.ResponseWriter, r *http.Request) {
	// user := r.Context().Value(middleware.ContextKey("user")).(string)

	title := r.PathValue("note")
	note, err := notes.LoadNote(title)
	urlEdit := myurls.Reverse("edit", urls.Repl{"note": title})
	urlNew := myurls.Reverse("new", urls.Repl{})
	urlDelete := myurls.Reverse("delete", urls.Repl{"note": title})
	if err != nil {
		http.Redirect(w, r, urlEdit, http.StatusFound)
		return
	}

	context := templ.Ctx{"note": note, "urlEdit": urlEdit, "urlDelete": urlDelete, "urlNew": urlNew}
	note.Render()
	err = templ.RenderTemplate(w, r, "view.tmpl.html", context)
	if err != nil {
		log.Print(err.Error())
		http.Error(w, "Couldn't load template", http.StatusInternalServerError)
		return
	}
}

func edit(w http.ResponseWriter, r *http.Request) {
	// user := r.Context().Value(middleware.ContextKey("user")).(string)

	encodedTitle := r.PathValue("note")
	note, err := notes.LoadNote(encodedTitle)
	if err != nil {
		title := notes.DecodeTitle(encodedTitle)
		note = &notes.Note{Title: title}
	}

	urlSave := myurls.Reverse("save", urls.Repl{"note": encodedTitle})
	context := templ.Ctx{"note": note, "urlSave": urlSave, "text": string(note.Body)}
	err = templ.RenderTemplate(w, r, "edit.tmpl.html", context)
	if err != nil {
		log.Print(err.Error())
		http.Error(w, "Couldn't load template", http.StatusInternalServerError)
		return
	}
}

func new(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value(middleware.ContextKey("user")).(string)

	title := r.FormValue("title")
	if len(title) == 0 {
		title = "<New Note>"
	}

	note := &notes.Note{Title: title, Owner: user}
	note.Save()
	notes.Notes.Add(note)

	urlEdit := myurls.Reverse("edit", urls.Repl{"note": note.EncodedTitle()})
	http.Redirect(w, r, urlEdit, http.StatusFound)
}

func delete(w http.ResponseWriter, r *http.Request) {
	// user := r.Context().Value(middleware.ContextKey("user")).(string)

	encodedTitle := r.PathValue("note")
	err := notes.DeleteNote(encodedTitle)
	if err != nil {
		log.Print(err.Error())
		http.Error(w, "Couldn't delete note", http.StatusInternalServerError)
		return
	}

	urlList := myurls.Reverse("list", urls.Repl{})
	http.Redirect(w, r, urlList, http.StatusFound)
}

func save(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value(middleware.ContextKey("user")).(string)
	oldTitle := r.PathValue("note")
	note, ok := notes.Notes.GetOne(user, oldTitle)

	if !ok {
		http.NotFound(w, r)
	}

	title := r.FormValue("title")
	body := r.FormValue("body")

	log.Printf("About to save to note %+v", note)
	note.Title = title
	note.Body = []byte(body)
	note.Save()

	if oldTitle != note.EncodedTitle() {
		notes.DeleteNote(oldTitle)
	}

	http.Redirect(w, r, myurls.Reverse("view", urls.Repl{"note": note.EncodedTitle()}), http.StatusFound)
}

func togglebox(w http.ResponseWriter, r *http.Request) {
	// user := r.Context().Value(middleware.ContextKey("user")).(string)

	title := r.PathValue("note")
	nthBox, err := strconv.Atoi(r.FormValue("box"))
	if err != nil {
		log.Fatal("You fucked up boy")
		return
	}

	note, err := notes.LoadNote(title)
	if err != nil {
		http.Redirect(w, r, myurls.Reverse("view", urls.Repl{"note": title}), http.StatusFound)
		return
	}

	note.ToggleBox(nthBox)

	http.Redirect(w, r, myurls.Reverse("view", urls.Repl{"note": note.EncodedTitle()}), http.StatusFound)
}

type titleAndURL struct {
	Title string
	URL   string
}

func list(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value(middleware.ContextKey("user")).(string)

	titlesAndUrls := make([]titleAndURL, 0)

	ns := notes.Notes.Get(user)
	log.Printf("Notes: %+v", notes.Notes)
	log.Printf("Notes for %s: %+v", user, ns)

	for _, note := range ns {
		titlesAndUrls = append(
			titlesAndUrls,
			titleAndURL{Title: note.Title, URL: myurls.Reverse("view", urls.Repl{"note": note.EncodedTitle()})},
		)
	}

	urlNew := myurls.Reverse("new", urls.Repl{})

	err := templ.RenderTemplate(w, r, "list.tmpl.html", templ.Ctx{"notes": titlesAndUrls, "urlNew": urlNew})
	if err != nil {
		log.Print(err.Error())
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}
}