/// <summary>
/// Commit message
/// Send the messages which are registered
/// </summary>
/// <param name="asynchronously">Commit message asynchronously</param>
/// <returns>Return send result</returns>
public static async Task <SendMessageResult> CommitAsync(bool asynchronously = true)
{
if (CurrentMessageBox?.Messages?.IsNullOrEmpty() ?? true)
{
return(SendMessageResult.MessageIsNullOrEmpty());
}
SendMessageResult sendMessageResult = null;
var currentMessages = CurrentMessageBox.Messages.Select(c => c).ToList();
CurrentMessageBox.Clear();
if (asynchronously)
{
InternalQueueMessageItem messageInternalCommand = new InternalQueueMessageItem(MessageProvider, currentMessages, WorkManager.Current);
InternalQueueManager.GetQueue(EZNEWConstants.InternalQueueNames.Message).Enqueue(messageInternalCommand);
sendMessageResult = SendMessageResult.SendSuccess();
}
else
{
sendMessageResult = await(MessageProvider?.SendAsync(new SendMessageOptions()
{
Messages = currentMessages
}) ?? Task.FromResult(SendMessageResult.NoProvider())).ConfigureAwait(false);
}
return(sendMessageResult);
}
/// <summary>
/// Send sms message
/// </summary>
/// <param name="smsAccount">Sms account</param>
/// <param name="messageTemplate">Message template</param>
/// <param name="message">Message</param>
/// <param name="smsTag">Sms tag</param>
/// <param name="mobiles">Mobiles</param>
/// <param name="asynchronously">Whether send by asynchronously</param>
/// <returns>Return send result</returns>
public static async Task <SendMessageResult> SendSmsMessageAsync(SmsAccount smsAccount, MessageTemplate messageTemplate, MessageInfo message, string smsTag, IEnumerable <string> mobiles, bool asynchronously = true)
{
var msgResult = GetSmsOptions(messageTemplate, message, smsTag, mobiles, asynchronously, out var smsOptions);
if (!msgResult.Success || smsOptions == null)
{
return(msgResult);
}
SendSmsResult smsSendResult = await SmsManager.SendAsync(smsAccount, smsOptions).ConfigureAwait(false);
return(smsSendResult.Success ? SendMessageResult.SendSuccess() : SendMessageResult.SendFailed(smsSendResult.Description));
}
/// <summary>
/// Send email message
/// </summary>
/// <param name="emailAccount">Email account</param>
/// <param name="messageTemplate">Message template</param>
/// <param name="message">Message</param>
/// <param name="emailCategory">Email category</param>
/// <param name="emails">Emails</param>
/// <param name="asynchronously">Whether send by asynchronously</param>
/// <returns>Return send result</returns>
public static async Task <SendMessageResult> SendEmailMessageAsync(EmailAccount emailAccount, MessageTemplate messageTemplate, MessageInfo message, string emailCategory, IEnumerable <string> emails, bool asynchronously = true)
{
var msgResult = GetEmailOptions(messageTemplate, message, emailCategory, emails, asynchronously, out var emailOptions);
if (!msgResult.Success || emailOptions == null)
{
return(msgResult);
}
SendEmailResult emailSendResult = (await EmailManager.SendAsync(emailAccount, emailOptions).ConfigureAwait(false))?.FirstOrDefault();
return((emailSendResult?.Success ?? false) ? SendMessageResult.SendSuccess() : SendMessageResult.SendFailed(emailSendResult?.Message));
}
static SendMessageResult GetSmsOptions(MessageTemplate messageTemplate, MessageInfo message, string smsTag, IEnumerable <string> mobiles, bool asynchronously, out SendSmsOptions sendSmsOptions)
{
sendSmsOptions = null;
if (messageTemplate == null)
{
throw new ArgumentNullException(nameof(MessageTemplate));
}
if (message == null)
{
throw new ArgumentNullException(nameof(MessageInfo));
}
if (string.IsNullOrWhiteSpace(messageTemplate.Content))
{
throw new Exception("The message template content is null or empty");
}
if (mobiles.IsNullOrEmpty())
{
throw new Exception("The mobiles is null or empty");
}
var parameterDict = message.Parameters?.ObjectToStringDcitionary();
Dictionary <string, string> templateParameters = GetTemplateParameters(parameterDict);
//content
var contentResolveResult = ResolveTemplate(messageTemplate.Content, templateParameters);
if (!contentResolveResult.Item1 || string.IsNullOrWhiteSpace(contentResolveResult.Item3))
{
if (!string.IsNullOrWhiteSpace(contentResolveResult.Item2))
{
return(SendMessageResult.NoParameter($"Not set '{contentResolveResult.Item2}' value in the sms body template"));
}
return(SendMessageResult.MessageIsNullOrEmpty($"The sms body is null or empty"));
}
//Send sms
sendSmsOptions = new SendSmsOptions()
{
Tag = smsTag,
Content = contentResolveResult.Item3,
Parameters = parameterDict,
Asynchronously = asynchronously,
Mobiles = mobiles,
};
sendSmsOptions.AddWorkId(message.WorkId);
sendSmsOptions.AddTemplateMessageId(message.Id);
return(SendMessageResult.SendSuccess());
}
/// <summary>
/// Send message
/// </summary>
/// <param name="options">Send message options</param>
/// <returns>Return send result</returns>
public async Task <SendMessageResult> SendAsync(SendMessageOptions options)
{
if (options?.Messages.IsNullOrEmpty() ?? true)
{
return(SendMessageResult.NoOptions());
}
Dictionary <string, List <MessageInfo> > messageGroups = new Dictionary <string, List <MessageInfo> >();
foreach (var msg in options.Messages)
{
if (messageGroups.ContainsKey(msg.Type))
{
messageGroups[msg.Type].Add(msg);
}
else
{
messageGroups.Add(msg.Type, new List <MessageInfo>()
{
msg
});
}
}
SendMessageResult sendResult = SendMessageResult.SendSuccess();
foreach (var msgGroup in messageGroups)
{
var messageHandler = MessageManager.GetMessageHandler(msgGroup.Key);
if (messageHandler == null)
{
return(SendMessageResult.NoHandler(string.Format("Not set handler for {0}", msgGroup.Key)));
}
var executeResult = await messageHandler.SendAsync(new SendMessageContext()
{
Messages = msgGroup.Value
}).ConfigureAwait(false);
if (!executeResult.Success)
{
return(executeResult);
}
sendResult.Add(executeResult);
}
return(sendResult);
}
static SendMessageResult GetEmailOptions(MessageTemplate messageTemplate, MessageInfo message, string emailCategory, IEnumerable <string> emails, bool asynchronously, out SendEmailOptions sendEmailOptions)
{
sendEmailOptions = null;
if (messageTemplate == null)
{
throw new ArgumentNullException(nameof(MessageTemplate));
}
if (message == null)
{
throw new ArgumentNullException(nameof(MessageInfo));
}
if (string.IsNullOrWhiteSpace(messageTemplate.Title))
{
throw new Exception("The message template title is null or empty");
}
if (string.IsNullOrWhiteSpace(messageTemplate.Content))
{
throw new Exception("The message template content is null or empty");
}
if (emails.IsNullOrEmpty())
{
throw new Exception("The emails is null or empty");
}
var parameterDict = message.Parameters?.ObjectToStringDcitionary();
Dictionary <string, string> templateParameters = GetTemplateParameters(parameterDict);
//title
var titleResolveResult = ResolveTemplate(messageTemplate.Title, templateParameters);
if (!titleResolveResult.Item1 || string.IsNullOrWhiteSpace(titleResolveResult.Item3))
{
if (!string.IsNullOrWhiteSpace(titleResolveResult.Item2))
{
return(SendMessageResult.NoParameter($"Not set '{titleResolveResult.Item2}' value in the email title template"));
}
return(SendMessageResult.MessageIsNullOrEmpty($"The email title is null or empty"));
}
//content
var contentResolveResult = ResolveTemplate(messageTemplate.Content, templateParameters);
if (!contentResolveResult.Item1 || string.IsNullOrWhiteSpace(contentResolveResult.Item3))
{
if (!string.IsNullOrWhiteSpace(contentResolveResult.Item2))
{
return(SendMessageResult.NoParameter($"Not set '{contentResolveResult.Item2}' value in the email body template"));
}
return(SendMessageResult.MessageIsNullOrEmpty($"The email body is null or empty"));
}
//Send email
sendEmailOptions = new SendEmailOptions()
{
Category = emailCategory,
Content = contentResolveResult.Item3,
Subject = titleResolveResult.Item3,
Asynchronously = asynchronously,
Emails = emails
};
sendEmailOptions.AddWorkId(message.WorkId);
sendEmailOptions.AddTemplateMessageId(message.Id);
return(SendMessageResult.SendSuccess());
}
