web.go

// Copyright 2024 bbaa
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//	http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package pastebin

import (
	"html/template"
	"io"
	"io/fs"
	"net/http"
	"slices"
	"strings"
	"time"

	"git.bbaa.fun/bbaa/go-pastebin/controllers"
	database "git.bbaa.fun/bbaa/go-pastebin/database"
	"github.com/fatih/color"
	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
	"golang.org/x/net/http2"
)

var e *echo.Echo

func httpServe() {
	e = echo.New()
	e.Use(middleware.LoggerWithConfig(middleware.LoggerConfig{
		Format: "[" + color.CyanString("Echo") + "] ${time_rfc3339} ${status} ${method} ${path} (${remote_ip}) ${latency_human}\n",
		Output: e.Logger.Output(),
	}))
	e.Use(middleware.Recover())
	e.Use(controllers.UserMiddleware)
	//e.Use(staticRender)

	e.GET("/api/paste/:uuid", controllers.PasteAccess)
	e.GET("/api/paste/check_shorturl/:id", controllers.CheckURL)
	e.GET("/api/paste/pastes", controllers.PasteList)
	e.GET("/api/paste/total_size", controllers.GetTotalPasteSize)
	e.GET("/api/user", controllers.GetUser)
	e.POST("/api/user/login", controllers.UserLogin)
	e.GET("/api/user/logout", controllers.UserLogout)
	e.POST("/api/user/add", controllers.AddUser)
	e.POST("/api/user/edit", controllers.EditUserProfile)
	e.GET("/api/user/pastes", controllers.UserPasteList)
	e.GET("/api/user/size", controllers.GetUserPasteSize)
	e.POST("/api/user/webauthn/register/request", controllers.UserWebAuthnRegisterRequest)
	e.POST("/api/user/webauthn/register", controllers.UserWebAuthnRegister)
	e.POST("/api/user/webauthn/login/request", controllers.UserWebAuthnLoginRequest)
	e.POST("/api/user/webauthn/login", controllers.UserWebAuthnLogin)
	e.GET("/api/user/webauthn/passkey/login/request", controllers.UserWebAuthnDiscoverableLoginRequest)
	e.POST("/api/user/webauthn/passkey/login", controllers.UserWebAuthnDiscoverableLogin)
	e.GET("/api/user/webauthn/list", controllers.UserWebAuthnList)
	e.POST("/api/user/webauthn/delete", controllers.UserWebAuthnDelete)
	e.POST("/", controllers.NewPaste)
	e.PUT("/:uuid", controllers.UpdatePaste)
	e.DELETE("/:uuid", controllers.DeletePaste)
	e.HEAD("/:id", controllers.GetPaste)

	initTemplate()
	setupIndex()
	setupLegacy()
	setupAdmin()
	setupSw()
	setupStatic()

	s := &http2.Server{
		MaxConcurrentStreams: 250,
		MaxReadFrameSize:     1048576,
		IdleTimeout:          10 * time.Second,
	}
	e.Logger.Fatal(e.StartH2CServer(":8080", s))
	//e.Logger.Fatal(e.StartTLS(":443", "./data/certificate.crt", "./data/private.key"))
}

type TemplateRender struct {
	templates *template.Template
}

func (t *TemplateRender) Render(w io.Writer, name string, data interface{}, c echo.Context) error {
	return t.templates.ExecuteTemplate(w, name, data)
}

var templateFuncs = template.FuncMap{
	"unescape": func(s string) template.HTML {
		return template.HTML(s)
	},
}

func initTemplate() {
	if database.Config.Mode == "debug" {
		e.Renderer = &DebugRender{}
	} else {
		e.Renderer = &TemplateRender{
			templates: template.Must(template.New("").Funcs(templateFuncs).ParseFS(embed_assets, "assets/*.html", "assets/manifest.json")),
		}
	}
}

type DebugRender struct{}

func (d *DebugRender) Render(w io.Writer, name string, data interface{}, c echo.Context) error {
	var tmpl *template.Template
	var err error
	tmpl, err = template.New("").Funcs(templateFuncs).ParseFiles("assets/" + name)
	if err != nil {
		return err
	}
	return tmpl.ExecuteTemplate(w, name, data)
}

func setupAdmin() {
	e.GET("/admin/", func(c echo.Context) error {
		user, ok := c.Get("user").(*database.User)
		if !ok || user.Role != "admin" {
			c.Redirect(http.StatusFound, "/")
			return nil
		}
		color_scheme := "light"
		if user_color_scheme, err := c.Cookie("color_scheme"); err == nil {
			color_scheme = user_color_scheme.Value
		}
		err := c.Render(200, "admin.html", map[string]any{
			"SiteName":    database.Config.SiteName,
			"SiteTitle":   database.Config.SiteTitle,
			"ColorScheme": color_scheme,
		})
		if err != nil {
			log.Error(err)
		}
		return err
	})
	e.GET("/admin", func(c echo.Context) error {
		return c.Redirect(http.StatusFound, "/admin/")
	})
	e.GET("/admin.html", func(c echo.Context) error {
		return c.Redirect(http.StatusFound, "/admin/")
	})
}

func setupLegacy() {
	e.GET("/legacy", controllers.LegacyIndex)
	e.POST("/legacy", controllers.LegacyMethod)
}

func setupIndex() {
	e.GET("/", func(c echo.Context) error {
		is_login := false
		if user, ok := c.Get("user").(*database.User); ok {
			is_login = user != nil
		}
		color_scheme := database.Config.DefaultColorScheme
		if user_color_scheme, err := c.Cookie("color_scheme"); err == nil && user_color_scheme.Value != "" {
			color_scheme = user_color_scheme.Value
		} else {
			c.SetCookie(&http.Cookie{
				Name:     "color_scheme",
				Value:    color_scheme,
				Path:     "/",
				HttpOnly: false,
			})
		}
		err := c.Render(200, "index.html", map[string]any{
			"SiteName":       database.Config.SiteName,
			"SiteTitle":      database.Config.SiteTitle,
			"ColorScheme":    color_scheme,
			"AllowAnonymous": database.Config.AllowAnonymous,
			"IsLogin":        is_login,
		})
		if err != nil {
			log.Error(err)
		}
		return err
	})
	e.GET("/manifest.json", func(c echo.Context) error {
		c.Response().Header().Set("Content-Type", "application/json; charset=utf-8")
		return c.Render(200, "manifest.json", map[string]any{
			"SiteTitle": database.Config.SiteTitle,
		})
	})
	e.GET("/index.html", func(c echo.Context) error {
		return c.Redirect(http.StatusFound, "/")
	})
}

type WarpPaste struct {
	echo.Context
	id      string
	variant string
}

func (c *WarpPaste) Param(name string) string {
	if name == "id" {
		return c.id
	}
	if name == "variant" {
		return c.variant
	}
	return ""
}

var variantList = []string{"raw", "download"}

func setupStatic() {
	var assets fs.FS
	if database.Config.Mode == "debug" {
		assets = echo.MustSubFS(e.Filesystem, "assets")
	} else {
		assets = echo.MustSubFS(embed_assets, "assets")
	}
	static_hanlder := echo.StaticDirectoryHandler(assets, false)
	e.GET("/*", func(c echo.Context) error {
		p := c.Param("*")
		if hash, ok := embedInfo.fileHash[p]; ok {
			c.Response().Header().Set("ETag", hash)
			c.Response().Header().Set("X-Revision", hash)
		}
		err := static_hanlder(c)
		if err == nil {
			return nil
		}
		id := ""
		variant := ""
		param_frag := strings.Split(p, "/")
		if len(param_frag) == 2 {
			variant = param_frag[1]
			if !slices.Contains(variantList, variant) {
				return c.NoContent(404)
			}
		}
		if len(param_frag) <= 2 {
			id = param_frag[0]
		} else {
			return c.NoContent(404)
		}
		return controllers.GetPaste(&WarpPaste{c, id, variant})
	})
}