/// <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>();
Guid guid = GetAttributeValue(action, "Activity").AsGuid();
if (guid.IsEmpty())
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
var workflow = action.Activity.Workflow;
var activityType = WorkflowActivityTypeCache.Get(guid);
if (activityType == null)
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
WorkflowActivity.Activate(activityType, workflow);
action.AddLogEntry(string.Format("Activated new '{0}' activity", activityType.ToString()));
return(true);
}
private bool activateActivity(RockContext rockContext, WorkflowAction action, string activityAttributeName)
{
Guid guid = GetAttributeValue(action, activityAttributeName).AsGuid();
if (guid.IsEmpty())
{
// No activity. Just be done.
return(true);
}
var workflow = action.Activity.Workflow;
var activityType = WorkflowActivityTypeCache.Get(guid);
if (activityType == null)
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
WorkflowActivity.Activate(activityType, workflow);
action.AddLogEntry(string.Format("Activated new '{0}' activity", activityType.ToString()));
return(true);
}
/// <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 itemListValue = GetAttributeValue(action, "ItemList");
Guid itemListValueAsGuid = itemListValue.AsGuid();
if (!itemListValueAsGuid.IsEmpty())
{
var workflowAttributeValue = action.GetWorklowAttributeValue(itemListValueAsGuid);
if (workflowAttributeValue != null)
{
itemListValue = workflowAttributeValue;
}
}
else
{
itemListValue = itemListValue.ResolveMergeFields(GetMergeFields(action));
}
if (string.IsNullOrWhiteSpace(itemListValue))
{
action.AddLogEntry("List is empty, not activating any activities.", true);
return(true);
}
Guid guid = GetAttributeValue(action, "Activity").AsGuid();
if (guid.IsEmpty())
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
var workflow = action.Activity.Workflow;
var activityTypeCache = WorkflowActivityTypeCache.Get(guid);
if (activityTypeCache == null)
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
string activityAttributeKey = GetAttributeValue(action, "ActivityAttributeKey");
bool hasActivityAttributeKey = !string.IsNullOrWhiteSpace(activityAttributeKey);
foreach (var item in itemListValue.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries))
{
var activity = WorkflowActivity.Activate(activityTypeCache, workflow);
if (hasActivityAttributeKey)
{
activity.SetAttributeValue(activityAttributeKey, item);
}
action.AddLogEntry(string.Format("Activated new '{0}' activity", activityTypeCache.ToString()));
}
return(true);
}
protected void ddlActivateNewActivity_SelectedIndexChanged(object sender, EventArgs e)
{
ParseControls();
int?activityTypeId = ddlActivateNewActivity.SelectedValueAsId();
if (activityTypeId.HasValue)
{
var activityType = WorkflowActivityTypeCache.Get(activityTypeId.Value);
if (activityType != null)
{
var activity = WorkflowActivity.Activate(activityType, Workflow);
activity.Guid = Guid.NewGuid();
foreach (var action in activity.Actions)
{
action.Guid = Guid.NewGuid();
}
Workflow.AddLogEntry(string.Format("Manually Activated new '{0}' activity", activityType.ToString()));
ExpandedActivities.Add(activity.Guid);
BuildControls(true, activity.Guid);
}
}
ddlActivateNewActivity.SelectedIndex = 0;
}
/// <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>();
Guid guid = GetAttributeValue(action, "Activity").AsGuid();
if (guid.IsEmpty())
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
var workflow = action.Activity.Workflow;
var activityType = WorkflowActivityTypeCache.Get(guid);
if (activityType == null)
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
Dictionary <string, string> keyValues = null;
var attributeValues = GetAttributeValue(action, "AttributeValues");
if (!string.IsNullOrWhiteSpace(attributeValues))
{
keyValues = attributeValues.AsDictionaryOrNull();
}
keyValues = keyValues ?? new Dictionary <string, string>();
var activity = WorkflowActivity.Activate(activityType, workflow);
activity.LoadAttributes(rockContext);
foreach (var keyPair in keyValues)
{
//
// Does the key exist as an attribute in the destination activity?
//
if (activity.Attributes.ContainsKey(keyPair.Key))
{
var value = keyPair.Value.ResolveMergeFields(GetMergeFields(action));
activity.SetAttributeValue(keyPair.Key, value);
}
else
{
errorMessages.Add(string.Format("'{0}' is not an attribute key in the activated activity: '{1}'", keyPair.Value, activityType.Name));
}
}
action.AddLogEntry(string.Format("Activated new '{0}' activity", activityType.ToString()));
return(true);
}
/// <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(System.Data.Entity.EntityState entityState, Rock.Data.DbContext dbContext)
{
var workflowTypeId = WorkflowActivityTypeCache.Get(this.ActivityTypeId, dbContext as RockContext)?.WorkflowTypeId;
if (workflowTypeId.HasValue)
{
WorkflowTypeCache.UpdateCachedEntity(workflowTypeId.Value, System.Data.Entity.EntityState.Modified);
}
WorkflowActivityTypeCache.UpdateCachedEntity(this.ActivityTypeId, System.Data.Entity.EntityState.Modified);
WorkflowActionTypeCache.UpdateCachedEntity(this.Id, entityState);
}
protected void bntMerge_Click(object sender, EventArgs e)
{
PDFWorkflowObject pdfWorkflowObject = new PDFWorkflowObject();
pdfWorkflowObject.LavaInput = ceLava.Text;
pdfWorkflowObject.MergeObjects = new Dictionary <string, object>();
if (cbCurrentPerson.Checked)
{
pdfWorkflowObject.MergeObjects.Add("CurrentPerson", CurrentPerson);
}
if (cbGlobal.Checked)
{
pdfWorkflowObject.MergeObjects.Add("GlobalAttributes", GlobalAttributesCache.Get());
}
Guid workflowTypeGuid = Guid.NewGuid();
if (Guid.TryParse(GetAttributeValue("WorkflowType"), out workflowTypeGuid))
{
var workflowRockContext = new RockContext();
var workflowTypeService = new WorkflowTypeService(workflowRockContext);
var workflowType = workflowTypeService.Get(workflowTypeGuid);
if (workflowType != null)
{
var workflow = Workflow.Activate(WorkflowTypeCache.Get(workflowType.Id), "PDFLavaWorkflow");
List <string> workflowErrors;
var workflowService = new WorkflowService(workflowRockContext);
var workflowActivity = GetAttributeValue("WorkflowActivity");
var activityType = workflowType.ActivityTypes.Where(a => a.Name == workflowActivity).FirstOrDefault();
if (activityType != null)
{
WorkflowActivity.Activate(WorkflowActivityTypeCache.Get(activityType.Id), workflow, workflowRockContext);
if (workflowService.Process(workflow, pdfWorkflowObject, out workflowErrors))
{
//success
}
}
}
}
RockContext rockContext = new RockContext();
BinaryFileService binaryFileService = new BinaryFileService(rockContext);
pdfWorkflowObject.PDF.FileName = "LavaGeneratedPDF.pdf";
binaryFileService.Add(pdfWorkflowObject.PDF);
rockContext.SaveChanges();
Response.Redirect(pdfWorkflowObject.PDF.Path);
}
/// <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 workflowActivityGuid = action.GetWorklowAttributeValue(GetAttributeValue(action, "Activity").AsGuid()).AsGuid();
if (workflowActivityGuid.IsEmpty())
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
var attributeKey = GetAttributeValue(action, "WorkflowAttributeKey", true);
var attributeValue = GetAttributeValue(action, "WorkflowAttributeValue", true);
if (string.IsNullOrWhiteSpace(attributeKey) || string.IsNullOrWhiteSpace(attributeValue))
{
action.AddLogEntry("Invalid Workflow Property", true);
return(false);
}
var activityType = WorkflowActivityTypeCache.Get(workflowActivityGuid);
if (activityType == null)
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
var entityType = EntityTypeCache.Get(typeof(Rock.Model.Workflow));
var workflowIds = new AttributeValueService(rockContext)
.Queryable()
.AsNoTracking()
.Where(a => a.Attribute.Key == attributeKey && a.Value == attributeValue && a.Attribute.EntityTypeId == entityType.Id)
.Select(a => a.EntityId);
var workflows = new WorkflowService(rockContext)
.Queryable()
//.AsNoTracking()
.Where(w => w.WorkflowType.ActivityTypes.Any(a => a.Guid == activityType.Guid) && workflowIds.Contains(w.Id))
.ToList();
foreach (var workflow in workflows)
{
WorkflowActivity.Activate(activityType, workflow);
action.AddLogEntry(string.Format("Activated new '{0}' activity in {1} {2}", activityType.ToString(), workflow.TypeName, workflow.WorkflowId));
}
return(true);
}
public static WorkflowActivity Activate(WorkflowActivityType activityType, Workflow workflow, RockContext rockContext)
{
if (activityType != null)
{
var activityTypeCache = WorkflowActivityTypeCache.Get(activityType.Id);
var activity = Activate(activityTypeCache, workflow, rockContext);
if (activity != null)
{
activity.ActivityType = activityType;
}
return(activity);
}
return(null);
}
/// <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 workflowActivityGuid = action.GetWorkflowAttributeValue(GetAttributeValue(action, "Activity").AsGuid()).AsGuid();
if (workflowActivityGuid.IsEmpty())
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
var reference = GetAttributeValue(action, "WorkflowReference", true);
Rock.Model.Workflow workflow = null;
if (reference.AsGuidOrNull() != null)
{
var referenceGuid = reference.AsGuid();
workflow = new WorkflowService(rockContext).Queryable()
.Where(w => w.Guid == referenceGuid)
.FirstOrDefault();
}
else if (reference.AsIntegerOrNull() != null)
{
var referenceInt = reference.AsInteger();
workflow = new WorkflowService(rockContext).Queryable()
.Where(w => w.Id == referenceInt)
.FirstOrDefault();
}
else
{
action.AddLogEntry("Invalid Workflow Property", true);
return(false);
}
var activityType = WorkflowActivityTypeCache.Get(workflowActivityGuid);
if (activityType == null)
{
action.AddLogEntry("Invalid Activity Property", true);
return(false);
}
WorkflowActivity.Activate(activityType, workflow);
action.AddLogEntry(string.Format("Activated new '{0}' activity", activityType.ToString()));
return(true);
}
protected void bntMerge_Click(object sender, EventArgs e)
{
var rockContext = new RockContext();
//Get the mergefields and pdf
BinaryFileService binaryFileService = new BinaryFileService(rockContext);
Dictionary <string, object> mergeFields = GetMergeFields();
BinaryFile pdf = binaryFileService.Get(int.Parse(fpSelectedFile.SelectedValue));
//Create the object we will need to pass to the workflow
if (pdf != null && mergeFields.Count > 0)
{
var pdfEntity = new PDFWorkflowObject();
pdfEntity.PDF = pdf;
pdfEntity.MergeObjects = mergeFields;
Guid workflowTypeGuid = Guid.NewGuid();
if (Guid.TryParse(GetAttributeValue("WorkflowType"), out workflowTypeGuid))
{
var workflowRockContext = new RockContext();
var workflowTypeService = new WorkflowTypeService(workflowRockContext);
var workflowType = workflowTypeService.Get(workflowTypeGuid);
if (workflowType != null)
{
var workflow = Workflow.Activate(WorkflowTypeCache.Get(workflowType.Id), pdf.FileName);
List <string> workflowErrors;
var workflowService = new WorkflowService(workflowRockContext);
var workflowActivity = GetAttributeValue("WorkflowActivity");
var activityType = workflowType.ActivityTypes.Where(a => a.Name == workflowActivity).FirstOrDefault();
if (activityType != null)
{
WorkflowActivity.Activate(WorkflowActivityTypeCache.Get(activityType.Id), workflow, workflowRockContext);
if (workflowService.Process(workflow, pdfEntity, out workflowErrors))
{
//success
}
}
}
}
var mergedPDF = pdfEntity.PDF;
//mergedPDF.Guid = Guid.NewGuid();
binaryFileService.Add(mergedPDF);
rockContext.SaveChanges();
Response.Redirect(mergedPDF.Path);
}
}
/// <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>();
double hoursElapsed = HoursElapsed(action);
string emailStatus = EmailStatus(action);
if (hoursElapsed <= 0)
{
SendEmail(rockContext, action);
}
else
{
var timedOut = false;
WorkflowActivityTypeCache unopenedActivityType = null;
int? unopenedTimeout = null;
Guid?guid = GetAttributeValue(action, "UnopenedTimeoutActivity").AsGuidOrNull();
if (guid.HasValue)
{
unopenedActivityType = WorkflowActivityTypeCache.Get(guid.Value);
unopenedTimeout = GetAttributeValue(action, "UnopenedTimeoutLength").AsIntegerOrNull();
if (emailStatus != OPENED_STATUS &&
emailStatus != CLICKED_STATUS &&
unopenedActivityType != null &&
unopenedTimeout.HasValue &&
unopenedTimeout.Value < hoursElapsed)
{
action.AddLogEntry("Unopened Timeout Occurred", true);
WorkflowActivity.Activate(unopenedActivityType, action.Activity.Workflow, rockContext);
timedOut = true;
}
}
WorkflowActivityTypeCache noActionActivityType = null;
int?noActionTimeout = null;
guid = GetAttributeValue(action, "NoActionTimeoutActivity").AsGuidOrNull();
if (guid.HasValue)
{
noActionActivityType = WorkflowActivityTypeCache.Get(guid.Value);
noActionTimeout = GetAttributeValue(action, "NoActionTimeoutLength").AsIntegerOrNull();
if (emailStatus != CLICKED_STATUS &&
noActionActivityType != null &&
noActionTimeout.HasValue &&
noActionTimeout.Value < hoursElapsed)
{
action.AddLogEntry("No Action Timeout Occurred", true);
WorkflowActivity.Activate(noActionActivityType, action.Activity.Workflow, rockContext);
timedOut = true;
}
}
if (timedOut)
{
UpdateEmailStatus(action.Guid, TIMEOUT_STATUS, string.Empty, rockContext, false);
return(true);
}
}
return(false);
}
/// <summary>
/// Updates the email status.
/// </summary>
/// <param name="actionGuid">The action unique identifier.</param>
/// <param name="status">The status.</param>
/// <param name="emailEventType">Type of the email event.</param>
/// <param name="rockContext">The rock context.</param>
/// <param name="ProcessWorkflow">if set to <c>true</c> [process workflow].</param>
public static void UpdateEmailStatus(Guid actionGuid, string status, string emailEventType, RockContext rockContext, bool ProcessWorkflow)
{
var action = new WorkflowActionService(rockContext).Get(actionGuid);
if (action != null && action.Activity != null)
{
string attrKey = action.ActionTypeCache.Guid.ToString() + "_EmailStatus";
action.Activity.LoadAttributes(rockContext);
string currentStatus = action.Activity.GetAttributeValue(attrKey);
// Sometimes Clicked events are reported before opens. If this is the case, do not update the status from clicked to opened.
bool updateStatus = true;
if (status == OPENED_STATUS && currentStatus == CLICKED_STATUS)
{
updateStatus = false;
}
if (!string.IsNullOrWhiteSpace(emailEventType) && (emailEventType != status || !updateStatus))
{
action.AddLogEntry(string.Format("Email Event Type: {0}", emailEventType), true);
}
if (updateStatus)
{
action.Activity.SetAttributeValue(attrKey, status);
action.Activity.SaveAttributeValues(rockContext);
action.AddLogEntry(string.Format("Email Status Updated to '{0}'", status), true);
}
Guid?activityGuid = null;
switch (status)
{
case OPENED_STATUS:
{
activityGuid = GetActionAttributeValue(action, "OnOpenActivity").AsGuid();
break;
}
case CLICKED_STATUS:
{
activityGuid = GetActionAttributeValue(action, "OnClickedActivity").AsGuid();
break;
}
case FAILED_STATUS:
{
activityGuid = GetActionAttributeValue(action, "OnFailedActivity").AsGuid();
break;
}
}
if (activityGuid.HasValue)
{
var workflow = action.Activity.Workflow;
var activityType = WorkflowActivityTypeCache.Get(activityGuid.Value);
if (workflow != null && activityType != null)
{
WorkflowActivity.Activate(activityType, workflow);
action.AddLogEntry(string.Format("Activated new '{0}' activity", activityType.ToString()));
if (ProcessWorkflow)
{
List <string> workflowErrors;
new WorkflowService(rockContext).Process(workflow, out workflowErrors);
}
}
}
}
}
protected void btnReopen_Command(object sender, CommandEventArgs e)
{
using (RockContext rockContext = new RockContext())
{
WorkflowService workflowService = new WorkflowService(rockContext);
Workflow workflow = workflowService.Get(e.CommandArgument.ToString().AsInteger());
if (workflow != null && !workflow.IsActive)
{
workflow.Status = "Active";
workflow.CompletedDateTime = null;
// Find the summary activity and activate it.
WorkflowActivityType workflowActivityType = workflow.WorkflowType.ActivityTypes.Where(at => at.Name.Contains("Summary")).FirstOrDefault();
WorkflowActivity workflowActivity = WorkflowActivity.Activate(WorkflowActivityTypeCache.Get(workflowActivityType.Id, rockContext), workflow, rockContext);
}
rockContext.SaveChanges();
}
BindGrid();
}
protected void btnUpdate_Click(object sender, EventArgs e)
{
var errors = new List <string>();
RockContext rockContext = new RockContext();
var workflows = GetWorkflows(rockContext);
//Get the new attribute values from the repeater
Dictionary <string, string> attributeUpdates = GetNewAttributeValues();
if (attributeUpdates.Any())
{
var mergeFields = LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson);
foreach (var workflow in workflows)
{
//Reuse the mergefields with new workflow
mergeFields["Workflow"] = workflow;
//We will store the attribute value changes and apply them all at once
Dictionary <string, string> toUpdate = new Dictionary <string, string>();
foreach (var update in attributeUpdates)
{
toUpdate[update.Key] = update.Value.ResolveMergeFields(mergeFields);
//if (toUpdate[update.Key])
//{
//}
}
foreach (var update in toUpdate)
{
workflow.SetAttributeValue(update.Key, update.Value);
}
workflow.SaveAttributeValues();
}
}
//Workflow settings
//Activate the workflows if requested or if a new activity is activated
if (ddlState.SelectedValue == "NotComplete" || ddlActivities.SelectedValue.IsNotNullOrWhiteSpace())
{
foreach (var workflow in workflows)
{
workflow.CompletedDateTime = null;
}
}
else if (ddlState.SelectedValue == "Complete")
{
foreach (var workflow in workflows)
{
workflow.MarkComplete();
}
}
//Update Status message
if (tbStatus.Text.IsNotNullOrWhiteSpace())
{
var mergeFields = LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson);
foreach (var workflow in workflows)
{
mergeFields["Workflow"] = workflow;
workflow.Status = tbStatus.Text.ResolveMergeFields(mergeFields);
}
}
//Activate New Activity
int?activityTypeId = ddlActivities.SelectedValueAsId();
if (activityTypeId.HasValue)
{
var activityType = WorkflowActivityTypeCache.Get(activityTypeId.Value);
if (activityType != null)
{
foreach (var workflow in workflows)
{
var activity = WorkflowActivity.Activate(activityType, workflow, rockContext);
activity.Guid = Guid.NewGuid();
foreach (var action in activity.Actions)
{
action.Guid = Guid.NewGuid();
}
}
}
}
rockContext.SaveChanges();
//Process workflows
List <string> errorMessages = new List <string>();
if (workflows.Where(w => w.IsActive).Any())
{
foreach (var workflow in workflows)
{
WorkflowService workflowService = new WorkflowService(new RockContext());
workflowService.Process(workflow, out errorMessages);
}
}
pnlConfirmation.Visible = false;
pnlDisplay.Visible = false;
pnlDone.Visible = true;
}
/// <summary>
/// Renders the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="result">The result.</param>
public override void Render(Context context, TextWriter result)
{
// first ensure that entity commands are allowed in the context
if (!this.IsAuthorized(context))
{
result.Write(string.Format(RockLavaBlockBase.NotAuthorizedMessage, this.Name));
base.Render(context, result);
return;
}
var attributes = new Dictionary <string, string>();
string parmWorkflowType = null;
string parmWorkflowName = null;
string parmWorkflowId = null;
string parmActivityType = null;
/* Parse the markup text to pull out configuration parameters. */
var parms = ParseMarkup(_markup, context);
foreach (var p in parms)
{
if (p.Key.ToLower() == "workflowtype")
{
parmWorkflowType = p.Value;
}
else if (p.Key.ToLower() == "workflowname")
{
parmWorkflowName = p.Value;
}
else if (p.Key.ToLower() == "workflowid")
{
parmWorkflowId = p.Value;
}
else if (p.Key.ToLower() == "activitytype")
{
parmActivityType = p.Value;
}
else
{
attributes.AddOrReplace(p.Key, p.Value);
}
}
/* Process inside a new stack level so our own created variables do not
* persist throughout the rest of the workflow. */
context.Stack((System.Action)(() =>
{
using (var rockContext = new RockContext())
{
WorkflowService workflowService = new WorkflowService(rockContext);
Rock.Model.Workflow workflow = null;
WorkflowActivity activity = null;
/* They provided a WorkflowType, so we need to kick off a new workflow. */
if (parmWorkflowType != null)
{
string type = parmWorkflowType;
string name = parmWorkflowName ?? string.Empty;
WorkflowTypeCache workflowType = null;
/* Get the type of workflow */
if (type.AsGuidOrNull() != null)
{
workflowType = WorkflowTypeCache.Get(type.AsGuid());
}
else if (type.AsIntegerOrNull() != null)
{
workflowType = WorkflowTypeCache.Get(type.AsInteger());
}
/* Try to activate the workflow */
if (workflowType != null)
{
workflow = Rock.Model.Workflow.Activate(( WorkflowTypeCache )workflowType, ( string )parmWorkflowName);
/* Set any workflow attributes that were specified. */
foreach (var attr in attributes)
{
if (workflow.Attributes.ContainsKey(attr.Key))
{
workflow.SetAttributeValue(attr.Key, attr.Value.ToString());
}
}
if (workflow != null)
{
List <string> errorMessages;
workflowService.Process(workflow, out errorMessages);
if (errorMessages.Any())
{
context["Error"] = string.Join("; ", errorMessages.ToArray());
}
context["Workflow"] = workflow;
}
else
{
context["Error"] = "Could not activate workflow.";
}
}
else
{
context["Error"] = "Workflow type not found.";
}
}
/* They instead provided a WorkflowId, so we are working with an existing Workflow. */
else if (parmWorkflowId != null)
{
string id = parmWorkflowId.ToString();
/* Get the workflow */
if (id.AsGuidOrNull() != null)
{
workflow = workflowService.Get(id.AsGuid());
}
else if (id.AsIntegerOrNull() != null)
{
workflow = workflowService.Get(id.AsInteger());
}
if (workflow != null)
{
if (workflow.CompletedDateTime == null)
{
/* Currently we cannot activate an activity in a workflow that is currently
* being processed. The workflow is held in-memory so the activity we would
* activate would not show up for the processor and probably never run.
*/
if (!workflow.IsProcessing)
{
bool hasError = false;
/* If they provided an ActivityType parameter then we need to activate
* a new activity in the workflow.
*/
if (parmActivityType != null)
{
string type = parmActivityType.ToString();
WorkflowActivityTypeCache activityType = null;
/* Get the type of activity */
if (type.AsGuidOrNull() != null)
{
activityType = WorkflowActivityTypeCache.Get(type.AsGuid());
}
else if (type.AsIntegerOrNull() != null)
{
activityType = WorkflowActivityTypeCache.Get(type.AsInteger());
}
if (activityType != null)
{
activity = WorkflowActivity.Activate(activityType, workflow);
/* Set any workflow attributes that were specified. */
foreach (var attr in attributes)
{
if (activity.Attributes.ContainsKey(attr.Key))
{
activity.SetAttributeValue(attr.Key, attr.Value.ToString());
}
}
}
else
{
context["Error"] = "Activity type was not found.";
hasError = true;
}
}
/* Process the existing Workflow. */
if (!hasError)
{
List <string> errorMessages;
workflowService.Process(workflow, out errorMessages);
if (errorMessages.Any())
{
context["Error"] = string.Join("; ", errorMessages.ToArray());
}
context["Workflow"] = workflow;
context["Activity"] = activity;
}
}
else
{
context["Error"] = "Cannot activate activity on workflow that is currently being processed.";
}
}
else
{
context["Error"] = "Workflow has already been completed.";
}
}
else
{
context["Error"] = "Workflow not found.";
}
}
else
{
context["Error"] = "Must specify one of WorkflowType or WorkflowId.";
}
RenderAll(NodeList, context, result);
}
}));
}
/// <summary>
/// Gets the cache object associated with this Entity
/// </summary>
/// <returns></returns>
public IEntityCache GetCacheObject()
{
return(WorkflowActivityTypeCache.Get(this.Id));
}
