evalphobia / aws-sdk-go-v2-wrapper

package ses

import (

	"bytes"

	"context"

	"fmt"

	"mime/multipart"

	"net/textproto"

	"strings"

)

// XSendRawEmail sends raw email.

func (svc *SES) XSendRawEmail(ctx context.Context, r XSendRawEmailRequest) error {

	req, err := r.ToRequest()

	if err != nil {

		return err

	}

	if req.ConfigurationSetName == "" {

		req.ConfigurationSetName = svc.defaultConfigurationSet

	}

	_, err = svc.SendRawEmail(ctx, req)

	return err

}

// XSendRawEmailRequest has parameters for `XSendRawEmail` function.

type XSendRawEmailRequest struct {

	From            string

	To              []string

	ReturnPath      string

	Subject         string

	TextBody        string

	TextCharset     string

	HTMLBody        string

	HTMLCharset     string

	ContentLanguage string

	MIMEVersion     string

	Attachments     []XAttachment

	// optional

	ConfigurationSetName string

	FromARN              string

	ReturnPathARN        string

	SourceARN            string

	Tags                 []MessageTag

}

// ToRequest converts to SendRawEmailRequest.

// most header codes are based on,

//   - https://gist.github.com/carelvwyk/60100f2421c6284391d08374bc887dca

//   - https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html

func (r XSendRawEmailRequest) ToRequest() (SendRawEmailRequest, error) {

	req := SendRawEmailRequest{

		ConfigurationSetName: r.ConfigurationSetName,

		Destinations:         r.To,

		FromARN:              r.FromARN,

		ReturnPathARN:        r.ReturnPathARN,

		Source:               r.From,

		SourceARN:            r.SourceARN,

		Tags:                 r.Tags,

	}

	buf := new(bytes.Buffer)

	writer := multipart.NewWriter(buf)

	// email header part

	h := make(textproto.MIMEHeader)

	if r.From != "" {

		h.Set("From", r.From)

	}

	if len(r.To) != 0 {

		h.Set("To", strings.Join(r.To, ", "))

	}

	switch {

	case r.ReturnPath != "":

		h.Set("Return-Path", r.ReturnPath)

	case r.From != "":

		h.Set("Return-Path", r.From)

	}

	if r.Subject != "" {

		h.Set("Subject", r.Subject)

	}

	if r.ContentLanguage != "" {

		h.Set("Content-Language", r.ContentLanguage)

	}

	if r.MIMEVersion != "" {

		h.Set("MIME-Version", r.MIMEVersion)

	}

	h.Set("Content-Type", "multipart/mixed; boundary=\""+writer.Boundary()+"\"")

	_, err := writer.CreatePart(h)

	if err != nil {

		return req, err

	}

	// text body part

	if r.TextBody != "" {

		h := make(textproto.MIMEHeader)

		charset := r.TextCharset

		if charset == "" {

			charset = "utf-8"

		}

		h.Set("Content-Type", fmt.Sprintf("text/plain; charset=%s", charset))

		part, err := writer.CreatePart(h)

		if err != nil {

			return req, err

		}

		_, err = part.Write([]byte(r.TextBody))

		if err != nil {

			return req, err

		}

	}

	// html body part

	if r.HTMLBody != "" {

		h := make(textproto.MIMEHeader)

		charset := r.HTMLCharset

		if charset == "" {

			charset = "utf-8"

		}

		h.Set("Content-Type", fmt.Sprintf("text/html; charset=%s", charset))

		part, err := writer.CreatePart(h)

		if err != nil {

			return req, err

		}

		_, err = part.Write([]byte(r.HTMLBody))

		if err != nil {

			return req, err

		}

	}

	// attachment part

	for _, v := range r.Attachments {

		h := make(textproto.MIMEHeader)

		h.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, v.Filename))

		mimeType := v.MIMEType

		if mimeType == "" {

			mimeType = "text/plain"

		}

		h.Set("Content-Type", fmt.Sprintf(`%s; name="%s"`, mimeType, v.Filename))

		h.Set("Content-Description", v.Filename)

		if v.ContentTransferEncoding != "" {

			h.Set("Content-Transfer-Encoding", v.ContentTransferEncoding)

		}

		part, err := writer.CreatePart(h)

		if err != nil {

			return req, err

		}

		_, err = part.Write(v.Data)

		if err != nil {

			return req, err

		}

		err = writer.Close()

		if err != nil {

			return req, err

		}

	}

	s := buf.String()

	ss := strings.SplitN(s, "\n", 2)

	if len(ss) < 2 {

		return req, fmt.Errorf("invalid e-mail content: [%+v]", ss)

	}

	req.RawMessageData = []byte(ss[1])

	return req, nil

}

	Data     []byte

	Filename string

	MIMEType string

	// if 'ContentTransferEncoding' is "base64", then 'Data' must be base64 encoded.

	ContentTransferEncoding string

}