Pretty HTML emails! Amazing!

Author: bvisness

src/admintools/admintools.go

@@ -300,6 +300,13 @@ func init() {
 				err = email.SendRegistrationEmail(toAddress, toName, "test_user", "test_token", "", p)
 			case "passwordreset":
 				err = email.SendPasswordReset(toAddress, toName, "test_user", "test_token", time.Now().Add(time.Hour*24), p)
+			case "ticketpurchased":
+				err = email.SendTicketPurchaseEmail(toAddress, toName, &models.Ticket{
+					ID:         uuid.New(),
+					EventSlug:  hmndata.HMNExpo2026.Slug,
+					OwnerName:  "Test User",
+					OwnerEmail: "test@example.org",
+				})
 			default:
 				fmt.Printf("You must provide a valid email type\n\n")
 				cmd.Usage()

src/email/email.go

@@ -11,7 +11,9 @@ import (
 	"time"
 
 	"git.handmade.network/hmn/hmn/src/config"
+	"git.handmade.network/hmn/hmn/src/hmndata"
 	"git.handmade.network/hmn/hmn/src/hmnurl"
+	"git.handmade.network/hmn/hmn/src/models"
 	"git.handmade.network/hmn/hmn/src/oops"
 	"git.handmade.network/hmn/hmn/src/perf"
 	"git.handmade.network/hmn/hmn/src/templates"
@@ -165,36 +167,72 @@ func SendTimeMachineEmail(profileUrl, username, userEmail, discordUsername strin
 	return nil
 }
 
+func SendTicketPurchaseEmail(toAddress string, toName string, ticket *models.Ticket) error {
+	event, ok := hmndata.FindTicketEventBySlug(ticket.EventSlug)
+	if !ok {
+		return oops.New(nil, "failed to find event for ticket in email")
+	}
+
+	type TicketPurchaseEmailData struct {
+		EventName string
+		Name      string
+		Email     string
+		CodeURL   string
+		TicketURL string
+	}
+	contents, err := renderTemplate("email_ticket_purchase.html", TicketPurchaseEmailData{
+		EventName: event.Name,
+		Name:      ticket.OwnerName,
+		Email:     ticket.OwnerEmail,
+		CodeURL:   hmnurl.BuildTicketQRCode(ticket.ID.String()),
+		TicketURL: hmnurl.BuildTicketSingle(ticket.ID.String()),
+	})
+	if err != nil {
+		return err
+	}
+
+	err = sendMail(toAddress, toName, fmt.Sprintf("Your ticket for the %s", event.Name), contents)
+	if err != nil {
+		return oops.New(err, "Failed to send email")
+	}
+
+	return nil
+}
+
 var EmailRegex = regexp.MustCompile(`^[^:\p{Cc} ]+@[^:\p{Cc} ]+\.[^:\p{Cc} ]+$`)
 
 func IsEmail(address string) bool {
 	return EmailRegex.Match([]byte(address))
 }
 
-func renderTemplate(name string, data any) (string, error) {
+func renderTemplate(name string, data any) ([]byte, error) {
 	var buffer bytes.Buffer
 	template, hasTemplate := templates.GetTemplate(name)
 	if !hasTemplate {
-		return "", oops.New(nil, "template not found: %s", name)
+		return nil, oops.New(nil, "template not found: %s", name)
 	}
 	err := template.Execute(&buffer, data)
 	if err != nil {
-		return "", oops.New(err, "Failed to render template for email")
+		return nil, oops.New(err, "Failed to render template for email")
 	}
-	contentString := string(buffer.Bytes())
-	contentString = strings.ReplaceAll(contentString, "\n", "\r\n")
+	contentString := buffer.Bytes()
+	contentString = bytes.ReplaceAll(contentString, []byte("\n"), []byte("\r\n"))
 	return contentString, nil
 }
 
-func sendMail(toAddress, toName, subject, contentHtml string) error {
+func sendMail(toAddress, toName, subject string, contentHTML []byte) error {
 	if config.Config.Email.ForceToAddress != "" {
 		toAddress = config.Config.Email.ForceToAddress
 	}
+	processedHTML, err := preprocessEmailHTML(contentHTML)
+	if err != nil {
+		return err
+	}
 	contents := prepMailContents(
 		makeHeaderAddress(toAddress, toName),
 		makeHeaderAddress(config.Config.Email.FromAddress, config.Config.Email.FromName),
 		subject,
-		contentHtml,
+		processedHTML,
 	)
 	return smtp.SendMail(
 		fmt.Sprintf("%s:%d", config.Config.Email.ServerAddress, config.Config.Email.ServerPort),
@@ -218,18 +256,18 @@ func makeHeaderAddress(email, fullname string) string {
 	}
 }
 
-func prepMailContents(toLine string, fromLine string, subject string, contentHtml string) []byte {
+func prepMailContents(toLine string, fromLine string, subject string, contentHtml []byte) []byte {
 	var builder strings.Builder
 
-	builder.WriteString(fmt.Sprintf("To: %s\r\n", toLine))
-	builder.WriteString(fmt.Sprintf("From: %s\r\n", fromLine))
-	builder.WriteString(fmt.Sprintf("Date: %s\r\n", time.Now().UTC().Format(time.RFC1123Z)))
-	builder.WriteString(fmt.Sprintf("Subject: %s\r\n", mime.QEncoding.Encode("utf-8", subject)))
+	fmt.Fprintf(&builder, "To: %s\r\n", toLine)
+	fmt.Fprintf(&builder, "From: %s\r\n", fromLine)
+	fmt.Fprintf(&builder, "Date: %s\r\n", time.Now().UTC().Format(time.RFC1123Z))
+	fmt.Fprintf(&builder, "Subject: %s\r\n", mime.QEncoding.Encode("utf-8", subject))
 	builder.WriteString("Content-Type: text/html; charset=UTF-8\r\n")
 	builder.WriteString("Content-Transfer-Encoding: quoted-printable\r\n")
 	builder.WriteString("\r\n")
 	writer := quotedprintable.NewWriter(&builder)
-	writer.Write([]byte(contentHtml))
+	writer.Write(contentHtml)
 	writer.Close()
 	builder.WriteString("\r\n")
 

src/email/preprocessor.go

@@ -0,0 +1,153 @@
+package email
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+func preprocessEmailHTML(html []byte) ([]byte, error) {
+	var errs []error
+
+	rules := make(cssRules)
+	remaining := html
+	out := make([]byte, 0, len(html))
+nextTag:
+	for {
+		locs := reOpeningTag.FindSubmatchIndex(remaining)
+		if locs == nil {
+			out = append(out, remaining...)
+			break
+		}
+		beforeTag := remaining[:locs[0]]
+		// fullMatch := remaining[locs[0]:locs[1]]
+		tagName := remaining[locs[2]:locs[3]]
+		var atts []byte
+		if locs[4] != -1 {
+			atts = remaining[locs[4]:locs[5]]
+		}
+		selfClose := remaining[locs[6]:locs[7]]
+
+		// Advance to just past the end of the tag. Sub-components of the tag will be
+		// parsed separately.
+		remaining = remaining[min(locs[1], len(remaining)):]
+
+		out = append(out, beforeTag...)
+		if string(tagName) == "style" {
+			// Naively find the closing tag, then parse the CSS rules.
+			locs := reClosingStyleTag.FindIndex(remaining)
+			if locs == nil {
+				// No closing tag? Strange. Just continue to the next iteration.
+				continue nextTag
+			}
+			rawCSS := remaining[:locs[0]]
+			remaining = remaining[min(locs[1], len(remaining)):] // Advance to past </style>
+
+			err := parseCSSRules(rawCSS, rules)
+			if err != nil {
+				errs = append(errs, fmt.Errorf("failed to parse CSS: %w", err))
+			}
+		} else {
+			// Process the tag's attributes, replacing `style` and `class` with a single new
+			// style attribute.
+
+			out = append(out, '<')
+			out = append(out, tagName...)
+
+			// First find any styles pertaining to the tag alone.
+			var finalStyles []string
+			if styles, ok := rules[string(tagName)]; ok {
+				finalStyles = append(finalStyles, styles...)
+			}
+
+			// Parse / output attributes and gather up styles from classes and styles.
+			attsRemaining := atts
+			for {
+				locs := reAttribute.FindSubmatchIndex(attsRemaining)
+				if locs == nil {
+					break
+				}
+				fullMatch := attsRemaining[locs[0]:locs[1]]
+				attName := attsRemaining[locs[2]:locs[3]]
+				attValue := attsRemaining[locs[4]:locs[5]]
+
+				attsRemaining = attsRemaining[min(locs[1], len(attsRemaining)):] // Advance to next attribute
+
+				switch string(attName) {
+				case "class":
+					// Classes are parsed and their styles pulled out of the map.
+					classesRemaining := attValue
+					for {
+						classesRemaining = bytes.TrimLeft(classesRemaining, " ")
+						if len(classesRemaining) == 0 {
+							break
+						}
+						afterClass := bytes.IndexByte(classesRemaining, ' ')
+						if afterClass == -1 {
+							afterClass = len(classesRemaining)
+						}
+						class := string(classesRemaining[:afterClass])
+						classesRemaining = classesRemaining[afterClass:]
+
+						if styles, ok := rules["."+class]; ok {
+							finalStyles = append(finalStyles, styles...)
+						} else {
+							errs = append(errs, fmt.Errorf("unknown class %s", class))
+						}
+					}
+				case "style":
+					// Existing inline styles are just dumped in as is (minus semicolons).
+					finalStyles = append(finalStyles, string(bytes.Trim(attValue, ";")))
+				default:
+					// All other attributes are immediately echoed.
+					out = append(out, ' ')
+					out = append(out, fullMatch...)
+				}
+			}
+
+			// Emit final styles and close the tag.
+			if len(finalStyles) > 0 {
+				out = append(out, []byte(` style="`)...)
+				out = append(out, []byte(strings.Join(finalStyles, ";"))...)
+				out = append(out, []byte(`;"`)...)
+			}
+
+			out = append(out, selfClose...)
+			out = append(out, '>')
+		}
+	}
+
+	return out, errors.Join(errs...)
+}
+
+var reOpeningTag = regexp.MustCompile(`<([a-zA-Z-]+)((?:\s+[a-zA-Z-]+=".*?")+)?\s*(/?)>`)
+var reClosingStyleTag = regexp.MustCompile(`</style\s*>`)
+var reAttribute = regexp.MustCompile(`([a-zA-Z-]+)="(.*?)"`)
+var reCSSRule = regexp.MustCompile(`(?s)(\.?[a-zA-Z0-9-]+)\s\{(.*?)}`)
+var reCSSComment = regexp.MustCompile(`/\*.*?\*/`)
+var reCSSStyle = regexp.MustCompile(`([a-zA-Z0-9-]+):\s*(.*?);`)
+
+type cssRules map[string][]string
+
+func parseCSSRules(css []byte, rules cssRules) error {
+	// We are a bit lazier with the parsing here.
+	cssMinusComments := reCSSComment.ReplaceAllLiteralString(string(css), "")
+	for _, rule := range reCSSRule.FindAllStringSubmatch(cssMinusComments, -1) {
+		selector := rule[1]
+		styles := rule[2]
+
+		var mapStyles []string
+		for line := range strings.SplitSeq(styles, "\n") {
+			match := reCSSStyle.FindStringSubmatch(line)
+			if match == nil {
+				continue
+			}
+			mapStyles = append(mapStyles, fmt.Sprintf("%s:%s", match[1], match[2]))
+		}
+		rules[selector] = mapStyles
+	}
+
+	return nil
+}

src/email/preprocessor_test.go

@@ -0,0 +1,84 @@
+package email
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSimple(t *testing.T) {
+	input := `
+<!DOCTYPE html>
+<html>
+
+<head>
+<meta charset="utf-8">
+</head>
+
+<body>
+<div style="background:#fff;font-size:16px">Hello!</div>
+</body>
+
+</html>
+	`
+	expected := `
+<!DOCTYPE html>
+<html>
+
+<head>
+<meta charset="utf-8">
+</head>
+
+<body>
+<div style="background:#fff;font-size:16px;">Hello!</div>
+</body>
+
+</html>
+	`
+	actual, err := preprocessEmailHTML([]byte(input))
+	assert.Nil(t, err)
+	assert.Equal(t, expected, string(actual))
+}
+
+func TestSimpleCSS(t *testing.T) {
+	input := `
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<style>
+	/* Hey, comments */
+	body {
+		font-size: 16px; /* we love comments */
+	}
+
+	.bg-white {
+		/* comments are so good */
+		background: #fff;
+	}
+	.f5 {
+		font-size: /* so good */ 16px;
+	}
+</style>
+</head>
+<body>
+<div class="bg-white f5" style="font-weight:bold;text-decoration:underline">Hello!</div>
+</body>
+</html>
+	`
+	expected := `
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+
+</head>
+<body style="font-size:16px;">
+<div style="background:#fff;font-size:16px;font-weight:bold;text-decoration:underline;">Hello!</div>
+</body>
+</html>
+	`
+	actual, err := preprocessEmailHTML([]byte(input))
+	assert.Nil(t, err)
+	assert.Equal(t, expected, string(actual))
+}

src/hmndata/tickets.go

@@ -3,3 +3,13 @@ package hmndata
 var AllTicketEvents = []Event{
 	HMNExpo2026.Event,
 }
+
+func FindTicketEventBySlug(slugOrUrlSlug string) (Event, bool) {
+	for _, e := range AllTicketEvents {
+		if e.Slug == slugOrUrlSlug || e.UrlSlug == slugOrUrlSlug {
+			return e, true
+		}
+	}
+
+	return Event{}, false
+}