Send raw email with attachments in Go via AWS SES v2

php editor Xiaoxin brings you an article about sending original emails with attachments using AWS SES v2 in Go. The combination of AWS SES v2, a flexible and reliable email service, and Go, a powerful programming language, can help you easily send original emails with attachments. This article will detail how to write code using the AWS SES v2 API and Go language to implement this functionality. Whether you're a beginner or an experienced developer, this article will provide you with clear guidance to get the job done successfully. Let’s get started!

Question content

I'm trying to create an http endpoint to handle form submissions from a website.

The form has the following fields:

• Name
• e-mail
• Telephone
• Email body (text of the email body)
• Photos (max 5)

My endpoint will then send an email to [email protected] with the photo as an attachment and the body of the email as follows:

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

I'm new to go but I've been trying to get it working for 2 weeks now and still haven't had any luck.

My current code 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 the original message in a format similar to this. Assuming this is correct, I just don't know how to do this in go

Workaround

In order to create the attachment you must use base64 the message content to encode.

Here is an example of sending a csv as attachment:

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

The above is the detailed content of Send raw email with attachments in Go via AWS SES v2. For more information, please follow other related articles on the PHP Chinese website!