/******************************************************************************* * Copyright 2012-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * Licensed under the Apache License, Version 2.0 (the "License"). You may not use * this file except in compliance with the License. A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. * This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. * ***************************************************************************** * * AWS Tools for Windows (TM) PowerShell (TM) * */ using System; using System.Collections.Generic; using System.Linq; using System.Management.Automation; using System.Text; using Amazon.PowerShell.Common; using Amazon.Runtime; using Amazon.SimpleEmail; using Amazon.SimpleEmail.Model; namespace Amazon.PowerShell.Cmdlets.SES { /// /// 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: /// /// Additionally, keep the following considerations in mind when using the SendRawEmail /// operation: /// /// [Cmdlet("Send", "SESRawEmail", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)] [OutputType("System.String")] [AWSCmdlet("Calls the Amazon Simple Email Service (SES) SendRawEmail API operation.", Operation = new[] {"SendRawEmail"}, SelectReturnType = typeof(Amazon.SimpleEmail.Model.SendRawEmailResponse))] [AWSCmdletOutput("System.String or Amazon.SimpleEmail.Model.SendRawEmailResponse", "This cmdlet returns a System.String object.", "The service call response (type Amazon.SimpleEmail.Model.SendRawEmailResponse) can also be referenced from properties attached to the cmdlet entry in the $AWSHistory stack." )] public partial class SendSESRawEmailCmdlet : AmazonSimpleEmailServiceClientCmdlet, IExecutor { #region Parameter ConfigurationSetName /// /// /// The name of the configuration set to use when you send an email using SendRawEmail. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String ConfigurationSetName { get; set; } #endregion #region Parameter RawMessage_Data /// /// /// The raw data of the message. This data needs to base64-encoded if you are accessing /// Amazon SES directly through the HTTPS interface. If you are accessing Amazon SES using /// an AWS SDK, the SDK takes care of the base 64-encoding for you. In all cases, the /// client must ensure that the message format complies with Internet email standards /// regarding email header fields, MIME types, and MIME encoding.The To:, CC:, and BCC: headers in the raw message can contain a group list.If you are using SendRawEmail with sending authorization, you can include /// X-headers in the raw message to specify the "Source," "From," and "Return-Path" addresses. /// For more information, see the documentation for SendRawEmail. Do not include these X-headers in the DKIM signature, because they are removed by /// Amazon SES before sending the email.For more information, go to the Amazon /// SES Developer Guide. /// /// The cmdlet will automatically convert the supplied parameter of type string, string[], System.IO.FileInfo or System.IO.Stream to byte[] before supplying it to the service. /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] [Amazon.PowerShell.Common.MemoryStreamParameterConverter] public byte[] RawMessage_Data { get; set; } #endregion #region Parameter Destination /// /// /// A list of destinations for the message, consisting of To:, CC:, and BCC: addresses. /// /// [System.Management.Automation.Parameter(Position = 1, ValueFromPipelineByPropertyName = true)] [Alias("Destinations")] public System.String[] Destination { get; set; } #endregion #region Parameter FromArn /// /// /// 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. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String FromArn { get; set; } #endregion #region Parameter ReturnPathArn /// /// /// 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. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String ReturnPathArn { get; set; } #endregion #region Parameter Source /// /// /// 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. /// 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. 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. 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. 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. /// /// [System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true)] public System.String Source { get; set; } #endregion #region Parameter SourceArn /// /// /// 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. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String SourceArn { get; set; } #endregion #region Parameter Tag /// /// /// 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. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Tags")] public Amazon.SimpleEmail.Model.MessageTag[] Tag { get; set; } #endregion #region Parameter Select /// /// Use the -Select parameter to control the cmdlet output. The default value is 'MessageId'. /// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.SimpleEmail.Model.SendRawEmailResponse). /// Specifying the name of a property of type Amazon.SimpleEmail.Model.SendRawEmailResponse will result in that property being returned. /// Specifying -Select '^ParameterName' will result in the cmdlet returning the selected cmdlet parameter value. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public string Select { get; set; } = "MessageId"; #endregion #region Parameter PassThru /// /// Changes the cmdlet behavior to return the value passed to the Source parameter. /// The -PassThru parameter is deprecated, use -Select '^Source' instead. This parameter will be removed in a future version. /// [System.Obsolete("The -PassThru parameter is deprecated, use -Select '^Source' instead. This parameter will be removed in a future version.")] [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter PassThru { get; set; } #endregion #region Parameter Force /// /// This parameter overrides confirmation prompts to force /// the cmdlet to continue its operation. This parameter should always /// be used with caution. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter Force { get; set; } #endregion protected override void ProcessRecord() { this._AWSSignerType = "v4"; base.ProcessRecord(); var resourceIdentifiersText = FormatParameterValuesForConfirmationMsg(nameof(this.Source), MyInvocation.BoundParameters); if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "Send-SESRawEmail (SendRawEmail)")) { return; } var context = new CmdletContext(); // allow for manipulation of parameters prior to loading into context PreExecutionContextLoad(context); #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute if (ParameterWasBound(nameof(this.Select))) { context.Select = CreateSelectDelegate(Select) ?? throw new System.ArgumentException("Invalid value for -Select parameter.", nameof(this.Select)); if (this.PassThru.IsPresent) { throw new System.ArgumentException("-PassThru cannot be used when -Select is specified.", nameof(this.Select)); } } else if (this.PassThru.IsPresent) { context.Select = (response, cmdlet) => this.Source; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute context.ConfigurationSetName = this.ConfigurationSetName; if (this.Destination != null) { context.Destination = new List(this.Destination); } context.FromArn = this.FromArn; context.RawMessage_Data = this.RawMessage_Data; #if MODULAR if (this.RawMessage_Data == null && ParameterWasBound(nameof(this.RawMessage_Data))) { WriteWarning("You are passing $null as a value for parameter RawMessage_Data which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.ReturnPathArn = this.ReturnPathArn; context.Source = this.Source; context.SourceArn = this.SourceArn; if (this.Tag != null) { context.Tag = new List(this.Tag); } // allow further manipulation of loaded context prior to processing PostExecutionContextLoad(context); var output = Execute(context) as CmdletOutput; ProcessOutput(output); } #region IExecutor Members public object Execute(ExecutorContext context) { System.IO.MemoryStream _RawMessage_DataStream = null; try { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.SimpleEmail.Model.SendRawEmailRequest(); if (cmdletContext.ConfigurationSetName != null) { request.ConfigurationSetName = cmdletContext.ConfigurationSetName; } if (cmdletContext.Destination != null) { request.Destinations = cmdletContext.Destination; } if (cmdletContext.FromArn != null) { request.FromArn = cmdletContext.FromArn; } // populate RawMessage var requestRawMessageIsNull = true; request.RawMessage = new Amazon.SimpleEmail.Model.RawMessage(); System.IO.MemoryStream requestRawMessage_rawMessage_Data = null; if (cmdletContext.RawMessage_Data != null) { _RawMessage_DataStream = new System.IO.MemoryStream(cmdletContext.RawMessage_Data); requestRawMessage_rawMessage_Data = _RawMessage_DataStream; } if (requestRawMessage_rawMessage_Data != null) { request.RawMessage.Data = requestRawMessage_rawMessage_Data; requestRawMessageIsNull = false; } // determine if request.RawMessage should be set to null if (requestRawMessageIsNull) { request.RawMessage = null; } if (cmdletContext.ReturnPathArn != null) { request.ReturnPathArn = cmdletContext.ReturnPathArn; } if (cmdletContext.Source != null) { request.Source = cmdletContext.Source; } if (cmdletContext.SourceArn != null) { request.SourceArn = cmdletContext.SourceArn; } if (cmdletContext.Tag != null) { request.Tags = cmdletContext.Tag; } CmdletOutput output; // issue call var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint); try { var response = CallAWSServiceOperation(client, request); object pipelineOutput = null; pipelineOutput = cmdletContext.Select(response, this); output = new CmdletOutput { PipelineOutput = pipelineOutput, ServiceResponse = response }; } catch (Exception e) { output = new CmdletOutput { ErrorResponse = e }; } return output; } finally { if( _RawMessage_DataStream != null) { _RawMessage_DataStream.Dispose(); } } } public ExecutorContext CreateContext() { return new CmdletContext(); } #endregion #region AWS Service Operation Call private Amazon.SimpleEmail.Model.SendRawEmailResponse CallAWSServiceOperation(IAmazonSimpleEmailService client, Amazon.SimpleEmail.Model.SendRawEmailRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Simple Email Service (SES)", "SendRawEmail"); try { #if DESKTOP return client.SendRawEmail(request); #elif CORECLR return client.SendRawEmailAsync(request).GetAwaiter().GetResult(); #else #error "Unknown build edition" #endif } catch (AmazonServiceException exc) { var webException = exc.InnerException as System.Net.WebException; if (webException != null) { throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException); } throw; } } #endregion internal partial class CmdletContext : ExecutorContext { public System.String ConfigurationSetName { get; set; } public List Destination { get; set; } public System.String FromArn { get; set; } public byte[] RawMessage_Data { get; set; } public System.String ReturnPathArn { get; set; } public System.String Source { get; set; } public System.String SourceArn { get; set; } public List Tag { get; set; } public System.Func Select { get; set; } = (response, cmdlet) => response.MessageId; } } }