Send raw email with attachments in Go via AWS SES v2

john ([email protected]) says:
email body ...

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)
    })
}

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))
}