private bool SendBatch(SendMessageData messageData)
{
MailingUtilities.Log.InfoFormat("[CESMaillingProvider.SendBatch]: Start: BulkEmailId: {0}. GroupId {1}.",
messageData.BulkEmail.Id, messageData.BatchId);
var sendResult = false;
try {
var startSendingTime = DateTime.UtcNow;
Utilities.RetryOnFailure(() => ServiceApi.SendTemplate(messageData.EmailMessage,
messageData.TemplateName, null, messageData.BulkEmail.Id));
sendResult = true;
BulkEmailEventLogger.LogInfo(messageData.BulkEmail.Id, startSendingTime,
GetLczStringValue("SentBatchStatus"), GetLczStringValue("SentBatchStatusDescription"),
UserConnection.CurrentUser.ContactId, messageData.BatchId);
} catch (Exception e) {
MailingUtilities.Log.ErrorFormat(
"[CESMaillingProvider.SendBatch]: Error while sending BulkEmail with Id: {0}. " +
"SessionId: {1}. GroupId {2}.", e, messageData.BulkEmail.Id, messageData.SessionId,
messageData.BatchId);
BulkEmailEventLogger.LogError(messageData.BulkEmail.Id, DateTime.UtcNow,
GetLczStringValue("BatchSendEvent"), e, GetLczStringValue("BatchSendErrorMsg"),
UserConnection.CurrentUser.ContactId, messageData.BulkEmail);
sendResult = false;
}
return(sendResult);
}
private bool SendTestMessageTemplate(Guid bulkEmailId, Guid contactId, string emailRecipient,
IMailingTemplate template, SendMessageData messageData, BulkEmailMacroComposer macroComposer)
{
var templateContent = template.Content;
if (templateContent?.IsEmpty() != false)
{
MailingUtilities.Log.InfoFormat("[SendTestMessage]: Can't save template");
return(false);
}
var emailMessage = InitEmailMessage(messageData, macroComposer, template);
emailMessage.images = template.InlineImages.ToCESImage();
emailMessage.html = templateContent;
emailMessage.tags = new List <string> {
TestMessageTag
};
PrepareTestRecipient(contactId, emailRecipient, macroComposer, emailMessage, template);
if (!Validator.ValidateTestMessage(bulkEmailId, contactId, template, emailMessage))
{
return(false);
}
try {
ServiceApi.SendMessage(emailMessage, bulkEmailId);
MailingUtilities.Log.InfoFormat("[SendTestMessage]: Can't save template");
return(true);
} catch (Exception e) {
MailingUtilities.Log.ErrorFormat("[SendTestMessage]: Error while sending message", e);
return(false);
}
}
private SendMessageData CreateSendMessageData(BulkEmail bulkEmail)
{
var startDateUtc = TimeZoneInfo.ConvertTimeToUtc(bulkEmail.StartDate,
Context.UserConnection.CurrentUser.TimeZone);
var messageData = new SendMessageData {
UserConnection = Context.UserConnection,
BulkEmailStartDate = startDateUtc
};
return(messageData);
}
private SendMessageData CreateSendMessageData(BulkEmail bulkEmail)
{
var startDateUtc = TimeZoneInfo.ConvertTimeToUtc(bulkEmail.StartDate, _userConnection.CurrentUser.TimeZone);
var messageData = new SendMessageData {
UserConnection = _userConnection,
BulkEmail = bulkEmail,
BulkEmailStartDate = startDateUtc,
SessionId = Guid.NewGuid()
};
return(messageData);
}
private EmailMessage InitDCEmailMessage(SendMessageData messageData)
{
var bulkEmail = messageData.BulkEmail;
var message = new EmailMessage {
track_clicks = true,
track_opens = true,
images = messageData.Images,
inline_css = true
};
message.tags = GetBulkEmailCategoryTags(bulkEmail);
return(message);
}
protected void ExecuteSendMessagePostProcessing(SendMessageData sendMessageData,
List <TypedCounter <MailingResponseCode> > sendResults, SendMessageTaskData sendMessageTaskData)
{
var bulkEmail = sendMessageData.BulkEmail;
var sessionId = sendMessageData.SessionId;
var blankEmailCount = sendResults.Sum("BlankEmail");
var doNotUseEmailCount = sendResults.Sum("DoNotUseEmail");
var incorrectEmailCount = sendResults.Sum("IncorrectEmail");
var unreachableEmailCount = sendResults.Sum("UnreachableEmail");
var communicationLimitCount = sendResults.Sum("CommunicationLimit");
var duplicateEmailCount = sendResults.Sum("DuplicateEmail");
var templateNotFoundCount = sendResults.Sum("TemplateNotFound");
var sendersDomainNotVerifiedCount = sendResults.Sum("SendersDomainNotVerified");
var sendersNameNotValidCount = sendResults.Sum("SendersNameNotValid");
var invalidAddresseeCount = sendResults.Sum("InvalidAddressee");
if (sendMessageTaskData.IsBreaking)
{
SetBulkEmailStatus(bulkEmail.Id, MailingConsts.BulkEmailStatusStoppedId);
BulkEmailEventLogger.LogInfo(bulkEmail.Id, DateTime.UtcNow, GetLczStringValue("MailingStoppedManually"),
GetLczStringValue("MailingStoppedManuallyDescription"), UserConnection.CurrentUser.ContactId);
SetInvalidBulkEmailCounters(bulkEmail.Id, invalidAddresseeCount);
CreateReminding(bulkEmail, "CESStoppedMailingMsg");
MailingUtilities.Log.InfoFormat("BulkEmail with Id: {0} Was stopped manually.", bulkEmail.Id);
return;
}
BulkEmailQueryHelper.UpdateBulkEmail(bulkEmail.Id, UserConnection,
new KeyValuePair <string, object>("SendDueDate", DateTime.UtcNow),
new KeyValuePair <string, object>("BlankEmailCount", blankEmailCount),
new KeyValuePair <string, object>("DoNotUseEmailCount", doNotUseEmailCount),
new KeyValuePair <string, object>("IncorrectEmailCount", incorrectEmailCount),
new KeyValuePair <string, object>("UnreachableEmailCount", unreachableEmailCount),
new KeyValuePair <string, object>("CommunicationLimitCount", communicationLimitCount),
new KeyValuePair <string, object>("DuplicateEmailCount", duplicateEmailCount),
new KeyValuePair <string, object>("TemplateNotFoundCount", templateNotFoundCount),
new KeyValuePair <string, object>("SendersDomainNotVerifiedCount", sendersDomainNotVerifiedCount),
new KeyValuePair <string, object>("SendersNameNotValidCount", sendersNameNotValidCount),
new KeyValuePair <string, object>("InvalidAddresseeCount", invalidAddresseeCount));
MailingUtilities.Log.InfoFormat(
"[CESMaillingProvider.ExecuteSendMessage]: Finished: BulkEmail.Id: {0}, SessionId: {1}", bulkEmail.Id,
sessionId);
if (sendMessageTaskData.ProcessedGroupsCounter == 0)
{
SetBulkEmailStatus(bulkEmail.Id, MailingConsts.BulkEmailStatusErrorId);
CreateReminding(bulkEmail, "CESNoRecipientsMsg");
MailingUtilities.Log.InfoFormat("BulkEmail with Id: {0} Has no recipients.", bulkEmail.Id);
}
}
private SendTestMessageResult ExecuteDCTestMessageSending(SendTestMessageData data, BulkEmail bulkEmail,
SendMessageData messageData, IEnumerable <DCReplicaModel> replicas)
{
var sentReplicaMasks = new List <int>();
var failedReplicaMasks = new List <int>();
var templates = TemplateFactory.CreateInstances(_userConnection, bulkEmail, replicas, BulkEmailMacroParser);
var templatesWithMasks = templates.Select(t => new {
Template = t,
ReplicaMask = replicas.First(replica => replica.Id == ((IMailingTemplateReplica)t).ReplicaId).Mask
});
var macroComposer = GetMacroComposer(data.ContactId, bulkEmail.Id);
foreach (var template in templatesWithMasks)
{
var sentSuccessfully = SendTestMessageTemplate(bulkEmail.Id, data.ContactId, data.EmailRecipients,
template.Template, messageData, macroComposer);
if (sentSuccessfully)
{
sentReplicaMasks.Add(template.ReplicaMask);
}
else
{
failedReplicaMasks.Add(template.ReplicaMask);
}
}
if (data.ReplicaMasks == null)
{
return(new SendTestMessageResult {
Success = sentReplicaMasks.Count > 0,
SentReplicaMasks = sentReplicaMasks.ToArray(),
FailedReplicaMasks = failedReplicaMasks.ToArray()
});
}
foreach (var mask in data.ReplicaMasks)
{
if (!sentReplicaMasks.Contains(mask) && !failedReplicaMasks.Contains(mask))
{
failedReplicaMasks.Add(mask);
}
}
return(new SendTestMessageResult {
Success = sentReplicaMasks.Count > 0,
SentReplicaMasks = sentReplicaMasks.ToArray(),
FailedReplicaMasks = failedReplicaMasks.ToArray()
});
}
private void UpdateSendEmailIterationResult(SendMessageData messageData,
IEnumerable <IMessageRecipientInfo> recipients, TypedCounter <MailingResponseCode> resultsCounter)
{
try {
HandleEmailResult(messageData.BulkEmailRId, recipients);
UpdateResultCounter(recipients, resultsCounter);
} catch (Exception e) {
MailingUtilities.Log.ErrorFormat(
"[CESMaillingProvider.SendBatch]: Error while handling result of BulkEmail with Id: {0}", e,
messageData.BulkEmail.Id);
BulkEmailEventLogger.LogError(messageData.BulkEmail.Id, DateTime.UtcNow,
GetLczStringValue("BatchSendEvent"), e, GetLczStringValue("HandleResultErrorMsg"),
UserConnection.CurrentUser.ContactId);
} finally {
messageData.EmailMessage = null;
}
MailingUtilities.Log.InfoFormat("[CESMaillingProvider.SendBatch]: Success: BulkEmailId: {0}. GroupId {1}.",
messageData.BulkEmail.Id, messageData.BatchId);
}
/// <summary>
/// Clones this instance.
/// </summary>
/// <returns></returns>
public SendMessageData Clone()
{
SendMessageData clone = new SendMessageData();
clone.UserConnection = UserConnection;
clone.SessionId = SessionId;
clone.BulkEmailStartDate = BulkEmailStartDate;
clone.BatchId = BatchId;
clone.TemplateName = TemplateName;
clone.BatchLength = BatchLength;
clone.MailingStartTS = MailingStartTS;
if (EmailContactCollection != null)
{
clone.EmailContactCollection = new Dictionary <Guid, int>(EmailContactCollection);
}
if (Images != null)
{
clone.Images = new List <image>(Images);
}
return(clone);
}
private EmailMessage InitEmailMessage(SendMessageData messageData, BulkEmailMacroComposer macroComposer,
IMailingTemplate template)
{
var bulkEmail = messageData.BulkEmail;
string senderEmail;
string senderName;
if (template is IMailingTemplateWithHeaders templateReplica)
{
senderEmail = templateReplica.SenderEmail;
senderName = templateReplica.SenderName;
}
else
{
senderEmail = bulkEmail.SenderEmail;
senderName = bulkEmail.SenderName;
}
var message = new EmailMessage {
subject = template.TemplateSubject,
from_email = senderEmail,
from_name = senderName,
track_clicks = true,
track_opens = true,
images = messageData.Images,
inline_css = true
};
var globalMacros = macroComposer.GetCommonMacrosValues(template.MacrosCollection);
var mergeVars = globalMacros.Select(macros => new merge_var {
name = macros.Key,
content = BulkEmailMacroParser.EncodeUrlMacrosValue(macros.Key, macros.Value)
}).ToList();
if (!mergeVars.Any())
{
return(message);
}
message.InitGlobalVariable();
message.global_merge_vars.AddRange(mergeVars);
return(message);
}
private void ExecuteSendMessageTask(SendMessageData sourceData)
{
var bulkEmail = sourceData.BulkEmail;
var bulkEmailRId = sourceData.BulkEmailRId;
var sessionId = sourceData.SessionId;
var culture = Thread.CurrentThread.CurrentCulture;
var sendMessageTaskData = new SendMessageTaskData();
var sendResults = new List <TypedCounter <MailingResponseCode> >();
_audienceDataSource.PageNumber = 0;
while (sendMessageTaskData.HasDataToProceed)
{
_audienceDataSource.PageNumber++;
sendMessageTaskData.BatchId = _audienceDataSource.PageNumber;
MailingUtilities.Log.InfoFormat(
"[CESMaillingProvider.ExecuteSendMessageTask]: Set BatchId - {0}. " +
"BulkEmail.Id {1}, Session {2}.", sendMessageTaskData.BatchId, bulkEmail.Id, sessionId);
var messageData = sourceData.Clone();
messageData.BulkEmail = sourceData.BulkEmail;
var email = InitDCEmailMessage(messageData);
messageData.BatchId = sendMessageTaskData.BatchId;
messageData.BatchLength = MassMailingRecipientsLimit;
List <IMessageRecipientInfo> recipients;
var nextBatchLength = 0;
try {
email.InitRecipientVariable();
var startGetRecipientTime = DateTime.UtcNow;
recipients = GetRecipients();
RecipientsValidator.Validate(recipients);
LogRecipientState(recipients, messageData.BulkEmail.Id, messageData.BatchId, startGetRecipientTime);
var validRecipients = GetValidRecipient(recipients);
var recipientEmailAddress = CreateEmailAddresses(validRecipients);
email.to = recipientEmailAddress;
nextBatchLength = recipients.Count;
MailingUtilities.Log.InfoFormat(
"[CESMaillingProvider.ExecuteSendMessageTask]: Prepared {0} " +
"recipients. BulkEmail.Id {1}, BatchId {2}, SessionId: {3}", nextBatchLength, bulkEmail.Id,
sendMessageTaskData.BatchId, sessionId);
} catch (SqlException e) {
MailingUtilities.Log.ErrorFormat(
"[CESMaillingProvider.GetRecipients]: Group processing fails. BulkEmailRId: {0}, " +
"SessionId: {1}. GroupId: {2}.", e, messageData.BulkEmailRId, messageData.SessionId,
messageData.BatchId);
BulkEmailEventLogger.LogError(messageData.BulkEmail.Id, DateTime.UtcNow,
GetLczStringValue("AudienceAddEvent"), e, GetLczStringValue("BatchProcessingErrorMsg"),
UserConnection.CurrentUser.ContactId, messageData.BatchId);
sendMessageTaskData.RetryMessageProcessing();
if (!sendMessageTaskData.HasDataToProceed)
{
MailingUtilities.Log.InfoFormat(
"[CESMaillingProvider.ExecuteSendMessage]: Terminated. Failed groups limit reached. " +
"BulkEmail.Id: {0}, SessionId: {1}", bulkEmailRId, sessionId);
}
continue;
} catch (Exception exception) {
MailingUtilities.Log.ErrorFormat(
"[CESMaillingProvider.GetRecipients]: Group processing fails. BulkEmailRId: {0}, " +
"SessionId: {1}. GroupId: {2}.", exception, messageData.BulkEmailRId, messageData.SessionId,
messageData.BatchId);
BulkEmailEventLogger.LogError(messageData.BulkEmail.Id, DateTime.UtcNow,
GetLczStringValue("AudienceAddEvent"), exception, GetLczStringValue("BatchProcessingErrorMsg"),
UserConnection.CurrentUser.ContactId, messageData.BatchId);
throw;
}
sendMessageTaskData.LastFailedGroupId = 0;
sendMessageTaskData.CheckMessageCanProceed(nextBatchLength);
BulkEmailQueryHelper.ResetBulkEmailCounters(sourceData.BulkEmailRId, UserConnection);
if (sendMessageTaskData.HasDataToProceed)
{
messageData.MailingStartTS = GetMailingStartTs(bulkEmail);
MailingUtilities.Log.InfoFormat(
"[CESMaillingProvider.ExecuteSendMessageTask]: Has data to " +
"proceed and start new thread. BulkEmail.Id {0}, BatchId {1}, SessionId: {2}", bulkEmail.Id,
sendMessageTaskData.BatchId, sessionId);
try {
Thread.CurrentThread.CurrentCulture = culture;
var resultsCounter = CreateResultsCounter();
messageData.EmailMessage = email;
var sentResult = true;
if (email.to.Any())
{
sentResult = SendBatch(messageData);
}
if (!sentResult)
{
recipients.Where(x => x.InitialResponseCode == (int)BulkEmailResponseCode.Sent).ForEach(y =>
y.InitialResponseCode = (int)MailingResponseCode.RequestFailed);
}
UpdateSendEmailIterationResult(messageData, recipients, resultsCounter);
sendResults.Add(resultsCounter);
} catch (Exception e) {
MailingUtilities.Log.ErrorFormat(
"[CESMaillingProvider.ExecuteSendMessageTask]: Error occurs when sends batch." +
" BulkEmailRId: {0}, SessionId: {1}. GroupId: {2}.", e, messageData.BulkEmailRId,
messageData.SessionId, messageData.BatchId);
}
}
else
{
MailingUtilities.Log.InfoFormat(
"[CESMaillingProvider.ExecuteSendMessageTask]: Has no data to " +
"proceed and BatchSendThreadPool released. BulkEmail.Id {0}, BatchId {1}, SessionId: {2}",
bulkEmail.Id, sendMessageTaskData.BatchId, sessionId);
}
}
ExecuteSendMessagePostProcessing(sourceData, sendResults, sendMessageTaskData);
}
