go__sqs_demo/back/web/routes.go

package web

import (
	_ "embed"
	"fmt"
	"html/template"
	"net/http"
	"path/filepath"

	"github.com/fgm/izidic"
	"github.com/gin-contrib/sessions"
	"github.com/gin-contrib/sessions/cookie"
	"github.com/gin-gonic/gin"

	"code.osinet.fr/fgm/sqs_demo/back/services"
	"code.osinet.fr/fgm/sqs_demo/back/services/redriver"
	"code.osinet.fr/fgm/sqs_demo/front"
)

func SetupRoutes(rd redriver.Redriver, renderer *template.Template, secret []byte) *gin.Engine {
	const assetsPrefix = "/assets/"
	r := gin.Default()
	r.SetHTMLTemplate(renderer)
	r.SetTrustedProxies(nil)
	store := cookie.NewStore(secret)
	r.Use(sessions.Sessions("defaultsession", store))

	r.GET("/", makeHomeHandler(rd))
	r.StaticFS(assetsPrefix, PrefixFileSystem(assetsPrefix, http.FS(front.Assets)))
	r.GET("/queue", gin.WrapH(http.RedirectHandler("/", http.StatusMovedPermanently)))
	r.GET("/queue/:name", makeQueueHandler(rd))
	r.GET("/queue/:name/delete", makeDeleteHandler(rd))
	r.POST("/queue/:name/delete", makeDeleteConfirmHandler(rd))
	r.GET("/queue/:name/purge", makePurgeHandler(rd))
	r.POST("/queue/:name/purge", makePurgeConfirmHandler(rd))
	r.POST("/queue/:name/redrive", makeRedriveHandler(rd))
	return r
}

func HttpService(dic *izidic.Container) (any, error) {
	secret := dic.MustParam(services.PSecret).([]byte)
	rd := dic.MustService(services.SvcRedriver).(redriver.Redriver)
	re := dic.MustService(services.SvcRenderer).(*template.Template)
	return SetupRoutes(rd, re, secret), nil
}

func RendererService(dic *izidic.Container) (any, error) {
	var err error
	renderer := template.New("redriver")
	for _, tpl := range []struct {
		name  string
		value string
	}{
		{"confirm", front.Confirm},
		{"flashes", front.Flashes},
		{"queue-get", front.QueueGet},
	} {
		renderer, err = renderer.New(tpl.name).Parse(tpl.value)
		if err != nil {
			return nil, fmt.Errorf("failed parsing %q template: %w", tpl.name, err)
		}
	}
	return renderer, nil
}

// PrefixFileSystem converts a http.FileSystem by serving it requests prefixed
// by the passed prefix, allowing rooted static directories matching the name
// of an embed.FS.
func PrefixFileSystem(prefix string, ifs http.FileSystem) http.FileSystem {
	return &prefixedFS{
		prefix: prefix,
		ifs:    ifs,
	}
}

type prefixedFS struct {
	prefix string
	ifs    http.FileSystem
}

// Open implements http.FileSystem
func (pfs *prefixedFS) Open(name string) (http.File, error) {
	return pfs.ifs.Open(filepath.Join(pfs.prefix, name))
}