dex/vendor/github.com/mailgun/mailgun-go/messages.go

package mailgun

import (
	"encoding/json"
	"errors"
	"io"
	"time"

	"github.com/mbanzon/simplehttp"
)

// MaxNumberOfRecipients represents the largest batch of recipients that Mailgun can support in a single API call.
// This figure includes To:, Cc:, Bcc:, etc. recipients.
const MaxNumberOfRecipients = 1000

// Message structures contain both the message text and the envelop for an e-mail message.
type Message struct {
	to                []string
	tags              []string
	campaigns         []string
	dkim              bool
	deliveryTime      *time.Time
	attachments       []string
	readerAttachments []ReaderAttachment
	inlines           []string

	testMode           bool
	tracking           bool
	trackingClicks     bool
	trackingOpens      bool
	headers            map[string]string
	variables          map[string]string
	recipientVariables map[string]map[string]interface{}

	dkimSet           bool
	trackingSet       bool
	trackingClicksSet bool
	trackingOpensSet  bool

	specific features
	mg       Mailgun
}

type ReaderAttachment struct {
	Filename   string
	ReadCloser io.ReadCloser
}

// StoredMessage structures contain the (parsed) message content for an email
// sent to a Mailgun account.
//
// The MessageHeaders field is special, in that it's formatted as a slice of pairs.
// Each pair consists of a name [0] and value [1].  Array notation is used instead of a map
// because that's how it's sent over the wire, and it's how encoding/json expects this field
// to be.
type StoredMessage struct {
	Recipients        string                 `json:"recipients"`
	Sender            string                 `json:"sender"`
	From              string                 `json:"from"`
	Subject           string                 `json:"subject"`
	BodyPlain         string                 `json:"body-plain"`
	StrippedText      string                 `json:"stripped-text"`
	StrippedSignature string                 `json:"stripped-signature"`
	BodyHtml          string                 `json:"body-html"`
	StrippedHtml      string                 `json:"stripped-html"`
	Attachments       []StoredAttachment     `json:"attachments"`
	MessageUrl        string                 `json:"message-url"`
	ContentIDMap      map[string]interface{} `json:"content-id-map"`
	MessageHeaders    [][]string             `json:"message-headers"`
}

// StoredAttachment structures contain information on an attachment associated with a stored message.
type StoredAttachment struct {
	Size        int    `json:"size"`
	Url         string `json:"url"`
	Name        string `json:"name"`
	ContentType string `json:"content-type"`
}

type StoredMessageRaw struct {
	Recipients string `json:"recipients"`
	Sender     string `json:"sender"`
	From       string `json:"from"`
	Subject    string `json:"subject"`
	BodyMime   string `json:"body-mime"`
}

// plainMessage contains fields relevant to plain API-synthesized messages.
// You're expected to use various setters to set most of these attributes,
// although from, subject, and text are set when the message is created with
// NewMessage.
type plainMessage struct {
	from    string
	cc      []string
	bcc     []string
	subject string
	text    string
	html    string
}

// mimeMessage contains fields relevant to pre-packaged MIME messages.
type mimeMessage struct {
	body io.ReadCloser
}

type sendMessageResponse struct {
	Message string `json:"message"`
	Id      string `json:"id"`
}

// features abstracts the common characteristics between regular and MIME messages.
// addCC, addBCC, recipientCount, and setHTML are invoked via the package-global AddCC, AddBCC,
// RecipientCount, and SetHtml calls, as these functions are ignored for MIME messages.
// Send() invokes addValues to add message-type-specific MIME headers for the API call
// to Mailgun.  isValid yeilds true if and only if the message is valid enough for sending
// through the API.  Finally, endpoint() tells Send() which endpoint to use to submit the API call.
type features interface {
	addCC(string)
	addBCC(string)
	setHtml(string)
	addValues(*simplehttp.FormDataPayload)
	isValid() bool
	endpoint() string
	recipientCount() int
}

// NewMessage returns a new e-mail message with the simplest envelop needed to send.
//
// DEPRECATED.
// The package will panic if you use AddRecipient(), AddBcc(), AddCc(), et. al.
// on a message already equipped with MaxNumberOfRecipients recipients.
// Use Mailgun.NewMessage() instead.
// It works similarly to this function, but supports larger lists of recipients.
func NewMessage(from string, subject string, text string, to ...string) *Message {
	return &Message{
		specific: &plainMessage{
			from:    from,
			subject: subject,
			text:    text,
		},
		to: to,
	}
}

// NewMessage returns a new e-mail message with the simplest envelop needed to send.
//
// Unlike the global function,
// this method supports arbitrary-sized recipient lists by
// automatically sending mail in batches of up to MaxNumberOfRecipients.
//
// To support batch sending, you don't want to provide a fixed To: header at this point.
// Pass nil as the to parameter to skip adding the To: header at this stage.
// You can do this explicitly, or implicitly, as follows:
//
//     // Note absence of To parameter(s)!
//     m := mg.NewMessage("me@example.com", "Help save our planet", "Hello world!")
//
// Note that you'll need to invoke the AddRecipientAndVariables or AddRecipient method
// before sending, though.
func (mg *MailgunImpl) NewMessage(from, subject, text string, to ...string) *Message {
	return &Message{
		specific: &plainMessage{
			from:    from,
			subject: subject,
			text:    text,
		},
		to: to,
		mg: mg,
	}
}

// NewMIMEMessage creates a new MIME message.  These messages are largely canned;
// you do not need to invoke setters to set message-related headers.
// However, you do still need to call setters for Mailgun-specific settings.
//
// DEPRECATED.
// The package will panic if you use AddRecipient(), AddBcc(), AddCc(), et. al.
// on a message already equipped with MaxNumberOfRecipients recipients.
// Use Mailgun.NewMIMEMessage() instead.
// It works similarly to this function, but supports larger lists of recipients.
func NewMIMEMessage(body io.ReadCloser, to ...string) *Message {
	return &Message{
		specific: &mimeMessage{
			body: body,
		},
		to: to,
	}
}

// NewMIMEMessage creates a new MIME message.  These messages are largely canned;
// you do not need to invoke setters to set message-related headers.
// However, you do still need to call setters for Mailgun-specific settings.
//
// Unlike the global function,
// this method supports arbitrary-sized recipient lists by
// automatically sending mail in batches of up to MaxNumberOfRecipients.
//
// To support batch sending, you don't want to provide a fixed To: header at this point.
// Pass nil as the to parameter to skip adding the To: header at this stage.
// You can do this explicitly, or implicitly, as follows:
//
//     // Note absence of To parameter(s)!
//     m := mg.NewMessage("me@example.com", "Help save our planet", "Hello world!")
//
// Note that you'll need to invoke the AddRecipientAndVariables or AddRecipient method
// before sending, though.
func (mg *MailgunImpl) NewMIMEMessage(body io.ReadCloser, to ...string) *Message {
	return &Message{
		specific: &mimeMessage{
			body: body,
		},
		to: to,
		mg: mg,
	}
}

// AddReaderAttachment arranges to send a file along with the e-mail message.
// File contents are read from a io.ReadCloser.
// The filename parameter is the resulting filename of the attachment.
// The readCloser parameter is the io.ReadCloser which reads the actual bytes to be used
// as the contents of the attached file.
func (m *Message) AddReaderAttachment(filename string, readCloser io.ReadCloser) {
	ra := ReaderAttachment{Filename: filename, ReadCloser: readCloser}
	m.readerAttachments = append(m.readerAttachments, ra)
}

// AddAttachment arranges to send a file from the filesystem along with the e-mail message.
// The attachment parameter is a filename, which must refer to a file which actually resides
// in the local filesystem.
func (m *Message) AddAttachment(attachment string) {
	m.attachments = append(m.attachments, attachment)
}

// AddInline arranges to send a file along with the e-mail message, but does so
// in a way that its data remains "inline" with the rest of the message.  This
// can be used to send image or font data along with an HTML-encoded message body.
// The attachment parameter is a filename, which must refer to a file which actually resides
// in the local filesystem.
func (m *Message) AddInline(inline string) {
	m.inlines = append(m.inlines, inline)
}

// AddRecipient appends a receiver to the To: header of a message.
//
// NOTE: Above a certain limit (currently 1000 recipients),
// this function will cause the message as it's currently defined to be sent.
// This allows you to support large mailing lists without running into Mailgun's API limitations.
func (m *Message) AddRecipient(recipient string) error {
	return m.AddRecipientAndVariables(recipient, nil)
}

// AddRecipientAndVariables appends a receiver to the To: header of a message,
// and as well attaches a set of variables relevant for this recipient.
//
// NOTE: Above a certain limit (see MaxNumberOfRecipients),
// this function will cause the message as it's currently defined to be sent.
// This allows you to support large mailing lists without running into Mailgun's API limitations.
func (m *Message) AddRecipientAndVariables(r string, vars map[string]interface{}) error {
	if m.RecipientCount() >= MaxNumberOfRecipients {
		_, _, err := m.send()
		if err != nil {
			return err
		}
		m.to = make([]string, len(m.to))
		m.recipientVariables = make(map[string]map[string]interface{}, len(m.recipientVariables))
	}
	m.to = append(m.to, r)
	if vars != nil {
		if m.recipientVariables == nil {
			m.recipientVariables = make(map[string]map[string]interface{})
		}
		m.recipientVariables[r] = vars
	}
	return nil
}

// RecipientCount returns the total number of recipients for the message.
// This includes To:, Cc:, and Bcc: fields.
//
// NOTE: At present, this method is reliable only for non-MIME messages, as the
// Bcc: and Cc: fields are easily accessible.
// For MIME messages, only the To: field is considered.
// A fix for this issue is planned for a future release.
// For now, MIME messages are always assumed to have 10 recipients between Cc: and Bcc: fields.
// If your MIME messages have more than 10 non-To: field recipients,
// you may find that some recipients will not receive your e-mail.
// It's perfectly OK, of course, for a MIME message to not have any Cc: or Bcc: recipients.
func (m *Message) RecipientCount() int {
	return len(m.to) + m.specific.recipientCount()
}

func (pm *plainMessage) recipientCount() int {
	return len(pm.bcc) + len(pm.cc)
}

func (mm *mimeMessage) recipientCount() int {
	return 10
}

func (m *Message) send() (string, string, error) {
	return m.mg.Send(m)
}

// AddCC appends a receiver to the carbon-copy header of a message.
func (m *Message) AddCC(recipient string) {
	m.specific.addCC(recipient)
}

func (pm *plainMessage) addCC(r string) {
	pm.cc = append(pm.cc, r)
}

func (mm *mimeMessage) addCC(_ string) {}

// AddBCC appends a receiver to the blind-carbon-copy header of a message.
func (m *Message) AddBCC(recipient string) {
	m.specific.addBCC(recipient)
}

func (pm *plainMessage) addBCC(r string) {
	pm.bcc = append(pm.bcc, r)
}

func (mm *mimeMessage) addBCC(_ string) {}

// If you're sending a message that isn't already MIME encoded, SetHtml() will arrange to bundle
// an HTML representation of your message in addition to your plain-text body.
func (m *Message) SetHtml(html string) {
	m.specific.setHtml(html)
}

func (pm *plainMessage) setHtml(h string) {
	pm.html = h
}

func (mm *mimeMessage) setHtml(_ string) {}

// AddTag attaches a tag to the message.  Tags are useful for metrics gathering and event tracking purposes.
// Refer to the Mailgun documentation for further details.
func (m *Message) AddTag(tag string) {
	m.tags = append(m.tags, tag)
}

// This feature is deprecated for new software.
func (m *Message) AddCampaign(campaign string) {
	m.campaigns = append(m.campaigns, campaign)
}

// SetDKIM arranges to send the o:dkim header with the message, and sets its value accordingly.
// Refer to the Mailgun documentation for more information.
func (m *Message) SetDKIM(dkim bool) {
	m.dkim = dkim
	m.dkimSet = true
}

// EnableTestMode allows submittal of a message, such that it will be discarded by Mailgun.
// This facilitates testing client-side software without actually consuming e-mail resources.
func (m *Message) EnableTestMode() {
	m.testMode = true
}

// SetDeliveryTime schedules the message for transmission at the indicated time.
// Pass nil to remove any installed schedule.
// Refer to the Mailgun documentation for more information.
func (m *Message) SetDeliveryTime(dt time.Time) {
	pdt := new(time.Time)
	*pdt = dt
	m.deliveryTime = pdt
}

// SetTracking sets the o:tracking message parameter to adjust, on a message-by-message basis,
// whether or not Mailgun will rewrite URLs to facilitate event tracking.
// Events tracked includes opens, clicks, unsubscribes, etc.
// Note: simply calling this method ensures that the o:tracking header is passed in with the message.
// Its yes/no setting is determined by the call's parameter.
// Note that this header is not passed on to the final recipient(s).
// Refer to the Mailgun documentation for more information.
func (m *Message) SetTracking(tracking bool) {
	m.tracking = tracking
	m.trackingSet = true
}

// Refer to the Mailgun documentation for more information.
func (m *Message) SetTrackingClicks(trackingClicks bool) {
	m.trackingClicks = trackingClicks
	m.trackingClicksSet = true
}

// Refer to the Mailgun documentation for more information.
func (m *Message) SetTrackingOpens(trackingOpens bool) {
	m.trackingOpens = trackingOpens
	m.trackingOpensSet = true
}

// AddHeader allows you to send custom MIME headers with the message.
func (m *Message) AddHeader(header, value string) {
	if m.headers == nil {
		m.headers = make(map[string]string)
	}
	m.headers[header] = value
}

// AddVariable lets you associate a set of variables with messages you send,
// which Mailgun can use to, in essence, complete form-mail.
// Refer to the Mailgun documentation for more information.
func (m *Message) AddVariable(variable string, value interface{}) error {
	j, err := json.Marshal(value)
	if err != nil {
		return err
	}
	if m.variables == nil {
		m.variables = make(map[string]string)
	}
	m.variables[variable] = string(j)
	return nil
}

// Send attempts to queue a message (see Message, NewMessage, and its methods) for delivery.
// It returns the Mailgun server response, which consists of two components:
// a human-readable status message, and a message ID.  The status and message ID are set only
// if no error occurred.
func (m *MailgunImpl) Send(message *Message) (mes string, id string, err error) {
	if !isValid(message) {
		err = errors.New("Message not valid")
	} else {
		payload := simplehttp.NewFormDataPayload()

		message.specific.addValues(payload)
		for _, to := range message.to {
			payload.AddValue("to", to)
		}
		for _, tag := range message.tags {
			payload.AddValue("o:tag", tag)
		}
		for _, campaign := range message.campaigns {
			payload.AddValue("o:campaign", campaign)
		}
		if message.dkimSet {
			payload.AddValue("o:dkim", yesNo(message.dkim))
		}
		if message.deliveryTime != nil {
			payload.AddValue("o:deliverytime", formatMailgunTime(message.deliveryTime))
		}
		if message.testMode {
			payload.AddValue("o:testmode", "yes")
		}
		if message.trackingSet {
			payload.AddValue("o:tracking", yesNo(message.tracking))
		}
		if message.trackingClicksSet {
			payload.AddValue("o:tracking-clicks", yesNo(message.trackingClicks))
		}
		if message.trackingOpensSet {
			payload.AddValue("o:tracking-opens", yesNo(message.trackingOpens))
		}
		if message.headers != nil {
			for header, value := range message.headers {
				payload.AddValue("h:"+header, value)
			}
		}
		if message.variables != nil {
			for variable, value := range message.variables {
				payload.AddValue("v:"+variable, value)
			}
		}
		if message.recipientVariables != nil {
			j, err := json.Marshal(message.recipientVariables)
			if err != nil {
				return "", "", err
			}
			payload.AddValue("recipient-variables", string(j))
		}
		if message.attachments != nil {
			for _, attachment := range message.attachments {
				payload.AddFile("attachment", attachment)
			}
		}
		if message.readerAttachments != nil {
			for _, readerAttachment := range message.readerAttachments {
				payload.AddReadCloser("attachment", readerAttachment.Filename, readerAttachment.ReadCloser)
			}
		}
		if message.inlines != nil {
			for _, inline := range message.inlines {
				payload.AddFile("inline", inline)
			}
		}

		r := simplehttp.NewHTTPRequest(generateApiUrl(m, message.specific.endpoint()))
		r.SetBasicAuth(basicAuthUser, m.ApiKey())

		var response sendMessageResponse
		err = postResponseFromJSON(r, payload, &response)
		if err == nil {
			mes = response.Message
			id = response.Id
		}
	}

	return
}

func (pm *plainMessage) addValues(p *simplehttp.FormDataPayload) {
	p.AddValue("from", pm.from)
	p.AddValue("subject", pm.subject)
	p.AddValue("text", pm.text)
	for _, cc := range pm.cc {
		p.AddValue("cc", cc)
	}
	for _, bcc := range pm.bcc {
		p.AddValue("bcc", bcc)
	}
	if pm.html != "" {
		p.AddValue("html", pm.html)
	}
}

func (mm *mimeMessage) addValues(p *simplehttp.FormDataPayload) {
	p.AddReadCloser("message", "message.mime", mm.body)
}

func (pm *plainMessage) endpoint() string {
	return messagesEndpoint
}

func (mm *mimeMessage) endpoint() string {
	return mimeMessagesEndpoint
}

// yesNo translates a true/false boolean value into a yes/no setting suitable for the Mailgun API.
func yesNo(b bool) string {
	if b {
		return "yes"
	} else {
		return "no"
	}
}

// isValid returns true if, and only if,
// a Message instance is sufficiently initialized to send via the Mailgun interface.
func isValid(m *Message) bool {
	if m == nil {
		return false
	}

	if !m.specific.isValid() {
		return false
	}

	if !validateStringList(m.to, true) {
		return false
	}

	if !validateStringList(m.tags, false) {
		return false
	}

	if !validateStringList(m.campaigns, false) || len(m.campaigns) > 3 {
		return false
	}

	return true
}

func (pm *plainMessage) isValid() bool {
	if pm.from == "" {
		return false
	}

	if !validateStringList(pm.cc, false) {
		return false
	}

	if !validateStringList(pm.bcc, false) {
		return false
	}

	if pm.text == "" {
		return false
	}

	return true
}

func (mm *mimeMessage) isValid() bool {
	return mm.body != nil
}

// validateStringList returns true if, and only if,
// a slice of strings exists AND all of its elements exist,
// OR if the slice doesn't exist AND it's not required to exist.
// The requireOne parameter indicates whether the list is required to exist.
func validateStringList(list []string, requireOne bool) bool {
	hasOne := false

	if list == nil {
		return !requireOne
	} else {
		for _, a := range list {
			if a == "" {
				return false
			} else {
				hasOne = hasOne || true
			}
		}
	}

	return hasOne
}

// GetStoredMessage retrieves information about a received e-mail message.
// This provides visibility into, e.g., replies to a message sent to a mailing list.
func (mg *MailgunImpl) GetStoredMessage(id string) (StoredMessage, error) {
	url := generateStoredMessageUrl(mg, messagesEndpoint, id)
	r := simplehttp.NewHTTPRequest(url)
	r.SetBasicAuth(basicAuthUser, mg.ApiKey())

	var response StoredMessage
	err := getResponseFromJSON(r, &response)
	return response, err
}

// GetStoredMessageRaw retrieves the raw MIME body of a received e-mail message.
// Compared to GetStoredMessage, it gives access to the unparsed MIME body, and
// thus delegates to the caller the required parsing.
func (mg *MailgunImpl) GetStoredMessageRaw(id string) (StoredMessageRaw, error) {
	url := generateStoredMessageUrl(mg, messagesEndpoint, id)
	r := simplehttp.NewHTTPRequest(url)
	r.SetBasicAuth(basicAuthUser, mg.ApiKey())
	r.AddHeader("Accept", "message/rfc2822")

	var response StoredMessageRaw
	err := getResponseFromJSON(r, &response)
	return response, err

}

// DeleteStoredMessage removes a previously stored message.
// Note that Mailgun institutes a policy of automatically deleting messages after a set time.
// Consult the current Mailgun API documentation for more details.
func (mg *MailgunImpl) DeleteStoredMessage(id string) error {
	url := generateStoredMessageUrl(mg, messagesEndpoint, id)
	r := simplehttp.NewHTTPRequest(url)
	r.SetBasicAuth(basicAuthUser, mg.ApiKey())
	_, err := makeDeleteRequest(r)
	return err
}