public void ThrowsArgumentExceptionWhenSenderNull()
{
var recipients = new EmailRecipients(
to: new[] { new MailAddress("*****@*****.**") });
var emailBuilder = new Mock <IEmailBuilder>();
emailBuilder
.Setup(m => m.GetRecipients())
.Returns(recipients)
.Verifiable();
emailBuilder
.Setup(m => m.Sender)
.Returns <MailAddress>(null)
.Verifiable();
var emailMessageEnqueuerMock = new Mock <IEmailMessageEnqueuer>();
var messageService = new AsynchronousEmailMessageService(
emailMessageEnqueuerMock.Object,
Mock.Of <ILogger <AsynchronousEmailMessageService> >(),
Mock.Of <IMessageServiceConfiguration>());
Assert.ThrowsAsync <ArgumentException>(() => messageService.SendMessageAsync(emailBuilder.Object, false, false));
emailBuilder.Verify();
emailMessageEnqueuerMock.Verify(
m => m.SendEmailMessageAsync(It.IsAny <EmailMessageData>()),
Times.Never);
}
public void SendEmail()
{
EmailClient client = CreateEmailClient();
#region Snippet:Azure_Communication_Email_Send
// Create the email content
var emailContent = new EmailContent("This is the subject");
emailContent.PlainText = "This is the body";
// Create the recipient list
var emailRecipients = new EmailRecipients(
new List <EmailAddress>
{
new EmailAddress(
//@@ email: "<recipient email address>"
//@@ displayName: "<recipient displayname>"
/*@@*/ email: TestEnvironment.ToEmailAddress,
/*@@*/ displayName: "Customer Name")
});
// Create the EmailMessage
var emailMessage = new EmailMessage(
//@@ sender: "<Send email address>" // The email address of the domain registered with the Communication Services resource
/*@@*/ sender: TestEnvironment.AzureManagedFromEmailAddress,
emailContent,
emailRecipients);
SendEmailResult sendResult = client.Send(emailMessage);
Console.WriteLine($"Email id: {sendResult.MessageId}");
#endregion Snippet:Azure_Communication_Email_Send
Assert.False(string.IsNullOrEmpty(sendResult.MessageId));
}
public override IEmailRecipients GetRecipients()
{
var to = EmailRecipients.GetAllOwners(
Package.PackageRegistration,
requireEmailAllowed: false);
return(new EmailRecipients(to));
}
public static void SetQueueRecipient(EmailRecipients value)
{
if (_instance == null)
{
throw new Exception("Create instance first before accessing method.");
}
_instance._queueRecipient = value;
Save();
}
public override IEmailRecipients GetRecipients()
{
var to = EmailRecipients.GetAllOwners(
Package.PackageRegistration,
requireEmailAllowed: true);
return(new EmailRecipients(
to,
replyTo: new[] { FromAddress }));
}
public WatcherConfig GetWatcherConfig()
{
EmailRecipients email = EmailRecipients.Everyone;
if (EmailRecipient.SelectedItem != null)
{
email = (EmailRecipients)EmailRecipient.SelectedItem;
}
return(new WatcherConfig(Identifier, (WatcherType)WatcherType.SelectedItem, false, ContentCompare.IsChecked ?? false, (NotifyFilters)FilterType.SelectedItem, FileFilter.Text, (WatcherChangeTypes)ChangeType.SelectedItem, (EmailType)EmailType.SelectedItem, Subfolder.IsChecked ?? false, _robot, email));
}
public List <string> RecipientList()
{
List <string> recipientList = new List <string>();
if (!string.IsNullOrEmpty(EmailRecipients))
{
recipientList = EmailRecipients.Split(new char[] { ';' }).ToList();
}
return(recipientList);
}
/// <summary>
///
/// </summary>
/// <param name="emailRecipients"></param>
/// <param name="conversationId"></param>
/// <param name="properties"></param>
/// <param name="exactTargetDelivery"></param>
/// <param name="externalKeyOfTriggeredSendDefn"></param>
/// <returns></returns>
private async static Task ForwardRequestToIrisApi(EmailRecipients emailRecipients, Guid conversationId, Dictionary <string, string> properties, ExactTargetDelivery exactTargetDelivery, string externalKeyOfTriggeredSendDefn)
{
var appTicket = s2sAuthClient.GetAccessTokenAsync(MucpTargetSite, CancellationToken.None).Result;
await publisher
.CreateRequest()
.WithEventName(externalKeyOfTriggeredSendDefn)
.WithModelProperties(properties)
.WithInstanceId(conversationId)
.WithDelivery(exactTargetDelivery)
.WithRecipient(emailRecipients)
.WithAppTicket(appTicket)
.SendAsync(TimeSpan.FromSeconds(120)).ConfigureAwait(false);
}
public WatcherConfig(string id, WatcherType watcher, bool enabled, bool content, NotifyFilters filters, string file, WatcherChangeTypes change, EmailType email, bool subfolder, int robot = -1, EmailRecipients recipients = EmailRecipients.Everyone)
{
Id = id;
Enabled = enabled;
ContentCompare = content;
NotifyFilters = filters;
FileFilters = file;
ChangeType = change;
EmailType = email;
WatcherType = watcher;
Robot = robot;
EmailRecipients = recipients;
Subfolder = subfolder;
}
public async Task SendEmailWithAttachmentAsync()
{
EmailClient client = CreateEmailClient();
var emailContent = new EmailContent("This is the subject");
emailContent.PlainText = "This is the body";
var emailRecipients = new EmailRecipients(
new List <EmailAddress>
{
new EmailAddress(
//@@ email: "<recipient email address>"
//@@ displayName: "<recipient displayname>"
/*@@*/ email: TestEnvironment.ToEmailAddress,
/*@@*/ displayName: "Customer Name")
});
#region Snippet:Azure_Communication_Email_Send_With_AttachmentsAsync
// Create the EmailMessage
var emailMessage = new EmailMessage(
//@@ sender: "<Send email address>" // The email address of the domain registered with the Communication Services resource
/*@@*/ sender: TestEnvironment.AzureManagedFromEmailAddress,
emailContent,
emailRecipients);
#if SNIPPET
var filePath = "<path to your file>";
var attachmentName = "<name of your attachment>"
EmailAttachmentType attachmentType = EmailAttachmentType.Txt;
#endif
// Convert the file content into a Base64 string
#if SNIPPET
byte[] bytes = File.ReadAllBytes(filePath);
string attachmentFileInBytes = Convert.ToBase64String(bytes);
#else
string attachmentName = "Attachment.txt";
EmailAttachmentType attachmentType = EmailAttachmentType.Txt;
var attachmentFileInBytes = "VGhpcyBpcyBhIHRlc3Q=";
#endif
var emailAttachment = new EmailAttachment(attachmentName, attachmentType, attachmentFileInBytes);
emailMessage.Attachments.Add(emailAttachment);
SendEmailResult sendResult = await client.SendAsync(emailMessage);
#endregion Snippet:Azure_Communication_Email_Send_With_AttachmentsAsync
}
public void ThrowsArgumentExceptionWhenPlainTextAndHtmlBodyEmpty()
{
var recipients = new EmailRecipients(
to: new[] { new MailAddress("*****@*****.**") });
var emailBuilder = new Mock <IEmailBuilder>();
emailBuilder
.Setup(m => m.Sender)
.Returns(new MailAddress("*****@*****.**"))
.Verifiable();
emailBuilder
.Setup(m => m.GetRecipients())
.Returns(recipients)
.Verifiable();
emailBuilder
.Setup(m => m.GetSubject())
.Returns("subject")
.Verifiable();
emailBuilder
.Setup(m => m.GetBody(EmailFormat.Html))
.Returns <string>(null)
.Verifiable();
emailBuilder
.Setup(m => m.GetBody(EmailFormat.PlainText))
.Returns <string>(null)
.Verifiable();
var emailMessageEnqueuerMock = new Mock <IEmailMessageEnqueuer>();
var messageService = new AsynchronousEmailMessageService(
Configuration,
emailMessageEnqueuerMock.Object);
Assert.ThrowsAsync <ArgumentException>(() => messageService.SendMessageAsync(emailBuilder.Object, false, false));
emailBuilder.Verify();
emailMessageEnqueuerMock.Verify(
m => m.SendEmailMessageAsync(It.IsAny <EmailMessageData>()),
Times.Never);
}
/// <summary>
/// Email the Log file on file rolled
/// </summary>
/// <param name="filePath"></param>
protected override void OnFileRolled(string filePath)
{
if (!File.Exists(filePath))
{
return;
}
try
{
int totalErrors = File.ReadAllLines(filePath).Count(line => Regex.IsMatch(line, ERROR_REGEX));
int totalWarnings = File.ReadAllLines(filePath).Count(line => Regex.IsMatch(line, WARNING_REGEX));
string environment = ApplicationSettingsHelper.LoadAppSetting("environment", false, string.Empty);
if (!string.IsNullOrEmpty(environment))
{
environment = "[{0}]".fmt(environment);
}
var info = new SysInfo();
using (Emailer mailer = Kernel.Get <Emailer>())
{
mailer.AddRecipient(EmailRecipients.Split(';', ','));
mailer.AttachFile(filePath);
mailer.Send(
"[{0} - {1}] {2} {3}"
.fmt(EmailSubject,
totalErrors != 0 ? "Error" : (totalWarnings != 0 ? "Warning" : "Information"),
environment,
DateTime.Now.ToString("dd/MM/yyyy")),
"{0}\r\n\r\nLog file attached".fmt(info.GetRamDiskUsage()));
}
}
catch (Exception e)
{
Logger.WriteUnexpectedException(e, "Failed to email rolled file.", Category.GeneralError);
}
}
public FileWatchConfig(MainWindow main, string id, EmailType type, NotifyFilters filters,
WatcherChangeTypes change, WatcherType watcher, string file, bool content,
EmailRecipients watcherEmailRecipients, bool recurse)
{
_main = main;
InitializeComponent();
WatcherType.ItemsSource = Enum.GetValues(typeof(WatcherType)).Cast <WatcherType>();
ChangeType.ItemsSource = Enum.GetValues(typeof(WatcherChangeTypes)).Cast <WatcherChangeTypes>();
FilterType.ItemsSource = Enum.GetValues(typeof(NotifyFilters)).Cast <NotifyFilters>();
EmailType.ItemsSource = Enum.GetValues(typeof(EmailType)).Cast <EmailType>();
EmailRecipient.ItemsSource = Enum.GetValues(typeof(EmailRecipients)).Cast <EmailRecipients>();
Identifier = id;
ContentCompare.IsChecked = content;
EmailType.SelectedItem = type;
FilterType.SelectedItem = filters;
ChangeType.SelectedItem = change;
WatcherType.SelectedItem = watcher;
EmailRecipient.SelectedItem = watcherEmailRecipients;
FileFilter.Text = file;
IdentLabel.Content = id;
Subfolder.IsChecked = recurse;
CheckExists();
}
public static async Task <bool> SendMessage(EmailType type, QueueEntry entry, EmailRecipients recipients, TextBox log = null)
{
try
{
return(await SendMessage(entry.EmailAddress ?? Settings.EmailAddress, Settings.EmailServerAddress,
$"[{type}] {DateTime.Now} - DVD Order Queue - {new FileInfo(entry.Source).Name}",
$"See DVD Progress Page for current status.\r\nThis message may be delayed due to processing time, subject lists current time sent.\r\nSource:\t{entry.Source}\r\nStatus:\t{entry.Status}\r\nCurrent Time Elapsed:\t{entry.TimeSpan}\r\nRobot:\t{entry.Robot}\r\nLines:\r\n{entry.Line1}\r\n{entry.Line2}\r\n{entry.Line3}", recipients));
}
catch (Exception e)
{
if (log != null)
{
log.Text = e.Message;
}
return(false);
}
}
public static async Task <bool> SendMessage(string to, string from, string subject, string message, EmailRecipients recipients, TextBox log = null)
{
try
{
if (recipients == EmailRecipients.None)
{
return(true);
}
using (var client = new SmtpClient(Settings.EmailServerSite, Settings.EmailServerPort))
{
client.EnableSsl = Settings.EmailServerSsl;
client.Credentials = new NetworkCredential(Settings.EmailServerUsername, Settings.EmailServerPassword);
using var mailMessage = new MailMessage(from, Settings.EmailAddress)
{
IsBodyHtml = true, Subject = subject, Body = message
};
if (recipients == EmailRecipients.Everyone || recipients == EmailRecipients.Sender)
{
foreach (var email in to.Split(';'))
{
mailMessage.To.Add(email);
}
}
await client.SendMailAsync(mailMessage);
}
return(true);
}
catch (Exception e)
{
if (log != null)
{
log.Text = e.Message;
}
return(false);
}
}
public override IEmailRecipients GetRecipients()
{
var to = EmailRecipients.GetOwnersSubscribedToPackagePushedNotification(_package.PackageRegistration);
return(new EmailRecipients(to));
}
/// <summary>
/// Handles incoming messages of AccountDeleteMessage type
/// </summary>
/// <param name="command"></param>
/// <returns>True if processed successfully, false if we failed for some reason.</returns>
/// <remarks>If accountManager.DeleteAccount throws, the entire method will throw and the message will go back into the queue.</remarks>
public async Task <bool> HandleAsync(AccountDeleteMessage command)
{
var messageProcessed = true;
var source = command.Source;
try
{
_logger.LogInformation("Processing Request from Source {Source}", source);
_accountDeleteConfigurationAccessor.Value.VerifySource(source);
var username = command.Username;
var user = _userService.FindByUsername(username);
if (user == null)
{
throw new UserNotFoundException();
}
if (_accountDeleteConfigurationAccessor.Value.RespectEmailContactSetting && !user.EmailAllowed)
{
throw new EmailContactNotAllowedException();
}
var recipientEmail = user.EmailAddress;
var deleteSuccess = await _accountManager.DeleteAccount(user);
_telemetryService.TrackDeleteResult(source, deleteSuccess);
var baseEmailBuilder = _emailBuilderFactory.GetEmailBuilder(source, deleteSuccess);
if (baseEmailBuilder != null)
{
var toEmail = new List <MailAddress>();
var configuration = _accountDeleteConfigurationAccessor.Value;
var senderAddress = configuration.EmailConfiguration.GalleryOwner;
var ccEmail = new List <MailAddress>();
// toEmail.Add(new MailAddress(recipientEmail)); // Temporarily disable sending to end user while we are in phase 1.
toEmail.Add(new MailAddress(senderAddress)); // Remove this when we switch to phase 2.
ccEmail.Add(new MailAddress(senderAddress));
var recipients = new EmailRecipients(toEmail, ccEmail);
var emailBuilder = new DisposableEmailBuilder(baseEmailBuilder, recipients, username);
await _messenger.SendMessageAsync(emailBuilder);
_telemetryService.TrackEmailSent(source, user.EmailAllowed);
messageProcessed = true;
}
}
catch (UnknownSourceException)
{
// Should definitely log if source isn't expected. Should we even send mail? or log and alert?
// Log unknown source and fail.
_logger.LogError("Unknown message source detected: {Source}.", command.Source);
_telemetryService.TrackUnknownSource(source);
messageProcessed = false;
}
catch (EmailContactNotAllowedException)
{
// Should we not send? or should we ignore the setting.
_logger.LogWarning("User did not allow Email Contact.");
_telemetryService.TrackEmailBlocked(source);
}
catch (UserNotFoundException)
{
_logger.LogWarning("User was not found. They may have already been deleted.");
_telemetryService.TrackUserNotFound(source);
messageProcessed = true;
}
catch (Exception e)
{
_logger.LogError(0, e, "An unknown exception occured: {ExceptionMessage}");
throw e;
}
return(messageProcessed);
}
/// <summary>
///
/// </summary>
/// <param name="dataTable">Data of flatfile</param>
/// <param name="externalKeyOfTriggeredSendDefnUnderThisAccountName">Specify External Key of your Triggered Send Definition</param>
public void SendTriggeredRequestsToSalesforceThruIrisApi(DataTable dataTable, string externalKeyOfTriggeredSendDefnUnderThisAccountName)
{
try
{
var customProperties = new Dictionary <string, string>();
var emailRecipients = new EmailRecipients();
List <Task> tasks = new List <Task>();
var totalCount = dataTable.Rows.Count;
var currentPosition = 0;
Console.WriteLine("Total: " + totalCount);
foreach (DataRow dataRow in dataTable.Rows)
{
currentPosition += 1;
customProperties.Clear();
for (var columnIdx = 0; columnIdx < dataRow.Table.Columns.Count; columnIdx++)
{
if (dataRow.Table.Columns[columnIdx].ColumnName.Equals("SubscriberKey"))
{
continue;
}
else if (dataRow.Table.Columns[columnIdx].ColumnName.Equals("EmailAddress"))
{
emailRecipients = new EmailRecipients
{
To = new List <string> {
Convert.ToString(dataRow[dataRow.Table.Columns[columnIdx]])
}
}
}
;
else
{
customProperties.Add(dataRow.Table.Columns[columnIdx].ColumnName, Convert.ToString(dataRow[dataRow.Table.Columns[columnIdx]]));
}
}
// This 'ConversationId' fights Salesforce from sending duplicate emails to end users despite multiple retries by the Tenant or IRIS.
// So please define a unique identifier per email delivery. Make sure you don’t send same email with different conversation ID otherwise duplicate emails
// would be send to the user.
var conversationId = Guid.NewGuid();
// Forwards the requests to IRIS API asychronously
tasks.Add(ForwardRequestToIrisApi(emailRecipients, conversationId, customProperties, exactTargetDelivery, externalKeyOfTriggeredSendDefnUnderThisAccountName));
Console.Write("\r" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff") + " | To go: " + (totalCount - currentPosition) + " ");
if (currentPosition % 1000 == 0)
{
try
{
Task.WaitAll(tasks.ToArray());
tasks = new List <Task>();
}
catch (Exception e)
{
var message = string.Format(CultureInfo.InvariantCulture, "Request failed with exception: [{0}]", e);
Console.WriteLine(message);
}
}
}
Task.WaitAll(tasks.ToArray());
Console.WriteLine(Environment.NewLine + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff") + " | Completed");
}
catch (Exception e)
{
var message = string.Format(CultureInfo.InvariantCulture, "Request failed with exception: [{0}]", e);
Console.WriteLine(message);
}
// Forcing logs to be written to 'TextWriterOutput.log'. See trace listener settings in app.config
Trace.Flush();
}
/// <summary>
///
/// </summary>
/// <param name="externalKeyOfTriggeredSendDefnUnderThisAccountName">Specify External Key of your Triggered Send Definition</param>
public void SendTriggeredRequestToSalesforceThruIrisApi(string externalKeyOfTriggeredSendDefnUnderThisAccountName)
{
try
{
var emailAddress = "*****@*****.**"; // target email address
var propertiesExample0 = new Dictionary <string, string>
{
{ "FirstName", "SampleFirstName001" },
{ "LastName", " SampleLastName001" },
{ "CustomProp001", " Sample CustomProp001" },
{ "CustomProp002", " Sample CustomProp002" }
};
var emailRecipients = new EmailRecipients
{
To = new List <string> {
emailAddress
}
};
var justForExampleNumberOfTriggeredSendRequests = 10;
List <Task> tasks = new List <Task>();
for (int idx = 0; idx < justForExampleNumberOfTriggeredSendRequests; idx += 1)
{
// This 'ConversationId' fights Salesforce from sending duplicate emails to end users despite multiple retries by the Tenant or IRIS.
// So please define a unique identifier per email delivery. Make sure you don’t send same email with different conversation ID otherwise duplicate emails
// would be send to the user.
var conversationId = Guid.NewGuid();
// Forwards the requests to IRIS API asychronously
tasks.Add(ForwardRequestToIrisApi(emailRecipients, conversationId, propertiesExample0, exactTargetDelivery, externalKeyOfTriggeredSendDefnUnderThisAccountName));
Console.Write("\r" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff") + " | To go: " + (justForExampleNumberOfTriggeredSendRequests - idx) + " ");
if (idx % 1000 == 0)
{
try
{
Task.WaitAll(tasks.ToArray());
tasks = new List <Task>();
}
catch (Exception e)
{
var message = string.Format(CultureInfo.InvariantCulture, "Request failed with exception: [{0}]", e);
Console.WriteLine(message);
}
}
}
Task.WaitAll(tasks.ToArray());
Console.WriteLine(Environment.NewLine + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff") + " | Completed");
}
catch (Exception e)
{
var message = string.Format(CultureInfo.InvariantCulture, "Request failed with exception: [{0}]", e);
Console.WriteLine(message);
}
// Forcing logs to be written to 'TextWriterOutput.log'. See trace listener settings in app.config
Trace.Flush();
}
public async Task CreatesAndSendsExpectedMessageOnce()
{
var subject = "subject";
var htmlBody = "html body";
var plainTextBody = "plain-text body";
var toAddress = "*****@*****.**";
var ccAddress = "*****@*****.**";
var bccAddress = "*****@*****.**";
var replyToAddress = "*****@*****.**";
var senderAddress = "*****@*****.**";
var recipients = new EmailRecipients(
to: new[] { new MailAddress(toAddress) },
cc: new[] { new MailAddress(ccAddress) },
bcc: new[] { new MailAddress(bccAddress) },
replyTo: new[] { new MailAddress(replyToAddress) });
var emailBuilder = new Mock <IEmailBuilder>();
emailBuilder
.Setup(m => m.GetRecipients())
.Returns(recipients)
.Verifiable();
emailBuilder
.Setup(m => m.GetSubject())
.Returns(subject)
.Verifiable();
emailBuilder
.Setup(m => m.GetBody(EmailFormat.Html))
.Returns(htmlBody)
.Verifiable();
emailBuilder
.Setup(m => m.GetBody(EmailFormat.PlainText))
.Returns(plainTextBody)
.Verifiable();
emailBuilder
.Setup(m => m.Sender)
.Returns(new MailAddress(senderAddress))
.Verifiable();
var emailMessageEnqueuerMock = new Mock <IEmailMessageEnqueuer>();
var messageService = new AsynchronousEmailMessageService(
emailMessageEnqueuerMock.Object,
Mock.Of <ILogger <AsynchronousEmailMessageService> >(),
Mock.Of <IMessageServiceConfiguration>());
await messageService.SendMessageAsync(emailBuilder.Object, false, false);
emailBuilder.Verify();
emailMessageEnqueuerMock.Verify(
m => m.SendEmailMessageAsync(It.Is <EmailMessageData>(
d =>
d.HtmlBody == htmlBody &&
d.PlainTextBody == plainTextBody &&
d.Subject == subject &&
d.Sender == senderAddress &&
d.To.Contains(toAddress) &&
d.CC.Contains(ccAddress) &&
d.Bcc.Contains(bccAddress) &&
d.ReplyTo.Contains(replyToAddress) &&
d.MessageTrackingId != Guid.Empty &&
d.DeliveryCount == 0)),
Times.Once);
emailMessageEnqueuerMock.Verify(m => m.SendEmailMessageAsync(It.IsAny <EmailMessageData>()), Times.Once);
}
public static void history()
{
EmailContext db = new EmailContext();
List <HistoryID> histories = db.HistoryIDs.ToList();
List <Message> messagelist = new List <Message>();
ulong? newesthistoryid;
//email all history ids being processed
while (true)
{
//System.Threading.Thread.Sleep(2000);
while (checkhistoryiddb(db, out newesthistoryid))
{
bool synced = fullsync(out messagelist, out newesthistoryid);
bool allrecordsmarkedasprocessed = true;
if (synced && messagelist.Count > 0)
{
foreach (Message message in messagelist)
{
string subjectline = message.Payload.Headers[0].Value;
int index = subjectline.IndexOf("AwolrID:");
string awolrid = message.Payload.Headers[0].Value.Substring(index + 8);
string rebuild = subjectline.Substring(0, index - 1);
//write to database
// Decode
string body = " ";
var encodedString2 = message.Payload.Parts[0].Body.Data;
if (encodedString2 != null)
{
var bytes2 = Decode(encodedString2);
body = System.Text.Encoding.UTF8.GetString(bytes2); // Hello Base64Url encoding!
}
string to = null;
try
{
EmailRecipients emailRecipients =
db.EmailRecipients.Where(er => er.bidfakeemailaddress.Contains(awolrid) || er.pidfakeemailaddress.Contains(awolrid)).FirstOrDefault();
if (emailRecipients.bidfakeemailaddress == awolrid)
{
subjectline = rebuild + " AwolrID:" + emailRecipients.pidfakeemailaddress;
to = emailRecipients.bidrealemailaddress;
}
else
{
subjectline = rebuild + " AwolrID:" + emailRecipients.bidfakeemailaddress;
to = emailRecipients.pidrealemailaddress;
}
try
{
Email email = new Email();
email.emailbody = body;
email.EmailRecipientsId = emailRecipients.Id;
email.fromaddress = "*****@*****.**";
email.toaddress = to;
email.IdItem = emailRecipients.IdItem;
email.subject = subjectline;
email.ItemDescription = subjectline;
db.Emails.Add(email);
db.SaveChanges();
Console.WriteLine("New Email Record Generated For Email " + email.Id);
}
catch (Exception e)
{
logger.Debug("Could not create relay response email. Returning method" + e.ToString() + "--------------\n\n");
return;
}
//ModifyMessageRequest mods = new ModifyMessageRequest();
//List<String> addedlabels = new List<String> { "Label_5558979356135685998" };
//List<String> removedlabels = new List<String> { };
//mods.AddLabelIds = addedlabels;
//mods.RemoveLabelIds = removedlabels;
//try
//{
// service.Users.Messages.Modify(mods, userId, message.Id).Execute();
//}
//catch (Exception e)
//{
// allrecordsmarkedasprocessed = false;
// throw new Exception("message could not be marked as processed.messageid " + message.Id + e.ToString());
//}
try
{
service.Users.Messages.Delete(userId, message.Id).Execute();
}
catch (Exception e)
{
logger.Debug("Could not delete processed email" + e.ToString());
}
}
catch (Exception e)
{
logger.Debug("message could not be marked as processed. messageid: " + message.Id + ":" + e.ToString() + "--------------\n\n");
}
}
}
}
}
//foreach (HistoryID historyid in histories)
//{
// long id = historyid.History;
// try
// {
// ulong historyid_start_conversionresult;
// List<History> result = null;
// try
// {
// historyid_start_conversionresult = Convert.ToUInt64(id);
// result = ListHistory(service, "*****@*****.**", historyid_start_conversionresult, messagelist);
// }
// catch (OverflowException)
// {
// Console.WriteLine("{0} is outside the range of the UInt64 type.", historyid);
// }
// if (result != null)
// {
// //loggerWrapper.PickAndExecuteLogging("Was able to retrieve history" + id.ToString());
// }
// }
// catch (Exception e)
// {
// }
//}
}
public async Task WillSendCopyToSenderIfAsked()
{
var subject = "subject";
var htmlBody = "html body";
var plainTextBody = "plain-text body";
var toAddress = "*****@*****.**";
var ccAddress = "*****@*****.**";
var bccAddress = "*****@*****.**";
var fromAddress = "*****@*****.**";
var senderAddress = "*****@*****.**";
var recipients = new EmailRecipients(
to: new[] { new MailAddress(toAddress) },
cc: new[] { new MailAddress(ccAddress) },
bcc: new[] { new MailAddress(bccAddress) },
replyTo: new[] { new MailAddress(fromAddress) });
var emailBuilder = new Mock <IEmailBuilder>();
emailBuilder
.Setup(m => m.GetRecipients())
.Returns(recipients)
.Verifiable();
emailBuilder
.Setup(m => m.GetSubject())
.Returns(subject)
.Verifiable();
emailBuilder
.Setup(m => m.GetBody(EmailFormat.Html))
.Returns(htmlBody)
.Verifiable();
emailBuilder
.Setup(m => m.GetBody(EmailFormat.PlainText))
.Returns(plainTextBody)
.Verifiable();
emailBuilder
.Setup(m => m.Sender)
.Returns(new MailAddress(senderAddress))
.Verifiable();
var messageServiceConfiguration = new TestMessageServiceConfiguration();
var emailMessageEnqueuerMock = new Mock <IEmailMessageEnqueuer>();
var messageService = new AsynchronousEmailMessageService(
emailMessageEnqueuerMock.Object,
Mock.Of <ILogger <AsynchronousEmailMessageService> >(),
messageServiceConfiguration);
// We want to copy the sender but not disclose the sender address
await messageService.SendMessageAsync(
emailBuilder.Object,
copySender : true,
discloseSenderAddress : false);
emailBuilder.Verify();
// Verify the original email is sent (not disclosing the sender address)
emailMessageEnqueuerMock.Verify(
m => m.SendEmailMessageAsync(It.Is <EmailMessageData>(
d =>
d.HtmlBody == htmlBody &&
d.PlainTextBody == plainTextBody &&
d.Subject == subject &&
d.Sender == senderAddress &&
d.To.Contains(toAddress) &&
d.CC.Contains(ccAddress) &&
d.Bcc.Contains(bccAddress) &&
d.ReplyTo.Contains(fromAddress) &&
d.MessageTrackingId != Guid.Empty &&
d.DeliveryCount == 0)),
Times.Once);
// Verify a copy is sent to the sender
var expectedPlainTextBody = string.Format(
CultureInfo.CurrentCulture,
"You sent the following message via {0}: {1}{1}{2}",
messageServiceConfiguration.GalleryOwner.DisplayName,
Environment.NewLine,
plainTextBody);
var expectedHtmlBody = string.Format(
CultureInfo.CurrentCulture,
"You sent the following message via {0}: {1}{1}{2}",
messageServiceConfiguration.GalleryOwner.DisplayName,
Environment.NewLine,
htmlBody);
emailMessageEnqueuerMock.Verify(
m => m.SendEmailMessageAsync(It.Is <EmailMessageData>(
d =>
d.HtmlBody == expectedHtmlBody &&
d.PlainTextBody == expectedPlainTextBody &&
d.Subject == subject + " [Sender Copy]" &&
d.Sender == messageServiceConfiguration.GalleryOwner.Address &&
d.To.Single() == fromAddress &&
!d.CC.Any() &&
!d.Bcc.Any() &&
d.ReplyTo.Single() == fromAddress &&
d.MessageTrackingId != Guid.Empty &&
d.DeliveryCount == 0)),
Times.Once);
emailMessageEnqueuerMock.Verify(m => m.SendEmailMessageAsync(It.IsAny <EmailMessageData>()), Times.Exactly(2));
}
/// <summary>
/// Handles incoming messages of AccountDeleteMessage type
/// </summary>
/// <param name="command"></param>
/// <returns>True if processed successfully, false if we failed for some reason.</returns>
/// <remarks>If accountManager.DeleteAccount throws, the entire method will throw and the message will go back into the queue.</remarks>
public async Task <bool> HandleAsync(AccountDeleteMessage command)
{
var messageProcessed = true;
var source = command.Source;
try
{
_logger.LogInformation("Processing Request from Source {Source}", source);
_accountDeleteConfigurationAccessor.Value.GetSourceConfiguration(source);
var username = command.Username;
var user = _userService.FindByUsername(username);
if (user == null)
{
throw new UserNotFoundException();
}
var recipientEmail = user.EmailAddress;
var emailAllowed = user.EmailAllowed;
var deleteSuccess = await _accountManager.DeleteAccount(user, source);
_telemetryService.TrackDeleteResult(source, deleteSuccess);
if (recipientEmail == null)
{
_logger.LogWarning("User has no confirmed email address. The user has been deleted but no email was sent.");
_telemetryService.TrackUnconfirmedUser(source);
messageProcessed = true;
}
else if (_accountDeleteConfigurationAccessor.Value.RespectEmailContactSetting && !emailAllowed)
{
_logger.LogWarning("User did not allow Email Contact. The user has been deleted but no email was sent.");
_telemetryService.TrackEmailBlocked(source);
messageProcessed = true;
}
else
{
var baseEmailBuilder = _emailBuilderFactory.GetEmailBuilder(source, deleteSuccess);
if (baseEmailBuilder != null)
{
var toEmail = new List <MailAddress>();
var configuration = _accountDeleteConfigurationAccessor.Value;
var senderAddress = configuration.EmailConfiguration.GalleryOwner;
var ccEmail = new List <MailAddress>();
toEmail.Add(new MailAddress(recipientEmail));
ccEmail.Add(new MailAddress(senderAddress));
var recipients = new EmailRecipients(toEmail, ccEmail);
var emailBuilder = new DisposableEmailBuilder(baseEmailBuilder, recipients, username);
await _messenger.SendMessageAsync(emailBuilder);
_telemetryService.TrackEmailSent(source, emailAllowed);
messageProcessed = true;
}
}
}
catch (UnknownSourceException)
{
// Should definitely log if source isn't expected. Should we even send mail? or log and alert?
// Log unknown source and fail.
_logger.LogError("Unknown message source detected: {Source}.", command.Source);
_telemetryService.TrackUnknownSource(source);
messageProcessed = false;
}
catch (UserNotFoundException)
{
_logger.LogWarning("User was not found. They may have already been deleted.");
_telemetryService.TrackUserNotFound(source);
messageProcessed = true;
}
catch (Exception e)
{
_logger.LogError(e, "An unknown exception occurred.");
throw;
}
return(messageProcessed);
}
