/// <summary>
/// Checks the attributes for this component and determines if the message
/// should be processed.
/// </summary>
/// <param name="action">The action that contains the configuration for this component.</param>
/// <param name="message">The message that is to be checked.</param>
/// <param name="errorMessage">If there is a problem processing, this should be set</param>
/// <returns>
/// <c>true</c> if the message should be processed.
/// </returns>
public override bool ShouldProcessMessage(SmsActionCache action, SmsMessage message, out string errorMessage)
{
//
// Give the base class a chance to check it's own settings to see if we
// should process this message.
//
if (!base.ShouldProcessMessage(action, message, out errorMessage))
{
return(false);
}
//
// Check if we have a valid workflow type.
//
var workflowType = WorkflowTypeCache.Get(GetAttributeValue(action, AttributeKey.WorkflowType).AsGuid());
if (workflowType == null)
{
return(false);
}
//
// Get the filter expression for the message body.
//
var attribute = action.Attributes.ContainsKey(AttributeKey.Message) ? action.Attributes[AttributeKey.Message] : null;
var msg = GetAttributeValue(action, AttributeKey.Message);
var filter = ValueFilterFieldType.GetFilterExpression(attribute?.QualifierValues, msg);
//
// Evaluate the message against the filter and return the match state.
//
return(filter != null?filter.Evaluate(message, AttributeKey.Message) : true);
}
/// <summary>
/// Processes the message that was received from the remote user.
/// </summary>
/// <param name="action">The action that contains the configuration for this component.</param>
/// <param name="message">The message that was received by Rock.</param>
/// <param name="errorMessage">If there is a problem processing, this should be set</param>
/// <returns>An SmsMessage that will be sent as the response or null if no response should be sent.</returns>
public override SmsMessage ProcessMessage(SmsActionCache action, SmsMessage message, out string errorMessage)
{
errorMessage = string.Empty;
//
// Process the message with lava to get the response that should be sent back.
//
var mergeObjects = new Dictionary <string, object>
{
{ "Message", message }
};
var responseMessage = action.GetAttributeValue("Response").ResolveMergeFields(mergeObjects, message.FromPerson);
//
// If there is no response message then return null.
//
if (string.IsNullOrWhiteSpace(responseMessage))
{
return(null);
}
return(new SmsMessage
{
Message = responseMessage.Trim()
});
}
/// <summary>
/// Handles the Click event of the btnSaveActionSettings control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void btnSaveActionSettings_Click(object sender, EventArgs e)
{
var rockContext = new RockContext();
var action = new SmsActionService(rockContext).Get(hfEditActionId.Value.AsInteger());
action.Name = tbName.Text;
action.IsActive = cbActive.Checked;
action.ContinueAfterProcessing = cbContinue.Checked;
action.ExpireDate = dpExpireDate.SelectedDate;
avcFilters.GetEditValues(action);
avcAttributes.GetEditValues(action);
rockContext.WrapTransaction(() =>
{
rockContext.SaveChanges();
action.SaveAttributeValues();
});
SmsActionCache.Clear();
pnlEditAction.Visible = false;
hfEditActionId.Value = string.Empty;
BindActions();
}
/// <summary>
/// Processes the drag events.
/// </summary>
private void ProcessDragEvents()
{
string argument = Request["__EVENTARGUMENT"].ToStringSafe();
var segments = argument.SplitDelimitedValues();
//
// Check for the event to add a new action.
//
if (segments.Length == 3 && segments[0] == "add-action")
{
var actionComponent = SmsActionContainer.GetComponent(segments[1]);
var order = segments[2].AsInteger();
var rockContext = new RockContext();
var smsActionService = new SmsActionService(rockContext);
var action = new SmsAction
{
SmsPipelineId = GetSmsPipelineId().Value,
Name = actionComponent.Title,
IsActive = true,
Order = order,
SmsActionComponentEntityTypeId = actionComponent.TypeId
};
smsActionService.Queryable()
.Where(a => a.Order >= order)
.ToList()
.ForEach(a => a.Order += 1);
smsActionService.Add(action);
rockContext.SaveChanges();
BindActions();
SmsActionCache.Clear();
}
//
// Check for the event to drag-reorder actions.
//
else if (segments.Length == 3 && segments[0] == "reorder-action")
{
var rockContext = new RockContext();
var smsActionService = new SmsActionService(rockContext);
var actions = smsActionService.Queryable()
.OrderBy(a => a.Order)
.ThenBy(a => a.Id)
.ToList();
smsActionService.Reorder(actions, segments[1].AsInteger(), segments[2].AsInteger());
rockContext.SaveChanges();
BindActions();
SmsActionCache.Clear();
}
}
/// <summary>
/// Checks the attributes for this component and determines if the message
/// should be processed.
/// </summary>
/// <param name="action">The action that contains the configuration for this component.</param>
/// <param name="message">The message that is to be checked.</param>
/// /// <param name="errorMessage">If there is a problem, this should be set</param>
/// <returns><c>true</c> if the message should be processed.</returns>
public virtual bool ShouldProcessMessage(SmsActionCache action, SmsMessage message, out string errorMessage)
{
errorMessage = string.Empty;
var attribute = action.Attributes.ContainsKey("PhoneNumbers") ? action.Attributes["PhoneNumbers"] : null;
var phoneNumbers = GetAttributeValue(action, "PhoneNumbers");
var filter = ValueFilterFieldType.GetFilterExpression(attribute?.QualifierValues, phoneNumbers);
return(filter != null?filter.Evaluate(message, "ToNumber") : true);
}
/// <summary>
/// Checks the attributes for this component and determines if the message
/// should be processed.
/// </summary>
/// <param name="action">The action that contains the configuration for this component.</param>
/// <param name="message">The message that is to be checked.</param>
/// <param name="errorMessage">If there is a problem processing, this should be set</param>
/// <returns>
/// <c>true</c> if the message should be processed.
/// </returns>
public override bool ShouldProcessMessage(SmsActionCache action, SmsMessage message, out string errorMessage)
{
//
// Give the base class a chance to check it's own settings to see if we
// should process this message.
//
if (!base.ShouldProcessMessage(action, message, out errorMessage))
{
return(false);
}
return(true);
}
/// <summary>
/// Processes the message that was received from the remote user.
/// </summary>
/// <param name="action">The action that contains the configuration for this component.</param>
/// <param name="message">The message that was received by Rock.</param>
/// <param name="errorMessage">If there is a problem processing, this should be set</param>
/// <returns>An SmsMessage that will be sent as the response or null if no response should be sent.</returns>
public override SmsMessage ProcessMessage(SmsActionCache action, SmsMessage message, out string errorMessage)
{
errorMessage = string.Empty;
//
// Get the list of workflow attributes to set.
//
var workflowAttributesSettings = new List <KeyValuePair <string, object> >();
var workflowAttributes = action.Attributes["WorkflowAttributes"];
if (workflowAttributes != null)
{
if (workflowAttributes.FieldType.Field is KeyValueListFieldType keyValueField)
{
workflowAttributesSettings = keyValueField.GetValuesFromString(null,
GetAttributeValue(action, "WorkflowAttributes"),
workflowAttributes.QualifierValues,
false);
}
}
var workflowType = WorkflowTypeCache.Get(GetAttributeValue(action, "WorkflowType").AsGuid());
//
// Launch the workflow.
//
Rock.Utility.TextToWorkflow.LaunchWorkflow(workflowType,
GetAttributeValue(action, "WorkflowNameTemplate"),
message.FromPerson,
message.FromNumber.Replace("+", ""),
message.ToNumber.Replace("+", ""),
message.Message,
message.Attachments,
workflowAttributesSettings,
out string response);
//
// If there is no response message then return null.
//
if (string.IsNullOrWhiteSpace(response))
{
return(null);
}
return(new SmsMessage
{
Message = response.Trim()
});
}
/// <summary>
/// Updates any Cache Objects that are associated with this entity
/// </summary>
/// <param name="entityState">State of the entity.</param>
/// <param name="dbContext">The database context.</param>
public void UpdateCache(EntityState entityState, Rock.Data.DbContext dbContext)
{
SmsActionCache.UpdateCachedEntity(Id, entityState);
}
/// <summary>
/// Gets the cache object associated with this Entity
/// </summary>
/// <returns></returns>
public IEntityCache GetCacheObject()
{
return(SmsActionCache.Get(Id));
}
/// <summary>
/// Processes the drag events.
/// </summary>
private void ProcessDragEvents()
{
string argument = Request["__EVENTARGUMENT"].ToStringSafe();
var segments = argument.SplitDelimitedValues();
var smsPipelineId = GetSmsPipelineId();
if (smsPipelineId == null || segments.Length != 3)
{
return;
}
using (var rockContext = new RockContext())
{
var smsActionService = new SmsActionService(rockContext);
var actions = smsActionService
.Queryable()
.Where(a => a.SmsPipelineId == smsPipelineId)
.OrderBy(a => a.Order)
.ThenBy(a => a.Id)
.ToList();
// Reset order actions to eliminate gaps.
for (var i = 0; i < actions.Count; i++)
{
actions[i].Order = i;
}
// Check for the event to add a new action.
if (segments[0] == "add-action")
{
var actionComponent = SmsActionContainer.GetComponent(segments[1]);
var order = segments[2].AsInteger();
var action = new SmsAction
{
SmsPipelineId = smsPipelineId.Value,
Name = actionComponent.Title,
IsActive = true,
Order = order,
SmsActionComponentEntityTypeId = actionComponent.TypeId
};
actions
.Where(a => a.Order >= order)
.ToList()
.ForEach(a => a.Order += 1);
smsActionService.Add(action);
}
else if (segments[0] == "reorder-action")
{
// Check for the event to drag-reorder actions.
smsActionService.Reorder(actions, segments[1].AsInteger(), segments[2].AsInteger());
}
rockContext.SaveChanges();
BindActions();
SmsActionCache.Clear();
}
}
/// <summary>
/// Processes the message that was received from the remote user.
/// </summary>
/// <param name="action">The action that contains the configuration for this component.</param>
/// <param name="message">The message that was received by Rock.</param>
/// <param name="errorMessage">If there is a problem processing, this should be set</param>
/// <returns>An SmsMessage that will be sent as the response or null if no response should be sent.</returns>
public override SmsMessage ProcessMessage(SmsActionCache action, SmsMessage message, out string errorMessage)
{
new Rock.Communication.Medium.Sms().ProcessResponse(message.ToNumber, message.FromNumber, message.Message, out errorMessage);
return(null);
}
/// <summary>
/// Processes the incoming message.
/// </summary>
/// <param name="message">The message received by the communications component.</param>
/// <param name="smsPipelineId">The SMS pipeline identifier.</param>
/// <returns>
/// If not null, identifies the response that should be sent back to the sender.
/// </returns>
static public List <SmsActionOutcome> ProcessIncomingMessage(SmsMessage message, int smsPipelineId)
{
var errorMessage = string.Empty;
var outcomes = new List <SmsActionOutcome>();
var smsPipelineService = new SmsPipelineService(new RockContext());
var smsPipeline = smsPipelineService.Get(smsPipelineId);
if (smsPipeline == null)
{
errorMessage = string.Format("The SMS Pipeline for SMS Pipeline Id {0} was null.", smsPipelineId);
return(CreateErrorOutcomesWithLogging(errorMessage));
}
if (!smsPipeline.IsActive)
{
errorMessage = string.Format("The SMS Pipeline for SMS Pipeline Id {0} was inactive.", smsPipelineId);
return(CreateErrorOutcomesWithLogging(errorMessage));
}
var smsActions = SmsActionCache.All()
.Where(a => a.IsActive)
.Where(a => a.SmsPipelineId == smsPipelineId)
.OrderBy(a => a.Order)
.ThenBy(a => a.Id);
foreach (var smsAction in smsActions)
{
if (smsAction.SmsActionComponent == null)
{
LogIfError(string.Format("The SmsActionComponent for {0} was null", smsAction.Name));
continue;
}
var outcome = new SmsActionOutcome
{
ActionName = smsAction.Name
};
outcomes.Add(outcome);
try
{
//
// Check if the action wants to process this message.
//
outcome.ShouldProcess = smsAction.SmsActionComponent.ShouldProcessMessage(smsAction, message, out errorMessage);
outcome.ErrorMessage = errorMessage;
LogIfError(errorMessage);
if (!outcome.ShouldProcess)
{
continue;
}
//
// Process the message and use either the response returned by the action
// or the previous response we already had.
//
outcome.Response = smsAction.SmsActionComponent.ProcessMessage(smsAction, message, out errorMessage);
outcome.ErrorMessage = errorMessage;
LogIfError(errorMessage);
if (outcome.Response != null)
{
LogIfError(errorMessage);
}
}
catch (Exception exception)
{
outcome.Exception = exception;
LogIfError(exception);
}
//
// If the action is set to not continue after processing then stop.
//
if (outcome.ShouldProcess && !smsAction.ContinueAfterProcessing)
{
break;
}
}
return(outcomes);
}
/// <summary> /// Processes the message that was received from the remote user. /// </summary> /// <param name="action">The action that contains the configuration for this component.</param> /// <param name="message">The message that was received by Rock.</param> /// <param name="errorMessage">If there is a problem processing, this should be set</param> /// <returns>An SmsMessage that will be sent as the response or null if no response should be sent.</returns> public abstract SmsMessage ProcessMessage(SmsActionCache action, SmsMessage message, out string errorMessage);
/// <summary>
/// Gets the attribute value for the service check type
/// </summary>
/// <param name="action">The SMS action.</param>
/// <param name="key">The key.</param>
/// <returns></returns>
public string GetAttributeValue(SmsActionCache action, string key)
{
return(action.GetAttributeValue(key));
}
