/// <summary>
/// Asynchronously sends a bulk email message and returns the response from the Injection API.
/// </summary>
/// <param name="message">A <c>BulkMessage</c> object to be sent.</param>
/// <param name="cancellationToken">A <c>CancellationToken</c> to handle cancellation between async threads.</param>
/// <returns>A <c>SendResponse</c> of an SocketLabsClient send request.</returns>
/// <example>
/// This sample shows you how to Send a Bulk Message
/// <code>
/// var client = new SocketLabsClient(00000, "apiKey");
///
/// var message = new BulkMessage();
///
/// message.PlainTextBody = "This is the body of my message sent to ##Name##";
/// message.HtmlBody = "<html>This is the HtmlBody of my message sent to ##Name##</html>";
/// message.Subject = "Sending a test message";
/// message.From.Email = "*****@*****.**";
///
/// var recipient1 = message.To.Add("*****@*****.**");
/// recipient1.MergeData.Add("Name", "Recipient1");
///
/// var recipient2 = message.To.Add("*****@*****.**");
/// recipient2.MergeData.Add("Name", "Recipient2");
///
/// var response = await client.Send(message);
///
/// if (response.Result != SendResult.Success)
/// {
/// // Handle Error
/// }
///</code>
/// </example>
public async Task <SendResponse> SendAsync(IBulkMessage message, CancellationToken cancellationToken)
{
var validator = new SendValidator();
var validationResult = validator.ValidateCredentials(_serverId, _apiKey);
if (validationResult.Result != SendResult.Success)
{
return(validationResult);
}
validationResult = validator.ValidateMessage(message);
if (validationResult.Result != SendResult.Success)
{
return(validationResult);
}
var factory = new InjectionRequestFactory(_serverId, _apiKey);
var injectionRequest = factory.GenerateRequest(message);
var json = injectionRequest.GetAsJson();
var retryHandler = new RetryHandler(_httpClient, EndpointUrl, new RetrySettings(NumberOfRetries));
var httpResponse = await retryHandler.SendAsync(json, cancellationToken);
var response = new InjectionResponseParser().Parse(httpResponse);
return(response);
}
public Task <SendResponse> SendAsync(IBulkMessage message)
{
return(Task.Run(() => new SendResponse()
{
Result = SendResult.Success
}));
}
public SendResponse Send(IBulkMessage message)
{
return(new SendResponse()
{
Result = SendResult.Success
});
}
/// <summary>
/// Asynchronously sends a bulk email message and returns the response from the Injection API.
/// </summary>
/// <param name="message">A <c>BulkMessage</c> object to be sent.</param>
/// <returns>A <c>SendResponse</c> of an SocketLabsClient send request.</returns>
/// <example>
/// This sample shows you how to Send a Bulk Message
/// <code>
/// var client = new SocketLabsClient(00000, "apiKey");
///
/// var message = new BulkMessage();
///
/// message.PlainTextBody = "This is the body of my message sent to ##Name##";
/// message.HtmlBody = "<html>This is the HtmlBody of my message sent to ##Name##</html>";
/// message.Subject = "Sending a test message";
/// message.From.Email = "*****@*****.**";
///
/// var recipient1 = message.To.Add("*****@*****.**");
/// recipient1.MergeData.Add("Name", "Recipient1");
///
/// var recipient2 = message.To.Add("*****@*****.**");
/// recipient2.MergeData.Add("Name", "Recipient2");
///
/// var response = await client.Send(message);
///
/// if (response.Result != SendResult.Success)
/// {
/// // Handle Error
/// }
///</code>
/// </example>
public async Task <SendResponse> SendAsync(IBulkMessage message)
{
var validator = new SendValidator();
var validationResult = validator.ValidateCredentials(_serverId, _apiKey);
if (validationResult.Result != SendResult.Success)
{
return(validationResult);
}
validationResult = validator.ValidateMessage(message);
if (validationResult.Result != SendResult.Success)
{
return(validationResult);
}
var factory = new InjectionRequestFactory(_serverId, _apiKey);
var injectionRequest = factory.GenerateRequest(message);
var httpResponse = await _httpClient.PostAsync(EndpointUrl, injectionRequest.GetAsJson());
var response = new InjectionResponseParser().Parse(httpResponse);
return(response);
}
/// <summary>
/// Check the To recipient list (List of <c>IEmailAddress</c>) for valid email addresses
/// </summary>
/// <param name="message">An <c>IBulkMessage</c> object to be sent.</param>
/// <returns>A List of <c>AddressResult</c> if an invalid email address is found.</returns>
internal virtual List <AddressResult> HasInvalidRecipients(IBulkMessage message)
{
var result = new List <AddressResult>();
var invalidTo = FindInvalidRecipients(message.To);
if (invalidTo != null && invalidTo.Any())
{
result.AddRange(invalidTo.ToList());
}
return(result);
}
/// <summary>
/// Validate a bulk email message before sending to the Injection API.
/// </summary>
/// <param name="message">An <c>IBulkMessage</c> object to be sent.</param>
/// <returns>A <c>SendResponse</c> with the validation results</returns>
public SendResponse ValidateMessage(IBulkMessage message)
{
var result = ValidateIMessageBase(message);
if (result == SendResult.Success)
{
return(ValidateRecipients(message));
}
return(new SendResponse()
{
Result = result
});
}
/// <summary>
/// Synchronously sends a bulk email message and returns the response from the Injection API.
/// </summary>
/// <param name="message">A <c>BulkMessage</c> object to be sent.</param>
/// <returns>A <c>SendResponse</c> of an SocketLabsClient send request.</returns>
/// <example>
/// This sample shows you how to Send a Bulk Message
/// <code>
/// var client = new SocketLabsClient(00000, "apiKey");
///
/// var message = new BulkMessage();
///
/// message.PlainTextBody = "This is the body of my message sent to ##Name##";
/// message.HtmlBody = "<html>This is the HtmlBody of my message sent to ##Name##</html>";
/// message.Subject = "Sending a test message";
/// message.From.Email = "*****@*****.**";
///
/// var recipient1 = message.To.Add("*****@*****.**");
/// recipient1.MergeData.Add("Name", "Recipient1");
///
/// var recipient2 = message.To.Add("*****@*****.**");
/// recipient2.MergeData.Add("Name", "Recipient2");
///
/// var response = client.Send(message);
///
/// if (response.Result != SendResult.Success)
/// {
/// // Handle Error
/// }
///</code>
/// </example>
public SendResponse Send(IBulkMessage message)
{
try
{
//Read this if you have questions: https://blogs.msdn.microsoft.com/pfxteam/2012/04/13/should-i-expose-synchronous-wrappers-for-asynchronous-methods/
return(Task.Run(() => SendAsync(message)).Result);
}
//for synchronous usage, try to simplify exceptions being thrown
catch (AggregateException e)
{
if (e.InnerException != null)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
}
throw;
}
}
/// <summary>
/// Generate the <c>InjectionRequest</c> for sending to the Injection Api
/// </summary>
/// <param name="message">An <c>IBulkMessage</c> object to be sent.</param>
/// <returns>An <c>InjectionRequest</c> for sending to the Injection Api</returns>
public InjectionRequest GenerateRequest(IBulkMessage message)
{
var request = new InjectionRequest(_serverId, _apiKey);
var jsonMsg = GenerateBaseMessageJson(message);
// Replace the "To" recipients with links to merge field data
jsonMsg.To = new List <AddressJson> {
new AddressJson("%%DeliveryAddress%%", "%%RecipientName%%")
};
// handle merge data per recipient for message
var mergeDataForEmail = GetBulkMergeFields(message.To);
jsonMsg.MergeData.PerMessage = mergeDataForEmail;
// handle global (per message) merge data
jsonMsg.MergeData.Global = PopulateMergeData(message.GlobalMergeData);
request.Messages.Add(jsonMsg);
return(request);
}
/// <summary>
/// Validate email recipients for a bulk message
/// </summary>
/// <remarks>
/// Checks the To recipient field (List of <c>IBulkRecipient</c>) for the following:
/// <list type="bullet">
/// <item>
/// <description>At least 1 recipient is in the list.</description>
/// </item>
/// <item>
/// <description>Recipients in list do not exceed the <c>MaximumRecipientsPerMessage</c>.</description>
/// </item>
/// <item>
/// <description>Recipients in list are valid.</description>
/// </item>
/// </list>
/// If errors are found, the <c>SendResponse</c> will contain the invalid email addresses
/// </remarks>
/// <param name="message">An <c>IBulkMessage</c> object to be sent.</param>
/// <returns>A <c>SendResponse</c> with the validation results</returns>
internal virtual SendResponse ValidateRecipients(IBulkMessage message)
{
if (message.To == null || message.To.Count <= 0)
{
return new SendResponse()
{
Result = SendResult.RecipientValidationMissingTo
}
}
;
if (message.To.Count > MaximumRecipientsPerMessage)
{
return new SendResponse()
{
Result = SendResult.RecipientValidationMaxExceeded
}
}
;
var invalidRec = HasInvalidRecipients(message);
if (invalidRec != null && invalidRec.Any())
{
return new SendResponse()
{
Result = SendResult.RecipientValidationInvalidRecipients,
AddressResults = invalidRec.ToArray()
}
}
;
return(new SendResponse()
{
Result = SendResult.Success
});
}
