taler-merchant-demos

app.go (17963B)

---

 // Package web contains the HTTP applications for the Taler merchant demos.
 package web
 
 import (
 	"bytes"
 	"crypto/rand"
 	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"html"
 	"html/template"
 	"io/fs"
 	"log"
 	"net/http"
 	"net/url"
 	"path"
 	"regexp"
 	"sort"
 	"strconv"
 	"strings"
 
 	"git.taler.net/taler-merchant-demos/internal/backend"
 )
 
 const (
 	sessionCookieName  = "taler_demo_session"
 	orderCookieName    = "order_id"
 	articlePriceUnits  = "0.5"
 	subscriptionUnits  = "10"
 	subscriptionPrefix = "blog_abo_"
 )
 
 // PublicURLs contains the externally visible entry points linked by the demos.
 type PublicURLs struct {
 	Landing   string
 	Bank      string
 	Blog      string
 	Donations string
 }
 
 // Options configures one of the three demo HTTP applications.
 type Options struct {
 	Shop             string
 	Currency         string
 	PublicURLs       PublicURLs
 	BlogBackend      *backend.Client
 	DonationBackends map[string]*backend.Client
 	DonauURL         string
 	EnableTokens     bool
 }
 
 // App serves one configured demo.
 type App struct {
 	opts      Options
 	catalogs  catalogs
 	articles  articleLibrary
 	templates map[string]*template.Template
 	static    http.Handler
 	mux       *http.ServeMux
 	routes    *http.ServeMux
 }
 
 type language struct {
 	Code string
 	Name template.HTML
 }
 
 var languages = []language{
 	{"en", "English [en]"}, {"de", "Deutsch [de]"},
 	{"fr", "Français [fr]"}, {"it", "Italiano [it]"},
 	{"pt", "Português [pt]"}, {"es", "Español [es]"},
 	{"ru", "Русский [ru]"}, {"tr", "Türkçe [tr]"},
 	{"uk", "Українська [uk]"},
 }
 
 var supportedLocales = func() map[string]bool {
 	result := make(map[string]bool, len(languages))
 	for _, language := range languages {
 		result[language.Code] = true
 	}
 	return result
 }()
 
 var localePattern = regexp.MustCompile(`^[A-Za-z]{2,3}([_-][A-Za-z0-9]{2,8})*$`)
 
 // resolveLocale returns a supported locale or its closest supported parent.
 // Separators and case do not affect matching, but the returned spelling is
 // always the one used by the application.
 func resolveLocale(requested string, supported map[string]bool) string {
 	if !localePattern.MatchString(requested) {
 		return ""
 	}
 	normalize := func(value string) string {
 		return strings.ToLower(strings.ReplaceAll(value, "_", "-"))
 	}
 	for candidate := normalize(requested); candidate != ""; {
 		for locale, enabled := range supported {
 			if enabled && normalize(locale) == candidate {
 				return locale
 			}
 		}
 		index := strings.LastIndexByte(candidate, '-')
 		if index < 0 {
 			break
 		}
 		candidate = candidate[:index]
 	}
 	return ""
 }
 
 type links struct {
 	Landing   string
 	Bank      string
 	Blog      string
 	Donations string
 }
 
 type page struct {
 	Lang         string
 	Title        string
 	Active       string
 	HeaderTitle  string
 	HeaderURL    string
 	HeaderText   template.HTML
 	Styles       []string
 	Prefix       string
 	StaticPrefix string
 	Links        links
 	Languages    []language
 	LanguageName template.HTML
 	Content      any
 }
 
 type errorContent struct {
 	Message string
 	Details string
 	Status  int
 	JSON    string
 }
 
 // New loads embedded resources and constructs an application.
 func New(opts Options) (*App, error) {
 	if opts.Currency == "" {
 		return nil, errors.New("currency is required")
 	}
 	if opts.Shop != "landing" && opts.Shop != "blog" && opts.Shop != "donations" {
 		return nil, fmt.Errorf("unknown shop %q", opts.Shop)
 	}
 	if opts.Shop == "blog" && opts.BlogBackend == nil {
 		return nil, errors.New("blog backend is required")
 	}
 	if opts.Shop == "donations" {
 		for _, receiver := range []string{"gnunet", "taler", "tor"} {
 			if opts.DonationBackends[receiver] == nil {
 				return nil, fmt.Errorf("donation backend %q is required", receiver)
 			}
 		}
 	}
 	cats, err := loadCatalogs(supportedLocales)
 	if err != nil {
 		return nil, err
 	}
 	a := &App{
 		opts: opts, catalogs: cats, templates: make(map[string]*template.Template),
 		mux: http.NewServeMux(), routes: http.NewServeMux(),
 	}
 	if opts.Shop == "blog" {
 		a.articles, err = loadArticles()
 		if err != nil {
 			return nil, err
 		}
 	}
 	staticFS, err := fs.Sub(Assets, "assets/static")
 	if err != nil {
 		return nil, err
 	}
 	a.static = http.FileServer(http.FS(staticFS))
 	if err := a.loadTemplates(); err != nil {
 		return nil, err
 	}
 	a.registerRoutes()
 	return a, nil
 }
 
 func (a *App) loadTemplates() error {
 	base, err := Assets.ReadFile("templates/base.gohtml")
 	if err != nil {
 		return err
 	}
 	names := []string{"error", "landing", "donations-index", "donations-checkout", "donations-provider", "donations-fulfillment", "blog-index", "blog-article", "blog-confirm-refund", "blog-refunded"}
 	funcs := template.FuncMap{
 		"tr": func(lang, message string) string { return a.catalogs.translate(lang, message) },
 		"trHTML": func(lang, message string) template.HTML {
 			return template.HTML(a.catalogs.translate(lang, message))
 		},
 		"trf": func(lang, message string, values ...any) string {
 			return formatNamed(a.catalogs.translate(lang, message), values...)
 		},
 		"trfHTML": func(lang, message string, values ...any) template.HTML {
 			escaped := make([]any, len(values))
 			copy(escaped, values)
 			for i := 1; i < len(escaped); i += 2 {
 				escaped[i] = html.EscapeString(fmt.Sprint(escaped[i]))
 			}
 			return template.HTML(formatNamed(a.catalogs.translate(lang, message), escaped...))
 		},
 		"pathEscape": url.PathEscape,
 		"talerURL":   func(lang string) string { return "https://taler.net/" + url.PathEscape(lang) + "/" },
 		"localIndex": func(prefix, lang string) string { return prefix + "/" + url.PathEscape(lang) + "/" },
 	}
 	for _, name := range names {
 		body, err := Assets.ReadFile("templates/" + name + ".gohtml")
 		if err != nil {
 			return err
 		}
 		t, err := template.New("base.gohtml").Funcs(funcs).Parse(string(base) + "\n" + string(body))
 		if err != nil {
 			return fmt.Errorf("parse template %s: %w", name, err)
 		}
 		a.templates[name] = t
 	}
 	return nil
 }
 
 // ServeHTTP adds common recovery and response tracking around the standard
 // library request multiplexer.
 func (a *App) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	tracked := &trackingResponseWriter{ResponseWriter: w}
 	defer func() {
 		if recovered := recover(); recovered != nil {
 			log.Printf("request panic: %v", recovered)
 			if !tracked.wroteHeader {
 				a.renderError(tracked, r, http.StatusInternalServerError, requestLang(r), "Internal error", nil)
 			}
 		}
 	}()
 	a.mux.ServeHTTP(tracked, r)
 }
 
 func (a *App) registerRoutes() {
 	a.mux.HandleFunc("GET /{$}", a.redirectRoot)
 	a.mux.HandleFunc("/{$}", a.methodNotAllowed)
 	a.mux.HandleFunc("GET /static/", a.serveStatic)
 	a.mux.HandleFunc("/static/", a.methodNotAllowed)
 	a.mux.HandleFunc("GET /{lang}", a.redirectLanguage)
 	a.mux.HandleFunc("/{lang}", a.methodNotAllowed)
 
 	switch a.opts.Shop {
 	case "landing":
 		a.registerLandingRoutes()
 	case "donations":
 		a.registerDonationRoutes()
 	case "blog":
 		a.registerBlogRoutes()
 	}
 	a.routes.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		a.renderError(w, r, http.StatusNotFound, requestLang(r), "Page not found", nil)
 	})
 	a.mux.HandleFunc("/{lang}/{path...}", func(w http.ResponseWriter, r *http.Request) {
 		if a.redirectLocale(w, r) {
 			return
 		}
 		a.routes.ServeHTTP(w, r)
 	})
 	a.mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		a.renderError(w, r, http.StatusNotFound, requestLang(r), "Page not found", nil)
 	})
 }
 
 func (a *App) handleGet(pattern string, handler http.HandlerFunc) {
 	a.routes.HandleFunc("GET "+pattern, handler)
 	a.routes.HandleFunc(pattern, a.methodNotAllowed)
 }
 
 func (a *App) handlePost(pattern string, handler http.HandlerFunc) {
 	a.routes.HandleFunc("POST "+pattern, handler)
 	a.routes.HandleFunc(pattern, a.methodNotAllowed)
 }
 
 func (a *App) methodNotAllowed(w http.ResponseWriter, r *http.Request) {
 	a.renderError(w, r, http.StatusMethodNotAllowed, requestLang(r), "HTTP method not allowed for this page", nil)
 }
 
 func (a *App) serveStatic(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Cache-Control", "public, max-age=3600")
 	http.StripPrefix("/static/", a.static).ServeHTTP(w, r)
 }
 
 func (a *App) redirectLanguage(w http.ResponseWriter, r *http.Request) {
 	if a.redirectLocale(w, r) {
 		return
 	}
 	target := forwardedPrefix(r) + "/" + url.PathEscape(r.PathValue("lang")) + "/"
 	if r.URL.RawQuery != "" {
 		target += "?" + r.URL.RawQuery
 	}
 	http.Redirect(w, r, target, http.StatusPermanentRedirect)
 }
 
 // redirectLocale handles language aliases before any page or payment handler
 // runs. It reports whether it has already answered the request.
 func (a *App) redirectLocale(w http.ResponseWriter, r *http.Request) bool {
 	requested := r.PathValue("lang")
 	if validLocale(requested) {
 		return false
 	}
 	if !localePattern.MatchString(requested) {
 		a.renderError(w, r, http.StatusNotFound, "en", "Page not found", nil)
 		return true
 	}
 	lang := resolveLocale(requested, supportedLocales)
 	if lang == "" {
 		lang = "en"
 	}
 	// Split the escaped path to retain encoded separators in article/file IDs.
 	_, rest, _ := strings.Cut(strings.TrimPrefix(r.URL.EscapedPath(), "/"), "/")
 	target := forwardedPrefix(r) + "/" + url.PathEscape(lang) + "/" + rest
 	if r.URL.RawQuery != "" {
 		target += "?" + r.URL.RawQuery
 	}
 	http.Redirect(w, r, target, http.StatusTemporaryRedirect)
 	return true
 }
 
 type trackingResponseWriter struct {
 	http.ResponseWriter
 	wroteHeader bool
 }
 
 func (w *trackingResponseWriter) WriteHeader(status int) {
 	if !w.wroteHeader {
 		w.wroteHeader = true
 		w.ResponseWriter.WriteHeader(status)
 	}
 }
 
 func (w *trackingResponseWriter) Write(data []byte) (int, error) {
 	if !w.wroteHeader {
 		w.WriteHeader(http.StatusOK)
 	}
 	return w.ResponseWriter.Write(data)
 }
 
 func requestLang(r *http.Request) string {
 	if lang := r.PathValue("lang"); validLocale(lang) {
 		return lang
 	}
 	first, _, _ := strings.Cut(strings.TrimPrefix(r.URL.Path, "/"), "/")
 	if validLocale(first) {
 		return first
 	}
 	return "en"
 }
 
 func validLocale(lang string) bool {
 	return supportedLocales[lang]
 }
 
 func (a *App) redirectRoot(w http.ResponseWriter, r *http.Request) {
 	lang := a.bestLanguage(r.Header.Get("Accept-Language"))
 	http.Redirect(w, r, forwardedPrefix(r)+"/"+lang+"/", http.StatusFound)
 }
 
 func (a *App) bestLanguage(header string) string {
 	type preference struct {
 		lang  string
 		q     float64
 		order int
 	}
 	var preferences []preference
 	for order, weighted := range strings.Split(header, ",") {
 		parts := strings.Split(weighted, ";")
 		candidate := strings.TrimSpace(parts[0])
 		candidate = strings.ReplaceAll(candidate, "-", "_")
 		quality := 1.0
 		for _, parameter := range parts[1:] {
 			key, value, ok := strings.Cut(strings.TrimSpace(parameter), "=")
 			if ok && strings.EqualFold(key, "q") {
 				if parsed, err := strconv.ParseFloat(value, 64); err == nil {
 					quality = parsed
 				}
 			}
 		}
 		if candidate == "" || candidate == "*" || quality <= 0 {
 			continue
 		}
 		preferences = append(preferences, preference{candidate, quality, order})
 	}
 	sort.SliceStable(preferences, func(i, j int) bool {
 		if preferences[i].q == preferences[j].q {
 			return preferences[i].order < preferences[j].order
 		}
 		return preferences[i].q > preferences[j].q
 	})
 	for _, preferred := range preferences {
 		if lang := resolveLocale(preferred.lang, supportedLocales); lang != "" {
 			return lang
 		}
 	}
 	return "en"
 }
 
 func (a *App) makePage(r *http.Request, lang, title string, content any) page {
 	prefix := forwardedPrefix(r)
 	p := page{
 		Lang: lang, Title: a.catalogs.translate(lang, title), Active: a.opts.Shop,
 		Prefix: prefix, StaticPrefix: prefix + "/static/", Languages: languages,
 		LanguageName: template.HTML("en"), Content: content,
 		Links: links{
 			Landing:   appLanguageURL(a.opts.PublicURLs.Landing, lang),
 			Bank:      appLanguageURL(a.opts.PublicURLs.Bank, lang),
 			Blog:      appLanguageURL(a.opts.PublicURLs.Blog, lang),
 			Donations: appLanguageURL(a.opts.PublicURLs.Donations, lang),
 		},
 	}
 	for _, language := range languages {
 		if language.Code == lang {
 			p.LanguageName = language.Name
 			break
 		}
 	}
 	switch a.opts.Shop {
 	case "landing":
 		p.HeaderTitle = a.catalogs.translate(lang, "Introduction")
 		p.HeaderURL = configuredURL(a.opts.PublicURLs.Landing)
 		p.HeaderText = a.translatedHTML(lang, "Try GNU Taler with a toy currency.")
 	case "donations":
 		p.HeaderTitle = a.catalogs.translate(lang, "Donations")
 		p.HeaderURL = configuredURL(a.opts.PublicURLs.Donations)
 		p.HeaderText = a.translatedHTML(lang, "Support Free Software projects with a toy currency.")
 		p.Styles = []string{"colors-donations.css"}
 	case "blog":
 		p.HeaderTitle = a.catalogs.translate(lang, "Essay Shop")
 		p.HeaderURL = configuredURL(a.opts.PublicURLs.Blog)
 		p.HeaderText = a.translatedHTML(lang, "Buy chapters from <cite>Free Software, Free Society</cite> with a toy currency.")
 		p.Styles = []string{"blog.css", "colors-blog.css"}
 	}
 	return p
 }
 
 func (a *App) translatedHTML(lang, message string) template.HTML {
 	return template.HTML(a.catalogs.translate(lang, message))
 }
 
 func (a *App) translatedHTMLf(lang, message string, values ...any) template.HTML {
 	escaped := make([]any, len(values))
 	copy(escaped, values)
 	for i := 1; i < len(escaped); i += 2 {
 		escaped[i] = html.EscapeString(fmt.Sprint(escaped[i]))
 	}
 	return template.HTML(formatNamed(a.catalogs.translate(lang, message), escaped...))
 }
 
 func (a *App) render(w http.ResponseWriter, name string, p page, status int) {
 	var output bytes.Buffer
 	if err := a.templates[name].ExecuteTemplate(&output, "base", p); err != nil {
 		log.Printf("render %s: %v", name, err)
 		http.Error(w, a.catalogs.translate(p.Lang, "Internal server error"), http.StatusInternalServerError)
 		return
 	}
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 	w.Header().Set("Cache-Control", "private, no-store")
 	w.Header().Set("Content-Security-Policy", "default-src 'self'; img-src 'self' https://taler.net; style-src 'self' 'unsafe-inline'; script-src 'unsafe-inline'; base-uri 'none'; frame-ancestors 'none'")
 	w.Header().Set("X-Content-Type-Options", "nosniff")
 	w.WriteHeader(status)
 	_, _ = w.Write(output.Bytes())
 }
 
 func (a *App) renderError(w http.ResponseWriter, r *http.Request, status int, lang, message string, err error) {
 	a.renderErrorf(w, r, status, lang, message, err)
 }
 
 func (a *App) renderErrorf(w http.ResponseWriter, r *http.Request, status int, lang, message string, err error, values ...any) {
 	content := errorContent{Message: formatNamed(a.catalogs.translate(lang, message), values...)}
 	var be *backend.Error
 	if errors.As(err, &be) {
 		content.Status = be.Status
 		if be.Body != nil {
 			encoded, _ := json.MarshalIndent(be.Body, "", "  ")
 			content.JSON = string(encoded)
 		}
 	}
 	if err != nil {
 		content.Details = err.Error()
 		log.Printf("%s: %v", message, err)
 	}
 	a.render(w, "error", a.makePage(r, lang, "GNU Taler Demo: Error", content), status)
 }
 
 func configuredURL(value string) string {
 	if value = strings.TrimSpace(value); value != "" {
 		return value
 	}
 	return "#"
 }
 
 func appLanguageURL(base, lang string) string {
 	base = configuredURL(base)
 	if base == "#" {
 		return "#"
 	}
 	target, err := url.Parse(base)
 	if err != nil {
 		return "#"
 	}
 	return target.JoinPath(url.PathEscape(lang) + "/").String()
 }
 
 func forwardedPrefix(r *http.Request) string {
 	value := strings.TrimSpace(strings.SplitN(r.Header.Get("X-Forwarded-Prefix"), ",", 2)[0])
 	if value == "" || !strings.HasPrefix(value, "/") || strings.HasPrefix(value, "//") {
 		return ""
 	}
 	raw := strings.TrimRight(value, "/")
 	value = path.Clean(value)
 	if value == "/" || value != raw {
 		return ""
 	}
 	return strings.TrimRight(value, "/")
 }
 
 func externalURL(r *http.Request) string {
 	scheme := "http"
 	if r.TLS != nil {
 		scheme = "https"
 	}
 	if forwarded := strings.TrimSpace(strings.SplitN(r.Header.Get("X-Forwarded-Proto"), ",", 2)[0]); forwarded == "http" || forwarded == "https" {
 		scheme = forwarded
 	}
 	host := r.Host
 	if forwarded := strings.TrimSpace(strings.SplitN(r.Header.Get("X-Forwarded-Host"), ",", 2)[0]); forwarded != "" {
 		host = forwarded
 	}
 	return (&url.URL{Scheme: scheme, Host: host, Path: forwardedPrefix(r) + r.URL.Path}).String()
 }
 
 func externalOrigin(r *http.Request) string {
 	parsed, _ := url.Parse(externalURL(r))
 	return parsed.Scheme + "://" + parsed.Host
 }
 
 func externalURLWithQuery(r *http.Request) string {
 	result := externalURL(r)
 	if r.URL.RawQuery != "" {
 		result += "?" + r.URL.RawQuery
 	}
 	return result
 }
 
 func newSessionID() (string, error) {
 	var raw [16]byte
 	if _, err := rand.Read(raw[:]); err != nil {
 		return "", err
 	}
 	return hex.EncodeToString(raw[:]), nil
 }
 
 func cookieSecure(r *http.Request) bool {
 	return r.TLS != nil || strings.EqualFold(strings.TrimSpace(strings.SplitN(r.Header.Get("X-Forwarded-Proto"), ",", 2)[0]), "https")
 }
 
 func setSessionCookie(w http.ResponseWriter, r *http.Request, sessionID string) {
 	http.SetCookie(w, &http.Cookie{Name: sessionCookieName, Value: sessionID, Path: forwardedPrefix(r) + "/", HttpOnly: true, Secure: cookieSecure(r), SameSite: http.SameSiteLaxMode, MaxAge: 86400})
 }
 
 func sessionID(r *http.Request) string {
 	cookie, err := r.Cookie(sessionCookieName)
 	if err != nil {
 		return ""
 	}
 	return cookie.Value
 }
 
 func setOrderCookie(w http.ResponseWriter, r *http.Request, lang, article, orderID string) {
 	http.SetCookie(w, &http.Cookie{Name: orderCookieName, Value: orderID, Path: forwardedPrefix(r) + "/" + url.PathEscape(lang) + "/essay/" + url.PathEscape(article), HttpOnly: true, Secure: cookieSecure(r), SameSite: http.SameSiteLaxMode, MaxAge: 86400})
 }
 
 func orderID(r *http.Request) string {
 	cookie, err := r.Cookie(orderCookieName)
 	if err != nil {
 		return ""
 	}
 	return cookie.Value
 }
 
 func queryRedirect(r *http.Request, mutate func(url.Values)) string {
 	target := *r.URL
 	query := target.Query()
 	mutate(query)
 	target.RawQuery = query.Encode()
 	return forwardedPrefix(r) + target.RequestURI()
 }