gostart/handlers.go
2022-12-05 19:43:38 -07:00

389 lines
9.7 KiB
Go

package main
import (
"bytes"
"context"
"encoding/json"
"github.com/go-chi/chi/v5"
"github.com/go-chi/render"
"golang.org/x/image/font"
"golang.org/x/image/font/basicfont"
"golang.org/x/image/math/fixed"
"html/template"
"image"
"image/color"
"image/png"
"net/http"
"strconv"
"suah.dev/gostart/data"
"unicode"
)
// TODO: make this more generic.
type ctxKey string
func (c ctxKey) String() string {
return string(c)
}
const ownerKey = ctxKey("ownerid")
func OwnerCtx(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
owner, err := app.getOwner(r)
if err != nil {
http.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ownerID := int64(owner.ID)
ctx := context.WithValue(r.Context(), ownerKey, ownerID)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
func iconGET(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
linkID, err := strconv.Atoi(chi.URLParam(r, "linkID"))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
link, err := app.queries.GetLinkByID(ctx, int64(linkID))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
icon, err := app.queries.GetIconByLinkID(ctx, data.GetIconByLinkIDParams{
LinkID: int64(linkID),
OwnerID: ownerID,
})
if err != nil {
size := 24
img := image.NewRGBA(image.Rect(0, 0, size, size))
co := color.RGBA{0, 0, 0, 255}
point := fixed.Point26_6{
fixed.I(size/2 - basicfont.Face7x13.Width),
fixed.I(size / 2),
}
d := &font.Drawer{
Dst: img,
Src: image.NewUniform(co),
Face: basicfont.Face7x13,
Dot: point,
}
r := []rune(link.Name)
l := string(unicode.ToUpper(r[0]))
d.DrawString(l)
buf := new(bytes.Buffer)
if err := png.Encode(buf, img); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
} else {
icon.Data = buf.Bytes()
icon.ContentType = "image/png"
}
}
w.Header().Add("Content-type", icon.ContentType)
w.WriteHeader(200)
_, _ = w.Write(icon.Data)
}
func watchitemGET(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
watches, err := app.queries.GetAllWatchItemsByOwner(app.ctx, ownerID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
wJson, err := json.Marshal(watches)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Add("Content-type", "application/json")
w.WriteHeader(200)
_, err = w.Write(wJson)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
func watchitemDELETE(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
watchID, err := strconv.Atoi(chi.URLParam(r, "watchID"))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
err = app.queries.DeleteWatchItem(app.ctx, data.DeleteWatchItemParams{ID: int64(watchID), OwnerID: ownerID})
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
func watchitemPOST(w http.ResponseWriter, r *http.Request) {
d := &data.AddWatchItemParams{}
if err := render.Decode(r, d); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
d.OwnerID = ownerID
_, err := app.queries.AddWatchItem(app.ctx, *d)
if err != nil {
http.Error(w, err.Error(), http.StatusUnprocessableEntity)
return
}
}
func pullrequestsPOST(w http.ResponseWriter, r *http.Request) {
d := &data.AddPullRequestParams{}
if err := render.Decode(r, d); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
d.OwnerID = ownerID
_, err := app.queries.AddPullRequest(app.ctx, *d)
if err != nil {
http.Error(w, err.Error(), http.StatusUnprocessableEntity)
return
}
}
func pullrequestsDELETE(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
prID, err := strconv.Atoi(chi.URLParam(r, "prID"))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
err = app.queries.DeletePullRequest(app.ctx, data.DeletePullRequestParams{ID: int64(prID), OwnerID: ownerID})
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
func pullrequestsGET(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
prs, err := app.queries.GetAllPullRequests(app.ctx, ownerID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
prJson, err := json.Marshal(prs)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Add("Content-type", "application/json")
w.WriteHeader(200)
_, err = w.Write(prJson)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
func linksGET(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
links, err := app.queries.GetAllLinksForOwner(app.ctx, ownerID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
linksJson, err := json.Marshal(links)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Add("Content-type", "application/json")
w.WriteHeader(200)
_, err = w.Write(linksJson)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
func linksPOST(w http.ResponseWriter, r *http.Request) {
d := &data.AddLinkParams{}
if err := render.Decode(r, d); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
d.OwnerID = ownerID
_, err := app.queries.AddLink(app.ctx, *d)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
func prignorePOST(w http.ResponseWriter, r *http.Request) {
d := &data.AddPullRequestIgnoreParams{}
if err := render.Decode(r, d); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
d.OwnerID = ownerID
_, err := app.queries.AddPullRequestIgnore(app.ctx, *d)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
func linkDELETE(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
linkID, err := strconv.Atoi(chi.URLParam(r, "linkID"))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
err = app.queries.DeleteLink(app.ctx, data.DeleteLinkParams{ID: int64(linkID), OwnerID: ownerID})
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
var templateFuncs = template.FuncMap{
"includeWatch": func(repo string, number int, ignoreList []data.PullRequestIgnore) bool {
for _, pri := range ignoreList {
if pri.Repo == repo && pri.Number == int64(number) {
return false
}
}
return true
},
}
func index(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
owner, err := app.getOwner(r)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
ownerID, ok := ctx.Value(ownerKey).(int64)
if !ok {
http.Error(w, http.StatusText(http.StatusUnprocessableEntity), http.StatusUnprocessableEntity)
return
}
dbCtx := context.Background()
links, err := app.queries.GetAllLinksForOwner(dbCtx, ownerID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
prs, err := app.queries.GetAllPullRequests(dbCtx, ownerID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
ignores, err := app.queries.GetAllPullRequestIgnores(ctx, ownerID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
stuff := &Page{
Node: *owner,
Title: "StartPage",
Links: links,
PullRequests: prs,
Watches: app.watches.forID(ownerID),
CurrentLimits: app.watches.GetLimits(),
Ignores: ignores,
}
stuff.Sort()
tmpl := template.Must(
template.New("").Funcs(templateFuncs).ParseFS(templates, "templates/main.html"),
)
err = tmpl.ExecuteTemplate(w, "main.html", stuff)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}