Sending a raw email with attachments in Go via AWS SES v2

I am trying to create an HTTP endpoint that will handle a form submission from a website.

The form has the following fields:

• Name
• Email
• Phone
• Email body (text for the body of the email)
• Photos (up to 5 of them)

My endpoint will then fire off an email to site@mysite.co.uk with the photos as attachments and the email body being something like:

> John (john@example.com) says:
>
> Email body ...

I am new to Go, but I've been trying to get this working for 2 weeks, and still haven't had any luck.

My code at the moment is:

package aj
import (
"bytes"
"encoding/base64"
"fmt"
"io/ioutil"
"mime"
"net/http"
"net/mail"
"net/textproto"
"os"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/sesv2"
"github.com/aws/aws-sdk-go-v2/service/sesv2/types"
"go.uber.org/zap"
)
const expectedContentType string = "multipart/form-data"
const charset string = "UTF-8"
func FormSubmissionHandler(logger *zap.Logger, emailSender EmailSender) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
logger.Info("running the form submission handler...")
// get the destination email address
destinationEmail := os.Getenv("DESTINATION_EMAIL")
// get the subject line of the email
emailSubject := os.Getenv("EMAIL_SUBJECT")
// enforce a multipart/form-data content-type
contentType := r.Header.Get("content-type")
mediatype, _, err := mime.ParseMediaType(contentType)
if err != nil {
logger.Error("error when parsing the mime type", zap.Error(err))
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
if mediatype != expectedContentType {
logger.Error("unsupported content-type", zap.Error(err))
http.Error(w, fmt.Sprintf("api expects %v content-type", expectedContentType), http.StatusUnsupportedMediaType)
return
}
err = r.ParseMultipartForm(10 << 20)
if err != nil {
logger.Error("error parsing form data", zap.Error(err))
http.Error(w, "error parsing form data", http.StatusBadRequest)
return
}
name := r.MultipartForm.Value["name"]
if len(name) == 0 {
logger.Error("name not set", zap.Error(err))
http.Error(w, "api expects name to be set", http.StatusBadRequest)
return
}
email := r.MultipartForm.Value["email"]
if len(email) == 0 {
logger.Error("email not set", zap.Error(err))
http.Error(w, "api expects email to be set", http.StatusBadRequest)
return
}
phone := r.MultipartForm.Value["phone"]
if len(phone) == 0 {
logger.Error("phone not set", zap.Error(err))
http.Error(w, "api expects phone to be set", http.StatusBadRequest)
return
}
body := r.MultipartForm.Value["body"]
if len(body) == 0 {
logger.Error("body not set", zap.Error(err))
http.Error(w, "api expects body to be set", http.StatusBadRequest)
return
}
files := r.MultipartForm.File["photos"]
if len(files) == 0 {
logger.Error("no files were submitted", zap.Error(err))
http.Error(w, "api expects one or more files to be submitted", http.StatusBadRequest)
return
}
emailService := NewEmailService()
sendEmailInput := sesv2.SendEmailInput{}
destination := &types.Destination{
ToAddresses: []string{destinationEmail},
}
// add the attachments to the email
for _, file := range files {
f, err := file.Open()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer f.Close()
// not sure what to do here to get the email with the attachements
}
message := &types.RawMessage{
Data: make([]byte, 0), // This must change to be the bytes of the raw message
}
content := &types.EmailContent{
Raw: message,
}
sendEmailInput.Content = content
sendEmailInput.Destination = destination
sendEmailInput.FromEmailAddress = aws.String(email[0])
err = emailService.SendEmail(logger, r.Context(), &sendEmailInput)
if err != nil {
logger.Error("an error occured sending the email", zap.Error(err))
http.Error(w, "error sending email", http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusOK)
})
}

My understanding is (please correct me if I'm wrong) that I have to build out a raw message in a format similar to this. Assuming that is right, I'm just not sure how to do that in Go

In order to create an attachment, you have to encode using base64 the content of the message.

Here an example that send a csv as attacchemnt:

import (
  // ...
  secretutils "github.com/alessiosavi/GoGPUtils/aws/secrets"
  sesutils "github.com/alessiosavi/GoGPUtils/aws/ses"
)

type MailConf struct {
	FromName string   `json:"from_name,omitempty"`
	FromMail string   `json:"from_mail,omitempty"`
	To       string   `json:"to,omitempty"`
	CC       []string `json:"cc,omitempty"`
}

func SendRawMail(filename string, data []byte) error {
	var mailConf MailConf
	if err := secretutils.UnmarshalSecret(os.Getenv("XXX_YOUR_SECRET_STORED_IN_AWS"), &mailConf); err != nil {
		return err
	}
	subject := fmt.Sprintf("Found errors for the following file: %s", filename)
	var carbonCopy string
	if len(mailConf.CC) > 0 {
		carbonCopy = stringutils.JoinSeparator(",", mailConf.CC...)
	} else {
		carbonCopy = ""
	}
	raw := fmt.Sprintf(`From: "%[1]s" <%[2]s>
To: %[3]s
Cc: %[4]s
Subject: %[5]s
Content-Type: multipart/mixed;
    boundary="1"

--1
Content-Type: multipart/alternative;
    boundary="sub_1"

--sub_1
Content-Type: string/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable

Please see the attached file for a list of errors

--sub_1
Content-Type: string/html; charset=utf-8
Content-Transfer-Encoding: quoted-printable

<html>
<head></head>
<body>
<h1>%[6]s</h1>
<p><h2>Please see the attached file for the list of the rows.<h2></p>
</body>
</html>

--sub_1--

--1
Content-Type: string/plain; name="errors_%[6]s"
Content-Description: errors_%[6]s
Content-Disposition: attachment;filename="errors_%[6]s";
creation-date="%[7]s";
Content-Transfer-Encoding: base64

%[8]s

--1--`, mailConf.FromName, mailConf.FromMail, mailConf.To, carbonCopy, subject, strings.Replace(filename, ".csv", ".json", 1), time.Now().Format("2-Jan-06 3.04.05 PM"), base64.StdEncoding.EncodeToString(data))

	return sesutils.SendMail([]byte(raw))
}