librapi/templates/templates.go

package templates

import (
	"bytes"
	_ "embed"
	"fmt"
	"html/template"
	"mime/multipart"
	"net/http"
	"path/filepath"
	"strconv"
	"strings"

	"github.com/rs/zerolog/log"

	"librapi/handlers/download"
)

var (
	//go:embed base.html.tpl
	base string

	//go:embed login/login_form.html.tpl
	loginForm string

	//go:embed login/login_success.html.tpl
	loginSuccess string

	//go:embed upload_form.html.tpl
	uploadForm string

	//go:embed home.html.tpl
	home string

	//go:embed error.html.tpl
	errorBase string

	loginFormTmpl    = loadLoginFormTmpl()
	loginSuccessTmpl = loadLoginSuccessTmpl()
	errTmpl          = loadErrorTmpl()
	homeTmpl         = loadHomeTmpl()
	uploadFormTmpl   = loadUploadFormTmpl()
)

var funcMap = template.FuncMap{
	"year": func(s int) string {
		if s == 0 {
			return ""
		}
		return strconv.Itoa(s)
	},
	"join": func(s []string) string {
		if len(s) == 0 {
			return ""
		} else {
			return strings.Join(s, ", ")
		}
	},
	"filename": func(h *multipart.FileHeader) string {
		if h != nil {
			return h.Filename
		}
		return ""
	},
	"errStr": func(err error) string {
		if err != nil {
			return err.Error()
		}
		return ""
	},
	"resourceUrl": func(path string) string {
		_, filename := filepath.Split(path)
		return fmt.Sprintf("%s?file=%s", download.URL, filename)
	},
	"noDesc": func(desc *string) string {
		if desc == nil {
			return ""
		}
		return *desc
	},
}

func loadErrorTmpl() *template.Template {
	baseTmpl, err := template.New("base").Parse(base)
	if err != nil {
		log.Fatal().Err(err).Msg("unable to parse base tmpl")
	}

	if _, err := baseTmpl.New("error").Funcs(funcMap).Parse(errorBase); err != nil {
		log.Fatal().Err(err).Msg("unable to parse error base tmpl")
	}

	return baseTmpl
}

func loadLoginSuccessTmpl() *template.Template {
	baseTmpl, err := template.New("base").Parse(base)
	if err != nil {
		log.Fatal().Err(err).Msg("unable to parse base tmpl")
	}

	if _, err := baseTmpl.New("loginSuccess").Funcs(funcMap).Parse(loginSuccess); err != nil {
		log.Fatal().Err(err).Msg("unable to parse login success tmpl")
	}

	return baseTmpl
}

func loadLoginFormTmpl() *template.Template {
	baseTmpl, err := template.New("base").Parse(base)
	if err != nil {
		log.Fatal().Err(err).Msg("unable to parse base tmpl")
	}

	if _, err := baseTmpl.New("loginForm").Funcs(funcMap).Parse(loginForm); err != nil {
		log.Fatal().Err(err).Msg("unable to parse login form tmpl")
	}

	return baseTmpl
}

func loadHomeTmpl() *template.Template {
	baseTmpl, err := template.New("base").Parse(base)
	if err != nil {
		log.Fatal().Err(err).Msg("unable to parse base tmpl")
	}

	if _, err := baseTmpl.New("home").Funcs(funcMap).Parse(home); err != nil {
		log.Fatal().Err(err).Msg("unable to parse home tmpl")
	}

	return baseTmpl
}

func loadUploadFormTmpl() *template.Template {
	baseTmpl, err := template.New("base").Parse(base)
	if err != nil {
		log.Fatal().Err(err).Msg("unable to parse base tmpl")
	}

	if _, err := baseTmpl.New("uploadform").Funcs(funcMap).Parse(uploadForm); err != nil {
		log.Fatal().Err(err).Msg("unable to parse upload form tmpl")
	}

	return baseTmpl
}

func GetHome() *template.Template {
	return homeTmpl
}

func executeTmpl(tmpl *template.Template, form any, w http.ResponseWriter) (string, error) {
	buf := bytes.NewBufferString("")
	if err := tmpl.Execute(buf, form); err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprint(w, errTmpl)
		return "", err
	}
	return buf.String(), nil
}

func ExecuteLoginSuccessTmpl(w http.ResponseWriter) (string, error) {
	return executeTmpl(loginSuccessTmpl, nil, w)
}

func ExecuteLoginFormTmpl(form any, w http.ResponseWriter) (string, error) {
	return executeTmpl(loginFormTmpl, form, w)
}

func ExecuteHomeTmpl(form any, w http.ResponseWriter) (string, error) {
	return executeTmpl(homeTmpl, form, w)
}

func ExecuteUploadFormTmpl(form any, w http.ResponseWriter) (string, error) {
	return executeTmpl(uploadFormTmpl, form, w)
}