cabinet/web/entry.go

package web

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"time"

	"github.com/rs/zerolog/log"

	"code.chrissexton.org/cws/cabinet/entry"
	"github.com/gorilla/mux"
)

func (web *Web) editEntry(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	slug := vars["slug"]
	dec := json.NewDecoder(r.Body)
	req := struct {
		Content string
	}{}
	err := dec.Decode(&req)
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}
	newEntry := entry.NewFromMd(web.db, req.Content)

	oldEntry, err := entry.GetBySlug(web.db, slug)
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}

	oldEntry.Content = newEntry.Content
	oldEntry.Title = newEntry.Title
	oldEntry.Slug = newEntry.UniqueSlug()
	oldEntry.Tags = newEntry.Tags
	oldEntry.Updated = time.Now()

	err = oldEntry.Update()
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}
	resp, err := json.Marshal(oldEntry)
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}

	w.Header().Set("content-type", "application/json")
	fmt.Fprint(w, string(resp))
}

func (web *Web) newMarkdownEntry(w http.ResponseWriter, r *http.Request) {
	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}
	newEntry := entry.NewFromMd(web.db, string(body))
	err = newEntry.Create()
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}

	resp, err := json.Marshal(newEntry)
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}
	w.Header().Set("content-type", "application/json")
	fmt.Fprint(w, string(resp))
}

func (web *Web) newEntry(w http.ResponseWriter, r *http.Request) {
	dec := json.NewDecoder(r.Body)
	newEntry := entry.New(web.db)
	err := dec.Decode(&newEntry)
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}

	err = newEntry.Create()
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}
	resp, err := json.Marshal(newEntry)
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}
	w.Header().Set("content-type", "application/json")
	fmt.Fprint(w, string(resp))
}

func (web *Web) allEntries(w http.ResponseWriter, r *http.Request) {
	query := ""
	tags := []string{}
	if !web.AuthCheck(r) {
		tags = append(tags, "public")
	}
	items, ok := r.URL.Query()["query"]
	if ok {
		query = items[0]
	}
	entries, err := entry.SearchByTag(web.db, query, tags)
	if err != nil {
		log.Error().Msgf("Error querying: %w", err)
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}

	resp, err := json.Marshal(entries)
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}
	w.Header().Set("content-type", "application/json")
	fmt.Fprint(w, string(resp))
}

func (web *Web) getEntry(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	slug := vars["slug"]

	entry, err := entry.GetBySlug(web.db, slug)
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}

	if !web.AuthCheck(r) && !entry.HasTag("public") {
		w.WriteHeader(401)
		fmt.Fprint(w, "not allowed")
		return
	}

	resp, err := json.Marshal(entry)
	if err != nil {
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}
	w.Header().Set("content-type", "application/json")
	fmt.Fprint(w, string(resp))
}

func (web *Web) removeEntry(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	slug := vars["slug"]

	err := entry.RemoveBySlug(web.db, slug)
	if err != nil {
		log.Error().Msgf("Error deleting: %s", err)
		w.WriteHeader(500)
		fmt.Fprint(w, err)
		return
	}
	w.WriteHeader(200)
}