dwelling-home/internal/http/handlers.go

package http

import (
	"math"
	"net/http"
	"strconv"
	"strings"
	"time"

	"git.arav.top/Arav/dwelling-home/pkg/mindflow"
	"git.arav.top/Arav/dwelling-home/pkg/servicestat"
	"git.arav.top/Arav/dwelling-home/pkg/util"
	"git.arav.top/Arav/dwelling-home/web"
	gbsqlite "git.arav.top/Arav/justguestbook/database/sqlite"
	"git.arav.top/Arav/justguestbook/guestbook"
)

type Handlers struct {
	guestbookDB       *gbsqlite.SQLiteDatabase
	captchaExpire     time.Duration
	guestbookOwner    string
	guestbookPageSize int64
}

func NewHandlers(captchaExpire time.Duration, dbPath, gbOwner string, gbPageSize int64) *Handlers {
	gbdb, err := gbsqlite.New(dbPath + "/guestbook.sqlite")
	if err != nil {
		panic(err)
	}

	return &Handlers{
		guestbookDB:       gbdb,
		captchaExpire:     captchaExpire,
		guestbookOwner:    gbOwner,
		guestbookPageSize: gbPageSize}
}

func (h *Handlers) CloseDB() {
	h.guestbookDB.Close()
}

func (h *Handlers) AssetsFS() http.FileSystem {
	return web.Assets()
}

func (h *Handlers) Index(w http.ResponseWriter, r *http.Request) {
	web.Index("", w)
}

func (h *Handlers) Stuff(w http.ResponseWriter, r *http.Request) {
	web.Stuff("/ Stuff", util.GetServiceByHost(r.Host, util.ServiceGit),
		util.GetServiceByHost(r.Host, util.ServiceFiles), w)
}

func (h *Handlers) Mindflow(w http.ResponseWriter, r *http.Request) {
	posts := []mindflow.Post{
		{Category: "Kek", Date: time.Now(), Title: "LMAO", Body: "Testing!"},
	}
	web.Mindflow("/ Mindflow", posts, r, w)
}

func (h *Handlers) About(w http.ResponseWriter, r *http.Request) {
	var lst servicestat.ServiceList = make(servicestat.ServiceList)
	reimu, err := servicestat.GatherStatus("http://reimu.arav.home.arpa:14882/processes")
	if err == nil {
		for k, v := range reimu {
			lst[k] = v
		}
	}
	sakuya, err := servicestat.GatherStatus("http://sakuya.arav.home.arpa:14882/processes")
	if err == nil {
		for k, v := range sakuya {
			lst[k] = v
		}
	}

	web.About("/ About", util.GetServiceByHost(r.Host, util.ServiceFiles), lst, w)
}

func (h *Handlers) Article(w http.ResponseWriter, r *http.Request) {
	name := r.URL.Path[strings.LastIndex(r.URL.Path, "/")+1:]
	artcl, err := web.GetArticle(name)
	if err != nil {
		http.Error(w, err.Error(), http.StatusNotFound)
		return
	}

	web.Article(artcl.Title, artcl.Description, string(artcl.Body), artcl.Date, r.Host, name, r, w)
}

func (h *Handlers) Guestbook(w http.ResponseWriter, r *http.Request) {
	var page int64
	var pageSize int64

	pageStr := r.URL.Query().Get("p")
	if pageStr != "" {
		page, _ = strconv.ParseInt(pageStr, 10, 64)
	} else {
		page = 1
	}

	pageSzStr := r.URL.Query().Get("ps")
	if pageSzStr != "" {
		pageSize, _ = strconv.ParseInt(pageSzStr, 10, 64)
	} else {
		pageSize = h.guestbookPageSize
	}

	entries, err := h.guestbookDB.Entries(page, pageSize)
	if err != nil {
		return
	}

	entriesCount, _ := h.guestbookDB.Count()
	pageCount := int64(math.Ceil(float64(entriesCount) / float64(h.guestbookPageSize)))

	web.Guestbook("/ Guestbook", h.guestbookOwner, "", pageCount, entries, r, w)
}

func (h *Handlers) GuestbookPost(w http.ResponseWriter, r *http.Request) {
	var entry *guestbook.Entry
	var err error

	if r.Header.Get("Content-Type") == "application/x-www-form-urlencoded" {
		r.ParseForm()

		if r.FormValue("name") == "" {
			r.Form.Set("name", "Anonymous")
		}

		entry, err = guestbook.NewEntry(r.FormValue("name"), r.FormValue("message"),
			r.FormValue("website"), r.FormValue("hide_website") != "")
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

	}

	if err = h.guestbookDB.NewEntry(entry); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, "/guestbook", http.StatusMovedPermanently)
}

func (h *Handlers) RSS(w http.ResponseWriter, r *http.Request) {
	posts := []mindflow.Post{
		{Category: "Kek", Date: time.Now(), Title: "LMAO", Body: "Testing!"},
	}
	web.RSS(r.URL.Scheme+"://"+r.Host, "Arav", posts, r, w)
}

func (h *Handlers) Robots(w http.ResponseWriter, r *http.Request) {
	data, _ := web.AssetsGetFile("robots.txt")
	w.Write(data)
}

func (h *Handlers) NotFound(w http.ResponseWriter, r *http.Request) {
	web.NotFound("Not Found", w)
}