/// <summary>
/// Gets the workflow attributes.
/// </summary>
/// <param name="workflowTypeId">The workflow type identifier.</param>
/// <returns></returns>
private List <EntityField> GetWorkflowAttributes(int?workflowTypeId)
{
List <EntityField> entityAttributeFields = new List <EntityField>();
if (workflowTypeId.HasValue)
{
var fakeWorkflow = new Rock.Model.Workflow {
WorkflowTypeId = workflowTypeId.Value
};
Rock.Attribute.Helper.LoadAttributes(fakeWorkflow);
var attributeList = fakeWorkflow.Attributes.Select(a => a.Value).ToList();
EntityHelper.AddEntityFieldsForAttributeList(entityAttributeFields, attributeList);
}
int index = 0;
var sortedFields = new List <EntityField>();
foreach (var entityProperty in entityAttributeFields.OrderBy(p => p.TitleWithoutQualifier).ThenBy(p => p.Name))
{
entityProperty.Index = index;
index++;
sortedFields.Add(entityProperty);
}
return(sortedFields);
}
private void GetState()
{
if (Session["CheckInKioskId"] != null)
{
CurrentKioskId = (int)Session["CheckInKioskId"];
}
if (Session["CheckInGroupTypeIds"] != null)
{
CurrentGroupTypeIds = Session["CheckInGroupTypeIds"] as List <int>;
}
if (Session["CheckInState"] != null)
{
CurrentCheckInState = Session["CheckInState"] as CheckInState;
}
if (Session["CheckInWorkflow"] != null)
{
CurrentWorkflow = Session["CheckInWorkflow"] as Rock.Model.Workflow;
}
if (CurrentCheckInState == null && CurrentKioskId.HasValue)
{
CurrentCheckInState = new CheckInState(CurrentKioskId.Value, CurrentGroupTypeIds);
}
}
/// <summary>
/// Cancels the check-in.
/// </summary>
protected void CancelCheckin()
{
CurrentWorkflow = null;
CurrentCheckInState = null;
SaveState();
NavigateToHomePage();
}
/// <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 workflowService = new WorkflowService(rockContext);
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);
}
workflowService.Process(workflow, out errorMessages);
return(true);
}
/// <summary>
/// Activates and processes a workflow activity. If the workflow has not yet been activated, it will
/// also be activated
/// </summary>
/// <param name="activityName">Name of the activity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
/// <exception cref="System.Exception"></exception>
protected bool ProcessActivity(string activityName, out List <string> errorMessages)
{
errorMessages = new List <string>();
Guid?guid = GetAttributeValue("WorkflowType").AsGuidOrNull();
if (guid.HasValue)
{
using (var rockContext = new RockContext())
{
var workflowTypeService = new WorkflowTypeService(rockContext);
var workflowService = new WorkflowService(rockContext);
var workflowType = workflowTypeService.Queryable("ActivityTypes")
.Where(w => w.Guid.Equals(guid.Value))
.FirstOrDefault();
if (workflowType != null)
{
if (CurrentWorkflow == null)
{
CurrentWorkflow = Rock.Model.Workflow.Activate(workflowType, CurrentCheckInState.Kiosk.Device.Name, rockContext);
if (Request["Override"] != null)
{
if (Request["Override"].ToString() == "True")
{
CurrentWorkflow.SetAttributeValue("Override", "True");
}
}
}
var activityType = workflowType.ActivityTypes.Where(a => a.Name == activityName).FirstOrDefault();
if (activityType != null)
{
WorkflowActivity.Activate(activityType, CurrentWorkflow, rockContext);
if (workflowService.Process(CurrentWorkflow, CurrentCheckInState, out errorMessages))
{
// Keep workflow active for continued processing
CurrentWorkflow.CompletedDateTime = null;
return(true);
}
}
else
{
errorMessages.Add(string.Format("Workflow type does not have a '{0}' activity type", activityName));
}
}
else
{
errorMessages.Add("Invalid Workflow Type");
}
}
}
return(false);
}
/// <summary>
/// Saves the attribute value.
/// </summary>
/// <param name="workflow">The workflow.</param>
/// <param name="key">The key.</param>
/// <param name="value">The value.</param>
/// <param name="fieldType">Type of the field.</param>
/// <param name="rockContext">The rock context.</param>
/// <param name="qualifiers">The qualifiers.</param>
/// <returns></returns>
private static bool SaveAttributeValue(Rock.Model.Workflow workflow, string key, string value,
FieldTypeCache fieldType, RockContext rockContext, Dictionary <string, string> qualifiers = null)
{
bool createdNewAttribute = false;
if (workflow.Attributes.ContainsKey(key))
{
workflow.SetAttributeValue(key, value);
}
else
{
// Read the attribute
var attributeService = new AttributeService(rockContext);
var attribute = attributeService
.Get(workflow.TypeId, "WorkflowTypeId", workflow.WorkflowTypeId.ToString())
.Where(a => a.Key == key)
.FirstOrDefault();
// If workflow attribute doesn't exist, create it
// ( should only happen first time a background check is processed for given workflow type)
if (attribute == null)
{
attribute = new Rock.Model.Attribute();
attribute.EntityTypeId = workflow.TypeId;
attribute.EntityTypeQualifierColumn = "WorkflowTypeId";
attribute.EntityTypeQualifierValue = workflow.WorkflowTypeId.ToString();
attribute.Name = key.SplitCase();
attribute.Key = key;
attribute.FieldTypeId = fieldType.Id;
attributeService.Add(attribute);
if (qualifiers != null)
{
foreach (var keyVal in qualifiers)
{
var qualifier = new Rock.Model.AttributeQualifier();
qualifier.Key = keyVal.Key;
qualifier.Value = keyVal.Value;
attribute.AttributeQualifiers.Add(qualifier);
}
}
createdNewAttribute = true;
}
// Set the value for this action's instance to the current time
var attributeValue = new Rock.Model.AttributeValue();
attributeValue.Attribute = attribute;
attributeValue.EntityId = workflow.Id;
attributeValue.Value = value;
new AttributeValueService(rockContext).Add(attributeValue);
}
return(createdNewAttribute);
}
/// <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 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 = new WorkflowActivityTypeService(rockContext).Queryable()
.Where(a => a.Guid.Equals(workflowActivityGuid)).FirstOrDefault();
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>
/// Gets the PersonEntryFamilyAttribute from either the WorkflowActionForm or WorkflowType.WorkflowFormBuilderTemplate
/// </summary>
/// <param name="workflow">The workflow</param>
/// <returns></returns>
public AttributeCache GetPersonEntryFamilyAttribute(Rock.Model.Workflow workflow)
{
var workflowType = workflow?.WorkflowTypeCache;
if (workflowType?.FormBuilderTemplate != null)
{
return(workflow.Attributes.GetValueOrNull("Family"));
}
else if (this.PersonEntryFamilyAttributeGuid.HasValue)
{
return(AttributeCache.Get(this.PersonEntryFamilyAttributeGuid.Value));
}
else
{
return(null);
}
}
private void PersistWorkflow(Rock.Model.Workflow workflow)
{
if (workflow.Id == 0)
{
var workflowService = new WorkflowService(_rockContext);
workflowService.Add(workflow);
}
_rockContext.WrapTransaction(() =>
{
_rockContext.SaveChanges();
workflow.SaveAttributeValues(_rockContext);
foreach (var activity in workflow.Activities)
{
activity.SaveAttributeValues(_rockContext);
}
});
}
/// <summary>
/// Saves the results.
/// </summary>
/// <param name="xResult">The x result.</param>
/// <param name="workflow">The workflow.</param>
/// <param name="rockContext">The rock context.</param>
public static void SaveResults(XDocument xResult, Rock.Model.Workflow workflow, RockContext rockContext)
{
var xOrderDetail = xResult.Descendants("OrderDetail").FirstOrDefault();
if (xOrderDetail != null)
{
string status = (from o in xOrderDetail.Descendants("Status") select o.Value).FirstOrDefault();
if (!string.IsNullOrWhiteSpace(status))
{
// Request has been completed
// Save the status
SaveAttributeValue(workflow, "ReportStatus", status == "NO RECORD" ? "Pass" : "Review",
FieldTypeCache.Read(Rock.SystemGuid.FieldType.SINGLE_SELECT.AsGuid()), rockContext,
new Dictionary <string, string> {
{ "fieldtype", "ddl" }, { "values", "Pass,Fail,Review" }
});
// Save the report link
string reportLink = (from o in xResult.Descendants("ReportLink") select o.Value).FirstOrDefault();
SaveAttributeValue(workflow, "ReportLink", reportLink,
FieldTypeCache.Read(Rock.SystemGuid.FieldType.URL_LINK.AsGuid()), rockContext);
// Save the recommendation
string recommendation = (from o in xResult.Descendants("Recommendation") select o.Value).FirstOrDefault();
SaveAttributeValue(workflow, "ReportRecommendation", recommendation,
FieldTypeCache.Read(Rock.SystemGuid.FieldType.TEXT.AsGuid()), rockContext,
new Dictionary <string, string> {
{ "ispassword", "false" }
});
// Save the report
Guid?binaryFileGuid = SaveFile(workflow.Attributes["Report"], reportLink, workflow.Id.ToString() + ".pdf");
if (binaryFileGuid.HasValue)
{
SaveAttributeValue(workflow, "Report", binaryFileGuid.Value.ToString(),
FieldTypeCache.Read(Rock.SystemGuid.FieldType.BINARY_FILE.AsGuid()), rockContext,
new Dictionary <string, string> {
{ "binaryFileType", "" }
});
}
}
}
}
private void SaveForProcessingLater(Rock.Model.Workflow newWorkflow, RockContext rockContext)
{
newWorkflow.IsPersisted = true;
var service = new WorkflowService(rockContext);
if (newWorkflow.Id == 0)
{
service.Add(newWorkflow);
}
rockContext.WrapTransaction(() =>
{
rockContext.SaveChanges();
newWorkflow.SaveAttributeValues(rockContext);
foreach (var activity in newWorkflow.Activities)
{
activity.SaveAttributeValues(rockContext);
}
});
}
/// <summary>
/// Activates and processes a workflow activity. If the workflow has not yet been activated, it will
/// also be activated
/// </summary>
/// <param name="activityName">Name of the activity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
/// <exception cref="System.Exception"></exception>
protected bool ProcessActivity(string activityName, out List <string> errorMessages)
{
errorMessages = new List <string>();
int workflowTypeId = 0;
if (Int32.TryParse(GetAttributeValue("WorkflowTypeId"), out workflowTypeId))
{
var workflowTypeService = new WorkflowTypeService();
var workflowType = workflowTypeService.Get(workflowTypeId);
if (workflowType != null)
{
if (CurrentWorkflow == null)
{
CurrentWorkflow = Rock.Model.Workflow.Activate(workflowType, CurrentCheckInState.Kiosk.Device.Name);
}
var activityType = workflowType.ActivityTypes.Where(a => a.Name == activityName).FirstOrDefault();
if (activityType != null)
{
WorkflowActivity.Activate(activityType, CurrentWorkflow);
if (CurrentWorkflow.Process(CurrentCheckInState, out errorMessages))
{
return(true);
}
}
else
{
errorMessages.Add(string.Format("Workflow type does not have a '{0}' activity type", activityName));
}
}
else
{
errorMessages.Add(string.Format("Invalid Workflow type Id", activityName));
}
}
return(false);
}
private void BindAttributes()
{
// Parse the attribute filters
AvailableAttributes = new List <AttributeCache>();
if (_workflowType != null)
{
int entityTypeId = new Rock.Model.Workflow().TypeId;
string workflowQualifier = _workflowType.Id.ToString();
foreach (var attributeModel in new AttributeService(new RockContext()).Queryable()
.Where(a =>
a.EntityTypeId == entityTypeId &&
a.IsGridColumn &&
a.EntityTypeQualifierColumn.Equals("WorkflowTypeId", StringComparison.OrdinalIgnoreCase) &&
a.EntityTypeQualifierValue.Equals(workflowQualifier))
.OrderByDescending(a => a.EntityTypeQualifierColumn)
.ThenBy(a => a.Order)
.ThenBy(a => a.Name))
{
AvailableAttributes.Add(AttributeCache.Get(attributeModel));
}
}
}
private void CopyAttributes(Rock.Model.Workflow newWorkflow, Rock.Model.WorkflowActivity currentActivity, RockContext rockContext)
{
if (currentActivity.Attributes == null)
{
currentActivity.LoadAttributes(rockContext);
}
if (currentActivity.Workflow.Attributes == null)
{
currentActivity.Workflow.LoadAttributes(rockContext);
}
// Pass attributes from current Workflow to new Workflow.
foreach (string key in currentActivity.Workflow.AttributeValues.Keys)
{
newWorkflow.SetAttributeValue(key, currentActivity.Workflow.GetAttributeValue(key));
}
// Pass attributes from current Activity to new Workflow.
foreach (string key in currentActivity.AttributeValues.Keys)
{
newWorkflow.SetAttributeValue(key, currentActivity.GetAttributeValue(key));
}
}
/// <summary>
/// Shows the detail.
/// </summary>
private void ShowDetail( int workflowId )
{
var rockContext = new RockContext();
Workflow = new WorkflowService( rockContext )
.Queryable( "WorkflowType, Activities")
.Where( w => w.Id == workflowId )
.FirstOrDefault();
if ( Workflow == null )
{
pnlContent.Visible = false;
return;
}
Workflow.LoadAttributes( rockContext );
foreach ( var activity in Workflow.Activities )
{
activity.LoadAttributes();
}
lReadOnlyTitle.Text = Workflow.Name.FormatAsHtmlTitle();
if ( Workflow.CompletedDateTime.HasValue )
{
hlState.LabelType = LabelType.Default;
hlState.Text = "Complete";
}
else
{
hlState.LabelType = LabelType.Success;
hlState.Text = "Active";
}
hlType.Text = Workflow.WorkflowType.Name;
ShowReadonlyDetails();
}
/// <summary>
/// Restores the view-state information from a previous user control request that was saved by the <see cref="M:System.Web.UI.UserControl.SaveViewState" /> method.
/// </summary>
/// <param name="savedState">An <see cref="T:System.Object" /> that represents the user control state to be restored.</param>
protected override void LoadViewState( object savedState )
{
base.LoadViewState( savedState );
string json = ViewState["Workflow"] as string;
if ( string.IsNullOrWhiteSpace( json ) )
{
Workflow = new Workflow();
}
else
{
Workflow = JsonConvert.DeserializeObject<Workflow>( json );
}
// Wire up type objects since they are not serialized
var rockContext = new RockContext();
var workflowTypeService = new WorkflowTypeService( rockContext );
var activityTypeService = new WorkflowActivityTypeService( rockContext );
var actionTypeService = new WorkflowActionTypeService( rockContext );
Workflow.WorkflowType = workflowTypeService.Get( Workflow.WorkflowTypeId );
foreach(var activity in Workflow.Activities)
{
activity.ActivityType = activityTypeService.Get( activity.ActivityTypeId );
foreach(var action in activity.Actions)
{
action.ActionType = actionTypeService.Get( action.ActionTypeId );
}
}
// Add new log entries since they are not serialized
LogEntries = ViewState["LogEntries"] as List<string>;
if ( LogEntries == null )
{
LogEntries = new List<string>();
}
LogEntries.ForEach( l => Workflow.AddLogEntry( l ) );
ExpandedActivities = ViewState["ExpandedActivities"] as List<Guid>;
if (ExpandedActivities == null)
{
ExpandedActivities = new List<Guid>();
}
}
/// <summary>
/// Handles the Click event of the btnSave 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 btnSave_Click( object sender, EventArgs e )
{
var rockContext = new RockContext();
var service = new WorkflowService( rockContext );
ParseControls( rockContext, true );
Workflow dbWorkflow = null;
if ( Workflow != null )
{
dbWorkflow = service.Get( Workflow.Id );
if ( dbWorkflow != null )
{
if ( !dbWorkflow.CompletedDateTime.HasValue && Workflow.CompletedDateTime.HasValue )
{
dbWorkflow.AddLogEntry( "Workflow Manually Completed." );
dbWorkflow.CompletedDateTime = Workflow.CompletedDateTime;
}
else if ( dbWorkflow.CompletedDateTime.HasValue && !Workflow.CompletedDateTime.HasValue )
{
dbWorkflow.AddLogEntry( "Workflow Manually Re-Activated." );
dbWorkflow.CompletedDateTime = null;
}
if ( dbWorkflow.Name.Trim() != Workflow.Name.Trim() )
{
dbWorkflow.AddLogEntry( string.Format( "Workflow name manually changed from '{0}' to '{0}'.", dbWorkflow.Name, tbName.Text ) );
dbWorkflow.Name = Workflow.Name;
}
if ( dbWorkflow.Status.Trim() != Workflow.Status.Trim() )
{
dbWorkflow.AddLogEntry( string.Format( "Workflow status manually changed from '{0}' to '{0}'.", dbWorkflow.Status, tbStatus.Text ) );
dbWorkflow.Status = Workflow.Status;
}
if ( !dbWorkflow.InitiatorPersonAliasId.Equals(Workflow.InitiatorPersonAliasId))
{
dbWorkflow.AddLogEntry( string.Format( "Workflow status manually changed from '{0}' to '{0}'.",
dbWorkflow.InitiatorPersonAlias != null ? dbWorkflow.InitiatorPersonAlias.Person.FullName : "",
Workflow.InitiatorPersonAlias != null ? Workflow.InitiatorPersonAlias.Person.FullName : "" ) );
dbWorkflow.InitiatorPersonAlias = Workflow.InitiatorPersonAlias;
dbWorkflow.InitiatorPersonAliasId = Workflow.InitiatorPersonAliasId;
}
if ( !Page.IsValid || !dbWorkflow.IsValid )
{
return;
}
foreach ( var activity in Workflow.Activities )
{
if ( !activity.IsValid )
{
return;
}
foreach ( var action in activity.Actions )
{
if ( !action.IsValid )
{
return;
}
}
}
rockContext.WrapTransaction( () =>
{
rockContext.SaveChanges();
dbWorkflow.LoadAttributes( rockContext );
foreach ( var attributeValue in Workflow.AttributeValues )
{
dbWorkflow.SetAttributeValue( attributeValue.Key, Workflow.GetAttributeValue( attributeValue.Key ) );
}
dbWorkflow.SaveAttributeValues( rockContext );
WorkflowActivityService workflowActivityService = new WorkflowActivityService( rockContext );
WorkflowActionService workflowActionService = new WorkflowActionService( rockContext );
var activitiesInUi = new List<Guid>();
var actionsInUI = new List<Guid>();
foreach ( var activity in Workflow.Activities )
{
activitiesInUi.Add( activity.Guid );
foreach ( var action in activity.Actions )
{
actionsInUI.Add( action.Guid );
}
}
// delete WorkflowActions that were removed in the UI
foreach ( var action in workflowActionService.Queryable()
.Where( a =>
a.Activity.WorkflowId.Equals( dbWorkflow.Id ) &&
!actionsInUI.Contains( a.Guid ) ) )
{
workflowActionService.Delete( action );
}
// delete WorkflowActivities that aren't assigned in the UI anymore
foreach ( var activity in workflowActivityService.Queryable()
.Where( a =>
a.WorkflowId.Equals( dbWorkflow.Id ) &&
!activitiesInUi.Contains( a.Guid ) ) )
{
workflowActivityService.Delete( activity );
}
rockContext.SaveChanges();
// add or update WorkflowActivities(and Actions) that are assigned in the UI
foreach ( var editorWorkflowActivity in Workflow.Activities )
{
// Add or Update the activity type
WorkflowActivity workflowActivity = dbWorkflow.Activities.FirstOrDefault( a => a.Guid.Equals( editorWorkflowActivity.Guid ) );
if ( workflowActivity == null )
{
workflowActivity = new WorkflowActivity();
workflowActivity.ActivityTypeId = editorWorkflowActivity.ActivityTypeId;
dbWorkflow.Activities.Add( workflowActivity );
}
workflowActivity.AssignedPersonAliasId = editorWorkflowActivity.AssignedPersonAliasId;
workflowActivity.AssignedGroupId = editorWorkflowActivity.AssignedGroupId;
workflowActivity.ActivatedDateTime = editorWorkflowActivity.ActivatedDateTime;
workflowActivity.LastProcessedDateTime = editorWorkflowActivity.LastProcessedDateTime;
if ( !workflowActivity.CompletedDateTime.HasValue && editorWorkflowActivity.CompletedDateTime.HasValue )
{
workflowActivity.AddLogEntry( "Activity Manually Completed." );
workflowActivity.CompletedDateTime = RockDateTime.Now;
}
if ( workflowActivity.CompletedDateTime.HasValue && !editorWorkflowActivity.CompletedDateTime.HasValue )
{
workflowActivity.AddLogEntry( "Activity Manually Re-Activated." );
workflowActivity.CompletedDateTime = null;
}
// Save Activity Type
rockContext.SaveChanges();
// Save ActivityType Attributes
workflowActivity.LoadAttributes( rockContext );
foreach ( var attributeValue in editorWorkflowActivity.AttributeValues )
{
workflowActivity.SetAttributeValue( attributeValue.Key, editorWorkflowActivity.GetAttributeValue( attributeValue.Key ) );
}
workflowActivity.SaveAttributeValues( rockContext );
foreach ( var editorWorkflowAction in editorWorkflowActivity.Actions )
{
WorkflowAction workflowAction = workflowActivity.Actions.FirstOrDefault( a => a.Guid.Equals( editorWorkflowAction.Guid ) );
if ( workflowAction == null )
{
// New action
workflowAction = new WorkflowAction();
workflowAction.ActionTypeId = editorWorkflowAction.ActionTypeId;
workflowActivity.Actions.Add( workflowAction );
}
workflowAction.LastProcessedDateTime = editorWorkflowAction.LastProcessedDateTime;
workflowAction.FormAction = editorWorkflowAction.FormAction;
if ( !workflowAction.CompletedDateTime.HasValue && editorWorkflowAction.CompletedDateTime.HasValue )
{
workflowAction.AddLogEntry( "Action Manually Completed." );
workflowAction.CompletedDateTime = RockDateTime.Now;
}
if ( workflowAction.CompletedDateTime.HasValue && !editorWorkflowAction.CompletedDateTime.HasValue )
{
workflowAction.AddLogEntry( "Action Manually Re-Activated." );
workflowAction.CompletedDateTime = null;
}
}
// Save action updates
rockContext.SaveChanges();
}
} );
}
Workflow = service
.Queryable("WorkflowType,Activities.ActivityType,Activities.Actions.ActionType")
.FirstOrDefault( w => w.Id == Workflow.Id );
var errorMessages = new List<string>();
service.Process( Workflow, out errorMessages );
}
ShowReadonlyDetails();
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
if (_rockContext == null)
{
_rockContext = new RockContext();
}
if (_workflowService == null)
{
_workflowService = new WorkflowService(_rockContext);
}
var paramWorkflowId = PageParameter("WorkflowId");
WorkflowId = paramWorkflowId.AsIntegerOrNull();
if (!WorkflowId.HasValue)
{
Guid guid = PageParameter("WorkflowGuid").AsGuid();
if (!guid.IsEmpty())
{
_workflow = _workflowService.Queryable()
.Where(w => w.Guid.Equals(guid))
.FirstOrDefault();
if (_workflow != null)
{
WorkflowId = _workflow.Id;
}
}
}
if (WorkflowId.HasValue)
{
if (_workflow == null)
{
_workflow = _workflowService.Queryable()
.Where(w => w.Id == WorkflowId.Value)
.FirstOrDefault();
}
//-------------------------------
if (_workflow != null)
{
_workflow.LoadAttributes();
}
}
if (_workflow != null)
{
if (_workflow.IsActive)
{
int personId = CurrentPerson != null ? CurrentPerson.Id : 0;
foreach (var activity in _workflow.Activities
.Where(a =>
a.IsActive &&
(
(!a.AssignedGroupId.HasValue && !a.AssignedPersonAliasId.HasValue) ||
(a.AssignedPersonAlias != null && a.AssignedPersonAlias.PersonId == personId) ||
(a.AssignedGroup != null && a.AssignedGroup.Members.Any(m => m.PersonId == personId))
)
)
.OrderBy(a => a.ActivityType.Order))
{
if ((activity.ActivityType.IsAuthorized(Authorization.VIEW, CurrentPerson)))
{
foreach (var action in activity.ActiveActions)
{
if (action.ActionType.WorkflowForm != null && action.IsCriteriaValid)
{
_activity = activity;
_activity.LoadAttributes(_rockContext);
}
}
}
}
if (_activity != null)
{
var entryPage = _workflow.GetAttributeValue("EntryFormPage");
if (!String.IsNullOrEmpty(entryPage))
{
var queryParams = new Dictionary <string, string>();
queryParams.Add("WorkflowTypeId", _activity.Workflow.WorkflowTypeId.ToString());
queryParams.Add("WorkflowId", _activity.WorkflowId.ToString());
var attrsToSend = GetAttributeValue("WorkflowAttributes");
if (!String.IsNullOrWhiteSpace(attrsToSend))
{
foreach (var attr in attrsToSend.Split(','))
{
var attrName = attr.Trim();
if (!String.IsNullOrEmpty(_activity.GetAttributeValue(attrName)))
{
queryParams.Add(attrName, _activity.GetAttributeValue(attrName));
}
else if (!String.IsNullOrEmpty(_activity.Workflow.GetAttributeValue(attrName)))
{
queryParams.Add(attrName, _activity.Workflow.GetAttributeValue(attrName));
}
}
}
var pageReference = new Rock.Web.PageReference(entryPage, queryParams);
bool paramsDiffer = false;
foreach (var pair in queryParams)
{
if (pair.Value != PageParameter(pair.Key))
{
paramsDiffer = true;
break;
}
}
if (paramsDiffer || (pageReference.PageId != CurrentPageReference.PageId))
{
Response.Redirect(pageReference.BuildUrl(), true);
}
}
}
}
}
}
/// <summary>
/// Saves the results.
/// </summary>
/// <param name="xResult">The x result.</param>
/// <param name="workflow">The workflow.</param>
/// <param name="rockContext">The rock context.</param>
/// <param name="saveResponse">if set to <c>true</c> [save response].</param>
public static void SaveResults(XDocument xResult, Rock.Model.Workflow workflow, RockContext rockContext, bool saveResponse = true)
{
bool createdNewAttribute = false;
var newRockContext = new RockContext();
var service = new BackgroundCheckService(newRockContext);
var backgroundCheck = service.Queryable()
.Where(c =>
c.WorkflowId.HasValue &&
c.WorkflowId.Value == workflow.Id)
.FirstOrDefault();
if (backgroundCheck != null && saveResponse)
{
// Clear any SSN nodes before saving XML to record
foreach (var xSSNElement in xResult.Descendants("SSN"))
{
xSSNElement.Value = "XXX-XX-XXXX";
}
backgroundCheck.ResponseXml = backgroundCheck.ResponseXml + string.Format(@"
Response XML ({0}):
------------------------
{1}
", RockDateTime.Now.ToString(), xResult.ToString());
}
var xOrderXML = xResult.Elements("OrderXML").FirstOrDefault();
if (xOrderXML != null)
{
var xOrder = xOrderXML.Elements("Order").FirstOrDefault();
if (xOrder != null)
{
bool resultFound = false;
// Find any order details with a status element
string reportStatus = "Pass";
foreach (var xOrderDetail in xOrder.Elements("OrderDetail"))
{
var xStatus = xOrderDetail.Elements("Status").FirstOrDefault();
if (xStatus != null)
{
resultFound = true;
if (xStatus.Value != "NO RECORD")
{
reportStatus = "Review";
break;
}
}
}
if (resultFound)
{
// If no records found, still double-check for any alerts
if (reportStatus != "Review")
{
var xAlerts = xOrder.Elements("Alerts").FirstOrDefault();
if (xAlerts != null)
{
if (xAlerts.Elements("OrderId").Any())
{
reportStatus = "Review";
}
}
}
// Save the recommendation
string recommendation = (from o in xOrder.Elements("Recommendation") select o.Value).FirstOrDefault();
if (!string.IsNullOrWhiteSpace(recommendation))
{
if (SaveAttributeValue(workflow, "ReportRecommendation", recommendation,
FieldTypeCache.Read(Rock.SystemGuid.FieldType.TEXT.AsGuid()), rockContext,
new Dictionary <string, string> {
{ "ispassword", "false" }
}))
{
createdNewAttribute = true;
}
}
// Save the report link
Guid? binaryFileGuid = null;
string reportLink = (from o in xOrder.Elements("ReportLink") select o.Value).FirstOrDefault();
if (!string.IsNullOrWhiteSpace(reportLink))
{
if (SaveAttributeValue(workflow, "ReportLink", reportLink,
FieldTypeCache.Read(Rock.SystemGuid.FieldType.URL_LINK.AsGuid()), rockContext))
{
createdNewAttribute = true;
}
// Save the report
binaryFileGuid = SaveFile(workflow.Attributes["Report"], reportLink, workflow.Id.ToString() + ".pdf");
if (binaryFileGuid.HasValue)
{
if (SaveAttributeValue(workflow, "Report", binaryFileGuid.Value.ToString(),
FieldTypeCache.Read(Rock.SystemGuid.FieldType.BINARY_FILE.AsGuid()), rockContext,
new Dictionary <string, string> {
{ "binaryFileType", "" }
}))
{
createdNewAttribute = true;
}
}
}
// Save the status
if (SaveAttributeValue(workflow, "ReportStatus", reportStatus,
FieldTypeCache.Read(Rock.SystemGuid.FieldType.SINGLE_SELECT.AsGuid()), rockContext,
new Dictionary <string, string> {
{ "fieldtype", "ddl" }, { "values", "Pass,Fail,Review" }
}))
{
createdNewAttribute = true;
}
// Update the background check file
if (backgroundCheck != null)
{
backgroundCheck.ResponseDate = RockDateTime.Now;
backgroundCheck.RecordFound = reportStatus == "Review";
if (binaryFileGuid.HasValue)
{
var binaryFile = new BinaryFileService(newRockContext).Get(binaryFileGuid.Value);
if (binaryFile != null)
{
backgroundCheck.ResponseDocumentId = binaryFile.Id;
}
}
}
}
}
}
newRockContext.SaveChanges();
if (createdNewAttribute)
{
AttributeCache.FlushEntityAttributes();
}
}
/// <summary>
/// Shows the detail.
/// </summary>
private void ShowDetail( int workflowId )
{
var rockContext = new RockContext();
Workflow = new WorkflowService( rockContext )
.Queryable( "WorkflowType, Activities")
.Where( w => w.Id == workflowId )
.FirstOrDefault();
if ( Workflow == null )
{
pnlContent.Visible = false;
// hide the panel drawer that show created and last modified dates
pdAuditDetails.Visible = false;
return;
}
pdAuditDetails.SetEntity( Workflow, ResolveRockUrl( "~" ) );
_canEdit = UserCanEdit || Workflow.IsAuthorized( Rock.Security.Authorization.EDIT, CurrentPerson );
Workflow.LoadAttributes( rockContext );
foreach ( var activity in Workflow.Activities )
{
activity.LoadAttributes();
}
lReadOnlyTitle.Text = Workflow.Name.FormatAsHtmlTitle();
if ( Workflow.CompletedDateTime.HasValue )
{
hlState.LabelType = LabelType.Default;
hlState.Text = "Complete";
}
else
{
hlState.LabelType = LabelType.Success;
hlState.Text = "Active";
}
hlType.Text = Workflow.WorkflowType.Name;
hlblWorkflowId.Text = Workflow.WorkflowId;
ShowReadonlyDetails();
}
/// <summary>
/// Gets the state.
/// </summary>
private void GetState()
{
if ( Session["CurrentTheme"] != null )
{
CurrentTheme = Session["CurrentTheme"].ToString();
}
if ( Session["CheckInKioskId"] != null )
{
CurrentKioskId = (int)Session["CheckInKioskId"];
}
if ( Session["CheckinTypeId"] != null )
{
CurrentCheckinTypeId = (int)Session["CheckinTypeId"];
}
if ( Session["CheckInGroupTypeIds"] != null )
{
CurrentGroupTypeIds = Session["CheckInGroupTypeIds"] as List<int>;
}
if ( Session["CheckInState"] != null )
{
CurrentCheckInState = Session["CheckInState"] as CheckInState;
}
if ( Session["CheckInWorkflow"] != null )
{
CurrentWorkflow = Session["CheckInWorkflow"] as Rock.Model.Workflow;
}
if ( CurrentCheckInState == null && CurrentKioskId.HasValue )
{
CurrentCheckInState = new CheckInState( CurrentKioskId.Value, CurrentCheckinTypeId, CurrentGroupTypeIds );
}
}
/// <summary>
/// Shows the detail.
/// </summary>
private void ShowDetail()
{
var rockContext = new RockContext();
int? workflowId = PageParameter( "workflowId" ).AsIntegerOrNull();
if ( workflowId.HasValue )
{
Workflow = new WorkflowService( rockContext )
.Queryable( "WorkflowType, Activities")
.Where( w => w.Id == workflowId.Value )
.FirstOrDefault();
}
if ( Workflow == null )
{
pnlDetails.Visible = false;
return;
}
if ( IsUserAuthorized( Authorization.VIEW ) && Workflow.IsAuthorized( Authorization.VIEW, CurrentPerson ) )
{
pnlDetails.Visible = true;
tbName.Visible = _canEdit;
ppInitiator.Visible = _canEdit;
tbStatus.Visible = _canEdit;
lName.Visible = !_canEdit;
lInitiator.Visible = !_canEdit;
lStatus.Visible = !_canEdit;
cbIsCompleted.Enabled = _canEdit;
ddlActivateNewActivity.Visible = _canEdit;
btnSave.Visible = _canEdit;
btnCancel.Visible = _canEdit;
if ( _canEdit )
{
ddlActivateNewActivity.Items.Clear();
ddlActivateNewActivity.Items.Add( new ListItem( "Activate New Activity", "0" ) );
foreach ( var activityType in Workflow.WorkflowType.ActivityTypes.OrderBy( a => a.Order ) )
{
ddlActivateNewActivity.Items.Add( new ListItem( activityType.Name, activityType.Id.ToString() ) );
}
}
ExpandedActivities = new List<Guid>();
Workflow.LoadAttributes( rockContext );
foreach ( var activity in Workflow.Activities )
{
activity.LoadAttributes();
}
BuildControls( true );
BindLog();
}
else
{
nbNotAuthorized.Visible = true;
pnlDetails.Visible = false;
}
}
/// <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(() =>
{
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.Read(type.AsGuid());
}
else if (type.AsIntegerOrNull() != null)
{
workflowType = WorkflowTypeCache.Read(type.AsInteger());
}
/* Try to activate the workflow */
if (workflowType != null)
{
workflow = Rock.Model.Workflow.Activate(workflowType, 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.Read(type.AsGuid());
}
else if (type.AsIntegerOrNull() != null)
{
activityType = WorkflowActivityTypeCache.Read(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>
/// Activates and processes a workflow activity. If the workflow has not yet been activated, it will
/// also be activated
/// </summary>
/// <param name="activityName">Name of the activity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
/// <exception cref="System.Exception"></exception>
protected bool ProcessActivity( string activityName, out List<string> errorMessages )
{
errorMessages = new List<string>();
Guid? guid = GetAttributeValue( "WorkflowType" ).AsGuidOrNull();
if ( guid.HasValue )
{
using ( var rockContext = new RockContext() )
{
var workflowTypeService = new WorkflowTypeService( rockContext );
var workflowService = new WorkflowService( rockContext );
var workflowType = workflowTypeService.Queryable( "ActivityTypes" )
.Where( w => w.Guid.Equals( guid.Value ) )
.FirstOrDefault();
if ( workflowType != null )
{
if ( CurrentWorkflow == null )
{
CurrentWorkflow = Rock.Model.Workflow.Activate( workflowType, CurrentCheckInState.Kiosk.Device.Name, rockContext );
if ( IsOverride )
{
CurrentWorkflow.SetAttributeValue( "Override", "True" );
}
}
var activityType = workflowType.ActivityTypes.Where( a => a.Name == activityName ).FirstOrDefault();
if ( activityType != null )
{
WorkflowActivity.Activate( activityType, CurrentWorkflow, rockContext );
if ( workflowService.Process( CurrentWorkflow, CurrentCheckInState, out errorMessages ) )
{
// Keep workflow active for continued processing
CurrentWorkflow.CompletedDateTime = null;
return true;
}
}
else
{
errorMessages.Add( string.Format( "Workflow type does not have a '{0}' activity type", activityName ) );
}
}
else
{
errorMessages.Add( "Invalid Workflow Type" );
}
}
}
return false;
}
/// <summary>
/// Sends a background request to Trak-1
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="workflow">The Workflow initiating the request.</param>
/// <param name="personAttribute">The person attribute.</param>
/// <param name="ssnAttribute">The SSN attribute.</param>
/// <param name="requestTypeAttribute">The request type attribute.</param>
/// <param name="billingCodeAttribute">The billing code attribute.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns>
/// True/False value of whether the request was successfully sent or not
/// </returns>
/// <exception cref="System.NotImplementedException"></exception>
/// <remarks>
/// Note: If the associated workflow type does not have attributes with the following keys, they
/// will automatically be added to the workflow type configuration in order to store the results
/// of the background check request
/// RequestStatus: The request status returned by request
/// RequestMessage: Any error messages returned by request
/// ReportStatus: The report status returned
/// ReportLink: The location of the background report on server
/// ReportRecommendation: Recomendataion
/// Report (BinaryFile): The downloaded background report
/// </remarks>
public override bool SendRequest(RockContext rockContext, Rock.Model.Workflow workflow,
AttributeCache personAttribute, AttributeCache ssnAttribute, AttributeCache requestTypeAttribute,
AttributeCache billingCodeAttribute, out List <string> errorMessages)
{
errorMessages = new List <string>();
try
{
// Check to make sure workflow is not null
if (workflow == null)
{
errorMessages.Add("Trak-1 background check provider requires a valid workflow.");
return(false);
}
// Get the person that the request is for
Person person = null;
if (personAttribute != null)
{
Guid?personAliasGuid = workflow.GetAttributeValue(personAttribute.Key).AsGuidOrNull();
if (personAliasGuid.HasValue)
{
person = new PersonAliasService(rockContext).Queryable()
.Where(p => p.Guid.Equals(personAliasGuid.Value))
.Select(p => p.Person)
.FirstOrDefault();
person.LoadAttributes(rockContext);
}
}
if (person == null)
{
errorMessages.Add("Trak-1 background check provider requires the workflow to have a 'Person' attribute that contains the person who the background check is for.");
return(false);
}
//Get required fields from workflow
var packageList = GetPackageList();
var packageName = workflow.GetAttributeValue(requestTypeAttribute.Key);
// If this is a defined value, fetch the value
if (requestTypeAttribute.FieldType.Guid.ToString().ToUpper() == Rock.SystemGuid.FieldType.DEFINED_VALUE)
{
packageName = DefinedValueCache.Get(packageName).Value;
}
var package = packageList.Where(p => p.PackageName == packageName).FirstOrDefault();
if (package == null)
{
errorMessages.Add("Package name not valid");
return(false);
}
var requiredFields = package.Components.SelectMany(c => c.RequiredFields).ToList();
var requiredFieldsDict = new Dictionary <string, string>();
foreach (var field in requiredFields)
{
if (!workflow.Attributes.ContainsKey(field.Name))
{
errorMessages.Add("Workflow does not contain attribute for required field " + field.Name);
return(false);
}
requiredFieldsDict[field.Name] = workflow.GetAttributeValue(field.Name);
}
//Generate Request
var authentication = new Trak1Authentication
{
UserName = GetAttributeValue("UserName"),
SubscriberCode = Encryption.DecryptString(GetAttributeValue("SubscriberCode")),
CompanyCode = Encryption.DecryptString(GetAttributeValue("CompanyCode")),
BranchName = "Main"
};
var ssn = "";
if (ssnAttribute != null)
{
ssn = Rock.Field.Types.SSNFieldType.UnencryptAndClean(workflow.GetAttributeValue(ssnAttribute.Key));
if (!string.IsNullOrWhiteSpace(ssn) && ssn.Length == 9)
{
ssn = ssn.Insert(5, "-").Insert(3, "-");
}
}
Location homeLocation = null;
var homeAddressDv = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME);
foreach (var family in person.GetFamilies(rockContext))
{
var loc = family.GroupLocations
.Where(l =>
l.GroupLocationTypeValueId == homeAddressDv.Id)
.Select(l => l.Location)
.FirstOrDefault();
if (loc != null)
{
homeLocation = loc;
}
}
if (homeLocation == null)
{
errorMessages.Add("A valid home location to submit a Trak-1 background check.");
return(false);
}
var applicant = new Trak1Applicant
{
SSN = ssn,
FirstName = person.FirstName,
MiddleName = person.MiddleName,
LastName = person.LastName,
DateOfBirth = (person.BirthDate ?? new DateTime()).ToString("yyyy-MM-dd"),
Address1 = homeLocation.Street1,
Address2 = homeLocation.Street2,
City = homeLocation.City,
State = homeLocation.State,
Zip = homeLocation.PostalCode,
RequiredFields = requiredFieldsDict
};
var request = new Trak1Request
{
Authentication = authentication,
Applicant = applicant,
PackageName = packageName
};
var content = JsonConvert.SerializeObject(request);
Trak1Response response = null;
using (var client = new HttpClient(new HttpClientHandler()))
{
client.BaseAddress = new Uri(GetAttributeValue("RequestURL"));
var clientResponse = client.PostAsync("", new StringContent(content, Encoding.UTF8, "application/json")).Result.Content.ReadAsStringAsync().Result;
response = JsonConvert.DeserializeObject <Trak1Response>(clientResponse);
}
if (!string.IsNullOrWhiteSpace(response.Error?.Message))
{
errorMessages.Add(response.Error.Message);
return(false);
}
var transactionId = response.TransactionId;
int?personAliasId = person.PrimaryAliasId;
if (personAliasId.HasValue)
{
// Create a background check file
using (var newRockContext = new RockContext())
{
var backgroundCheckService = new BackgroundCheckService(newRockContext);
var backgroundCheck = backgroundCheckService.Queryable()
.Where(c =>
c.WorkflowId.HasValue &&
c.WorkflowId.Value == workflow.Id)
.FirstOrDefault();
if (backgroundCheck == null)
{
backgroundCheck = new Rock.Model.BackgroundCheck();
backgroundCheck.PersonAliasId = personAliasId.Value;
backgroundCheck.WorkflowId = workflow.Id;
backgroundCheckService.Add(backgroundCheck);
}
backgroundCheck.RequestDate = RockDateTime.Now;
backgroundCheck.RequestId = transactionId.ToString();
backgroundCheck.PackageName = request.PackageName;
newRockContext.SaveChanges();
}
}
return(true);
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
errorMessages.Add(ex.Message);
return(false);
}
}
/// <summary>
/// Activates and processes a workflow activity. If the workflow has not yet been activated, it will
/// also be activated
/// </summary>
/// <param name="activityName">Name of the activity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
/// <exception cref="System.Exception"></exception>
protected bool ProcessActivity( string activityName, out List<string> errorMessages )
{
errorMessages = new List<string>();
int workflowTypeId = 0;
if ( Int32.TryParse( GetAttributeValue( "WorkflowTypeId" ), out workflowTypeId ) )
{
var workflowTypeService = new WorkflowTypeService();
var workflowType = workflowTypeService.Get( workflowTypeId );
if ( workflowType != null )
{
if ( CurrentWorkflow == null )
{
CurrentWorkflow = Rock.Model.Workflow.Activate( workflowType, CurrentCheckInState.Kiosk.Device.Name );
}
var activityType = workflowType.ActivityTypes.Where( a => a.Name == activityName ).FirstOrDefault();
if ( activityType != null )
{
WorkflowActivity.Activate( activityType, CurrentWorkflow );
if ( CurrentWorkflow.Process( CurrentCheckInState, out errorMessages ) )
{
return true;
}
}
else
{
errorMessages.Add( string.Format( "Workflow type does not have a '{0}' activity type", activityName ) );
}
}
else
{
errorMessages.Add( string.Format( "Invalid Workflow type Id", activityName ) );
}
}
return false;
}
/// <summary>
/// Cancels the check-in.
/// </summary>
protected void CancelCheckin()
{
CurrentWorkflow = null;
CurrentCheckInState = null;
SaveState();
NavigateToHomePage();
}
/// <summary>
/// Processes the specified workflow.
/// </summary>
/// <param name="workflow">The workflow.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public bool Process(Workflow workflow, out List <string> errorMessages)
{
return(Process(workflow, null, out errorMessages));
}
/// <summary>
/// Gets the workflow attributes.
/// </summary>
/// <param name="workflowTypeId">The workflow type identifier.</param>
/// <returns></returns>
private List<EntityField> GetWorkflowAttributes( int? workflowTypeId )
{
List<EntityField> entityAttributeFields = new List<EntityField>();
if ( workflowTypeId.HasValue )
{
var fakeWorkflow = new Rock.Model.Workflow { WorkflowTypeId = workflowTypeId.Value };
Rock.Attribute.Helper.LoadAttributes( fakeWorkflow );
foreach ( var attribute in fakeWorkflow.Attributes.Select( a => a.Value ) )
{
EntityHelper.AddEntityFieldForAttribute( entityAttributeFields, attribute );
}
}
int index = 0;
var sortedFields = new List<EntityField>();
foreach ( var entityProperty in entityAttributeFields.OrderBy( p => p.TitleWithoutQualifier ).ThenBy( p => p.Name ) )
{
entityProperty.Index = index;
index++;
sortedFields.Add( entityProperty );
}
return sortedFields;
}
