service/ses/api_op_SendRawEmail.go

// Code generated by smithy-go-codegen DO NOT EDIT.

package ses

import (
	"context"
	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
	"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
	"github.com/aws/aws-sdk-go-v2/service/ses/types"
	"github.com/aws/smithy-go/middleware"
	smithyhttp "github.com/aws/smithy-go/transport/http"
)

// Composes an email message and immediately queues it for sending. This operation
// is more flexible than the SendEmail API operation. When you use the SendRawEmail
// operation, you can specify the headers of the message as well as its content.
// This flexibility is useful, for example, when you want to send a multipart MIME
// email (such a message that contains both a text and an HTML version). You can
// also use this operation to send messages that include attachments. The
// SendRawEmail operation has the following requirements:
//
// * You can only send
// email from verified email addresses or domains
// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html).
// If you try to send email from an address that isn't verified, the operation
// results in an "Email address not verified" error.
//
// * If your account is still in
// the Amazon SES sandbox
// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/request-production-access.html),
// you can only send email to other verified addresses in your account, or to
// addresses that are associated with the Amazon SES mailbox simulator
// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/mailbox-simulator.html).
//
// *
// The maximum message size, including attachments, is 10 MB.
//
// * Each message has
// to include at least one recipient address. A recipient address includes any
// address on the To:, CC:, or BCC: lines.
//
// * If you send a single message to more
// than one recipient address, and one of the recipient addresses isn't in a valid
// format (that is, it's not in the format
// UserName@[SubDomain.]Domain.TopLevelDomain), Amazon SES rejects the entire
// message, even if the other addresses are valid.
//
// * Each message can include up
// to 50 recipient addresses across the To:, CC:, or BCC: lines. If you need to
// send a single message to more than 50 recipients, you have to split the list of
// recipient addresses into groups of less than 50 recipients, and send separate
// messages to each group.
//
// * Amazon SES allows you to specify 8-bit
// Content-Transfer-Encoding for MIME message parts. However, if Amazon SES has to
// modify the contents of your message (for example, if you use open and click
// tracking), 8-bit content isn't preserved. For this reason, we highly recommend
// that you encode all content that isn't 7-bit ASCII. For more information, see
// MIME Encoding
// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html#send-email-mime-encoding)
// in the Amazon SES Developer Guide.
//
// Additionally, keep the following
// considerations in mind when using the SendRawEmail operation:
//
// * Although you
// can customize the message headers when using the SendRawEmail operation, Amazon
// SES will automatically apply its own Message-ID and Date headers; if you passed
// these headers when creating the message, they will be overwritten by the values
// that Amazon SES provides.
//
// * If you are using sending authorization to send on
// behalf of another user, SendRawEmail enables you to specify the cross-account
// identity for the email's Source, From, and Return-Path parameters in one of two
// ways: you can pass optional parameters SourceArn, FromArn, and/or ReturnPathArn
// to the API, or you can include the following X-headers in the header of your raw
// email:
//
// * X-SES-SOURCE-ARN
//
// * X-SES-FROM-ARN
//
// * X-SES-RETURN-PATH-ARN
//
// Don't
// include these X-headers in the DKIM signature. Amazon SES removes these before
// it sends the email. If you only specify the SourceIdentityArn parameter, Amazon
// SES sets the From and Return-Path addresses to the same identity that you
// specified. For more information about sending authorization, see the Using
// Sending Authorization with Amazon SES
// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html)
// in the Amazon SES Developer Guide.
//
// * For every message that you send, the total
// number of recipients (including each recipient in the To:, CC: and BCC: fields)
// is counted against the maximum number of emails you can send in a 24-hour period
// (your sending quota). For more information about sending quotas in Amazon SES,
// see Managing Your Amazon SES Sending Limits
// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/manage-sending-limits.html)
// in the Amazon SES Developer Guide.
func (c *Client) SendRawEmail(ctx context.Context, params *SendRawEmailInput, optFns ...func(*Options)) (*SendRawEmailOutput, error) {
	if params == nil {
		params = &SendRawEmailInput{}
	}

	result, metadata, err := c.invokeOperation(ctx, "SendRawEmail", params, optFns, addOperationSendRawEmailMiddlewares)
	if err != nil {
		return nil, err
	}

	out := result.(*SendRawEmailOutput)
	out.ResultMetadata = metadata
	return out, nil
}

// Represents a request to send a single raw email using Amazon SES. For more
// information, see the Amazon SES Developer Guide
// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html).
type SendRawEmailInput struct {

	// The raw email message itself. The message has to meet the following criteria:
	//
	// *
	// The message has to contain a header and a body, separated by a blank line.
	//
	// *
	// All of the required header fields must be present in the message.
	//
	// * Each part
	// of a multipart MIME message must be formatted properly.
	//
	// * Attachments must be
	// of a content type that Amazon SES supports. For a list on unsupported content
	// types, see Unsupported Attachment Types
	// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/mime-types.html) in the
	// Amazon SES Developer Guide.
	//
	// * The entire message must be base64-encoded.
	//
	// * If
	// any of the MIME parts in your message contain content that is outside of the
	// 7-bit ASCII character range, we highly recommend that you encode that content.
	// For more information, see Sending Raw Email
	// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html) in
	// the Amazon SES Developer Guide.
	//
	// * Per RFC 5321
	// (https://tools.ietf.org/html/rfc5321#section-4.5.3.1.6), the maximum length of
	// each line of text, including the , must not exceed 1,000 characters.
	//
	// This member is required.
	RawMessage *types.RawMessage

	// The name of the configuration set to use when you send an email using
	// SendRawEmail.
	ConfigurationSetName *string

	// A list of destinations for the message, consisting of To:, CC:, and BCC:
	// addresses.
	Destinations []string

	// This parameter is used only for sending authorization. It is the ARN of the
	// identity that is associated with the sending authorization policy that permits
	// you to specify a particular "From" address in the header of the raw email.
	// Instead of using this parameter, you can use the X-header X-SES-FROM-ARN in the
	// raw message of the email. If you use both the FromArn parameter and the
	// corresponding X-header, Amazon SES uses the value of the FromArn parameter. For
	// information about when to use this parameter, see the description of
	// SendRawEmail in this guide, or see the Amazon SES Developer Guide
	// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization-delegate-sender-tasks-email.html).
	FromArn *string

	// This parameter is used only for sending authorization. It is the ARN of the
	// identity that is associated with the sending authorization policy that permits
	// you to use the email address specified in the ReturnPath parameter. For example,
	// if the owner of example.com (which has ARN
	// arn:aws:ses:us-east-1:123456789012:identity/example.com) attaches a policy to it
	// that authorizes you to use feedback@example.com, then you would specify the
	// ReturnPathArn to be arn:aws:ses:us-east-1:123456789012:identity/example.com, and
	// the ReturnPath to be feedback@example.com. Instead of using this parameter, you
	// can use the X-header X-SES-RETURN-PATH-ARN in the raw message of the email. If
	// you use both the ReturnPathArn parameter and the corresponding X-header, Amazon
	// SES uses the value of the ReturnPathArn parameter. For information about when to
	// use this parameter, see the description of SendRawEmail in this guide, or see
	// the Amazon SES Developer Guide
	// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization-delegate-sender-tasks-email.html).
	ReturnPathArn *string

	// The identity's email address. If you do not provide a value for this parameter,
	// you must specify a "From" address in the raw text of the message. (You can also
	// specify both.) Amazon SES does not support the SMTPUTF8 extension, as described
	// inRFC6531 (https://tools.ietf.org/html/rfc6531). For this reason, the local part
	// of a source email address (the part of the email address that precedes the @
	// sign) may only contain 7-bit ASCII characters
	// (https://en.wikipedia.org/wiki/Email_address#Local-part). If the domain part of
	// an address (the part after the @ sign) contains non-ASCII characters, they must
	// be encoded using Punycode, as described in RFC3492
	// (https://tools.ietf.org/html/rfc3492.html). The sender name (also known as the
	// friendly name) may contain non-ASCII characters. These characters must be
	// encoded using MIME encoded-word syntax, as described in RFC 2047
	// (https://tools.ietf.org/html/rfc2047). MIME encoded-word syntax uses the
	// following form: =?charset?encoding?encoded-text?=. If you specify the Source
	// parameter and have feedback forwarding enabled, then bounces and complaints will
	// be sent to this email address. This takes precedence over any Return-Path header
	// that you might include in the raw text of the message.
	Source *string

	// This parameter is used only for sending authorization. It is the ARN of the
	// identity that is associated with the sending authorization policy that permits
	// you to send for the email address specified in the Source parameter. For
	// example, if the owner of example.com (which has ARN
	// arn:aws:ses:us-east-1:123456789012:identity/example.com) attaches a policy to it
	// that authorizes you to send from user@example.com, then you would specify the
	// SourceArn to be arn:aws:ses:us-east-1:123456789012:identity/example.com, and the
	// Source to be user@example.com. Instead of using this parameter, you can use the
	// X-header X-SES-SOURCE-ARN in the raw message of the email. If you use both the
	// SourceArn parameter and the corresponding X-header, Amazon SES uses the value of
	// the SourceArn parameter. For information about when to use this parameter, see
	// the description of SendRawEmail in this guide, or see the Amazon SES Developer
	// Guide
	// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization-delegate-sender-tasks-email.html).
	SourceArn *string

	// A list of tags, in the form of name/value pairs, to apply to an email that you
	// send using SendRawEmail. Tags correspond to characteristics of the email that
	// you define, so that you can publish email sending events.
	Tags []types.MessageTag
}

// Represents a unique message ID.
type SendRawEmailOutput struct {

	// The unique message identifier returned from the SendRawEmail action.
	//
	// This member is required.
	MessageId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

func addOperationSendRawEmailMiddlewares(stack *middleware.Stack, options Options) (err error) {
	err = stack.Serialize.Add(&awsAwsquery_serializeOpSendRawEmail{}, middleware.After)
	if err != nil {
		return err
	}
	err = stack.Deserialize.Add(&awsAwsquery_deserializeOpSendRawEmail{}, middleware.After)
	if err != nil {
		return err
	}
	if err = addSetLoggerMiddleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
		return err
	}
	if err = addResolveEndpointMiddleware(stack, options); err != nil {
		return err
	}
	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
		return err
	}
	if err = addRetryMiddlewares(stack, options); err != nil {
		return err
	}
	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
		return err
	}
	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
		return err
	}
	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
		return err
	}
	if err = addClientUserAgent(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = addOpSendRawEmailValidationMiddleware(stack); err != nil {
		return err
	}
	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSendRawEmail(options.Region), middleware.Before); err != nil {
		return err
	}
	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
		return err
	}
	if err = addResponseErrorMiddleware(stack); err != nil {
		return err
	}
	if err = addRequestResponseLogging(stack, options); err != nil {
		return err
	}
	return nil
}

func newServiceMetadataMiddleware_opSendRawEmail(region string) *awsmiddleware.RegisterServiceMetadata {
	return &awsmiddleware.RegisterServiceMetadata{
		Region:        region,
		ServiceID:     ServiceID,
		SigningName:   "ses",
		OperationName: "SendRawEmail",
	}
}