public override void Send(Dictionary <string, string> mediumData, List <string> recipients, string appRoot, string themeRoot)
{
var message = new RockPushMessage();
message.Title = mediumData.GetValueOrNull("Title") ?? string.Empty;
message.Message = mediumData.GetValueOrNull("Message") ?? string.Empty;
message.Sound = mediumData.GetValueOrNull("Sound") ?? string.Empty;
message.SetRecipients(recipients);
message.SendSeperatelyToEachRecipient = false;
message.ThemeRoot = themeRoot;
message.AppRoot = appRoot;
var errorMessages = new List <string>();
int mediumEntityId = EntityTypeCache.Get(Rock.SystemGuid.EntityType.COMMUNICATION_MEDIUM_PUSH_NOTIFICATION.AsGuid())?.Id ?? 0;
Send(message, mediumEntityId, null, out errorMessages);
}
/// <summary>
/// Pushes the message.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="to">To.</param>
/// <param name="emailMessage">The email message.</param>
/// <param name="mergeFields">The merge fields.</param>
private void PushMessage(Sender sender, List <string> to, RockPushMessage emailMessage, Dictionary <string, object> mergeFields)
{
string title = ResolveText(emailMessage.Title, emailMessage.CurrentPerson, emailMessage.EnabledLavaCommands, mergeFields, emailMessage.AppRoot, emailMessage.ThemeRoot);
string sound = ResolveText(emailMessage.Sound, emailMessage.CurrentPerson, emailMessage.EnabledLavaCommands, mergeFields, emailMessage.AppRoot, emailMessage.ThemeRoot);
string message = ResolveText(emailMessage.Message, emailMessage.CurrentPerson, emailMessage.EnabledLavaCommands, mergeFields, emailMessage.AppRoot, emailMessage.ThemeRoot);
var notification = new Message
{
RegistrationIds = to,
Notification = new FCM.Net.Notification
{
Title = title,
Body = message,
Sound = sound,
}
};
Utility.AsyncHelpers.RunSync(() => sender.SendAsync(notification));
}
/// <summary>
/// Pushes the message.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="to">To.</param>
/// <param name="emailMessage">The email message.</param>
/// <param name="mergeFields">The merge fields.</param>
//private void PushMessage( Sender sender, List<string> to, RockPushMessage pushMessage, Dictionary<string, object> mergeFields )
private void PushMessage(List <string> to, RockPushMessage pushMessage, Dictionary <string, object> mergeFields)
{
string title = ResolveText(pushMessage.Title, pushMessage.CurrentPerson, pushMessage.EnabledLavaCommands, mergeFields, pushMessage.AppRoot, pushMessage.ThemeRoot);
string sound = ResolveText(pushMessage.Sound, pushMessage.CurrentPerson, pushMessage.EnabledLavaCommands, mergeFields, pushMessage.AppRoot, pushMessage.ThemeRoot);
string message = ResolveText(pushMessage.Message, pushMessage.CurrentPerson, pushMessage.EnabledLavaCommands, mergeFields, pushMessage.AppRoot, pushMessage.ThemeRoot);
string appId = GetAttributeValue("AppId");
string restApiKey = GetAttributeValue("RestAPIKey");
OneSignalClient client = new OneSignalClient(restApiKey);
var options = new NotificationCreateOptions
{
AppId = new Guid(appId),
IncludeExternalUserIds = to
};
options.Headings.Add(LanguageCodes.English, title);
options.Contents.Add(LanguageCodes.English, message);
client.Notifications.Create(options);
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
var mergeFields = GetMergeFields(action);
var recipients = new List <RockPushMessageRecipient>();
string toValue = GetAttributeValue(action, "To");
Guid guid = toValue.AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Get(guid, rockContext);
if (attribute != null)
{
string toAttributeValue = action.GetWorkflowAttributeValue(guid);
if (!string.IsNullOrWhiteSpace(toAttributeValue))
{
switch (attribute.FieldType.Class)
{
case "Rock.Field.Types.PersonFieldType":
{
Guid personAliasGuid = toAttributeValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var personAlias = new PersonAliasService(rockContext).Get(personAliasGuid);
List <string> devices = new PersonalDeviceService(rockContext).Queryable()
.Where(a => a.PersonAliasId.HasValue && a.PersonAliasId == personAlias.Id && a.NotificationsEnabled)
.Select(a => a.DeviceRegistrationId)
.ToList();
string deviceIds = String.Join(",", devices);
if (devices.Count == 0)
{
action.AddLogEntry("Invalid Recipient: Person does not have devices that support notifications", true);
}
else
{
var person = new PersonAliasService(rockContext).GetPerson(personAliasGuid);
var recipient = new RockPushMessageRecipient(person, deviceIds, mergeFields);
recipients.Add(recipient);
if (person != null)
{
recipient.MergeFields.Add(recipient.PersonMergeFieldKey, person);
}
}
}
break;
}
case "Rock.Field.Types.GroupFieldType":
case "Rock.Field.Types.SecurityRoleFieldType":
{
int? groupId = toAttributeValue.AsIntegerOrNull();
Guid?groupGuid = toAttributeValue.AsGuidOrNull();
IQueryable <GroupMember> qry = null;
// Handle situations where the attribute value is the ID
if (groupId.HasValue)
{
qry = new GroupMemberService(rockContext).GetByGroupId(groupId.Value);
}
// Handle situations where the attribute value stored is the Guid
else if (groupGuid.HasValue)
{
qry = new GroupMemberService(rockContext).GetByGroupGuid(groupGuid.Value);
}
else
{
action.AddLogEntry("Invalid Recipient: No valid group id or Guid", true);
}
if (qry != null)
{
foreach (var person in qry
.Where(m => m.GroupMemberStatus == GroupMemberStatus.Active)
.Select(m => m.Person))
{
List <string> devices = new PersonalDeviceService(rockContext).Queryable()
.Where(p => p.PersonAliasId.HasValue && p.PersonAliasId == person.PrimaryAliasId && p.NotificationsEnabled && !string.IsNullOrEmpty(p.DeviceRegistrationId))
.Select(p => p.DeviceRegistrationId)
.ToList();
string deviceIds = String.Join(",", devices);
if (deviceIds.AsBoolean())
{
var recipient = new RockPushMessageRecipient(person, deviceIds, mergeFields);
recipients.Add(recipient);
recipient.MergeFields.Add(recipient.PersonMergeFieldKey, person);
}
}
}
break;
}
}
}
}
}
else
{
if (!string.IsNullOrWhiteSpace(toValue))
{
recipients.Add(RockPushMessageRecipient.CreateAnonymous(toValue.ResolveMergeFields(mergeFields), mergeFields));
}
}
string message = GetAttributeValue(action, "Message");
Guid messageGuid = message.AsGuid();
if (!messageGuid.IsEmpty())
{
var attribute = AttributeCache.Get(messageGuid, rockContext);
if (attribute != null)
{
string messageAttributeValue = action.GetWorkflowAttributeValue(messageGuid);
if (!string.IsNullOrWhiteSpace(messageAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.TextFieldType")
{
message = messageAttributeValue;
}
}
}
}
string title = GetAttributeValue(action, "Title");
Guid titleGuid = title.AsGuid();
if (!titleGuid.IsEmpty())
{
var attribute = AttributeCache.Get(titleGuid, rockContext);
if (attribute != null)
{
string titleAttributeValue = action.GetWorkflowAttributeValue(titleGuid);
if (!string.IsNullOrWhiteSpace(titleAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.TextFieldType")
{
title = titleAttributeValue;
}
}
}
}
string sound = GetAttributeValue(action, "Sound");
Guid soundGuid = sound.AsGuid();
if (!soundGuid.IsEmpty())
{
var attribute = AttributeCache.Get(soundGuid, rockContext);
if (attribute != null)
{
string soundAttributeValue = action.GetWorkflowAttributeValue(soundGuid);
if (!string.IsNullOrWhiteSpace(soundAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.BooleanFieldType")
{
sound = soundAttributeValue;
}
}
}
}
sound = sound.AsBoolean() ? "default" : "";
if (recipients.Any() && !string.IsNullOrWhiteSpace(message))
{
var pushMessage = new RockPushMessage();
pushMessage.SetRecipients(recipients);
pushMessage.Title = title;
pushMessage.Message = message;
pushMessage.Sound = sound;
pushMessage.Send();
}
return(true);
}
/// <summary>
/// Sends the meeting reminders.
/// </summary>
/// <param name="context">The overall job context.</param>
/// <param name="rockContext">The rockContext.</param>
/// <param name="occurrenceData">The occurrenceData to process.</param>
/// <param name="systemCommunication">The system communication.</param>
/// <param name="jobPreferredCommunicationType">Type of the job preferred communication.</param>
/// <returns></returns>
private SendMessageResult SendMeetingReminders(IJobExecutionContext context,
RockContext rockContext,
Dictionary <RoomOccurrence, Group> occurrenceData,
SystemCommunication systemCommunication,
CommunicationType jobPreferredCommunicationType,
bool isSmsEnabled,
bool isPushEnabled)
{
var result = new SendMessageResult();
var errorsEmail = new List <string>();
var errorsSms = new List <string>();
var errorsPush = new List <string>();
// Loop through the room occurrence data
foreach (var occurrence in occurrenceData)
{
var emailMessage = new RockEmailMessage(systemCommunication);
RockSMSMessage smsMessage = isSmsEnabled ? new RockSMSMessage(systemCommunication) : null;
RockPushMessage pushMessage = isPushEnabled ? new RockPushMessage(systemCommunication) : null;
var group = occurrence.Value;
foreach (var groupMember in group.ActiveMembers().ToList())
{
groupMember.Person.LoadAttributes();
var smsNumber = groupMember.Person.PhoneNumbers.GetFirstSmsNumber();
var personAlias = new PersonAliasService(rockContext).Get(groupMember.Person.PrimaryAliasId.Value);
List <string> pushDevices = new PersonalDeviceService(rockContext).Queryable()
.Where(a => a.PersonAliasId.HasValue && a.PersonAliasId == personAlias.Id && a.NotificationsEnabled)
.Select(a => a.DeviceRegistrationId)
.ToList();
if (!groupMember.Person.CanReceiveEmail(false) && smsNumber.IsNullOrWhiteSpace() && pushDevices.Count == 0)
{
continue;
}
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null, groupMember.Person);
mergeFields.Add("Group", group);
mergeFields.Add("Occurrence", occurrence.Key);
mergeFields.Add("Person", groupMember.Person);
var notificationType = ( CommunicationType )Communication.DetermineMediumEntityTypeId(
( int )CommunicationType.Email,
( int )CommunicationType.SMS,
( int )CommunicationType.PushNotification,
jobPreferredCommunicationType,
groupMember.CommunicationPreference,
groupMember.Person.CommunicationPreference);
switch (notificationType)
{
case CommunicationType.Email:
if (!groupMember.Person.CanReceiveEmail(false))
{
errorCount += 1;
errorMessages.Add(string.Format("{0} does not have a valid email address.", groupMember.Person.FullName));
}
else
{
emailMessage.AddRecipient(new RockEmailMessageRecipient(groupMember.Person, mergeFields));
}
break;
case CommunicationType.SMS:
if (string.IsNullOrWhiteSpace(smsNumber) || smsMessage == null)
{
errorCount += 1;
errorMessages.Add(string.Format("No SMS number could be found for {0}.", groupMember.Person.FullName));
goto case CommunicationType.Email;
}
else
{
smsMessage.AddRecipient(new RockSMSMessageRecipient(groupMember.Person, smsNumber, mergeFields));
}
break;
case CommunicationType.PushNotification:
if (pushDevices.Count == 0 || pushMessage == null)
{
errorCount += 1;
errorMessages.Add(string.Format("No devices that support notifications could be found for {0}.", groupMember.Person.FullName));
goto case CommunicationType.Email;
}
else
{
string deviceIds = String.Join(",", pushDevices);
pushMessage.AddRecipient(new RockPushMessageRecipient(groupMember.Person, deviceIds, mergeFields));
}
break;
default:
break;
}
}
if (emailMessage.GetRecipients().Count > 0)
{
emailMessage.Send(out errorsEmail);
if (errorsEmail.Any())
{
result.Errors.AddRange(errorsEmail);
}
else
{
notificationEmails++;
}
}
if (smsMessage != null && smsMessage.GetRecipients().Count > 0)
{
smsMessage.Send(out errorsSms);
if (errorsSms.Any())
{
result.Errors.AddRange(errorsSms);
}
else
{
notificationSms++;
}
}
if (pushMessage != null && pushMessage.GetRecipients().Count > 0)
{
pushMessage.Send(out errorsPush);
if (errorsPush.Any())
{
result.Errors.AddRange(errorsPush);
}
else
{
notificationPush++;
}
}
}
if (errorMessages.Any())
{
StringBuilder sb = new StringBuilder();
sb.AppendLine();
sb.Append(string.Format("{0} Errors: ", errorCount));
errorMessages.ForEach(e => { sb.AppendLine(); sb.Append(e); });
string errors = sb.ToString();
context.Result += errors;
var exception = new Exception(errors);
HttpContext context2 = HttpContext.Current;
ExceptionLogService.LogException(exception, context2);
throw exception;
}
return(result);
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
var mergeFields = GetMergeFields(action);
var recipients = new List <RockPushMessageRecipient>();
string toValue = GetAttributeValue(action, "To");
Guid guid = toValue.AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Get(guid, rockContext);
if (attribute != null)
{
string toAttributeValue = action.GetWorkflowAttributeValue(guid);
if (!string.IsNullOrWhiteSpace(toAttributeValue))
{
switch (attribute.FieldType.Class)
{
case "Rock.Field.Types.PersonFieldType":
{
Guid personAliasGuid = toAttributeValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var personAlias = new PersonAliasService(rockContext).Get(personAliasGuid);
List <string> devices = new PersonalDeviceService(rockContext).Queryable()
.Where(a => a.PersonAliasId.HasValue && a.PersonAliasId == personAlias.Id && a.IsActive && a.NotificationsEnabled)
.Select(a => a.DeviceRegistrationId)
.ToList();
string deviceIds = String.Join(",", devices);
if (devices.Count == 0)
{
action.AddLogEntry("Invalid Recipient: Person does not have devices that support notifications", true);
}
else
{
var person = new PersonAliasService(rockContext).GetPerson(personAliasGuid);
var recipient = new RockPushMessageRecipient(person, deviceIds, mergeFields);
recipients.Add(recipient);
if (person != null)
{
recipient.MergeFields.Add(recipient.PersonMergeFieldKey, person);
}
}
}
break;
}
case "Rock.Field.Types.GroupFieldType":
case "Rock.Field.Types.SecurityRoleFieldType":
{
int? groupId = toAttributeValue.AsIntegerOrNull();
Guid?groupGuid = toAttributeValue.AsGuidOrNull();
IQueryable <GroupMember> qry = null;
// Handle situations where the attribute value is the ID
if (groupId.HasValue)
{
qry = new GroupMemberService(rockContext).GetByGroupId(groupId.Value);
}
// Handle situations where the attribute value stored is the Guid
else if (groupGuid.HasValue)
{
qry = new GroupMemberService(rockContext).GetByGroupGuid(groupGuid.Value);
}
else
{
action.AddLogEntry("Invalid Recipient: No valid group id or Guid", true);
}
if (qry != null)
{
foreach (var person in qry
.Where(m => m.GroupMemberStatus == GroupMemberStatus.Active)
.Select(m => m.Person))
{
List <string> devices = new PersonalDeviceService(rockContext).Queryable()
.Where(p => p.PersonAliasId.HasValue && p.PersonAliasId == person.PrimaryAliasId && p.IsActive && p.NotificationsEnabled && !string.IsNullOrEmpty(p.DeviceRegistrationId))
.Select(p => p.DeviceRegistrationId)
.ToList();
string deviceIds = String.Join(",", devices);
if (deviceIds.IsNotNullOrWhiteSpace())
{
var recipient = new RockPushMessageRecipient(person, deviceIds, mergeFields);
recipients.Add(recipient);
recipient.MergeFields.Add(recipient.PersonMergeFieldKey, person);
}
}
}
break;
}
}
}
}
}
else
{
if (!string.IsNullOrWhiteSpace(toValue))
{
recipients.Add(RockPushMessageRecipient.CreateAnonymous(toValue.ResolveMergeFields(mergeFields), mergeFields));
}
}
string message = GetAttributeValue(action, "Message");
Guid messageGuid = message.AsGuid();
if (!messageGuid.IsEmpty())
{
var attribute = AttributeCache.Get(messageGuid, rockContext);
if (attribute != null)
{
string messageAttributeValue = action.GetWorkflowAttributeValue(messageGuid);
if (!string.IsNullOrWhiteSpace(messageAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.TextFieldType")
{
message = messageAttributeValue;
}
}
}
}
string title = GetAttributeValue(action, "Title");
Guid titleGuid = title.AsGuid();
if (!titleGuid.IsEmpty())
{
var attribute = AttributeCache.Get(titleGuid, rockContext);
if (attribute != null)
{
string titleAttributeValue = action.GetWorkflowAttributeValue(titleGuid);
if (!string.IsNullOrWhiteSpace(titleAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.TextFieldType")
{
title = titleAttributeValue;
}
}
}
}
string sound = GetAttributeValue(action, "Sound");
Guid soundGuid = sound.AsGuid();
if (!soundGuid.IsEmpty())
{
var attribute = AttributeCache.Get(soundGuid, rockContext);
if (attribute != null)
{
string soundAttributeValue = action.GetWorkflowAttributeValue(soundGuid);
if (!string.IsNullOrWhiteSpace(soundAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.BooleanFieldType")
{
sound = soundAttributeValue;
}
}
}
}
sound = sound.AsBoolean() ? "default" : "";
string url = GetAttributeValue(action, "Url");
Guid urlGuid = url.AsGuid();
if (!urlGuid.IsEmpty())
{
var attribute = AttributeCache.Get(urlGuid, rockContext);
if (attribute != null)
{
string urlAttributeValue = action.GetWorkflowAttributeValue(urlGuid);
if (!string.IsNullOrWhiteSpace(urlAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.TextFieldType")
{
url = urlAttributeValue;
}
}
}
}
if (recipients.Any() && !string.IsNullOrWhiteSpace(message))
{
var pushMessage = new RockPushMessage();
pushMessage.SetRecipients(recipients);
pushMessage.Title = title;
pushMessage.Message = message;
pushMessage.Sound = sound;
pushMessage.OpenAction = url.IsNotNullOrWhiteSpace() ? Utility.PushOpenAction.LinkToUrl : Utility.PushOpenAction.NoAction;
pushMessage.Data = new PushData
{
Url = url
};
// Check if the URL is a mobile app style URL, which is "<guid>[?key=value]".
if (url.Length >= 36 && Guid.TryParse(url.Substring(0, 36), out var pageGuid))
{
var pageId = PageCache.Get(pageGuid)?.Id;
if (pageId.HasValue)
{
pushMessage.Data.MobilePageId = pageId.Value;
// Check if there are any query string values.
if (url.Length >= 38 && url[36] == '?')
{
var queryString = url.Substring(37).ParseQueryString();
pushMessage.Data.MobilePageQueryString = new Dictionary <string, string>();
foreach (string key in queryString.Keys)
{
pushMessage.Data.MobilePageQueryString.AddOrReplace(key, queryString[key].ToString());
}
}
pushMessage.OpenAction = Utility.PushOpenAction.LinkToMobilePage;
}
}
pushMessage.Send(out errorMessages);
}
return(true);
}
