answer/internal/service/export/email_service.go

package export

import (
	"bytes"
	"encoding/json"
	"html/template"

	"github.com/segmentfault/answer/internal/base/reason"
	"github.com/segmentfault/answer/internal/service/config"
	"github.com/segmentfault/pacman/errors"
	"github.com/segmentfault/pacman/log"
	"golang.org/x/net/context"
	"gopkg.in/gomail.v2"
)

// EmailService kit service
type EmailService struct {
	configRepo config.ConfigRepo
	emailRepo  EmailRepo
}

// EmailRepo email repository
type EmailRepo interface {
	SetCode(ctx context.Context, code, content string) error
	VerifyCode(ctx context.Context, code string) (content string, err error)
}

// NewEmailService email service
func NewEmailService(configRepo config.ConfigRepo, emailRepo EmailRepo) *EmailService {
	return &EmailService{
		configRepo: configRepo,
		emailRepo:  emailRepo,
	}
}

// EmailConfig email config
type EmailConfig struct {
	FromEmailAddress string `json:"from_email_address"`
	FromName         string `json:"from_name"`
	SMTPHost         string `json:"smtp_host"`
	SMTPPort         int    `json:"smtp_port"`
	Encryption       string `json:"encryption"` // "" SSL
	SMTPUsername     string `json:"smtp_username"`
	SMTPPassword     string `json:"smtp_password"`

	RegisterTitle  string `json:"register_title"`
	RegisterBody   string `json:"register_body"`
	PassResetTitle string `json:"pass_reset_title"`
	PassResetBody  string `json:"pass_reset_body"`
	ChangeTitle    string `json:"change_title"`
	ChangeBody     string `json:"change_body"`
}

func (e *EmailConfig) IsSSL() bool {
	return e.Encryption == "SSL"
}

type RegisterTemplateData struct {
	SiteName    string
	RegisterUrl string
}

type PassResetTemplateData struct {
	SiteName     string
	PassResetUrl string
}

type ChangeEmailTemplateData struct {
	SiteName       string
	ChangeEmailUrl string
}

// Send email send
func (es *EmailService) Send(ctx context.Context, toEmailAddr, subject, body, code, codeContent string) {
	ec, err := es.GetEmailConfig()
	if err != nil {
		log.Error(err)
		return
	}

	m := gomail.NewMessage()
	m.SetHeader("From", ec.FromEmailAddress)
	m.SetHeader("To", toEmailAddr)
	m.SetHeader("Subject", subject)
	m.SetBody("text/html", body)

	d := gomail.NewDialer(ec.SMTPHost, ec.SMTPPort, ec.SMTPUsername, ec.SMTPPassword)
	if ec.IsSSL() {
		d.SSL = true
	}
	if err := d.DialAndSend(m); err != nil {
		log.Error(err)
	}

	err = es.emailRepo.SetCode(ctx, code, codeContent)
	if err != nil {
		log.Error(err)
	}
	return
}

// VerifyUrlExpired email send
func (es *EmailService) VerifyUrlExpired(ctx context.Context, code string) (content string) {
	content, err := es.emailRepo.VerifyCode(ctx, code)
	if err != nil {
		log.Error(err)
	}
	return content
}

func (es *EmailService) RegisterTemplate(registerUrl string) (title, body string, err error) {
	ec, err := es.GetEmailConfig()
	if err != nil {
		return
	}

	templateData := RegisterTemplateData{
		SiteName: ec.FromName, RegisterUrl: registerUrl,
	}
	tmpl, err := template.New("register_title").Parse(ec.RegisterTitle)
	if err != nil {
		return "", "", err
	}
	titleBuf := &bytes.Buffer{}
	bodyBuf := &bytes.Buffer{}
	err = tmpl.Execute(titleBuf, templateData)
	if err != nil {
		return "", "", err
	}

	tmpl, err = template.New("register_body").Parse(ec.RegisterBody)
	err = tmpl.Execute(bodyBuf, templateData)
	if err != nil {
		return "", "", err
	}

	return titleBuf.String(), bodyBuf.String(), nil
}

func (es *EmailService) PassResetTemplate(passResetUrl string) (title, body string, err error) {
	ec, err := es.GetEmailConfig()
	if err != nil {
		return
	}

	templateData := PassResetTemplateData{SiteName: ec.FromName, PassResetUrl: passResetUrl}
	tmpl, err := template.New("pass_reset_title").Parse(ec.PassResetTitle)
	if err != nil {
		return "", "", err
	}
	titleBuf := &bytes.Buffer{}
	bodyBuf := &bytes.Buffer{}
	err = tmpl.Execute(titleBuf, templateData)
	if err != nil {
		return "", "", err
	}

	tmpl, err = template.New("pass_reset_body").Parse(ec.PassResetBody)
	err = tmpl.Execute(bodyBuf, templateData)
	if err != nil {
		return "", "", err
	}
	return titleBuf.String(), bodyBuf.String(), nil
}

func (es *EmailService) ChangeEmailTemplate(changeEmailUrl string) (title, body string, err error) {
	ec, err := es.GetEmailConfig()
	if err != nil {
		return
	}

	templateData := ChangeEmailTemplateData{
		SiteName:       ec.FromName,
		ChangeEmailUrl: changeEmailUrl,
	}
	tmpl, err := template.New("email_change_title").Parse(ec.ChangeTitle)
	if err != nil {
		return "", "", err
	}
	titleBuf := &bytes.Buffer{}
	bodyBuf := &bytes.Buffer{}
	err = tmpl.Execute(titleBuf, templateData)
	if err != nil {
		return "", "", err
	}

	tmpl, err = template.New("email_change_body").Parse(ec.ChangeBody)
	err = tmpl.Execute(bodyBuf, templateData)
	if err != nil {
		return "", "", err
	}
	return titleBuf.String(), bodyBuf.String(), nil
}

func (es *EmailService) GetEmailConfig() (ec *EmailConfig, err error) {
	emailConf, err := es.configRepo.GetString("email.config")
	if err != nil {
		return nil, err
	}
	ec = &EmailConfig{}
	err = json.Unmarshal([]byte(emailConf), ec)
	if err != nil {
		return nil, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
	}
	return ec, nil
}

// SetEmailConfig set email config
func (es *EmailService) SetEmailConfig(ec *EmailConfig) (err error) {
	data, _ := json.Marshal(ec)
	return es.configRepo.SetConfig("email.config", string(data))
}