jfa-go/email.go

package main

import (
	"bytes"
	"context"
	"crypto/tls"
	"crypto/x509"
	"errors"
	"fmt"
	"html/template"
	"io"
	"io/fs"
	"net/smtp"
	"os"
	"strconv"
	"strings"
	"sync"
	textTemplate "text/template"
	"time"

	"github.com/gomarkdown/markdown"
	"github.com/gomarkdown/markdown/html"
	"github.com/itchyny/timefmt-go"
	jEmail "github.com/jordan-wright/email"
	"github.com/mailgun/mailgun-go/v4"
)

var renderer = html.NewRenderer(html.RendererOptions{Flags: html.Smartypants})

// EmailClient implements email sending, right now via smtp, mailgun or a dummy client.
type EmailClient interface {
	Send(fromName, fromAddr string, message *Message, address ...string) error
}

type DummyClient struct{}

func (dc *DummyClient) Send(fromName, fromAddr string, email *Message, address ...string) error {
	fmt.Printf("FROM: %s <%s>\nTO: %s\nTEXT: %s\n", fromName, fromAddr, strings.Join(address, ", "), email.Text)
	return nil
}

// Mailgun client implements EmailClient.
type Mailgun struct {
	client *mailgun.MailgunImpl
}

func (mg *Mailgun) Send(fromName, fromAddr string, email *Message, address ...string) error {
	message := mg.client.NewMessage(
		fmt.Sprintf("%s <%s>", fromName, fromAddr),
		email.Subject,
		email.Text,
	)
	for _, a := range address {
		// Adding variable tells mailgun to do a batch send, so users don't see other recipients.
		message.AddRecipientAndVariables(a, map[string]interface{}{"unique_id": a})
	}
	message.SetHtml(email.HTML)
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
	defer cancel()
	_, _, err := mg.client.Send(ctx, message)
	return err
}

// SMTP supports SSL/TLS and STARTTLS; implements EmailClient.
type SMTP struct {
	sslTLS    bool
	server    string
	port      int
	auth      smtp.Auth
	tlsConfig *tls.Config
}

func (sm *SMTP) Send(fromName, fromAddr string, email *Message, address ...string) error {
	server := fmt.Sprintf("%s:%d", sm.server, sm.port)
	from := fmt.Sprintf("%s <%s>", fromName, fromAddr)
	var wg sync.WaitGroup
	var err error
	for _, addr := range address {
		wg.Add(1)
		go func(addr string) {
			defer wg.Done()
			e := jEmail.NewEmail()
			e.Subject = email.Subject
			e.From = from
			e.Text = []byte(email.Text)
			e.HTML = []byte(email.HTML)
			e.To = []string{addr}
			if sm.sslTLS {
				err = e.SendWithTLS(server, sm.auth, sm.tlsConfig)
			} else {
				err = e.SendWithStartTLS(server, sm.auth, sm.tlsConfig)
			}
		}(addr)
	}
	wg.Wait()
	return err
}

// Emailer contains the email sender, translations, and methods to construct messages.
type Emailer struct {
	fromAddr, fromName string
	lang               emailLang
	sender             EmailClient
}

// Message stores content.
type Message struct {
	Subject  string `json:"subject"`
	HTML     string `json:"html"`
	Text     string `json:"text"`
	Markdown string `json:"markdown"`
}

func (emailer *Emailer) formatExpiry(expiry time.Time, tzaware bool, datePattern, timePattern string) (d, t, expiresIn string) {
	d = timefmt.Format(expiry, datePattern)
	t = timefmt.Format(expiry, timePattern)
	currentTime := time.Now()
	if tzaware {
		currentTime = currentTime.UTC()
	}
	_, _, days, hours, minutes, _ := timeDiff(expiry, currentTime)
	if days != 0 {
		expiresIn += strconv.Itoa(days) + "d "
	}
	if hours != 0 {
		expiresIn += strconv.Itoa(hours) + "h "
	}
	if minutes != 0 {
		expiresIn += strconv.Itoa(minutes) + "m "
	}
	expiresIn = strings.TrimSuffix(expiresIn, " ")
	return
}

// NewEmailer configures and returns a new emailer.
func NewEmailer(app *appContext) *Emailer {
	emailer := &Emailer{
		fromAddr: app.config.Section("email").Key("address").String(),
		fromName: app.config.Section("email").Key("from").String(),
		lang:     app.storage.lang.Email[app.storage.lang.chosenEmailLang],
	}
	method := app.config.Section("email").Key("method").String()
	if method == "smtp" {
		sslTLS := false
		if app.config.Section("smtp").Key("encryption").String() == "ssl_tls" {
			sslTLS = true
		}
		username := ""
		if u := app.config.Section("smtp").Key("username").MustString(""); u != "" {
			username = u
		} else {
			username = emailer.fromAddr
		}
		err := emailer.NewSMTP(app.config.Section("smtp").Key("server").String(), app.config.Section("smtp").Key("port").MustInt(465), username, app.config.Section("smtp").Key("password").String(), sslTLS, app.config.Section("smtp").Key("ssl_cert").MustString(""))
		if err != nil {
			app.err.Printf("Error while initiating SMTP mailer: %v", err)
		}
	} else if method == "mailgun" {
		emailer.NewMailgun(app.config.Section("mailgun").Key("api_url").String(), app.config.Section("mailgun").Key("api_key").String())
	} else if method == "dummy" {
		emailer.sender = &DummyClient{}
	}
	return emailer
}

// NewMailgun returns a Mailgun emailClient.
func (emailer *Emailer) NewMailgun(url, key string) {
	sender := &Mailgun{
		client: mailgun.NewMailgun(strings.Split(emailer.fromAddr, "@")[1], key),
	}
	// Mailgun client takes the base url, so we need to trim off the end (e.g 'v3/messages')
	if strings.Contains(url, "messages") {
		url = url[0:strings.LastIndex(url, "/")]
		url = url[0:strings.LastIndex(url, "/")]
	}
	sender.client.SetAPIBase(url)
	emailer.sender = sender
}

// NewSMTP returns an SMTP emailClient.
func (emailer *Emailer) NewSMTP(server string, port int, username, password string, sslTLS bool, certPath string) (err error) {
	// x509.SystemCertPool is unavailable on windows
	if PLATFORM == "windows" {
		emailer.sender = &SMTP{
			auth:   smtp.PlainAuth("", username, password, server),
			server: server,
			port:   port,
			sslTLS: sslTLS,
			tlsConfig: &tls.Config{
				InsecureSkipVerify: false,
				ServerName:         server,
			},
		}
		return
	}
	rootCAs, err := x509.SystemCertPool()
	if rootCAs == nil || err != nil {
		rootCAs = x509.NewCertPool()
	}
	if certPath != "" {
		var cert []byte
		cert, err = os.ReadFile(certPath)
		if rootCAs.AppendCertsFromPEM(cert) == false {
			err = errors.New("Failed to append cert to pool")
		}
	}
	emailer.sender = &SMTP{
		auth:   smtp.PlainAuth("", username, password, server),
		server: server,
		port:   port,
		sslTLS: sslTLS,
		tlsConfig: &tls.Config{
			InsecureSkipVerify: false,
			ServerName:         server,
			RootCAs:            rootCAs,
		},
	}
	return
}

type templ interface {
	Execute(wr io.Writer, data interface{}) error
}

func (emailer *Emailer) construct(app *appContext, section, keyFragment string, data map[string]interface{}) (html, text, markdown string, err error) {
	var tpl templ
	if substituteStrings == "" {
		data["jellyfin"] = "Jellyfin"
	} else {
		data["jellyfin"] = substituteStrings
	}
	var keys []string
	plaintext := app.config.Section("email").Key("plaintext").MustBool(false)
	if plaintext {
		if telegramEnabled || discordEnabled {
			keys = []string{"text"}
			text, markdown = "", ""
		} else {
			keys = []string{"text"}
			text = ""
		}
	} else {
		if telegramEnabled || discordEnabled {
			keys = []string{"html", "text", "markdown"}
		} else {
			keys = []string{"html", "text"}
		}
	}
	for _, key := range keys {
		var filesystem fs.FS
		var fpath string
		if key == "markdown" {
			filesystem, fpath = app.GetPath(section, keyFragment+"text")
		} else {
			filesystem, fpath = app.GetPath(section, keyFragment+key)
		}
		if key == "html" {
			tpl, err = template.ParseFS(filesystem, fpath)
		} else {
			tpl, err = textTemplate.ParseFS(filesystem, fpath)
		}
		if err != nil {
			return
		}
		// For constructTemplate, if "md" is found in data it's used in stead of "text".
		foundMarkdown := false
		if key == "markdown" {
			_, foundMarkdown = data["md"]
			if foundMarkdown {
				data["plaintext"], data["md"] = data["md"], data["plaintext"]
			}
		}
		var tplData bytes.Buffer
		err = tpl.Execute(&tplData, data)
		if err != nil {
			return
		}
		if foundMarkdown {
			data["plaintext"], data["md"] = data["md"], data["plaintext"]
		}
		if key == "html" {
			html = tplData.String()
		} else if key == "text" {
			text = tplData.String()
		} else {
			markdown = tplData.String()
		}
	}
	return
}

func (emailer *Emailer) confirmationValues(code, username, key string, app *appContext, noSub bool) map[string]interface{} {
	template := map[string]interface{}{
		"clickBelow":    emailer.lang.EmailConfirmation.get("clickBelow"),
		"ifItWasNotYou": emailer.lang.Strings.get("ifItWasNotYou"),
		"confirmEmail":  emailer.lang.EmailConfirmation.get("confirmEmail"),
		"message":       "",
		"username":      username,
	}
	if noSub {
		template["helloUser"] = emailer.lang.Strings.get("helloUser")
		empty := []string{"confirmationURL"}
		for _, v := range empty {
			template[v] = "{" + v + "}"
		}
	} else {
		message := app.config.Section("messages").Key("message").String()
		inviteLink := app.config.Section("invite_emails").Key("url_base").String()
		inviteLink = fmt.Sprintf("%s/%s?key=%s", inviteLink, code, key)
		template["helloUser"] = emailer.lang.Strings.template("helloUser", tmpl{"username": username})
		template["confirmationURL"] = inviteLink
		template["message"] = message
	}
	return template
}

func (emailer *Emailer) constructConfirmation(code, username, key string, app *appContext, noSub bool) (*Message, error) {
	email := &Message{
		Subject: app.config.Section("email_confirmation").Key("subject").MustString(emailer.lang.EmailConfirmation.get("title")),
	}
	var err error
	template := emailer.confirmationValues(code, username, key, app, noSub)
	if app.storage.customEmails.EmailConfirmation.Enabled {
		content := templateEmail(
			app.storage.customEmails.EmailConfirmation.Content,
			app.storage.customEmails.EmailConfirmation.Variables,
			nil,
			template,
		)
		email, err = emailer.constructTemplate(email.Subject, content, app)
	} else {
		email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "email_confirmation", "email_", template)
	}
	if err != nil {
		return nil, err
	}
	return email, nil
}

// username is optional, but should only be passed once.
func (emailer *Emailer) constructTemplate(subject, md string, app *appContext, username ...string) (*Message, error) {
	if len(username) != 0 {
		md = templateEmail(md, []string{"{username}"}, nil, map[string]interface{}{"username": username[0]})
		subject = templateEmail(subject, []string{"{username}"}, nil, map[string]interface{}{"username": username[0]})
	}
	email := &Message{Subject: subject}
	html := markdown.ToHTML([]byte(md), nil, renderer)
	text := stripMarkdown(md)
	message := app.config.Section("messages").Key("message").String()
	var err error
	data := map[string]interface{}{
		"text":      template.HTML(html),
		"plaintext": text,
		"message":   message,
		"md":        md,
	}
	if len(username) != 0 {
		data["username"] = username[0]
	}
	email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "template_email", "email_", data)
	if err != nil {
		return nil, err
	}
	return email, nil
}

func (emailer *Emailer) inviteValues(code string, invite Invite, app *appContext, noSub bool) map[string]interface{} {
	expiry := invite.ValidTill
	d, t, expiresIn := emailer.formatExpiry(expiry, false, app.datePattern, app.timePattern)
	message := app.config.Section("messages").Key("message").String()
	inviteLink := app.config.Section("invite_emails").Key("url_base").String()
	if !strings.HasSuffix(inviteLink, "/invite") {
		inviteLink += "/invite"
	}
	inviteLink = fmt.Sprintf("%s/%s", inviteLink, code)
	template := map[string]interface{}{
		"hello":              emailer.lang.InviteEmail.get("hello"),
		"youHaveBeenInvited": emailer.lang.InviteEmail.get("youHaveBeenInvited"),
		"toJoin":             emailer.lang.InviteEmail.get("toJoin"),
		"linkButton":         emailer.lang.InviteEmail.get("linkButton"),
		"message":            "",
		"date":               d,
		"time":               t,
		"expiresInMinutes":   expiresIn,
	}
	if noSub {
		template["inviteExpiry"] = emailer.lang.InviteEmail.get("inviteExpiry")
		empty := []string{"inviteURL"}
		for _, v := range empty {
			template[v] = "{" + v + "}"
		}
	} else {
		template["inviteExpiry"] = emailer.lang.InviteEmail.template("inviteExpiry", tmpl{"date": d, "time": t, "expiresInMinutes": expiresIn})
		template["inviteURL"] = inviteLink
		template["message"] = message
	}
	return template
}

func (emailer *Emailer) constructInvite(code string, invite Invite, app *appContext, noSub bool) (*Message, error) {
	email := &Message{
		Subject: app.config.Section("invite_emails").Key("subject").MustString(emailer.lang.InviteEmail.get("title")),
	}
	template := emailer.inviteValues(code, invite, app, noSub)
	var err error
	if app.storage.customEmails.InviteEmail.Enabled {
		content := templateEmail(
			app.storage.customEmails.InviteEmail.Content,
			app.storage.customEmails.InviteEmail.Variables,
			nil,
			template,
		)
		email, err = emailer.constructTemplate(email.Subject, content, app)
	} else {
		email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "invite_emails", "email_", template)
	}
	if err != nil {
		return nil, err
	}
	return email, nil
}

func (emailer *Emailer) expiryValues(code string, invite Invite, app *appContext, noSub bool) map[string]interface{} {
	expiry := app.formatDatetime(invite.ValidTill)
	template := map[string]interface{}{
		"inviteExpired":      emailer.lang.InviteExpiry.get("inviteExpired"),
		"notificationNotice": emailer.lang.InviteExpiry.get("notificationNotice"),
		"code":               "\"" + code + "\"",
		"time":               expiry,
	}
	if noSub {
		template["expiredAt"] = emailer.lang.InviteExpiry.get("expiredAt")
	} else {
		template["expiredAt"] = emailer.lang.InviteExpiry.template("expiredAt", tmpl{"code": template["code"].(string), "time": template["time"].(string)})
	}
	return template
}

func (emailer *Emailer) constructExpiry(code string, invite Invite, app *appContext, noSub bool) (*Message, error) {
	email := &Message{
		Subject: emailer.lang.InviteExpiry.get("title"),
	}
	var err error
	template := emailer.expiryValues(code, invite, app, noSub)
	if app.storage.customEmails.InviteExpiry.Enabled {
		content := templateEmail(
			app.storage.customEmails.InviteExpiry.Content,
			app.storage.customEmails.InviteExpiry.Variables,
			nil,
			template,
		)
		email, err = emailer.constructTemplate(email.Subject, content, app)
	} else {
		email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "notifications", "expiry_", template)
	}
	if err != nil {
		return nil, err
	}
	return email, nil
}

func (emailer *Emailer) createdValues(code, username, address string, invite Invite, app *appContext, noSub bool) map[string]interface{} {
	template := map[string]interface{}{
		"nameString":         emailer.lang.Strings.get("name"),
		"addressString":      emailer.lang.Strings.get("emailAddress"),
		"timeString":         emailer.lang.UserCreated.get("time"),
		"notificationNotice": "",
		"code":               "\"" + code + "\"",
	}
	if noSub {
		template["aUserWasCreated"] = emailer.lang.UserCreated.get("aUserWasCreated")
		empty := []string{"name", "address", "time"}
		for _, v := range empty {
			template[v] = "{" + v + "}"
		}
	} else {
		created := app.formatDatetime(invite.Created)
		var tplAddress string
		if app.config.Section("email").Key("no_username").MustBool(false) {
			tplAddress = "n/a"
		} else {
			tplAddress = address
		}
		template["aUserWasCreated"] = emailer.lang.UserCreated.template("aUserWasCreated", tmpl{"code": template["code"].(string)})
		template["name"] = username
		template["address"] = tplAddress
		template["time"] = created
		template["notificationNotice"] = emailer.lang.UserCreated.get("notificationNotice")
	}
	return template
}

func (emailer *Emailer) constructCreated(code, username, address string, invite Invite, app *appContext, noSub bool) (*Message, error) {
	email := &Message{
		Subject: emailer.lang.UserCreated.get("title"),
	}
	template := emailer.createdValues(code, username, address, invite, app, noSub)
	var err error
	if app.storage.customEmails.UserCreated.Enabled {
		content := templateEmail(
			app.storage.customEmails.UserCreated.Content,
			app.storage.customEmails.UserCreated.Variables,
			nil,
			template,
		)
		email, err = emailer.constructTemplate(email.Subject, content, app)
	} else {
		email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "notifications", "created_", template)
	}
	if err != nil {
		return nil, err
	}
	return email, nil
}

func (emailer *Emailer) resetValues(pwr PasswordReset, app *appContext, noSub bool) map[string]interface{} {
	d, t, expiresIn := emailer.formatExpiry(pwr.Expiry, true, app.datePattern, app.timePattern)
	message := app.config.Section("messages").Key("message").String()
	template := map[string]interface{}{
		"someoneHasRequestedReset": emailer.lang.PasswordReset.get("someoneHasRequestedReset"),
		"ifItWasNotYou":            emailer.lang.Strings.get("ifItWasNotYou"),
		"pinString":                emailer.lang.PasswordReset.get("pin"),
		"link_reset":               false,
		"message":                  "",
		"username":                 pwr.Username,
		"date":                     d,
		"time":                     t,
		"expiresInMinutes":         expiresIn,
	}
	linkResetEnabled := app.config.Section("password_resets").Key("link_reset").MustBool(false)
	if linkResetEnabled {
		template["ifItWasYou"] = emailer.lang.PasswordReset.get("ifItWasYouLink")
	} else {
		template["ifItWasYou"] = emailer.lang.PasswordReset.get("ifItWasYou")
	}
	if noSub {
		template["helloUser"] = emailer.lang.Strings.get("helloUser")
		template["codeExpiry"] = emailer.lang.PasswordReset.get("codeExpiry")
		empty := []string{"pin"}
		for _, v := range empty {
			template[v] = "{" + v + "}"
		}
	} else {
		template["helloUser"] = emailer.lang.Strings.template("helloUser", tmpl{"username": pwr.Username})
		template["codeExpiry"] = emailer.lang.PasswordReset.template("codeExpiry", tmpl{"date": d, "time": t, "expiresInMinutes": expiresIn})
		url := app.config.Section("password_resets").Key("url_base").String()
		if linkResetEnabled {
			if url != "" {
				// Strip /invite form end of this URL, ik its ugly.
				template["link_reset"] = true
				pinLink := fmt.Sprintf("%s/reset?pin=%s", url, pwr.Pin)
				template["pin"] = pinLink
				// Only used in html email.
				template["pin_code"] = pwr.Pin
			} else {
				app.info.Println("Password Reset link disabled as no URL Base provided. Set in Settings > Password Resets.")
				template["pin"] = pwr.Pin
			}
		} else {
			template["pin"] = pwr.Pin
		}
		template["message"] = message
	}
	return template
}

func (emailer *Emailer) constructReset(pwr PasswordReset, app *appContext, noSub bool) (*Message, error) {
	email := &Message{
		Subject: app.config.Section("password_resets").Key("subject").MustString(emailer.lang.PasswordReset.get("title")),
	}
	template := emailer.resetValues(pwr, app, noSub)
	var err error
	if app.storage.customEmails.PasswordReset.Enabled {
		content := templateEmail(
			app.storage.customEmails.PasswordReset.Content,
			app.storage.customEmails.PasswordReset.Variables,
			nil,
			template,
		)
		email, err = emailer.constructTemplate(email.Subject, content, app)
	} else {
		email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "password_resets", "email_", template)
	}
	if err != nil {
		return nil, err
	}
	return email, nil
}

func (emailer *Emailer) deletedValues(reason string, app *appContext, noSub bool) map[string]interface{} {
	template := map[string]interface{}{
		"yourAccountWas": emailer.lang.UserDeleted.get("yourAccountWasDeleted"),
		"reasonString":   emailer.lang.Strings.get("reason"),
		"message":        "",
	}
	if noSub {
		empty := []string{"reason"}
		for _, v := range empty {
			template[v] = "{" + v + "}"
		}
	} else {
		template["reason"] = reason
		template["message"] = app.config.Section("messages").Key("message").String()
	}
	fmt.Println("TTTT", template)
	return template
}

func (emailer *Emailer) constructDeleted(reason string, app *appContext, noSub bool) (*Message, error) {
	email := &Message{
		Subject: app.config.Section("deletion").Key("subject").MustString(emailer.lang.UserDeleted.get("title")),
	}
	var err error
	template := emailer.deletedValues(reason, app, noSub)
	if app.storage.customEmails.UserDeleted.Enabled {
		content := templateEmail(
			app.storage.customEmails.UserDeleted.Content,
			app.storage.customEmails.UserDeleted.Variables,
			nil,
			template,
		)
		email, err = emailer.constructTemplate(email.Subject, content, app)
	} else {
		email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "deletion", "email_", template)
	}
	if err != nil {
		return nil, err
	}
	return email, nil
}

func (emailer *Emailer) disabledValues(reason string, app *appContext, noSub bool) map[string]interface{} {
	template := map[string]interface{}{
		"yourAccountWas": emailer.lang.UserDisabled.get("yourAccountWasDisabled"),
		"reasonString":   emailer.lang.Strings.get("reason"),
		"message":        "",
	}
	if noSub {
		empty := []string{"reason"}
		for _, v := range empty {
			template[v] = "{" + v + "}"
		}
	} else {
		template["reason"] = reason
		template["message"] = app.config.Section("messages").Key("message").String()
	}
	return template
}

func (emailer *Emailer) constructDisabled(reason string, app *appContext, noSub bool) (*Message, error) {
	email := &Message{
		Subject: app.config.Section("disable_enable").Key("subject_disabled").MustString(emailer.lang.UserDisabled.get("title")),
	}
	var err error
	template := emailer.disabledValues(reason, app, noSub)
	if app.storage.customEmails.UserDisabled.Enabled {
		content := templateEmail(
			app.storage.customEmails.UserDisabled.Content,
			app.storage.customEmails.UserDisabled.Variables,
			nil,
			template,
		)
		email, err = emailer.constructTemplate(email.Subject, content, app)
	} else {
		email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "disable_enable", "disabled_", template)
	}
	if err != nil {
		return nil, err
	}
	return email, nil
}

func (emailer *Emailer) enabledValues(reason string, app *appContext, noSub bool) map[string]interface{} {
	template := map[string]interface{}{
		"yourAccountWas": emailer.lang.UserEnabled.get("yourAccountWasEnabled"),
		"reasonString":   emailer.lang.Strings.get("reason"),
		"message":        "",
	}
	if noSub {
		empty := []string{"reason"}
		for _, v := range empty {
			template[v] = "{" + v + "}"
		}
	} else {
		template["reason"] = reason
		template["message"] = app.config.Section("messages").Key("message").String()
	}
	return template
}

func (emailer *Emailer) constructEnabled(reason string, app *appContext, noSub bool) (*Message, error) {
	email := &Message{
		Subject: app.config.Section("disable_enable").Key("subject_enabled").MustString(emailer.lang.UserEnabled.get("title")),
	}
	var err error
	template := emailer.enabledValues(reason, app, noSub)
	if app.storage.customEmails.UserEnabled.Enabled {
		content := templateEmail(
			app.storage.customEmails.UserEnabled.Content,
			app.storage.customEmails.UserEnabled.Variables,
			nil,
			template,
		)
		email, err = emailer.constructTemplate(email.Subject, content, app)
	} else {
		email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "disable_enable", "enabled_", template)
	}
	if err != nil {
		return nil, err
	}
	return email, nil
}

func (emailer *Emailer) welcomeValues(username string, expiry time.Time, app *appContext, noSub bool, custom bool) map[string]interface{} {
	template := map[string]interface{}{
		"welcome":               emailer.lang.WelcomeEmail.get("welcome"),
		"youCanLoginWith":       emailer.lang.WelcomeEmail.get("youCanLoginWith"),
		"jellyfinURLString":     emailer.lang.WelcomeEmail.get("jellyfinURL"),
		"usernameString":        emailer.lang.Strings.get("username"),
		"message":               "",
		"yourAccountWillExpire": "",
	}
	if noSub {
		empty := []string{"jellyfinURL", "username", "yourAccountWillExpire"}
		for _, v := range empty {
			template[v] = "{" + v + "}"
		}
	} else {
		template["jellyfinURL"] = app.config.Section("jellyfin").Key("public_server").String()
		template["username"] = username
		template["message"] = app.config.Section("messages").Key("message").String()
		exp := app.formatDatetime(expiry)
		if !expiry.IsZero() {
			if custom {
				template["yourAccountWillExpire"] = exp
			} else if !expiry.IsZero() {
				template["yourAccountWillExpire"] = emailer.lang.WelcomeEmail.template("yourAccountWillExpire", tmpl{
					"date": exp,
				})
			}
		}
	}
	return template
}

func (emailer *Emailer) constructWelcome(username string, expiry time.Time, app *appContext, noSub bool) (*Message, error) {
	email := &Message{
		Subject: app.config.Section("welcome_email").Key("subject").MustString(emailer.lang.WelcomeEmail.get("title")),
	}
	var err error
	var template map[string]interface{}
	if app.storage.customEmails.WelcomeEmail.Enabled {
		template = emailer.welcomeValues(username, expiry, app, noSub, true)
	} else {
		template = emailer.welcomeValues(username, expiry, app, noSub, false)
	}
	if noSub {
		template["yourAccountWillExpire"] = emailer.lang.WelcomeEmail.template("yourAccountWillExpire", tmpl{
			"date": "{yourAccountWillExpire}",
		})
	}
	if app.storage.customEmails.WelcomeEmail.Enabled {
		content := templateEmail(
			app.storage.customEmails.WelcomeEmail.Content,
			app.storage.customEmails.WelcomeEmail.Variables,
			app.storage.customEmails.WelcomeEmail.Conditionals,
			template,
		)
		email, err = emailer.constructTemplate(email.Subject, content, app)
	} else {
		email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "welcome_email", "email_", template)
	}
	if err != nil {
		return nil, err
	}
	return email, nil
}

func (emailer *Emailer) userExpiredValues(app *appContext, noSub bool) map[string]interface{} {
	template := map[string]interface{}{
		"yourAccountHasExpired": emailer.lang.UserExpired.get("yourAccountHasExpired"),
		"contactTheAdmin":       emailer.lang.UserExpired.get("contactTheAdmin"),
		"message":               "",
	}
	if !noSub {
		template["message"] = app.config.Section("messages").Key("message").String()
	}
	return template
}

func (emailer *Emailer) constructUserExpired(app *appContext, noSub bool) (*Message, error) {
	email := &Message{
		Subject: app.config.Section("user_expiry").Key("subject").MustString(emailer.lang.UserExpired.get("title")),
	}
	var err error
	template := emailer.userExpiredValues(app, noSub)
	if app.storage.customEmails.UserExpired.Enabled {
		content := templateEmail(
			app.storage.customEmails.UserExpired.Content,
			app.storage.customEmails.UserExpired.Variables,
			nil,
			template,
		)
		email, err = emailer.constructTemplate(email.Subject, content, app)
	} else {
		email.HTML, email.Text, email.Markdown, err = emailer.construct(app, "user_expiry", "email_", template)
	}
	if err != nil {
		return nil, err
	}
	return email, nil
}

// calls the send method in the underlying emailClient.
func (emailer *Emailer) send(email *Message, address ...string) error {
	return emailer.sender.Send(emailer.fromName, emailer.fromAddr, email, address...)
}

func (app *appContext) sendByID(email *Message, ID ...string) error {
	for _, id := range ID {
		var err error
		if tgChat, ok := app.storage.telegram[id]; ok && tgChat.Contact && telegramEnabled {
			err = app.telegram.Send(email, tgChat.ChatID)
			if err != nil {
				return err
			}
		}
		if dcChat, ok := app.storage.discord[id]; ok && dcChat.Contact && discordEnabled {
			err = app.discord.Send(email, dcChat.ChannelID)
			if err != nil {
				return err
			}
		}
		if mxChat, ok := app.storage.matrix[id]; ok && mxChat.Contact && matrixEnabled {
			err = app.matrix.Send(email, mxChat)
			if err != nil {
				return err
			}
		}
		if address, ok := app.storage.emails[id]; ok && address.Contact && emailEnabled {
			err = app.email.send(email, address.Addr)
			if err != nil {
				return err
			}
		}
		if err != nil {
			return err
		}
	}
	return nil
}

func (app *appContext) getAddressOrName(jfID string) string {
	if dcChat, ok := app.storage.discord[jfID]; ok && dcChat.Contact && discordEnabled {
		return dcChat.Username + "#" + dcChat.Discriminator
	}
	if tgChat, ok := app.storage.telegram[jfID]; ok && tgChat.Contact && telegramEnabled {
		return "@" + tgChat.Username
	}
	if addr, ok := app.storage.emails[jfID]; ok {
		return addr.Addr
	}
	return ""
}