feat: responsive HTML email templates with DreamHost SMTP

- Add professional HTML email template matching CV aesthetic - Implement multipart emails (HTML + plain text fallback) - Configure DreamHost SMTP with SSL (port 465) - Add "light only" color scheme for Gmail iOS compatibility - Include Reply-To header for easy sender response - Add email validation and integration tests - Update .env.example with DreamHost/Gmail SMTP examples - Add .env to .gitignore to protect credentials - Document email template customization and dark mode approach
2025-12-02 13:42:36 +00:00
parent 40733034ca
commit 41dbd77c2f
9 changed files with 1019 additions and 94 deletions
@@ -3,11 +3,13 @@ package services
 import (
 	"bytes"
 	"crypto/tls"
+	"encoding/base64"
 	"fmt"
-	"html/template"
+	htmltemplate "html/template"
 	"log"
 	"net/smtp"
 	"strings"
+	texttemplate "text/template"
 	"time"
 )

@@ -102,7 +104,7 @@ func containsNewlines(s string) bool {
 	return strings.ContainsAny(s, "\r\n")
 }

-// SendContactForm sends a contact form email
+// SendContactForm sends a contact form email with HTML and plain text versions
 func (e *EmailService) SendContactForm(data *ContactFormData) error {
 	// Validate data
 	if err := data.Validate(); err != nil {
@@ -114,17 +116,17 @@ func (e *EmailService) SendContactForm(data *ContactFormData) error {
 	if data.Subject != "" {
 		subject += data.Subject
 	} else {
-		subject += "New Message"
+		subject += "New Message from " + data.Name
 	}

-	// Build email body
-	body, err := e.buildEmailBody(data)
+	// Build email bodies (HTML and plain text)
+	htmlBody, textBody, err := e.buildEmailBody(data)
 	if err != nil {
 		return fmt.Errorf("failed to build email body: %w", err)
 	}

-	// Send email
-	if err := e.sendEmail(subject, body); err != nil {
+	// Send multipart email
+	if err := e.sendMultipartEmail(subject, htmlBody, textBody, data.Email); err != nil {
 		return fmt.Errorf("failed to send email: %w", err)
 	}

@@ -134,37 +136,129 @@ func (e *EmailService) SendContactForm(data *ContactFormData) error {
 	return nil
 }

-// buildEmailBody creates the email body from template
-func (e *EmailService) buildEmailBody(data *ContactFormData) (string, error) {
-	emailTemplate := `New contact form submission:
-
-From: {{.Email}}
-Name: {{if .Name}}{{.Name}}{{else}}Not provided{{end}}
-Company: {{if .Company}}{{.Company}}{{else}}Not provided{{end}}
-Subject: {{if .Subject}}{{.Subject}}{{else}}Not provided{{end}}
-
-Message:
-{{.Message}}
-
---
-IP: {{.IP}}
-Time: {{.Time.Format "2006-01-02 15:04:05 MST"}}
-`
-
-	tmpl, err := template.New("contact").Parse(emailTemplate)
-	if err != nil {
-		return "", err
-	}
-
-	var body bytes.Buffer
-	if err := tmpl.Execute(&body, data); err != nil {
-		return "", err
-	}
-
-	return body.String(), nil
+// emailTemplateData wraps ContactFormData with display-safe fields
+type emailTemplateData struct {
+	Name    string
+	Email   string
+	Company string
+	Subject string
+	Message string
+	IP      string
+	Time    time.Time
 }

-// sendEmail sends an email using SMTP
+// buildEmailBody creates both HTML and plain text email bodies
+func (e *EmailService) buildEmailBody(data *ContactFormData) (htmlBody, textBody string, err error) {
+	// Prepare template data with safe defaults
+	tmplData := emailTemplateData{
+		Name:    data.Name,
+		Email:   data.Email,
+		Company: data.Company,
+		Subject: data.Subject,
+		Message: data.Message,
+		IP:      data.IP,
+		Time:    data.Time,
+	}
+
+	// Set defaults for empty fields
+	if tmplData.Name == "" {
+		tmplData.Name = "Not provided"
+	}
+
+	// Build HTML body
+	htmlTmpl, err := htmltemplate.New("contact-html").Parse(ContactEmailHTMLTemplate())
+	if err != nil {
+		return "", "", fmt.Errorf("failed to parse HTML template: %w", err)
+	}
+
+	var htmlBuf bytes.Buffer
+	if err := htmlTmpl.Execute(&htmlBuf, tmplData); err != nil {
+		return "", "", fmt.Errorf("failed to execute HTML template: %w", err)
+	}
+
+	// Build plain text body
+	textTmpl, err := texttemplate.New("contact-text").Parse(ContactEmailPlainTemplate())
+	if err != nil {
+		return "", "", fmt.Errorf("failed to parse text template: %w", err)
+	}
+
+	var textBuf bytes.Buffer
+	if err := textTmpl.Execute(&textBuf, tmplData); err != nil {
+		return "", "", fmt.Errorf("failed to execute text template: %w", err)
+	}
+
+	return htmlBuf.String(), textBuf.String(), nil
+}
+
+
+// sendMultipartEmail sends an email with both HTML and plain text parts
+func (e *EmailService) sendMultipartEmail(subject, htmlBody, textBody, replyTo string) error {
+	// Validate config
+	if e.config.SMTPHost == "" || e.config.SMTPPort == "" {
+		return fmt.Errorf("SMTP configuration incomplete")
+	}
+	if e.config.SMTPUser == "" || e.config.SMTPPassword == "" {
+		return fmt.Errorf("SMTP credentials missing")
+	}
+	if e.config.ToEmail == "" {
+		return fmt.Errorf("recipient email not configured")
+	}
+
+	from := e.config.FromEmail
+	if from == "" {
+		from = e.config.SMTPUser
+	}
+	to := e.config.ToEmail
+
+	// Build multipart message
+	message := e.formatMultipartMessage(from, to, replyTo, subject, htmlBody, textBody)
+
+	// SMTP server address
+	addr := fmt.Sprintf("%s:%s", e.config.SMTPHost, e.config.SMTPPort)
+
+	// Setup authentication
+	auth := smtp.PlainAuth("", e.config.SMTPUser, e.config.SMTPPassword, e.config.SMTPHost)
+
+	// Connect to SMTP server with TLS
+	client, err := e.connectSMTP(addr)
+	if err != nil {
+		return fmt.Errorf("failed to connect to SMTP server: %w", err)
+	}
+	defer client.Close()
+
+	// Authenticate
+	if err = client.Auth(auth); err != nil {
+		return fmt.Errorf("SMTP authentication failed: %w", err)
+	}
+
+	// Set sender and recipient
+	if err = client.Mail(from); err != nil {
+		return fmt.Errorf("failed to set sender: %w", err)
+	}
+	if err = client.Rcpt(to); err != nil {
+		return fmt.Errorf("failed to set recipient: %w", err)
+	}
+
+	// Send message
+	w, err := client.Data()
+	if err != nil {
+		return fmt.Errorf("failed to get data writer: %w", err)
+	}
+
+	_, err = w.Write([]byte(message))
+	if err != nil {
+		return fmt.Errorf("failed to write message: %w", err)
+	}
+
+	err = w.Close()
+	if err != nil {
+		return fmt.Errorf("failed to close writer: %w", err)
+	}
+
+	return client.Quit()
+}
+
+// sendEmail sends an email using SMTP (plain text only - legacy)
 func (e *EmailService) sendEmail(subject, body string) error {
 	// Validate config
 	if e.config.SMTPHost == "" || e.config.SMTPPort == "" {
@@ -233,18 +327,33 @@ func (e *EmailService) sendEmail(subject, body string) error {

 // connectSMTP establishes an SMTP connection with TLS
 func (e *EmailService) connectSMTP(addr string) (*smtp.Client, error) {
-	// Connect to server
-	client, err := smtp.Dial(addr)
-	if err != nil {
-		return nil, err
-	}
-
-	// Start TLS
 	tlsConfig := &tls.Config{
 		ServerName: e.config.SMTPHost,
 		MinVersion: tls.VersionTLS12,
 	}

+	// Port 465 uses implicit SSL (direct TLS connection)
+	// Port 587 uses STARTTLS (plain connection upgraded to TLS)
+	if e.config.SMTPPort == "465" {
+		// Implicit SSL: Connect with TLS from the start
+		conn, err := tls.Dial("tcp", addr, tlsConfig)
+		if err != nil {
+			return nil, fmt.Errorf("TLS dial failed: %w", err)
+		}
+		client, err := smtp.NewClient(conn, e.config.SMTPHost)
+		if err != nil {
+			conn.Close()
+			return nil, fmt.Errorf("SMTP client creation failed: %w", err)
+		}
+		return client, nil
+	}
+
+	// STARTTLS: Connect plain, then upgrade to TLS
+	client, err := smtp.Dial(addr)
+	if err != nil {
+		return nil, err
+	}
+
 	if err = client.StartTLS(tlsConfig); err != nil {
 		client.Close()
 		return nil, err
@@ -253,7 +362,57 @@ func (e *EmailService) connectSMTP(addr string) (*smtp.Client, error) {
 	return client, nil
 }

-// formatMessage formats an email message with proper headers
+// formatMultipartMessage formats a multipart email with HTML and plain text
+func (e *EmailService) formatMultipartMessage(from, to, replyTo, subject, htmlBody, textBody string) string {
+	// Generate boundary for multipart
+	boundary := fmt.Sprintf("----=_Part_%d", time.Now().UnixNano())
+
+	var message strings.Builder
+
+	// Headers
+	message.WriteString(fmt.Sprintf("From: %s\r\n", from))
+	message.WriteString(fmt.Sprintf("To: %s\r\n", to))
+	if replyTo != "" {
+		message.WriteString(fmt.Sprintf("Reply-To: %s\r\n", replyTo))
+	}
+	message.WriteString(fmt.Sprintf("Subject: %s\r\n", subject))
+	message.WriteString("MIME-Version: 1.0\r\n")
+	message.WriteString(fmt.Sprintf("Content-Type: multipart/alternative; boundary=\"%s\"\r\n", boundary))
+	message.WriteString(fmt.Sprintf("Date: %s\r\n", time.Now().Format(time.RFC1123Z)))
+	message.WriteString("\r\n")
+
+	// Plain text part
+	message.WriteString(fmt.Sprintf("--%s\r\n", boundary))
+	message.WriteString("Content-Type: text/plain; charset=\"utf-8\"\r\n")
+	message.WriteString("Content-Transfer-Encoding: quoted-printable\r\n")
+	message.WriteString("\r\n")
+	message.WriteString(textBody)
+	message.WriteString("\r\n")
+
+	// HTML part
+	message.WriteString(fmt.Sprintf("--%s\r\n", boundary))
+	message.WriteString("Content-Type: text/html; charset=\"utf-8\"\r\n")
+	message.WriteString("Content-Transfer-Encoding: base64\r\n")
+	message.WriteString("\r\n")
+	// Encode HTML as base64 for safe transmission
+	encoded := base64.StdEncoding.EncodeToString([]byte(htmlBody))
+	// Split into 76-character lines per RFC 2045
+	for i := 0; i < len(encoded); i += 76 {
+		end := i + 76
+		if end > len(encoded) {
+			end = len(encoded)
+		}
+		message.WriteString(encoded[i:end])
+		message.WriteString("\r\n")
+	}
+
+	// End boundary
+	message.WriteString(fmt.Sprintf("--%s--\r\n", boundary))
+
+	return message.String()
+}
+
+// formatMessage formats an email message with proper headers (plain text only)
 func (e *EmailService) formatMessage(from, to, subject, body string) string {
 	headers := make(map[string]string)
 	headers["From"] = from