/// <summary> /// Executes the specified workflow action. /// </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? personAliasGuid = GetAttributeValue( action, "Person" ).AsGuidOrNull(); if ( personAliasGuid.HasValue ) { var personAlias = new PersonAliasService( rockContext ).Queryable( "Person" ) .Where( a => a.Guid.Equals( personAliasGuid.Value ) ) .FirstOrDefault(); if (personAlias != null) { action.Activity.AssignedPersonAlias = personAlias; action.Activity.AssignedPersonAliasId = personAlias.Id; action.Activity.AssignedGroup = null; action.Activity.AssignedGroupId = null; action.AddLogEntry( string.Format( "Assigned activity to '{0}' ({1})", personAlias.Person.FullName, personAlias.Person.Id ) ); return true; } } return false; }
/// <summary> /// Executes the action. /// </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>(); if (HttpContext.Current != null) { var referrer = HttpContext.Current.Request.UrlReferrer.ToString(); if (! String.IsNullOrEmpty(referrer)) { var urlAttrGuid = GetAttributeValue( action,"URLField" ).AsGuid(); var attribute = AttributeCache.Read( urlAttrGuid, rockContext ); if (attribute != null) { if (attribute.EntityTypeId == new Rock.Model.Workflow().TypeId) { action.Activity.Workflow.SetAttributeValue( attribute.Key, referrer ); } else { action.Activity.SetAttributeValue( attribute.Key, referrer ); } } } else { action.AddLogEntry( "No HTTP Referrer detected" ); } } else { action.AddLogEntry( "SetAttributeFromHTTPReferrer triggered outside an http context"); } 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>(); Guid guid = GetAttributeValue( action, "Activity" ).AsGuid(); if ( guid.IsEmpty() ) { action.AddLogEntry( "Invalid Activity Property", true ); return false; } var workflow = action.Activity.Workflow; var activityType = new WorkflowActivityTypeService( rockContext ).Queryable() .Where( a => a.Guid.Equals( guid ) ).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> /// Executes the specified workflow. /// </summary> /// <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( WorkflowAction action, Object entity, out List<string> errorMessages ) { errorMessages = new List<string>(); string activityTypeId = GetAttributeValue( action, "ActivityType" ); if ( String.IsNullOrWhiteSpace( activityTypeId ) ) { action.AddLogEntry( "Invalid Activity Type Property" ); return false; } var workflow = action.Activity.Workflow; var activityType = workflow.WorkflowType.ActivityTypes .Where( a => a.Id.ToString() == activityTypeId).FirstOrDefault(); if (activityType != null) { WorkflowActivity.Activate( activityType, workflow ); action.AddLogEntry( string.Format( "Activated new '{0}' activity", activityType.ToString() ) ); return true; } action.AddLogEntry( string.Format( "Could Not activate new '{0}' activity!", activityType.ToString() ) ); return false; }
/// <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, "Attribute" ).AsGuid(); if ( !guid.IsEmpty() ) { var attribute = AttributeCache.Read( guid, rockContext ); if ( attribute != null ) { string value = GetAttributeValue( action, "Value" ); value = value.ResolveMergeFields( GetMergeFields( action ) ); if ( attribute.EntityTypeId == new Rock.Model.Workflow().TypeId ) { action.Activity.Workflow.SetAttributeValue( attribute.Key, value ); action.AddLogEntry( string.Format( "Set '{0}' attribute to '{1}'.", attribute.Name, value ) ); } else if ( attribute.EntityTypeId == new Rock.Model.WorkflowActivity().TypeId ) { action.Activity.SetAttributeValue( attribute.Key, value ); action.AddLogEntry( string.Format( "Set '{0}' attribute to '{1}'.", attribute.Name, value ) ); } } } 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 guid = GetAttributeValue( action, "Workflow" ).AsGuid(); if (guid.IsEmpty()) { action.AddLogEntry( "Invalid Workflow Property", true ); return false; } var currentActivity = action.Activity; var newWorkflowType = new WorkflowTypeService( rockContext ).Get( guid ); var newWorkflowName = GetAttributeValue(action, "WorkflowName" ); if (newWorkflowType == null) { action.AddLogEntry( "Invalid Workflow Property", true ); return false; } var newWorkflow = Rock.Model.Workflow.Activate( newWorkflowType, newWorkflowName ); if (newWorkflow == null) { action.AddLogEntry( "The Workflow could not be activated", true ); return false; } CopyAttributes( newWorkflow, currentActivity, rockContext ); SaveForProcessingLater( newWorkflow, rockContext ); return true; // Kick off processing of new Workflow /*if(newWorkflow.Process( rockContext, entity, out errorMessages )) { if (newWorkflow.IsPersisted || newWorkflowType.IsPersisted) { var workflowService = new Rock.Model.WorkflowService( rockContext ); workflowService.Add( newWorkflow ); rockContext.WrapTransaction( () => { rockContext.SaveChanges(); newWorkflow.SaveAttributeValues( rockContext ); foreach (var activity in newWorkflow.Activities) { activity.SaveAttributeValues( rockContext ); } } ); } return true; } else { return false; }*/ }
/// <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 query = GetAttributeValue( action, "SQLQuery" ); var mergeFields = GetMergeFields( action ); query = query.ResolveMergeFields( mergeFields ); try { object sqlResult = DbService.ExecuteScaler( query ); action.AddLogEntry( "SQL query has been run" ); if ( sqlResult != null ) { Guid? attributeGuid = GetAttributeValue( action, "ResultAttribute" ).AsGuidOrNull(); if ( attributeGuid.HasValue ) { var attribute = AttributeCache.Read( attributeGuid.Value, rockContext ); if ( attribute != null ) { string resultValue = sqlResult.ToString(); if ( attribute.EntityTypeId == new Rock.Model.Workflow().TypeId ) { action.Activity.Workflow.SetAttributeValue( attribute.Key, resultValue ); action.AddLogEntry( string.Format( "Set '{0}' attribute to '{1}'.", attribute.Name, resultValue ) ); } else if ( attribute.EntityTypeId == new Rock.Model.WorkflowActivity().TypeId ) { action.Activity.SetAttributeValue( attribute.Key, resultValue ); action.AddLogEntry( string.Format( "Set '{0}' attribute to '{1}'.", attribute.Name, resultValue ) ); } } } } return true; } catch (Exception ex) { action.AddLogEntry( ex.Message, true ); if ( !GetAttributeValue( action, "ContinueOnError" ).AsBoolean() ) { errorMessages.Add( ex.Message ); return false; } else { 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>(); Guid guid = GetAttributeValue( action, "Attribute" ).AsGuid(); if (!guid.IsEmpty()) { var attribute = AttributeCache.Read( guid, rockContext ); if ( attribute != null ) { string existingValue = action.GetWorklowAttributeValue( guid ); string value = GetAttributeValue( action, "Value" ); string separator; if (String.IsNullOrEmpty( existingValue )) { separator = ""; } else { separator = GetAttributeValue( action, "Separator" ); } var mergeFields = GetMergeFields( action ); value = value.ResolveMergeFields( mergeFields ); string valueAction; string newValue; if (GetAttributeValue(action,"Prepend").AsBoolean()) { valueAction = "Prepended"; newValue = string.Format("{1}{2}{0}", existingValue, value, separator); } else { valueAction = "Appended"; newValue = string.Format("{0}{2}{1}", existingValue, value, separator); } if ( attribute.EntityTypeId == new Rock.Model.Workflow().TypeId ) { action.Activity.Workflow.SetAttributeValue( attribute.Key, newValue ); action.AddLogEntry( string.Format( "{2} '{0}' attribute to '{1}'.", attribute.Name, newValue, valueAction ) ); } else if ( attribute.EntityTypeId == new Rock.Model.WorkflowActivity().TypeId ) { action.Activity.SetAttributeValue( attribute.Key, newValue ); action.AddLogEntry( string.Format( "{2} '{0}' attribute to '{1}'.", attribute.Name, newValue, valueAction ) ); } } } 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 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 = new WorkflowActivityTypeService( rockContext ).Queryable() .Where( a => a.Guid.Equals( workflowActivityGuid ) ).FirstOrDefault(); if ( activityType == null ) { action.AddLogEntry( "Invalid Activity Property", true ); return false; } var entityType = EntityTypeCache.Read( 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; }
/// <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 groupAttribute = GetAttributeValue( action, "GroupAttribute" ); Guid groupAttrGuid = groupAttribute.AsGuid(); if (!groupAttrGuid.IsEmpty()) { string attributeGroupValue = action.GetWorklowAttributeValue( groupAttrGuid ); Guid groupGuid = attributeGroupValue.AsGuid(); var groupRoleAttr = GetAttributeValue( action, "Group Role" ); Guid groupRoleGuid = groupRoleAttr.AsGuid(); if (!groupRoleGuid.IsEmpty()) { var groupM = (new GroupService( rockContext )).Get( groupGuid ); if (groupM != null) { var groupRole = (new GroupTypeRoleService( rockContext )).Get( groupRoleGuid ); var person = (from m in groupM.Members where m.GroupRoleId == groupRole.Id select m.Person).FirstOrDefault(); if (person != null) { action.Activity.AssignedPersonAlias = person.PrimaryAlias; action.Activity.AssignedPersonAliasId = person.PrimaryAliasId; action.Activity.AssignedGroup = null; action.Activity.AssignedGroupId = null; action.AddLogEntry( string.Format( "Assigned activity to '{0}' ({1})", person.FullName, person.Id ) ); return true; } else { action.AddLogEntry( string.Format( "Nobody assigned to Role ({0}) for Group ({1})", groupRole.Name, groupM.Name ) ); } } } } errorMessages.Add( "An assignment to person could not be completed." ); return false; }
/// <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>(); string attributeValue = GetAttributeValue( action, "Attribute" ); Guid guid = attributeValue.AsGuid(); if (!guid.IsEmpty()) { var attribute = AttributeCache.Read( guid, rockContext ); if ( attribute != null ) { string value = GetAttributeValue( action, "Person" ); guid = value.AsGuid(); if ( !guid.IsEmpty() ) { var personAlias = new PersonAliasService( rockContext ).Get( guid ); if ( personAlias != null && personAlias.Person != null ) { action.Activity.Workflow.SetAttributeValue( attribute.Key, value ); action.AddLogEntry( string.Format( "Set '{0}' attribute to '{1}'.", attribute.Name, personAlias.Person.FullName ) ); return true; } else { errorMessages.Add( string.Format( "Person could not be found for selected value ('{0}')!", guid.ToString() ) ); } } else { action.Activity.Workflow.SetAttributeValue( attribute.Key, string.Empty ); action.AddLogEntry( string.Format( "Set '{0}' attribute to nobody.", attribute.Name ) ); return true; } } else { errorMessages.Add( string.Format( "Attribute could not be found for selected attribute value ('{0}')!", guid.ToString() ) ); } } else { errorMessages.Add( string.Format( "Selected attribute value ('{0}') was not a valid Guid!", attributeValue ) ); } errorMessages.ForEach( m => action.AddLogEntry( m, true ) ); return true; }
/// <summary> /// Executes the specified workflow action. /// </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 parts = ( GetAttributeValue( action, "Group" ) ?? string.Empty ).Split( '|' ); Guid? groupTypeGuid = null; Guid? groupGuid = null; if ( parts.Length >= 1 ) { groupTypeGuid = parts[0].AsGuidOrNull(); if ( parts.Length >= 2 ) { groupGuid = parts[1].AsGuidOrNull(); } } if ( groupGuid.HasValue ) { var group = new GroupService( rockContext ).Get( groupGuid.Value ); if ( group != null ) { action.Activity.AssignedPersonAlias = null; action.Activity.AssignedPersonAliasId = null; action.Activity.AssignedGroup = group; action.Activity.AssignedGroupId = group.Id; action.AddLogEntry( string.Format( "Assigned activity to '{0}' group ({1})", group.Name, group.Id ) ); return true; } } return false; }
/// <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>(); string nameValue = GetAttributeValue( action, "NameValue" ); Guid guid = nameValue.AsGuid(); if (guid.IsEmpty()) { nameValue = nameValue.ResolveMergeFields( GetMergeFields( action ) ); } else { nameValue = action.GetWorklowAttributeValue( guid, true, true ); // HtmlDecode the name since we are storing it in the database and it might be formatted to be shown in HTML nameValue = System.Web.HttpUtility.HtmlDecode( nameValue ); } if ( !string.IsNullOrWhiteSpace( nameValue ) ) { action.Activity.Workflow.Name = nameValue; action.AddLogEntry( string.Format( "Set Workflow Name to '{0}'", nameValue ) ); } return true; }
/// <summary> /// Executes the specified workflow action. /// </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>(); // Get the attribute's guid Guid guid = GetAttributeValue( action, "PersonAttribute" ).AsGuid(); if ( !guid.IsEmpty() ) { // Get the attribute var attribute = AttributeCache.Read( guid, rockContext ); if ( attribute != null ) { if ( attribute.FieldTypeId == FieldTypeCache.Read( SystemGuid.FieldType.PERSON.AsGuid(), rockContext ).Id ) { // If attribute type is a person, value should be person alias id Guid? personAliasGuid = action.GetWorklowAttributeValue( guid ).AsGuidOrNull(); if ( personAliasGuid.HasValue ) { var personAlias = new PersonAliasService( rockContext ).Queryable( "Person" ) .Where( a => a.Guid.Equals( personAliasGuid.Value ) ) .FirstOrDefault(); if ( personAlias != null ) { action.Activity.Workflow.InitiatorPersonAlias = personAlias; action.Activity.Workflow.InitiatorPersonAliasId = personAlias.Id; action.AddLogEntry( string.Format( "Assigned initiator to '{0}' ({1})", personAlias.Person.FullName, personAlias.Person.Id ) ); return true; } } } } } return false; }
/// <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>(); if ( entity is Model.BinaryFile ) { var binaryFile = (Model.BinaryFile) entity; if ( binaryFile.BinaryFileType.Guid != new Guid( SystemGuid.BinaryFiletype.CHECKIN_LABEL ) ) { errorMessages.Add( "Binary file is not a check-in label" ); action.AddLogEntry( "Binary file is not a check-in label", true ); return false; } StringBuilder sb = new StringBuilder(); var contentString = binaryFile.ContentsToString(); foreach ( Match match in Regex.Matches( contentString, @"(?<=\^FD)[^\^FS]*(?=\^FS)" ) ) { sb.AppendFormat( "{0}^|", match.Value ); } binaryFile.LoadAttributes(); var attributeValue = new AttributeValue(); attributeValue.Value = sb.ToString(); binaryFile.AttributeValues["MergeCodes"] = attributeValue; binaryFile.SaveAttributeValues( rockContext ); } return true; }
public override bool Execute( RockContext rockContext, WorkflowAction action, Object entity, out List<string> errorMessages ) { errorMessages = new List<string>(); var JobGuid = GetAttributeValue( action, "Job" ).AsGuid(); if ( !JobGuid.IsEmpty() ) { ServiceJob Job = new ServiceJobService( rockContext ).Get( JobGuid ); if ( Job != null ) { var transaction = new Rock.Transactions.RunJobNowTransaction( Job.Id ); // Process the transaction on another thread System.Threading.Tasks.Task.Run( () => transaction.Execute() ); action.AddLogEntry( string.Format( "The '{0}' job has been started.", Job.Name ) ); return true; } } errorMessages.Add("The specified Job could not be found"); return false; }
/// <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 workflow = action.Activity.Workflow; workflow.IsPersisted = true; if ( GetAttributeValue( action, "PersistImmediately" ).AsBoolean( false ) ) { var service = new WorkflowService( rockContext ); if ( workflow.Id == 0 ) { service.Add( workflow ); } rockContext.WrapTransaction( () => { rockContext.SaveChanges(); workflow.SaveAttributeValues( rockContext ); foreach ( var activity in workflow.Activities ) { activity.SaveAttributeValues( rockContext ); } } ); } action.AddLogEntry( "Updated workflow to be persisted!" ); return true; }
/// <summary> /// Executes the specified workflow. /// </summary> /// <param name="action">The action.</param> /// <param name="dto">The dto.</param> /// <param name="errorMessages">The error messages.</param> /// <returns></returns> public override bool Execute( WorkflowAction action, IDto dto, out List<string> errorMessages ) { errorMessages = new List<string>(); action.Activity.Workflow.MarkComplete(); action.AddLogEntry( "Marked workflow complete" ); return true; }
/// <summary> /// Executes the specified workflow action. /// </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>(); action.Activity.MarkComplete(); action.AddLogEntry( "Marked activity complete" ); 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>(); Guid? workflowGuid = GetAttributeValue( action, "Workflow", true ).AsGuidOrNull(); if ( workflowGuid.HasValue ) { using ( var newRockContext = new RockContext() ) { var workflowService = new WorkflowService( newRockContext ); var workflow = workflowService.Get( workflowGuid.Value ); if ( workflow != null ) { string status = GetAttributeValue( action, "Status" ).ResolveMergeFields( GetMergeFields( action ) ); workflow.Status = status; workflow.AddLogEntry( string.Format( "Status set to '{0}' by another workflow: {1}", status, action.Activity.Workflow ) ); newRockContext.SaveChanges(); action.AddLogEntry( string.Format( "Set Status to '{0}' on another workflow: {1}", status, workflow ) ); bool processNow = GetAttributeValue( action, "ProcessNow" ).AsBoolean(); if ( processNow ) { var processErrors = new List<string>(); if ( !workflowService.Process( workflow, out processErrors ) ) { action.AddLogEntry( "Error(s) occurred processing target workflow: " + processErrors.AsDelimited( ", " ) ); } } return true; } } action.AddLogEntry( "Could not find selected workflow." ); } else { action.AddLogEntry( "Workflow attribute was not set." ); return true; // Continue processing in this case } return false; }
/// <summary> /// Executes the specified workflow. /// </summary> /// <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( WorkflowAction action, Object entity, out List<string> errorMessages ) { errorMessages = new List<string>(); string status = GetAttributeValue( action, "Status" ); action.Activity.Workflow.Status = status; action.AddLogEntry( string.Format( "Set Status to '{0}'", status ) ); 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 workflow = action.Activity.Workflow; workflow.IsPersisted = true; action.AddLogEntry( "Updated workflow to be persisted!" ); return true; }
/// <summary> /// Executes the specified workflow. /// </summary> /// <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( WorkflowAction action, Object entity, out List<string> errorMessages ) { errorMessages = new List<string>(); var query = GetAttributeValue( action, "SQLQuery" ); int rows = new Service().ExecuteCommand( query, new object[] { } ); action.AddLogEntry( "SQL query has been run" ); 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>(); string status = GetAttributeValue( action, "Status", true ).ResolveMergeFields( GetMergeFields( action ) ); action.Activity.Workflow.MarkComplete( status ); action.AddLogEntry( "Marked workflow complete" ); 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>(); foreach ( var a in action.Activity.Actions ) { a.CompletedDateTime = null; } action.AddLogEntry( string.Format( "Activated all actions for '{0}' activity.", action.ActionType.Name ) ); 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 mergeFields = GetMergeFields( action ); var benevolenceRequest = new BenevolenceRequestService( rockContext ).Get( GetAttributeValue( action, "BenevolenceRequest", true ).AsGuid() ); if ( benevolenceRequest == null ) { var errorMessage = "Benevolence request could not be found."; errorMessages.Add( errorMessage ); action.AddLogEntry( errorMessage, true ); return false; } var attribute = AttributeCache.Read( GetAttributeValue( action, "BenevolenceRequestAttribute" ).AsGuid() ); if ( attribute == null ) { var errorMessage = "Could not find a benevolence attribute matching the one provided."; errorMessages.Add( errorMessage ); action.AddLogEntry( errorMessage, true ); return false; } var attributeValue = GetAttributeValue( action, "Value", true ).ResolveMergeFields( mergeFields ); bool useBlankValues = GetActionAttributeValue( action, "UseBlankValue" ).AsBoolean(); if ( !string.IsNullOrWhiteSpace( attributeValue ) || useBlankValues) { benevolenceRequest.LoadAttributes(); Rock.Attribute.Helper.SaveAttributeValue( benevolenceRequest, attribute, attributeValue, rockContext ); action.AddLogEntry( $"Updated benevolence attribute '{attribute.Name}' to '{attributeValue}'." ); } 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 adultRoleGuid = SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid(); var person = GetPersonAliasFromActionAttribute( "Person", rockContext, action, errorMessages ); if ( person != null ) { string HeadOfHouseholdAttributeValue = GetAttributeValue( action, "HeadOfHouseholdAttribute" ); Guid? headOfHouseholdGuid = HeadOfHouseholdAttributeValue.AsGuidOrNull(); if ( headOfHouseholdGuid.HasValue ) { var headofHouseholdAttribute = AttributeCache.Read( headOfHouseholdGuid.Value, rockContext ); if ( headofHouseholdAttribute != null ) { var headOfHousehold = person.GetHeadOfHousehold( rockContext ); if ( headOfHousehold != null ) { action.Activity.Workflow.SetAttributeValue( headofHouseholdAttribute.Key, headOfHousehold.PrimaryAlias.Guid.ToString() ); action.AddLogEntry( string.Format( "Set Head Of Household attribute '{0}' attribute to '{1}'.", headofHouseholdAttribute.Name, headOfHousehold.FullName ) ); return true; } else { action.AddLogEntry( string.Format( "No head of Household found for {0}.", person.FullName ) ); } } } } else { errorMessages.Add( "No person was provided." ); return false; } errorMessages.ForEach( m => action.AddLogEntry( m, true ) ); 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 mergeFields = GetMergeFields( action ); BenevolenceRequestService benevolenceRequestService = new BenevolenceRequestService( rockContext ); var benevolenceRequest = benevolenceRequestService.Get( GetAttributeValue( action, "BenevolenceRequest", true ).AsGuid() ); if (benevolenceRequest == null ) { var errorMessage = "Benevolence request could not be found."; errorMessages.Add( errorMessage ); action.AddLogEntry( errorMessage, true ); return false; } var binaryFile = new BinaryFileService(rockContext).Get(GetAttributeValue( action, "Document", true ).AsGuid()); if ( binaryFile == null ) { action.AddLogEntry( "The document to add to the benevolence request was not be found.", true ); return true; // returning true here to allow the action to run 'successfully' without a document. This allows the action to be easily used when the document is optional without a bunch of action filter tests. } BenevolenceRequestDocument requestDocument = new BenevolenceRequestDocument(); benevolenceRequest.Documents.Add( requestDocument ); requestDocument.BinaryFileId = binaryFile.Id; rockContext.SaveChanges(); action.AddLogEntry( "Added document to the benevolence request." ); 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 adultRoleGuid = SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid(); var maritalStatusMarried = DefinedValueCache.Read( SystemGuid.DefinedValue.PERSON_MARITAL_STATUS_MARRIED.AsGuid() ); var familyGroupType = GroupTypeCache.Read( SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid() ); var adultRole = familyGroupType.Roles.Where( r => r.Guid == adultRoleGuid ).FirstOrDefault(); var person = GetPersonAliasFromActionAttribute("Person", rockContext, action, errorMessages); if (person != null) { string spouseAttributeValue = GetAttributeValue( action, "SpouseAttribute" ); Guid? spouseGuid = spouseAttributeValue.AsGuidOrNull(); if ( spouseGuid.HasValue ) { var spouseAttribute = AttributeCache.Read( spouseGuid.Value, rockContext ); if ( spouseAttribute != null ) { var spouse = person.GetSpouse( rockContext ); if ( spouse != null ) { action.Activity.Workflow.SetAttributeValue( spouseAttribute.Key, spouse.PrimaryAlias.Guid.ToString() ); action.AddLogEntry( string.Format( "Set spouse attribute '{0}' attribute to '{1}'.", spouseAttribute.Name, spouse.FullName ) ); return true; } else { action.AddLogEntry( string.Format( "No spouse found for {0}.", person.FullName ) ); } } } } else { errorMessages.Add("No person was provided."); return false; } errorMessages.ForEach( m => action.AddLogEntry( m, true ) ); 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>(); if ( entity is Model.BinaryFile ) { var binaryFile = (Model.BinaryFile) entity; if ( binaryFile.BinaryFileType.Guid != new Guid( SystemGuid.BinaryFiletype.CHECKIN_LABEL ) ) { errorMessages.Add( "Binary file is not a check-in label" ); action.AddLogEntry( "Binary file is not a check-in label", true ); return false; } binaryFile.LoadAttributes(); // Get the existing merge fields var existingMergeFields = new Dictionary<string, string>(); foreach ( var keyAndVal in binaryFile.GetAttributeValue( "MergeCodes" ).Split( new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries ) ) { var keyVal = keyAndVal.Split( new char[] { '^' } ); if ( keyVal.Length == 2 ) { existingMergeFields.AddOrIgnore( keyVal[0], keyVal[1] ); } } // Build new merge fields var newMergeFields = new List<string>(); foreach ( Match match in Regex.Matches( binaryFile.ContentsToString(), @"(?<=\^FD)((?!\^FS).)*(?=\^FS)" ) ) { string value = existingMergeFields.ContainsKey( match.Value ) ? existingMergeFields[match.Value] : ""; newMergeFields.Add( string.Format( "{0}^{1}", match.Value, value ) ); } // Save attribute value var attributeValue = new AttributeValueCache(); attributeValue.Value = newMergeFields.AsDelimited( "|" ); binaryFile.AttributeValues["MergeCodes"] = attributeValue; binaryFile.SaveAttributeValues( rockContext ); } 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>(); // Get the entity type EntityTypeCache entityType = null; var entityTypeGuid = GetAttributeValue( action, AttributeKey.EntityType ).AsGuidOrNull(); if ( entityTypeGuid.HasValue ) { entityType = EntityTypeCache.Get( entityTypeGuid.Value ); } if ( entityType == null ) { var message = $"Entity Type could not be found for selected value ('{entityTypeGuid.ToString()}')!"; errorMessages.Add( message ); action.AddLogEntry( message, true ); return false; } var mergeFields = GetMergeFields( action ); var _rockContext = new RockContext(); // Get the entity var entityTypeService = new EntityTypeService( _rockContext ); IEntity entityObject = null; var entityIdGuidString = GetAttributeValue( action, AttributeKey.EntityIdOrGuid, true ).ResolveMergeFields( mergeFields ).Trim(); var entityId = entityIdGuidString.AsIntegerOrNull(); if ( entityId.HasValue ) { entityObject = entityTypeService.GetEntity( entityType.Id, entityId.Value ); } else { var entityGuid = entityIdGuidString.AsGuidOrNull(); if ( entityGuid.HasValue ) { entityObject = entityTypeService.GetEntity( entityType.Id, entityGuid.Value ); } } if ( entityObject == null ) { var value = GetActionAttributeValue( action, AttributeKey.EntityIdOrGuid ); entityObject = action.GetEntityFromAttributeValue( value, rockContext ); } if ( entityObject == null ) { var message = $"Entity could not be found for selected value ('{entityIdGuidString}')!"; errorMessages.Add( message ); action.AddLogEntry( message, true ); return false; } var attributeFilteredDocumentType = GetAttributeValue( action, AttributeKey.DocumentType ).Split( ',' ).Select( int.Parse ).FirstOrDefault(); var documentType = DocumentTypeCache.Get( attributeFilteredDocumentType ); if ( documentType == null ) { var message = $"Document Type could not be found for selected value ('{attributeFilteredDocumentType}')!"; errorMessages.Add( message ); action.AddLogEntry( message, true ); return false; } var documentypesForContextEntityType = DocumentTypeCache.GetByEntity( entityType.Id, true ); if ( !documentypesForContextEntityType.Any( d => attributeFilteredDocumentType == d.Id ) ) { var message = "The Document Type does not match the selected entity type."; errorMessages.Add( message ); action.AddLogEntry( message, true ); return false; } var binaryFile = new BinaryFileService( rockContext ).Get( GetAttributeValue( action, AttributeKey.DocumentAttribute, true ).AsGuid() ); if ( binaryFile == null ) { action.AddLogEntry( "The document to add to the entity was not found.", true ); // returning true here to allow the action to run 'successfully' without a document. // This allows the action to be easily used when the document is optional without a bunch of action filter tests. return true; } var documentName = GetAttributeValue( action, AttributeKey.DocumentName ).ResolveMergeFields( mergeFields ); if ( documentName.IsNullOrWhiteSpace() ) { documentName = Path.GetFileNameWithoutExtension( binaryFile.FileName ); } var document = new Document(); document.Name = documentName; document.Description = GetAttributeValue( action, AttributeKey.DocumentDescription ).ResolveMergeFields( mergeFields ); document.EntityId = entityObject.Id; document.DocumentTypeId = documentType.Id; document.SetBinaryFile( binaryFile.Id, rockContext ); var documentService = new DocumentService( rockContext ); documentService.Add( document ); rockContext.SaveChanges(); action.AddLogEntry( "Added document to the Entity." ); 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>(); Guid? groupGuid = null; string filterValue = string.Empty; string filterKey = string.Empty; // get the group attribute groupGuid = GetAttributeValue(action, "SelectionGroup").AsGuid(); if (!groupGuid.HasValue) { errorMessages.Add("The selection group could not be found!"); } // get filter key filterKey = GetAttributeValue(action, "GroupMemberAttributeKey"); // get the filter value filterValue = GetAttributeValue(action, "FilterValue"); Guid?filterValueGuid = filterValue.AsGuidOrNull(); if (filterValueGuid.HasValue) { filterValue = action.GetWorklowAttributeValue(filterValueGuid.Value); } else { filterValue = filterValue.ResolveMergeFields(GetMergeFields(action)); } // get group members var qry = new GroupMemberService(rockContext).Queryable().AsNoTracking() .Where(g => g.Group.Guid == groupGuid); if (!string.IsNullOrWhiteSpace(filterKey)) { qry = qry.WhereAttributeValue(rockContext, filterKey, filterValue); } var groupMembers = qry.Select(g => new { g.Person.NickName, g.Person.LastName, g.Person.SuffixValueId, PrimaryAliasGuid = g.Person.Aliases.FirstOrDefault().Guid }) .ToList(); if (groupMembers.Count() > 0) { // get random group member from options Random rnd = new Random(); int r = rnd.Next(groupMembers.Count); var selectedGroupMember = groupMembers[r]; // set value Guid selectPersonGuid = GetAttributeValue(action, "SelectedPerson").AsGuid(); if (!selectPersonGuid.IsEmpty()) { var selectedPersonAttribute = AttributeCache.Read(selectPersonGuid, rockContext); if (selectedPersonAttribute != null) { // If this is a person type attribute if (selectedPersonAttribute.FieldTypeId == FieldTypeCache.Read(Rock.SystemGuid.FieldType.PERSON.AsGuid(), rockContext).Id) { SetWorkflowAttributeValue(action, selectPersonGuid, selectedGroupMember.PrimaryAliasGuid.ToString()); } else if (selectedPersonAttribute.FieldTypeId == FieldTypeCache.Read(Rock.SystemGuid.FieldType.TEXT.AsGuid(), rockContext).Id) { SetWorkflowAttributeValue(action, selectPersonGuid, Person.FormatFullName(selectedGroupMember.NickName, selectedGroupMember.LastName, selectedGroupMember.SuffixValueId)); } } } } else { errorMessages.Add("No group member for the selected campus could be found."); } errorMessages.ForEach(m => action.AddLogEntry(m, true)); 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 person = GetPersonAliasFromActionAttribute(AttributeKey.Person, rockContext, action, errorMessages); if (person != null) { var mergeFields = GetMergeFields(action); NoteService noteService = new NoteService(rockContext); Note note = new Note(); note.EntityId = person.Id; note.Caption = GetAttributeValue(action, AttributeKey.Caption).ResolveMergeFields(mergeFields); note.IsAlert = GetAttributeValue(action, AttributeKey.Alert).AsBoolean(); note.IsPrivateNote = false; note.Text = GetAttributeValue(action, AttributeKey.Text).ResolveMergeFields(mergeFields); note.EditedDateTime = RockDateTime.Now; // Add a NoteUrl for a person based on the existing Person Profile page, routes, and parameters. var personPageService = new PageService(rockContext); var personPage = personPageService.Get(SystemGuid.Page.PERSON_PROFILE_PERSON_PAGES.AsGuid()); // If the Person Profile Page has at least one route and at least one Page Context, use those to build the Note URL. if (personPage.PageRoutes.Count > 0 && personPage.PageContexts.Count > 0) { var personPageRoute = personPage.PageRoutes.First(); var personPageContext = personPage.PageContexts.First(); var personIdParameter = personPageContext.IdParameter; var personPageParameter = new Dictionary <string, string> { { personIdParameter, person.Id.ToString() } }; var personPageReference = new Web.PageReference(personPage.Id, personPageRoute.Id); note.NoteUrl = personPageReference.BuildRouteURL(personPageParameter); } var noteType = NoteTypeCache.Get(GetAttributeValue(action, AttributeKey.NoteType).AsGuid()); if (noteType != null) { note.NoteTypeId = noteType.Id; } // get author var author = GetPersonAliasFromActionAttribute(AttributeKey.Author, rockContext, action, errorMessages); if (author != null) { note.CreatedByPersonAliasId = author.PrimaryAlias.Id; } noteService.Add(note); rockContext.SaveChanges(); return(true); } else { errorMessages.Add("No person was provided for the note."); } errorMessages.ForEach(m => action.AddLogEntry(m, true)); 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>(); Guid? groupGuid = null; string attributeValue = string.Empty; string attributeKey = string.Empty; // get the group attribute Guid groupAttributeGuid = GetAttributeValue(action, "Group").AsGuid(); if (!groupAttributeGuid.IsEmpty()) { groupGuid = action.GetWorkflowAttributeValue(groupAttributeGuid).AsGuidOrNull(); if (!groupGuid.HasValue) { errorMessages.Add("The group could not be found!"); } } // get group attribute value attributeValue = GetAttributeValue(action, "AttributeValue"); Guid guid = attributeValue.AsGuid(); if (guid.IsEmpty()) { attributeValue = attributeValue.ResolveMergeFields(GetMergeFields(action)); } else { var workflowAttributeValue = action.GetWorkflowAttributeValue(guid); if (workflowAttributeValue != null) { attributeValue = workflowAttributeValue; } } // get attribute key attributeKey = GetAttributeValue(action, "GroupAttributeKey").Replace(" ", ""); // set attribute if (groupGuid.HasValue) { var qry = new GroupService(rockContext).Queryable() .Where(m => m.Guid == groupGuid); foreach (var group in qry.ToList()) { group.LoadAttributes(rockContext); if (group.Attributes.ContainsKey(attributeKey)) { var attribute = group.Attributes[attributeKey]; Rock.Attribute.Helper.SaveAttributeValue(group, attribute, attributeValue, rockContext); } else { action.AddLogEntry(string.Format("The group attribute {0} does not exist!", attributeKey)); break; } } } errorMessages.ForEach(m => action.AddLogEntry(m, true)); 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>(); Guid? groupGuid = null; Person person = null; Group group = null; string noteValue = string.Empty; // get the group attribute Guid groupAttributeGuid = GetAttributeValue(action, "Group").AsGuid(); if (!groupAttributeGuid.IsEmpty()) { groupGuid = action.GetWorklowAttributeValue(groupAttributeGuid).AsGuidOrNull(); if (groupGuid.HasValue) { group = new GroupService(rockContext).Get(groupGuid.Value); if (group == null) { errorMessages.Add("The group provided does not exist."); } } else { errorMessages.Add("Invalid group provided."); } } // get person alias guid Guid personAliasGuid = Guid.Empty; string personAttribute = GetAttributeValue(action, "Person"); Guid guid = personAttribute.AsGuid(); if (!guid.IsEmpty()) { var attribute = AttributeCache.Get(guid, rockContext); if (attribute != null) { string value = action.GetWorklowAttributeValue(guid); personAliasGuid = value.AsGuid(); } if (personAliasGuid != Guid.Empty) { person = new PersonAliasService(rockContext).Queryable() .Where(p => p.Guid.Equals(personAliasGuid)) .Select(p => p.Person) .FirstOrDefault(); if (person == null) { errorMessages.Add("The person could not be found."); } } else { errorMessages.Add("Invalid person provided."); } } // get group member note noteValue = GetAttributeValue(action, "Note"); guid = noteValue.AsGuid(); if (guid.IsEmpty()) { noteValue = noteValue.ResolveMergeFields(GetMergeFields(action)); } else { var workflowAttributeValue = action.GetWorklowAttributeValue(guid); if (workflowAttributeValue != null) { noteValue = workflowAttributeValue; } } // set note if (group != null && person != null) { var groupMembers = new GroupMemberService(rockContext).Queryable() .Where(m => m.Group.Guid == groupGuid && m.PersonId == person.Id).ToList(); if (groupMembers.Count() > 0) { foreach (var groupMember in groupMembers) { groupMember.Note = noteValue; rockContext.SaveChanges(); } } else { errorMessages.Add(string.Format("{0} is not a member of the group {1}.", person.FullName, group.Name)); } } errorMessages.ForEach(m => action.AddLogEntry(m, true)); return(true); }
/// <summary> /// Executes the action. /// </summary> /// <param name="rockContext">The rock context.</param> /// <param name="action">The workflow 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 documentTemplateId = GetAttributeValue(action, AttributeKeys.DocumentTemplate).AsIntegerOrNull(); Person person = null; // get person Guid?personAttributeGuid = GetAttributeValue(action, AttributeKeys.Person).AsGuidOrNull(); if (personAttributeGuid.HasValue) { Guid?personAliasGuid = action.GetWorkflowAttributeValue(personAttributeGuid.Value).AsGuidOrNull(); if (personAliasGuid.HasValue) { var personAlias = new PersonAliasService(rockContext).Get(personAliasGuid.Value); if (personAlias != null) { person = personAlias.Person; } } } if (person == null) { errorMessages.Add("There is no person set on the attribute. Please try again."); return(false); } if (documentTemplateId.HasValue) { var signatureDocument = new SignatureDocumentService(rockContext) .Queryable().AsNoTracking() .Where(d => d.SignatureDocumentTemplateId == documentTemplateId.Value && d.AppliesToPersonAlias != null && d.AppliesToPersonAlias.PersonId == person.Id && d.LastStatusDate.HasValue && d.Status == SignatureDocumentStatus.Signed && d.BinaryFile != null) .OrderByDescending(d => d.LastStatusDate.Value) .FirstOrDefault(); if (signatureDocument != null) { // get the attribute to store the document/file guid var signatureDocumentAttributeGuid = GetAttributeValue(action, AttributeKeys.SignatureDocument).AsGuidOrNull(); if (signatureDocumentAttributeGuid.HasValue) { var signatureDocumentAttribute = AttributeCache.Get(signatureDocumentAttributeGuid.Value, rockContext); if (signatureDocumentAttribute != null) { if (signatureDocumentAttribute.FieldTypeId == FieldTypeCache.Get(Rock.SystemGuid.FieldType.FILE.AsGuid(), rockContext).Id) { SetWorkflowAttributeValue(action, signatureDocumentAttributeGuid.Value, signatureDocument.BinaryFile.Guid.ToString()); return(true); } else { errorMessages.Add("Invalid field type for signature document attribute set."); return(false); } } else { errorMessages.Add("Invalid signature document attribute set."); return(false); } } else { errorMessages.Add("Signature document attribute must be set."); return(false); } } else { var now = RockDateTime.Now; var activatedDateTime = GetDateTimeActivated(action); int?minutes = GetAttributeValue(action, AttributeKeys.MinutesToTimeout).AsIntegerOrNull(); if (minutes.HasValue) { if (activatedDateTime.AddMinutes(minutes.Value).CompareTo(now) <= 0) { action.AddLogEntry(string.Format("{0:N0} minutes have passed. Process timed out.", minutes.Value), true); return(true); } else { return(false); } } return(false); } } else { errorMessages.Add("There was no valid document template id set on this action."); return(false); } }
/// <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 <RecipientData>(); string to = GetAttributeValue(action, "Recipient"); Guid?guid = to.AsGuidOrNull(); if (guid.HasValue) { var attribute = AttributeCache.Get(guid.Value, rockContext); if (attribute != null) { string toValue = action.GetWorklowAttributeValue(guid.Value); if (!string.IsNullOrWhiteSpace(toValue)) { switch (attribute.FieldType.Class) { case "Rock.Field.Types.TextFieldType": case "Rock.Field.Types.EmailFieldType": { var recipientList = toValue.SplitDelimitedValues().ToList(); foreach (string recipient in recipientList) { recipients.Add(new RecipientData(recipient, mergeFields)); } break; } case "Rock.Field.Types.PersonFieldType": { Guid personAliasGuid = toValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { var person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); if (person == null) { action.AddLogEntry("Invalid Recipient: Person not found", true); } else if (string.IsNullOrWhiteSpace(person.Email)) { action.AddLogEntry("Email was not sent: Recipient does not have an email address", true); } else if (!(person.IsEmailActive)) { action.AddLogEntry("Email was not sent: Recipient email is not active", true); } else if (person.EmailPreference == EmailPreference.DoNotEmail) { action.AddLogEntry("Email was not sent: Recipient has requested 'Do Not Email'", true); } else { var personDict = new Dictionary <string, object>(mergeFields); personDict.Add("Person", person); recipients.Add(new RecipientData(person.Email, personDict)); } } break; } case "Rock.Field.Types.GroupFieldType": case "Rock.Field.Types.SecurityRoleFieldType": { int? groupId = toValue.AsIntegerOrNull(); Guid?groupGuid = toValue.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)) { if (person.IsEmailActive && person.EmailPreference != EmailPreference.DoNotEmail && !string.IsNullOrWhiteSpace(person.Email)) { var personDict = new Dictionary <string, object>(mergeFields); personDict.Add("Person", person); recipients.Add(new RecipientData(person.Email, personDict)); } } } break; } } } } } else { var recipientList = to.SplitDelimitedValues().ToList(); foreach (string recipient in recipientList) { recipients.Add(new RecipientData(recipient, mergeFields)); } } if (recipients.Any()) { var emailMessage = new RockEmailMessage(GetAttributeValue(action, "SystemEmail").AsGuid()); emailMessage.SetRecipients(recipients); emailMessage.CreateCommunicationRecord = GetAttributeValue(action, "SaveCommunicationHistory").AsBoolean(); emailMessage.Send(); } 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>(); // Determine which group to add the person to Group group = null; int? groupRoleId = null; var groupAndRoleValues = (GetAttributeValue(action, "GroupAndRole") ?? string.Empty).Split('|'); if (groupAndRoleValues.Count() > 1) { var groupGuid = groupAndRoleValues[1].AsGuidOrNull(); if (groupGuid.HasValue) { group = new GroupService(rockContext).Get(groupGuid.Value); if (groupAndRoleValues.Count() > 2) { var groupTypeRoleGuid = groupAndRoleValues[2].AsGuidOrNull(); if (groupTypeRoleGuid.HasValue) { var groupRole = new GroupTypeRoleService(rockContext).Get(groupTypeRoleGuid.Value); if (groupRole != null) { groupRoleId = groupRole.Id; } } } if (!groupRoleId.HasValue && group != null) { // use the group's grouptype's default group role if a group role wasn't specified groupRoleId = group.GroupType.DefaultGroupRoleId; } } } if (group == null) { errorMessages.Add("No group was provided"); } if (!groupRoleId.HasValue) { errorMessages.Add("No group role was provided and group doesn't have a default group role"); } // determine the person that will be added to the group Person person = null; // get the Attribute.Guid for this workflow's Person Attribute so that we can lookup the value var guidPersonAttribute = GetAttributeValue(action, "Person").AsGuidOrNull(); if (guidPersonAttribute.HasValue) { var attributePerson = AttributeCache.Get(guidPersonAttribute.Value, rockContext); if (attributePerson != null) { string attributePersonValue = action.GetWorklowAttributeValue(guidPersonAttribute.Value); if (!string.IsNullOrWhiteSpace(attributePersonValue)) { if (attributePerson.FieldType.Class == typeof(Rock.Field.Types.PersonFieldType).FullName) { Guid personAliasGuid = attributePersonValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); } } else { errorMessages.Add("The attribute used to provide the person was not of type 'Person'."); } } } } if (person == null) { errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString())); } // Add Person to Group if (!errorMessages.Any()) { var status = this.GetAttributeValue(action, "GroupMemberStatus").ConvertToEnum <GroupMemberStatus>(GroupMemberStatus.Active); var groupMemberService = new GroupMemberService(rockContext); var groupMember = groupMemberService.GetByGroupIdAndPersonIdAndPreferredGroupRoleId(group.Id, person.Id, groupRoleId.Value); bool isNew = false; if (groupMember == null) { groupMember = new GroupMember(); groupMember.PersonId = person.Id; groupMember.GroupId = group.Id; groupMember.GroupRoleId = groupRoleId.Value; groupMember.GroupMemberStatus = status; isNew = true; } else { if (GetAttributeValue(action, "UpdateExisting").AsBoolean()) { groupMember.GroupRoleId = groupRoleId.Value; groupMember.GroupMemberStatus = status; } action.AddLogEntry($"{person.FullName} was already a member of the selected group.", true); } if (groupMember.IsValidGroupMember(rockContext)) { if (isNew) { groupMemberService.Add(groupMember); } rockContext.SaveChanges(); } else { // if the group member couldn't be added (for example, one of the group membership rules didn't pass), add the validation messages to the errormessages errorMessages.AddRange(groupMember.ValidationResults.Select(a => a.ErrorMessage)); } } errorMessages.ForEach(m => action.AddLogEntry(m, true)); return(true); }
private void CompleteFormAction(string formAction) { if (!string.IsNullOrWhiteSpace(formAction) && _workflow != null && _actionType != null && _actionType.WorkflowForm != null && _activity != null && _action != null) { var mergeFields = Rock.Web.Cache.GlobalAttributesCache.GetMergeFields(null); mergeFields.Add("Action", _action); mergeFields.Add("Activity", _activity); mergeFields.Add("Workflow", _workflow); if (CurrentPerson != null) { mergeFields.Add("CurrentPerson", CurrentPerson); } Guid activityTypeGuid = Guid.Empty; string responseText = "Your information has been submitted succesfully."; foreach (var action in _actionType.WorkflowForm.Actions.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries)) { var actionDetails = action.Split(new char[] { '^' }); if (actionDetails.Length > 0 && actionDetails[0] == formAction) { if (actionDetails.Length > 2) { activityTypeGuid = actionDetails[2].AsGuid(); } if (actionDetails.Length > 3 && !string.IsNullOrWhiteSpace(actionDetails[3])) { responseText = actionDetails[3].ResolveMergeFields(mergeFields); } break; } } _action.MarkComplete(); _action.FormAction = formAction; _action.AddLogEntry("Form Action Selected: " + _action.FormAction); if (_action.ActionType.IsActivityCompletedOnSuccess) { _action.Activity.MarkComplete(); } if (_actionType.WorkflowForm.ActionAttributeGuid.HasValue) { var attribute = AttributeCache.Read(_actionType.WorkflowForm.ActionAttributeGuid.Value); if (attribute != null) { IHasAttributes item = null; if (attribute.EntityTypeId == _workflow.TypeId) { item = _workflow; } else if (attribute.EntityTypeId == _activity.TypeId) { item = _activity; } if (item != null) { item.SetAttributeValue(attribute.Key, formAction); } } } if (!activityTypeGuid.IsEmpty()) { var activityType = _workflowType.ActivityTypes.Where(a => a.Guid.Equals(activityTypeGuid)).FirstOrDefault(); if (activityType != null) { WorkflowActivity.Activate(activityType, _workflow); } } List <string> errorMessages; if (_workflowService.Process(_workflow, out errorMessages)) { int?previousActionId = null; if (_action != null) { previousActionId = _action.Id; } ActionTypeId = null; _action = null; _actionType = null; _activity = null; if (HydrateObjects() && _action != null && _action.Id != previousActionId) { BuildForm(true); } else { ShowMessage(NotificationBoxType.Success, string.Empty, responseText, (_action == null || _action.Id != previousActionId)); } } else { ShowMessage(NotificationBoxType.Danger, "Workflow Processing Error(s):", "<ul><li>" + errorMessages.AsDelimited("</li><li>") + "</li></ul>"); } if (_workflow.Id != 0) { WorkflowId = _workflow.Id; } } }
/// <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>(); // Determine which group to add the person to Group group = null; var guidGroupAttribute = GetAttributeValue(action, "Group").AsGuidOrNull(); if (guidGroupAttribute.HasValue) { var attributeGroup = AttributeCache.Get(guidGroupAttribute.Value, rockContext); if (attributeGroup != null) { var groupGuid = action.GetWorklowAttributeValue(guidGroupAttribute.Value).AsGuidOrNull(); if (groupGuid.HasValue) { group = new GroupService(rockContext).Get(groupGuid.Value); } } } if (group == null) { errorMessages.Add("No group was provided"); } // determine the person that will be added to the group Person person = null; // get the Attribute.Guid for this workflow's Person Attribute so that we can lookup the value var guidPersonAttribute = GetAttributeValue(action, "Person").AsGuidOrNull(); if (guidPersonAttribute.HasValue) { var attributePerson = AttributeCache.Get(guidPersonAttribute.Value, rockContext); if (attributePerson != null) { string attributePersonValue = action.GetWorklowAttributeValue(guidPersonAttribute.Value); if (!string.IsNullOrWhiteSpace(attributePersonValue)) { if (attributePerson.FieldType.Class == typeof(Rock.Field.Types.PersonFieldType).FullName) { Guid personAliasGuid = attributePersonValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); } } else { errorMessages.Add("The attribute used to provide the person was not of type 'Person'."); } } } } if (person == null) { errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString())); } // // Check if person is in the group. // if (!errorMessages.Any()) { var groupMemberService = new GroupMemberService(rockContext); var groupMembers = groupMemberService.Queryable().Where(m => m.GroupId == group.Id && m.PersonId == person.Id).ToList(); var statuses = this.GetAttributeValue(action, "GroupMemberStatus") .SplitDelimitedValues() .Select(s => ( GroupMemberStatus )Enum.Parse(typeof(GroupMemberStatus), s)) .ToList(); groupMembers = groupMembers.Where(m => statuses.Contains(m.GroupMemberStatus)).ToList(); if (!string.IsNullOrWhiteSpace(GetAttributeValue(action, "GroupRole"))) { var groupRole = new GroupTypeRoleService(rockContext).Get(GetAttributeValue(action, "GroupRole").AsGuid()); groupMembers = groupMembers.Where(m => m.GroupRoleId == groupRole.Id).ToList(); } // // Set value of the selected attribute. // Guid selectAttributeGuid = GetAttributeValue(action, "Attribute").AsGuid(); if (!selectAttributeGuid.IsEmpty()) { var selectedPersonAttribute = AttributeCache.Get(selectAttributeGuid, rockContext); if (selectedPersonAttribute != null) { if (selectedPersonAttribute.FieldTypeId == FieldTypeCache.Get(Rock.SystemGuid.FieldType.BOOLEAN.AsGuid(), rockContext).Id) { SetWorkflowAttributeValue(action, selectAttributeGuid, groupMembers.Any() ? "True" : "False"); } else if (selectedPersonAttribute.FieldTypeId == FieldTypeCache.Get(Rock.SystemGuid.FieldType.INTEGER.AsGuid(), rockContext).Id) { SetWorkflowAttributeValue(action, selectAttributeGuid, groupMembers.Any() ? "1" : "0"); } else if (selectedPersonAttribute.FieldTypeId == FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT.AsGuid(), rockContext).Id) { if (GetAttributeValue(action, "StoreAsId").AsBoolean(false) == true) { SetWorkflowAttributeValue(action, selectAttributeGuid, string.Join(",", groupMembers.Select(m => m.GroupRoleId.ToString()))); } else { SetWorkflowAttributeValue(action, selectAttributeGuid, string.Join(",", groupMembers.Select(m => m.GroupRole.Name))); } } } } } errorMessages.ForEach(m => action.AddLogEntry(m, true)); 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 mergeFields = GetMergeFields(action); string to = GetAttributeValue(action, AttributeKey.To); string fromValue = GetAttributeValue(action, AttributeKey.From); string replyTo = GetAttributeValue(action, AttributeKey.ReplyTo); string subject = GetAttributeValue(action, AttributeKey.Subject); string body = GetAttributeValue(action, AttributeKey.Body); string cc = GetActionAttributeValue(action, AttributeKey.Cc); string bcc = GetActionAttributeValue(action, AttributeKey.Bcc); var attachmentOneGuid = GetAttributeValue(action, AttributeKey.AttachmentOne, true).AsGuid(); var attachmentTwoGuid = GetAttributeValue(action, AttributeKey.AttachmentTwo, true).AsGuid(); var attachmentThreeGuid = GetAttributeValue(action, AttributeKey.AttachmentThree, true).AsGuid(); var attachmentList = new List <BinaryFile>(); if (!attachmentOneGuid.IsEmpty()) { attachmentList.Add(new BinaryFileService(rockContext).Get(attachmentOneGuid)); } if (!attachmentTwoGuid.IsEmpty()) { attachmentList.Add(new BinaryFileService(rockContext).Get(attachmentTwoGuid)); } if (!attachmentThreeGuid.IsEmpty()) { attachmentList.Add(new BinaryFileService(rockContext).Get(attachmentThreeGuid)); } var attachments = attachmentList.ToArray(); bool createCommunicationRecord = GetAttributeValue(action, AttributeKey.SaveCommunicationHistory).AsBoolean(); string fromEmailAddress = string.Empty; string fromName = string.Empty; Guid? fromGuid = fromValue.AsGuidOrNull(); if (fromGuid.HasValue) { var attribute = AttributeCache.Get(fromGuid.Value, rockContext); if (attribute != null) { string fromAttributeValue = action.GetWorkflowAttributeValue(fromGuid.Value); if (!string.IsNullOrWhiteSpace(fromAttributeValue)) { if (attribute.FieldType.Class == "Rock.Field.Types.PersonFieldType") { Guid personAliasGuid = fromAttributeValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { var person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); if (person != null && !string.IsNullOrWhiteSpace(person.Email)) { fromEmailAddress = person.Email; fromName = person.FullName; } } } else { fromEmailAddress = fromAttributeValue; } } } } else { fromEmailAddress = fromValue.ResolveMergeFields(mergeFields); } string replyToEmailAddress = string.Empty; Guid? replyToGuid = replyTo.AsGuidOrNull(); // If there is a "Reply To" value for the attribute, use that to get the "Reply To" email. if (replyToGuid.HasValue) { var attribute = AttributeCache.Get(replyToGuid.Value, rockContext); if (attribute != null) { string replyToAttributeValue = action.GetWorkflowAttributeValue(replyToGuid.Value); if (!string.IsNullOrWhiteSpace(replyToAttributeValue)) { if (attribute.FieldType.Class == "Rock.Field.Types.PersonFieldType") { Guid personAliasGuid = replyToAttributeValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { var personEmail = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person.Email) .FirstOrDefault(); if (personEmail.IsNotNullOrWhiteSpace()) { replyToEmailAddress = personEmail; } } } else { replyToEmailAddress = replyToAttributeValue; } } } } else { replyToEmailAddress = replyTo.ResolveMergeFields(mergeFields); } // To Email recipients list. if (GetEmailsFromAttributeValue(RecipientType.SendTo, to, action, mergeFields, rockContext, out string toDelimitedEmails, out List <RockEmailMessageRecipient> toRecipients)) { // CC emails recipients list. GetEmailsFromAttributeValue(RecipientType.CC, cc, action, mergeFields, rockContext, out string ccDelimitedEmails, out List <RockEmailMessageRecipient> ccRecipients); List <string> ccEmails = BuildEmailList(ccDelimitedEmails, mergeFields, ccRecipients); // BCC emails recipients list. GetEmailsFromAttributeValue(RecipientType.BCC, bcc, action, mergeFields, rockContext, out string bccDelimitedEmails, out List <RockEmailMessageRecipient> bccRecipients); List <string> bccEmails = BuildEmailList(bccDelimitedEmails, mergeFields, bccRecipients); if (!string.IsNullOrWhiteSpace(toDelimitedEmails)) { Send(toDelimitedEmails, fromEmailAddress, fromName, replyToEmailAddress, subject, body, ccEmails, bccEmails, mergeFields, createCommunicationRecord, attachments, out errorMessages); } else if (toRecipients != null) { Send(toRecipients, fromEmailAddress, fromName, replyToEmailAddress, subject, body, ccEmails, bccEmails, createCommunicationRecord, attachments, out errorMessages); } } errorMessages.ForEach(m => action.AddLogEntry(m, true)); 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>(); // get person int?personId = null; string personAttributeValue = GetAttributeValue(action, "Person"); Guid? guidPersonAttribute = personAttributeValue.AsGuidOrNull(); if (guidPersonAttribute.HasValue) { var attributePerson = AttributeCache.Get(guidPersonAttribute.Value, rockContext); if (attributePerson != null && attributePerson.FieldType.Class == "Rock.Field.Types.PersonFieldType") { string attributePersonValue = action.GetWorklowAttributeValue(guidPersonAttribute.Value); if (!string.IsNullOrWhiteSpace(attributePersonValue)) { Guid personAliasGuid = attributePersonValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { personId = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.PersonId) .FirstOrDefault(); if (personId == null) { errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString())); return(false); } } } } } if (personId == null) { errorMessages.Add("The attribute used to provide the person was invalid, or not of type 'Person'."); return(false); } // determine the phone type to edit DefinedValueCache phoneType = null; var phoneTypeAttributeValue = action.GetWorklowAttributeValue(GetAttributeValue(action, "PhoneTypeAttribute").AsGuid()); if (phoneTypeAttributeValue != null) { phoneType = DefinedValueCache.Get(phoneTypeAttributeValue.AsGuid()); } if (phoneType == null) { phoneType = DefinedValueCache.Get(GetAttributeValue(action, "PhoneType").AsGuid()); } if (phoneType == null) { errorMessages.Add("The phone type to be updated was not selected."); return(false); } // get the ignore blank setting var ignoreBlanks = GetActionAttributeValue(action, "IgnoreBlankValues").AsBoolean(true); // get the new phone number value string phoneNumberValue = GetAttributeValue(action, "PhoneNumber"); Guid? phoneNumberValueGuid = phoneNumberValue.AsGuidOrNull(); if (phoneNumberValueGuid.HasValue) { phoneNumberValue = action.GetWorklowAttributeValue(phoneNumberValueGuid.Value); } else { phoneNumberValue = phoneNumberValue.ResolveMergeFields(GetMergeFields(action)); } phoneNumberValue = PhoneNumber.CleanNumber(phoneNumberValue); // gets value indicating if phone number is unlisted string unlistedValue = GetAttributeValue(action, "Unlisted"); Guid? unlistedValueGuid = unlistedValue.AsGuidOrNull(); if (unlistedValueGuid.HasValue) { unlistedValue = action.GetWorklowAttributeValue(unlistedValueGuid.Value); } else { unlistedValue = unlistedValue.ResolveMergeFields(GetMergeFields(action)); } bool?unlisted = unlistedValue.AsBooleanOrNull(); // gets value indicating if messaging should be enabled for phone number string smsEnabledValue = GetAttributeValue(action, "MessagingEnabled"); Guid? smsEnabledValueGuid = smsEnabledValue.AsGuidOrNull(); if (smsEnabledValueGuid.HasValue) { smsEnabledValue = action.GetWorklowAttributeValue(smsEnabledValueGuid.Value); } else { smsEnabledValue = smsEnabledValue.ResolveMergeFields(GetMergeFields(action)); } bool?smsEnabled = smsEnabledValue.AsBooleanOrNull(); bool updated = false; bool newPhoneNumber = false; var phoneNumberService = new PhoneNumberService(rockContext); var phoneNumber = phoneNumberService.Queryable() .Where(n => n.PersonId == personId.Value && n.NumberTypeValueId == phoneType.Id) .FirstOrDefault(); string oldValue = string.Empty; if (phoneNumber == null) { phoneNumber = new PhoneNumber { NumberTypeValueId = phoneType.Id, PersonId = personId.Value }; newPhoneNumber = true; updated = true; } else { oldValue = phoneNumber.NumberFormattedWithCountryCode; } if (!string.IsNullOrWhiteSpace(phoneNumberValue) || !ignoreBlanks) { updated = updated || phoneNumber.Number != phoneNumberValue; phoneNumber.Number = phoneNumberValue; } if (unlisted.HasValue) { updated = updated || phoneNumber.IsUnlisted != unlisted.Value; phoneNumber.IsUnlisted = unlisted.Value; } if (smsEnabled.HasValue) { updated = updated || phoneNumber.IsMessagingEnabled != smsEnabled.Value; phoneNumber.IsMessagingEnabled = smsEnabled.Value; } if (updated) { if (oldValue != phoneNumber.NumberFormattedWithCountryCode) { var changes = new History.HistoryChangeList(); changes.AddChange(History.HistoryVerb.Modify, History.HistoryChangeType.Record, "Phone").SetSourceOfChange($"{action.ActionTypeCache.ActivityType.WorkflowType.Name} workflow"); HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), personId.Value, changes, false); } if (phoneNumber.Number.IsNullOrWhiteSpace()) { if (!newPhoneNumber) { phoneNumberService.Delete(phoneNumber); } } else { if (newPhoneNumber) { phoneNumberService.Add(phoneNumber); } } rockContext.SaveChanges(); if (action.Activity != null && action.Activity.Workflow != null) { var workflowType = action.Activity.Workflow.WorkflowTypeCache; if (workflowType != null && workflowType.LoggingLevel == WorkflowLoggingLevel.Action) { var person = new PersonService(rockContext).Get(personId.Value); action.AddLogEntry(string.Format("Updated {0} phone for {1} to {2}.", phoneType.Value, person.FullName, phoneNumber.NumberFormattedWithCountryCode)); } } } 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>(); string providerGuid = GetAttributeValue(action, "Provider"); if (!string.IsNullOrWhiteSpace(providerGuid)) { var provider = BackgroundCheckContainer.GetComponent(providerGuid); if (provider != null) { BackgroundCheckService backgroundCheckService = new BackgroundCheckService(rockContext); var backgroundCheck = backgroundCheckService.Queryable().Where(b => b.WorkflowId == action.Activity.Workflow.Id).FirstOrDefault(); if (backgroundCheck == null) { //If for some reason a background check entity isn't available //Add a log and set the report Status To Error. //This allows the workflow to handle issues gracefully action.AddLogEntry("No valid background check exists for this workflow", true); SetWorkflowAttributeValue(action, GetAttributeValue(action, "ReportStatus").AsGuid(), "Error"); return(true); } var transactionId = backgroundCheck.RequestId; var statusURL = provider.GetAttributeValue("StatusURL"); var subscriberCode = Encryption.DecryptString(provider.GetAttributeValue("SubscriberCode")); var companyCode = Encryption.DecryptString(provider.GetAttributeValue("CompanyCode")); Trak1ReportStatus status = null; var resource = string.Format("/{0}/{1}/{2}", subscriberCode, companyCode, transactionId); using (var client = new HttpClient(new HttpClientHandler())) { client.BaseAddress = new Uri(statusURL + resource); var clientResponse = client.GetAsync("").Result.Content.ReadAsStringAsync().Result; status = JsonConvert.DeserializeObject <Trak1ReportStatus>(clientResponse); } SetWorkflowAttributeValue(action, GetAttributeValue(action, "ReportStatus").AsGuid(), status.ReportStatus); backgroundCheck.Status = status.ReportStatus; SetWorkflowAttributeValue(action, GetAttributeValue(action, "HitColor").AsGuid(), status.HitColor); backgroundCheck.RecordFound = status.HitColor == "Green"; var reportURL = provider.GetAttributeValue("ReportURL"); Trak1Report response = null; using (var client = new HttpClient(new HttpClientHandler())) { client.BaseAddress = new Uri(reportURL + resource); var clientResponse = client.GetAsync("").Result.Content.ReadAsStringAsync().Result; response = JsonConvert.DeserializeObject <Trak1Report>(clientResponse); } SetWorkflowAttributeValue(action, GetAttributeValue(action, "ReportUrl").AsGuid(), response.ReportUrl); backgroundCheck.ResponseDate = Rock.RockDateTime.Now; backgroundCheck.ResponseData = response.ReportUrl; return(true); } else { errorMessages.Add("Invalid Background Check Provider!"); } } else { errorMessages.Add("Invalid Background Check Provider Guid!"); } return(false); }
/// <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>(); if (entity != null && entity is IEntity) { Guid guid = GetAttributeValue(action, "Attribute").AsGuid(); if (!guid.IsEmpty()) { var attribute = AttributeCache.Get(guid, rockContext); if (attribute != null) { // If a lava template was specified, use that to set the attribute value string lavaTemplate = GetAttributeValue(action, "LavaTemplate"); if (!string.IsNullOrWhiteSpace(lavaTemplate)) { var mergeFields = GetMergeFields(action); mergeFields.Add("Entity", entity); string parsedValue = lavaTemplate.ResolveMergeFields(mergeFields); SetWorkflowAttributeValue(action, guid, parsedValue); } else { // Person + PersonFieldType is handled differently since it needs to be stored as PersonAlias.Guid if (entity is Person && attribute.FieldTypeId == FieldTypeCache.Get(SystemGuid.FieldType.PERSON.AsGuid(), rockContext).Id) { var primaryAlias = GetPrimaryPersonAlias(( Person )entity, rockContext, errorMessages); if (primaryAlias != null) { SetWorkflowAttributeValue(action, guid, primaryAlias.Guid.ToString()); return(true); } } // If the attribute is an Entity FieldType, store the value as EntityType.Guid|Entity.Id else if (attribute.FieldTypeId == FieldTypeCache.Get(SystemGuid.FieldType.ENTITY.AsGuid(), rockContext).Id) { // Person + EntityFieldType is handled differently since it needs to be stored as PersonAlias's EntityType.Guid EntityTypeCache entityType = entity is Person ? EntityTypeCache.Get(SystemGuid.EntityType.PERSON_ALIAS) : EntityTypeCache.Get(entity.GetType(), rockContext: rockContext); if (entityType == null) { errorMessages.Add("Unable to find the entity type. Type=" + entity.GetType().FullName); } else { // Person + EntityFieldType is handled differently since it needs to be stored as PersonAlias.Id int?entityId = entity is Person ? GetPrimaryPersonAlias(( Person )entity, rockContext, errorMessages)?.Id : (( IEntity )entity).Id; if (entityId.HasValue) { var value = $"{entityType.Guid}|{entityId.ToStringSafe()}"; SetWorkflowAttributeValue(action, guid, value); } } } else { if (GetAttributeValue(action, "UseId").AsBoolean()) { SetWorkflowAttributeValue(action, guid, ((IEntity)entity).Id.ToString()); } else { SetWorkflowAttributeValue(action, guid, ((IEntity)entity).Guid.ToString()); } } } return(true); } else { errorMessages.Add("Unable to find the attribute from the attribute GUID=" + guid.ToStringSafe()); } } else { errorMessages.Add("Unable to find the attribute GUID."); } } else { if (!GetAttributeValue(action, "EntityIsRequired").AsBoolean(true)) { return(true); } errorMessages.Add("No entity was specified or the entity is not a Rock Entity."); } errorMessages.ForEach(m => action.AddLogEntry(m, true)); return(false); }
/// <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); string to = GetAttributeValue(action, "To"); string fromValue = GetAttributeValue(action, "From"); string subject = GetAttributeValue(action, "Subject"); string body = GetAttributeValue(action, "Body"); BinaryFile[] attachments = { new BinaryFileService(rockContext).Get(GetAttributeValue(action, "AttachmentOne", true).AsGuid()), new BinaryFileService(rockContext).Get(GetAttributeValue(action, "AttachmentTwo", true).AsGuid()), new BinaryFileService(rockContext).Get(GetAttributeValue(action, "AttachmentThree", true).AsGuid()) }; bool createCommunicationRecord = GetAttributeValue(action, "SaveCommunicationHistory").AsBoolean(); string fromEmail = string.Empty; string fromName = string.Empty; Guid? fromGuid = fromValue.AsGuidOrNull(); if (fromGuid.HasValue) { var attribute = AttributeCache.Get(fromGuid.Value, rockContext); if (attribute != null) { string fromAttributeValue = action.GetWorklowAttributeValue(fromGuid.Value); if (!string.IsNullOrWhiteSpace(fromAttributeValue)) { if (attribute.FieldType.Class == "Rock.Field.Types.PersonFieldType") { Guid personAliasGuid = fromAttributeValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { var person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); if (person != null && !string.IsNullOrWhiteSpace(person.Email)) { fromEmail = person.Email; fromName = person.FullName; } } } else { fromEmail = fromAttributeValue; } } } } else { fromEmail = fromValue; } Guid?guid = to.AsGuidOrNull(); if (guid.HasValue) { var attribute = AttributeCache.Get(guid.Value, rockContext); if (attribute != null) { string toValue = action.GetWorklowAttributeValue(guid.Value); if (!string.IsNullOrWhiteSpace(toValue)) { switch (attribute.FieldType.Class) { case "Rock.Field.Types.TextFieldType": case "Rock.Field.Types.EmailFieldType": { Send(toValue, fromEmail, fromName, subject, body, mergeFields, rockContext, createCommunicationRecord, attachments); break; } case "Rock.Field.Types.PersonFieldType": { Guid personAliasGuid = toValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { var person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); if (person == null) { action.AddLogEntry("Invalid Recipient: Person not found", true); } else if (string.IsNullOrWhiteSpace(person.Email)) { action.AddLogEntry("Email was not sent: Recipient does not have an email address", true); } else if (!person.IsEmailActive) { action.AddLogEntry("Email was not sent: Recipient email is not active", true); } else if (person.EmailPreference == EmailPreference.DoNotEmail) { action.AddLogEntry("Email was not sent: Recipient has requested 'Do Not Email'", true); } else { var personDict = new Dictionary <string, object>(mergeFields); personDict.Add("Person", person); Send(person.Email, fromEmail, fromName, subject, body, personDict, rockContext, createCommunicationRecord, attachments); } } break; } case "Rock.Field.Types.GroupFieldType": case "Rock.Field.Types.SecurityRoleFieldType": { int? groupId = toValue.AsIntegerOrNull(); Guid?groupGuid = toValue.AsGuidOrNull(); // Get the Group Role attribute value Guid?groupRoleValueGuid = GetGroupRoleValue(action); IQueryable <GroupMember> qry = null; // Handle situations where the attribute value is the ID if (groupId.HasValue) { qry = new GroupMemberService(rockContext).GetByGroupId(groupId.Value); } else if (groupGuid.HasValue) { // Handle situations where the attribute value stored is the Guid qry = new GroupMemberService(rockContext).GetByGroupGuid(groupGuid.Value); } else { action.AddLogEntry("Invalid Recipient: No valid group id or Guid", true); } if (groupRoleValueGuid.HasValue) { qry = qry.Where(m => m.GroupRole != null && m.GroupRole.Guid.Equals(groupRoleValueGuid.Value)); } if (qry != null) { foreach (var person in qry .Where(m => m.GroupMemberStatus == GroupMemberStatus.Active) .Select(m => m.Person)) { if (person.IsEmailActive && person.EmailPreference != EmailPreference.DoNotEmail && !string.IsNullOrWhiteSpace(person.Email)) { var personDict = new Dictionary <string, object>(mergeFields); personDict.Add("Person", person); Send(person.Email, fromEmail, fromName, subject, body, personDict, rockContext, createCommunicationRecord, attachments); } } } break; } } } } } else { Send(to.ResolveMergeFields(mergeFields), fromEmail, fromName, subject, body, mergeFields, rockContext, createCommunicationRecord, attachments); } 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 attribute = AttributeCache.Get(GetAttributeValue(action, "PersonAttribute").AsGuid(), rockContext); if (attribute != null) { var mergeFields = GetMergeFields(action); string firstName = GetAttributeValue(action, "FirstName", true).ResolveMergeFields(mergeFields); string lastName = GetAttributeValue(action, "LastName", true).ResolveMergeFields(mergeFields); string email = GetAttributeValue(action, "Email", true).ResolveMergeFields(mergeFields); string phone = GetAttributeValue(action, "Phone", true).ResolveMergeFields(mergeFields); DateTime?dateofBirth = GetAttributeValue(action, "DOB", true).AsDateTime(); Guid? addressGuid = GetAttributeValue(action, "Address", true).AsGuidOrNull(); Guid? familyOrPersonGuid = GetAttributeValue(action, "FamilyAttribute", true).AsGuidOrNull(); Location address = null; // Set the street and postal code if we have an address if (addressGuid.HasValue) { LocationService addressService = new LocationService(rockContext); address = addressService.Get(addressGuid.Value); } if (string.IsNullOrWhiteSpace(firstName) || string.IsNullOrWhiteSpace(lastName) || (string.IsNullOrWhiteSpace(email) && string.IsNullOrWhiteSpace(phone) && !dateofBirth.HasValue && (address == null || address != null && string.IsNullOrWhiteSpace(address.Street1))) ) { errorMessages.Add("First Name, Last Name, and one of Email, Phone, DoB, or Address Street are required. One or more of these values was not provided!"); } else { Rock.Model.Person person = null; PersonAlias personAlias = null; var personService = new PersonService(rockContext); var people = personService.GetByMatch(firstName, lastName, dateofBirth, email, phone, address?.Street1, address?.PostalCode).ToList(); if (people.Count == 1 && // Make sure their email matches. If it doesn't, we need to go ahead and create a new person to be matched later. (string.IsNullOrWhiteSpace(email) || (people.First().Email != null && email.ToLower().Trim() == people.First().Email.ToLower().Trim())) ) { person = people.First(); personAlias = person.PrimaryAlias; } else if (!GetAttributeValue(action, "MatchOnly").AsBoolean()) { // Add New Person person = new Rock.Model.Person(); person.FirstName = firstName; person.LastName = lastName; person.IsEmailActive = true; person.Email = email; if (dateofBirth.HasValue) { person.BirthDay = dateofBirth.Value.Day; person.BirthMonth = dateofBirth.Value.Month; person.BirthYear = dateofBirth.Value.Year; } person.EmailPreference = EmailPreference.EmailAllowed; person.RecordTypeValueId = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid()).Id; var defaultConnectionStatus = DefinedValueCache.Get(GetAttributeValue(action, "DefaultConnectionStatus").AsGuid()); if (defaultConnectionStatus != null) { person.ConnectionStatusValueId = defaultConnectionStatus.Id; } var defaultRecordStatus = DefinedValueCache.Get(GetAttributeValue(action, "DefaultRecordStatus").AsGuid()); if (defaultRecordStatus != null) { person.RecordStatusValueId = defaultRecordStatus.Id; } var defaultCampus = CampusCache.Get(GetAttributeValue(action, "DefaultCampus", true).AsGuid()); // Get the default family if applicable Group family = null; if (familyOrPersonGuid.HasValue) { PersonAliasService personAliasService = new PersonAliasService(rockContext); family = personAliasService.Get(familyOrPersonGuid.Value)?.Person?.GetFamily(); if (family == null) { GroupService groupService = new GroupService(rockContext); family = groupService.Get(familyOrPersonGuid.Value); } } var familyGroup = SaveNewPerson(person, family, (defaultCampus != null ? defaultCampus.Id : ( int? )null), rockContext); if (familyGroup != null && familyGroup.Members.Any()) { personAlias = person.PrimaryAlias; // If we have an address, go ahead and save it here. if (address != null) { GroupLocation location = new GroupLocation(); location.GroupLocationTypeValueId = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME).Id; location.Location = address; familyGroup.GroupLocations.Add(location); } } } // Save/update the phone number if (!string.IsNullOrWhiteSpace(phone)) { List <string> changes = new List <string>(); var numberType = DefinedValueCache.Get(GetAttributeValue(action, "PhoneNumberType").AsGuid()); if (numberType != null) { // gets value indicating if phone number is unlisted string unlistedValue = GetAttributeValue(action, "Unlisted"); Guid? unlistedValueGuid = unlistedValue.AsGuidOrNull(); if (unlistedValueGuid.HasValue) { unlistedValue = action.GetWorklowAttributeValue(unlistedValueGuid.Value); } else { unlistedValue = unlistedValue.ResolveMergeFields(GetMergeFields(action)); } bool unlisted = unlistedValue.AsBoolean(); // gets value indicating if messaging should be enabled for phone number string smsEnabledValue = GetAttributeValue(action, "MessagingEnabled"); Guid? smsEnabledValueGuid = smsEnabledValue.AsGuidOrNull(); if (smsEnabledValueGuid.HasValue) { smsEnabledValue = action.GetWorklowAttributeValue(smsEnabledValueGuid.Value); } else { smsEnabledValue = smsEnabledValue.ResolveMergeFields(GetMergeFields(action)); } bool smsEnabled = smsEnabledValue.AsBoolean(); var phoneModel = person.PhoneNumbers.FirstOrDefault(p => p.NumberTypeValueId == numberType.Id); string oldPhoneNumber = phoneModel != null ? phoneModel.NumberFormattedWithCountryCode : string.Empty; string newPhoneNumber = PhoneNumber.CleanNumber(phone); if (newPhoneNumber != string.Empty && newPhoneNumber != oldPhoneNumber) { if (phoneModel == null) { phoneModel = new PhoneNumber(); person.PhoneNumbers.Add(phoneModel); phoneModel.NumberTypeValueId = numberType.Id; } else { oldPhoneNumber = phoneModel.NumberFormattedWithCountryCode; } phoneModel.Number = newPhoneNumber; phoneModel.IsUnlisted = unlisted; phoneModel.IsMessagingEnabled = smsEnabled; } } } if (person != null && personAlias != null) { SetWorkflowAttributeValue(action, attribute.Guid, personAlias.Guid.ToString()); action.AddLogEntry(string.Format("Set '{0}' attribute to '{1}'.", attribute.Name, person.FullName)); return(true); } else if (!GetAttributeValue(action, "MatchOnly").AsBoolean()) { errorMessages.Add("Person or Primary Alias could not be determined!"); } } } else { errorMessages.Add("Person Attribute could not be found!"); } if (errorMessages.Any()) { errorMessages.ForEach(m => action.AddLogEntry(m, true)); if (GetAttributeValue(action, "ContinueOnError").AsBoolean()) { errorMessages.Clear(); return(true); } else { return(false); } } 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 service = new PageShortLinkService(rockContext); // Get the merge fields var mergeFields = GetMergeFields(action); // Get the site int siteId = GetAttributeValue(action, "Site", true).AsInteger(); SiteCache site = SiteCache.Get(siteId); if (site == null) { errorMessages.Add(string.Format("Invalid Site Value")); return(false); } // Get the token string token = GetAttributeValue(action, "Token", true).ResolveMergeFields(mergeFields); if (token.IsNullOrWhiteSpace()) { int tokenLen = GetAttributeValue(action, "RandomTokenLength").AsIntegerOrNull() ?? 7; token = service.GetUniqueToken(site.Id, tokenLen); } // Get the target url string url = GetAttributeValue(action, "Url", true).ResolveMergeFields(mergeFields).RemoveCrLf().Trim(); if (url.IsNullOrWhiteSpace()) { errorMessages.Add("A valid Target URL was not specified."); return(false); } // Save the short link var link = service.GetByToken(token, site.Id); if (link != null) { if (!GetAttributeValue(action, "Overwrite").AsBoolean()) { errorMessages.Add(string.Format("The selected token ('{0}') already exists. Please specify a unique token, or configure action to allow token re-use.", token)); return(false); } else { link.Url = url; } } else { link = new PageShortLink(); link.SiteId = site.Id; link.Token = token; link.Url = url; service.Add(link); } rockContext.SaveChanges(); // Save the resulting short link url var attribute = AttributeCache.Get(GetAttributeValue(action, "Attribute").AsGuid(), rockContext); if (attribute != null) { string shortLink = link.ShortLinkUrl; SetWorkflowAttributeValue(action, attribute.Guid, shortLink); action.AddLogEntry(string.Format("Set '{0}' attribute to '{1}'.", attribute.Name, shortLink)); } return(true); }
private void SendEmail(RockContext rockContext, WorkflowAction action) { var mergeFields = GetMergeFields(action); string to = GetAttributeValue(action, "To"); string fromValue = GetAttributeValue(action, "From"); string subject = GetAttributeValue(action, "Subject"); string body = GetAttributeValue(action, "Body"); bool createCommunicationRecord = GetAttributeValue(action, "SaveCommunicationHistory").AsBoolean(); string fromEmailAddress = string.Empty; string fromName = string.Empty; Guid? fromGuid = fromValue.AsGuidOrNull(); if (fromGuid.HasValue) { var attribute = AttributeCache.Get(fromGuid.Value, rockContext); if (attribute != null) { string fromAttributeValue = action.GetWorklowAttributeValue(fromGuid.Value); if (!string.IsNullOrWhiteSpace(fromAttributeValue)) { if (attribute.FieldType.Class == "Rock.Field.Types.PersonFieldType") { Guid personAliasGuid = fromAttributeValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { var person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); if (person != null && !string.IsNullOrWhiteSpace(person.Email)) { fromEmailAddress = person.Email; fromName = person.FullName; } } } else { fromEmailAddress = fromAttributeValue; } } } } else { fromEmailAddress = fromValue; } var metaData = new Dictionary <string, string>(); metaData.Add("workflow_action_guid", action.Guid.ToString()); Guid?guid = to.AsGuidOrNull(); if (guid.HasValue) { var attribute = AttributeCache.Get(guid.Value, rockContext); if (attribute != null) { string toValue = action.GetWorklowAttributeValue(guid.Value); if (!string.IsNullOrWhiteSpace(toValue)) { switch (attribute.FieldType.Class) { case "Rock.Field.Types.TextFieldType": { var recipientEmails = toValue.ResolveMergeFields(mergeFields); Send(recipientEmails, fromEmailAddress, fromName, subject, body, mergeFields, createCommunicationRecord, metaData); break; } case "Rock.Field.Types.PersonFieldType": { Guid personAliasGuid = toValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { var person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); if (person == null) { action.AddLogEntry("Invalid Recipient: Person not found", true); } else if (string.IsNullOrWhiteSpace(person.Email)) { action.AddLogEntry("Email was not sent: Recipient does not have an email address", true); } else if (!person.IsEmailActive) { action.AddLogEntry("Email was not sent: Recipient email is not active", true); } else if (person.EmailPreference == EmailPreference.DoNotEmail) { action.AddLogEntry("Email was not sent: Recipient has requested 'Do Not Email'", true); } else { var personDict = new Dictionary <string, object>(mergeFields); personDict.Add("Person", person); var recipients = new RockEmailMessageRecipient[1] { new RockEmailMessageRecipient(person, personDict) }.ToList(); Send(recipients, fromEmailAddress, fromName, subject, body, createCommunicationRecord, metaData); } } break; } } } } } else { var recipientEmails = to.ResolveMergeFields(mergeFields); Send(recipientEmails, fromEmailAddress, fromName, subject, body, mergeFields, createCommunicationRecord, metaData); } }
/// <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>(); // Get Group Type var groupTypeGuid = GetAttributeValue(action, "GroupType", true).AsGuid(); var groupType = GroupTypeCache.Read(groupTypeGuid); if (groupType == null) { // Appears Group type cache by gui is not always working. Try to read from db. var groupTypeModel = new GroupTypeService(rockContext).Get(groupTypeGuid); if (groupTypeModel != null) { groupType = GroupTypeCache.Read(groupTypeModel.Id); } } if (groupType == null) { errorMessages.Add("The Group Type could not be determined or found!"); } // Group Name var groupName = GetAttributeValue(action, "GroupName", true); if (groupName.IsNullOrWhiteSpace()) { errorMessages.Add("The Group Type could not be determined or found!"); } // Parent Group Group parentGroup = null; var parentGroupGuid = GetAttributeValue(action, "ParentGroup", true).AsGuidOrNull(); if (parentGroupGuid.HasValue) { parentGroup = new GroupService(rockContext).Get(parentGroupGuid.Value); } // Add request if (!errorMessages.Any()) { var groupService = new GroupService(rockContext); Group group = null; int?parentGroupId = parentGroup != null ? parentGroup.Id : (int?)null; if (GetAttributeValue(action, "CheckExisting", true).AsBoolean()) { group = groupService.Queryable() .Where(g => g.GroupTypeId == groupType.Id && g.Name == groupName && ((!parentGroupId.HasValue && !g.ParentGroupId.HasValue) || (parentGroupId.HasValue && g.ParentGroupId.HasValue && g.ParentGroupId.Value == parentGroupId.Value))) .FirstOrDefault(); } if (group == null) { group = new Group(); groupService.Add(group); group.GroupTypeId = groupType.Id; group.Name = groupName; if (parentGroup != null) { group.ParentGroupId = parentGroup.Id; } rockContext.SaveChanges(); } if (group.Id > 0) { string resultValue = group.Guid.ToString(); var attribute = SetWorkflowAttributeValue(action, "ResultAttribute", resultValue); if (attribute != null) { action.AddLogEntry(string.Format("Set '{0}' attribute to '{1}'.", attribute.Name, resultValue)); } } } errorMessages.ForEach(m => action.AddLogEntry(m, true)); return(!errorMessages.Any()); }
/// <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> /// 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>(); if (entity != null && entity is IEntity) { Guid guid = GetAttributeValue(action, "Attribute").AsGuid(); if (!guid.IsEmpty()) { var attribute = AttributeCache.Get(guid, rockContext); if (attribute != null) { // If a lava template was specified, use that to set the attribute value string lavaTemplate = GetAttributeValue(action, "LavaTemplate"); if (!string.IsNullOrWhiteSpace(lavaTemplate)) { var mergeFields = GetMergeFields(action); mergeFields.Add("Entity", entity); string parsedValue = lavaTemplate.ResolveMergeFields(mergeFields); SetWorkflowAttributeValue(action, guid, parsedValue); } else { // Person is handled special since it needs the person alias id if (entity is Person && attribute.FieldTypeId == FieldTypeCache.Get(SystemGuid.FieldType.PERSON.AsGuid(), rockContext).Id) { var person = (Person)entity; var primaryAlias = new PersonAliasService(rockContext).Queryable().FirstOrDefault(a => a.AliasPersonId == person.Id); if (primaryAlias != null) { SetWorkflowAttributeValue(action, guid, primaryAlias.Guid.ToString()); return(true); } else { errorMessages.Add("Person Entity: Could not determine person's primary alias. PersonId=" + person.Id); } } else { if (GetAttributeValue(action, "UseId").AsBoolean()) { SetWorkflowAttributeValue(action, guid, ((IEntity)entity).Id.ToString()); } else { SetWorkflowAttributeValue(action, guid, ((IEntity)entity).Guid.ToString()); } } } return(true); } else { errorMessages.Add("Unable to find the attribute from the attribute GUID=" + guid.ToStringSafe()); } } else { errorMessages.Add("Unable to find the attribute GUID."); } } else { if (!GetAttributeValue(action, "EntityIsRequired").AsBoolean(true)) { return(true); } errorMessages.Add("No entity was specified or the entity is not a Rock Entity."); } errorMessages.ForEach(m => action.AddLogEntry(m, true)); return(false); }
/// <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); int? fromId = null; Guid?fromGuid = GetAttributeValue(action, "From").AsGuidOrNull(); if (fromGuid.HasValue) { var fromValue = DefinedValueCache.Read(fromGuid.Value, rockContext); if (fromValue != null) { fromId = fromValue.Id; } } var recipients = new List <RecipientData>(); string toValue = GetAttributeValue(action, "To"); Guid guid = toValue.AsGuid(); if (!guid.IsEmpty()) { var attribute = AttributeCache.Read(guid, rockContext); if (attribute != null) { string toAttributeValue = action.GetWorklowAttributeValue(guid); if (!string.IsNullOrWhiteSpace(toAttributeValue)) { switch (attribute.FieldType.Class) { case "Rock.Field.Types.TextFieldType": { recipients.Add(new RecipientData(toAttributeValue)); break; } case "Rock.Field.Types.PersonFieldType": { Guid personAliasGuid = toAttributeValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { var phoneNumber = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .SelectMany(a => a.Person.PhoneNumbers) .Where(p => p.IsMessagingEnabled) .FirstOrDefault(); if (phoneNumber == null) { action.AddLogEntry("Invalid Recipient: Person or valid SMS phone number not found", true); } else { string smsNumber = phoneNumber.Number; if (!string.IsNullOrWhiteSpace(phoneNumber.CountryCode)) { smsNumber = "+" + phoneNumber.CountryCode + phoneNumber.Number; } var recipient = new RecipientData(smsNumber); recipients.Add(recipient); var person = new PersonAliasService(rockContext).GetPerson(personAliasGuid); if (person != null) { recipient.MergeFields.Add("Person", 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)) { var phoneNumber = person.PhoneNumbers .Where(p => p.IsMessagingEnabled) .FirstOrDefault(); if (phoneNumber != null) { string smsNumber = phoneNumber.Number; if (!string.IsNullOrWhiteSpace(phoneNumber.CountryCode)) { smsNumber = "+" + phoneNumber.CountryCode + phoneNumber.Number; } var recipient = new RecipientData(smsNumber); recipients.Add(recipient); recipient.MergeFields.Add("Person", person); } } } break; } } } } } else { if (!string.IsNullOrWhiteSpace(toValue)) { recipients.Add(new RecipientData(toValue.ResolveMergeFields(mergeFields))); } } string message = GetAttributeValue(action, "Message"); Guid messageGuid = message.AsGuid(); if (!messageGuid.IsEmpty()) { var attribute = AttributeCache.Read(messageGuid, rockContext); if (attribute != null) { string messageAttributeValue = action.GetWorklowAttributeValue(messageGuid); if (!string.IsNullOrWhiteSpace(messageAttributeValue)) { if (attribute.FieldType.Class == "Rock.Field.Types.TextFieldType") { message = messageAttributeValue; } } } } if (recipients.Any() && !string.IsNullOrWhiteSpace(message)) { var mediumEntity = EntityTypeCache.Read(Rock.SystemGuid.EntityType.COMMUNICATION_MEDIUM_SMS.AsGuid(), rockContext); if (mediumEntity != null) { var medium = MediumContainer.GetComponent(mediumEntity.Name); if (medium != null && medium.IsActive) { var transport = medium.Transport; if (transport != null && transport.IsActive) { var appRoot = GlobalAttributesCache.Read(rockContext).GetValue("InternalApplicationRoot"); foreach (var recipient in recipients) { var recipientMergeFields = new Dictionary <string, object>(mergeFields); foreach (var mergeField in recipient.MergeFields) { recipientMergeFields.Add(mergeField.Key, mergeField.Value); } var mediumData = new Dictionary <string, string>(); mediumData.Add("FromValue", fromId.Value.ToString()); mediumData.Add("Message", message.ResolveMergeFields(recipientMergeFields)); var number = new List <string> { recipient.To }; transport.Send(mediumData, number, appRoot, string.Empty); } } } } } return(true); }
/// <summary> /// Executes the specified workflow. /// </summary> /// <param name="rockContext">The rock context.</param> /// <param name="action">The workflow 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 actionType = action.ActionTypeCache; if (!action.LastProcessedDateTime.HasValue && actionType != null && actionType.WorkflowForm != null && actionType.WorkflowForm.NotificationSystemEmailId.HasValue) { if (action.Activity != null && (action.Activity.AssignedPersonAliasId.HasValue || action.Activity.AssignedGroupId.HasValue)) { var recipients = new List <RecipientData>(); var workflowMergeFields = GetMergeFields(action); if (action.Activity.AssignedPersonAliasId.HasValue) { var person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Id == action.Activity.AssignedPersonAliasId.Value) .Select(a => a.Person) .FirstOrDefault(); if (person != null && !string.IsNullOrWhiteSpace(person.Email)) { recipients.Add(new RecipientData(person.Email, CombinePersonMergeFields(person, workflowMergeFields))); action.AddLogEntry(string.Format("Form notification sent to '{0}'", person.FullName)); } } if (action.Activity.AssignedGroupId.HasValue) { var personList = new GroupMemberService(rockContext).GetByGroupId(action.Activity.AssignedGroupId.Value) .Where(m => m.GroupMemberStatus == GroupMemberStatus.Active && m.Person.Email != "") .Select(m => m.Person) .ToList(); foreach (var person in personList) { recipients.Add(new RecipientData(person.Email, CombinePersonMergeFields(person, workflowMergeFields))); action.AddLogEntry(string.Format("Form notification sent to '{0}'", person.FullName)); } } if (recipients.Count > 0) { // The email may need to reference activity Id, so we need to save here. WorkflowService workflowService = new WorkflowService(rockContext); workflowService.PersistImmediately(action); var systemEmail = new SystemEmailService(rockContext).Get(action.ActionTypeCache.WorkflowForm.NotificationSystemEmailId.Value); if (systemEmail != null) { var emailMessage = new RockEmailMessage(systemEmail); emailMessage.SetRecipients(recipients); emailMessage.CreateCommunicationRecord = false; emailMessage.AppRoot = GlobalAttributesCache.Get().GetValue("InternalApplicationRoot") ?? string.Empty; emailMessage.Send(); } else { action.AddLogEntry("Could not find the selected notification system email", true); } } else { action.AddLogEntry("Could not send form notification due to no assigned person or group member not having email address", true); } } else { action.AddLogEntry("Could not send form notification due to no assigned person or group", true); } } return(false); }
/// <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>(); Dictionary <string, object> mergeFields = GetMergeFields(action); List <Metric> metricList = GetFromAttribute(action, "Metric", "MetricAttribute", MetricListConverter, new MetricListConverterData { MergeFields = mergeFields, MetricService = new MetricService(rockContext) }); MetricValueType?metricValueType = GetFromAttribute(action, "ValueType", "ValueTypeAttribute", EnumConverter <MetricValueType>, mergeFields); DateTime? metricValueDate = GetFromAttribute(action, "ValueDate", "ValueDateAttribute", DateConverter, mergeFields); string metricValueNote = GetFromAttribute(action, "ValueNote", "ValueNoteAttribute", StringConverter, mergeFields); var partitionsConfig = GetAttributeValue(action, "PartitionConfig") .ResolveMergeFields(mergeFields) .Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries) .Select(s => s.Split(':')) .Where(s => s.Length == 2) .Select(c => new { Label = c[0], Value = c[1].AsIntegerOrNull() }) .Where(c => c.Value != null) .ToList(); string mValStr = GetAttributeValue(action, "MetricValue"); if (Guid.TryParse(mValStr, out Guid mValGuid)) { mValStr = action.GetWorkflowAttributeValue(mValGuid); } decimal?metricValueValue = mValStr.ResolveMergeFields(mergeFields).AsDecimalOrNull(); if (metricList == null) { errorMessages.Add("No Metric(s) selected."); } if (metricValueType == null) { errorMessages.Add("No Value Type selected."); } if (metricValueDate == null) { errorMessages.Add("No Value Date selected."); } if (metricValueValue == null) { errorMessages.Add("No Value set."); } if (metricList == null || metricValueType == null || metricValueDate == null || metricValueValue == null || errorMessages.Any()) { errorMessages.ForEach(m => action.AddLogEntry(m, true)); return(false); } new MetricValueService(rockContext).AddRange(metricList.Select(m => new MetricValue { Metric = m, MetricValueDateTime = metricValueDate, MetricValueType = metricValueType.Value, Note = metricValueNote, YValue = metricValueValue, MetricValuePartitions = partitionsConfig .Select(p => new MetricValuePartition { EntityId = p.Value, MetricPartition = m.MetricPartitions.FirstOrDefault(mp => mp.Label == p.Label) }) .Where(mvp => mvp.MetricPartition != null).ToList() } )); rockContext.SaveChanges(); 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 mergeFields = GetMergeFields(action); // get benevolence request id var requestGuid = GetAttributeValue(action, "BenevolenceRequest", true).AsGuidOrNull(); if (!requestGuid.HasValue) { var errorMessage = "A valid benevolence request ID was not provided."; errorMessages.Add(errorMessage); action.AddLogEntry(errorMessage, true); return(false); } // get result summary var resultSummary = GetAttributeValue(action, "ResultSummary", true).ResolveMergeFields(mergeFields); // get next steps var nextSteps = GetAttributeValue(action, "NextSteps", true).ResolveMergeFields(mergeFields); // get result type var resultType = DefinedValueCache.Get(GetAttributeValue(action, "ResultType", true).AsGuid()); if (resultType == null) { var errorMessage = "A valid result type was not provided."; errorMessages.Add(errorMessage); action.AddLogEntry(errorMessage, true); return(false); } // get result details var resultDetails = GetAttributeValue(action, "ResultDetails", true).ResolveMergeFields(mergeFields); // get amount var amount = GetAttributeValue(action, "ResultAmount", true).AsDecimalOrNull(); if (!amount.HasValue) { var errorMessage = "A valid result amount was not provided."; errorMessages.Add(errorMessage); action.AddLogEntry(errorMessage, true); return(false); } // create benevolence request BenevolenceRequestService benevolenceRequestService = new BenevolenceRequestService(rockContext); BenevolenceRequest request = benevolenceRequestService.Get(requestGuid.Value); if (request == null) { var errorMessage = "The benevolence request provided could not be found."; errorMessages.Add(errorMessage); action.AddLogEntry(errorMessage, true); return(false); } if (nextSteps.IsNotNullOrWhiteSpace()) { request.ProvidedNextSteps = nextSteps; } if (resultSummary.IsNotNullOrWhiteSpace()) { request.ResultSummary = resultSummary; } BenevolenceResult result = new BenevolenceResult(); request.BenevolenceResults.Add(result); result.Amount = amount; result.ResultTypeValueId = resultType.Id; result.ResultSummary = resultDetails; rockContext.SaveChanges(); return(true); }
/// <summary> /// Executes the action. /// </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 now = RockDateTime.Now; // Save/Get the datetime this action was first activated var activatedDateTime = GetDateTimeActivated(action); // First check if number of minutes to delay int?minutes = GetAttributeValue(action, "MinutesToDelay").AsIntegerOrNull(); if (minutes.HasValue) { if (activatedDateTime.AddMinutes(minutes.Value).CompareTo(now) <= 0) { action.AddLogEntry(string.Format("{0:N0} Minute Delay Completed.", minutes.Value), true); return(true); } else { return(false); } } // Then check for specific date/time Guid dateAttributeGuid = GetAttributeValue(action, "DateInAttribute").AsGuid(); if (!dateAttributeGuid.IsEmpty()) { var attribute = AttributeCache.Read(dateAttributeGuid, rockContext); if (attribute != null) { DateTime?attributeDate = action.GetWorklowAttributeValue(dateAttributeGuid).AsDateTime(); if (attributeDate.HasValue) { if (attributeDate.Value.CompareTo(now) <= 0) { action.AddLogEntry(string.Format("Delay until {0} Completed.", attributeDate.Value), true); return(true); } else { return(false); } } } } // Finally check weekday int?dayOfTheWeek = GetAttributeValue(action, "NextWeekday").AsIntegerOrNull(); if (dayOfTheWeek.HasValue) { if ((int)now.DayOfWeek == dayOfTheWeek.Value) { action.AddLogEntry(string.Format("Delay until {0} Completed.", now.DayOfWeek.ConvertToString()), true); return(true); } else { return(false); } } // If delay has not elapsed, return false so that processing of activity stops return(false); }
/// <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>(); // Get the Person, Group and GroupRole from the attributes Person person = GetEntityFromWorkflowAttributes(action, "Person", "PersonAttribute", new PersonAliasService(rockContext))?.Person; Group group = GetEntityFromWorkflowAttributes(action, "Group", "GroupAttribute", new GroupService(rockContext)); GroupTypeRole groupRole = GetEntityFromWorkflowAttributes(action, "GroupRole", "GroupRoleAttribute", new GroupTypeRoleService(rockContext)) ?? group?.GroupType?.DefaultGroupRole; GroupMemberStatus?groupMemberStatus = null; Guid?groupMemberWorkflowAttributeAttribute = GetAttributeValue(action, "GroupMemberStatusAttribute").AsGuidOrNull(); if (groupMemberWorkflowAttributeAttribute.HasValue) { string groupMemberWorkflowAttribute = action.GetWorklowAttributeValue(groupMemberWorkflowAttributeAttribute.Value); if (!string.IsNullOrWhiteSpace(groupMemberWorkflowAttribute)) { if (Enum.TryParse(groupMemberWorkflowAttribute, true, out GroupMemberStatus groupMemberStatusOut)) { groupMemberStatus = groupMemberStatusOut; } } } if (groupMemberStatus == null) { string groupMemberAttribute = GetAttributeValue(action, "GroupMemberStatus"); if (!string.IsNullOrWhiteSpace(groupMemberAttribute)) { if (Enum.TryParse(groupMemberAttribute, true, out GroupMemberStatus groupMemberStatusOut)) { groupMemberStatus = groupMemberStatusOut; } } } if (person == null) { errorMessages.Add("Invalid Person."); } if (group == null) { errorMessages.Add("Invalid Group."); } if (groupRole == null) { errorMessages.Add("Invalid Group Role."); } if (person == null || group == null || groupRole == null || errorMessages.Any()) { errorMessages.ForEach(m => action.AddLogEntry(m, true)); return(false); } if (group.Members.Any(m => m.PersonId == person.Id && m.GroupRoleId == groupRole.Id)) { action.AddLogEntry("Skipping adding duplicate Group Member."); } else { var groupMember = new GroupMember { PersonId = person.Id, GroupId = group.Id, GroupRoleId = groupRole.Id, GroupMemberStatus = groupMemberStatus ?? GroupMemberStatus.Pending }; if (groupMember.IsValid) { new GroupMemberService(rockContext).Add(groupMember); rockContext.SaveChanges(); } else { // If the group member couldn't be added (for example, one of the group membership rules didn't pass), add the validation messages to the errormessages errorMessages.AddRange(groupMember.ValidationResults.Select(a => a.ErrorMessage)); } } errorMessages.ForEach(m => action.AddLogEntry(m, true)); 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>(); // Determine which group to add the person to Group group = null; int? groupRoleId = null; var guidGroupAttribute = GetAttributeValue(action, AttributeKey.GroupKey).AsGuidOrNull(); if (guidGroupAttribute.HasValue) { var attributeGroup = AttributeCache.Get(guidGroupAttribute.Value, rockContext); if (attributeGroup != null) { var groupGuid = action.GetWorkflowAttributeValue(guidGroupAttribute.Value).AsGuidOrNull(); if (groupGuid.HasValue) { group = new GroupService(rockContext).Get(groupGuid.Value); if (group != null) { // use the group's grouptype's default group role if a group role wasn't specified groupRoleId = GroupTypeCache.Get(group.GroupTypeId).DefaultGroupRoleId; } } } } if (group == null) { errorMessages.Add("No group was provided"); } else { // Check if this is a security group and show an error if that functionality has been disabled. var disableSecurityGroups = GetAttributeValue(action, AttributeKey.DisableSecurityGroups).AsBooleanOrNull() ?? false; if (group.IsSecurityRoleOrSecurityGroupType() && disableSecurityGroups) { errorMessages.Add($"\"{group.Name}\" is a Security group. The settings for this workflow action do not allow it to add a person to a security group."); } // If LimitToGroupsOfType has any values check if this Group's GroupType is in that list var limitToGroupsOfTypeGuid = GetAttributeValue(action, AttributeKey.LimitToGroupsOfType).AsGuidOrNull(); if (limitToGroupsOfTypeGuid.HasValue) { var limitToGroupType = GroupTypeCache.Get(limitToGroupsOfTypeGuid.Value); var limitToGroupTypeIds = new GroupTypeService(rockContext).GetChildGroupTypes(limitToGroupType.Id).Select(a => a.Id).ToList(); limitToGroupTypeIds.Add(limitToGroupType.Id); if (!limitToGroupTypeIds.Contains(group.GroupTypeId)) { errorMessages.Add($"The group type for group \"{group.Name} is \"{group.GroupType.Name}\". This action is configured to only add persons to groups of type \"{limitToGroupType.Name}\" and its child types."); } } // If LimitToGroupsUnderSpecificParentGroup has any values check if this Group is a child of that group var limitToChildGroupsOfGroupGuid = GetAttributeValue(action, AttributeKey.LimitToGroupsUnderSpecificParentGroup).AsGuidOrNull(); if (limitToChildGroupsOfGroupGuid.HasValue) { var groupService = new GroupService(rockContext); var limitToChildGroupsOfGroup = groupService.Get(limitToChildGroupsOfGroupGuid.Value); var limitToGroupIds = groupService.GetAllDescendentGroupIds(limitToChildGroupsOfGroup.Id, true); limitToGroupIds.Add(limitToChildGroupsOfGroup.Id); if (!limitToGroupIds.Contains(group.Id)) { errorMessages.Add($"Cannot add the person to group \"{group.Name}\". This workflow action is configured to only add persons to groups that are a descendant of Group {limitToChildGroupsOfGroup.Name}."); } } } if (!groupRoleId.HasValue) { errorMessages.Add("Provided group doesn't have a default group role"); } // determine the person that will be added to the group Person person = null; // get the Attribute.Guid for this workflow's Person Attribute so that we can lookup the value var guidPersonAttribute = GetAttributeValue(action, AttributeKey.PersonKey).AsGuidOrNull(); if (guidPersonAttribute.HasValue) { var attributePerson = AttributeCache.Get(guidPersonAttribute.Value, rockContext); if (attributePerson != null) { string attributePersonValue = action.GetWorkflowAttributeValue(guidPersonAttribute.Value); if (!string.IsNullOrWhiteSpace(attributePersonValue)) { if (attributePerson.FieldType.Class == typeof(Rock.Field.Types.PersonFieldType).FullName) { Guid personAliasGuid = attributePersonValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); } } else { errorMessages.Add("The attribute used to provide the person was not of type 'Person'."); } } } } if (person == null) { errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString())); } // Add Person to Group if (!errorMessages.Any()) { var groupMemberService = new GroupMemberService(rockContext); var groupMember = groupMemberService.GetByGroupIdAndPersonIdAndPreferredGroupRoleId(group.Id, person.Id, groupRoleId.Value); bool isNew = false; if (groupMember == null) { groupMember = new GroupMember(); groupMember.PersonId = person.Id; groupMember.GroupId = group.Id; isNew = true; } else { action.AddLogEntry($"{person.FullName} was already a member of the selected group.", true); } groupMember.GroupRoleId = groupRoleId.Value; groupMember.GroupMemberStatus = GroupMemberStatus.Active; if (groupMember.IsValidGroupMember(rockContext)) { if (isNew) { groupMemberService.Add(groupMember); } rockContext.SaveChanges(); } else { // if the group member couldn't be added (for example, one of the group membership rules didn't pass), add the validation messages to the errormessages errorMessages.AddRange(groupMember.ValidationResults.Select(a => a.ErrorMessage)); } } errorMessages.ForEach(m => action.AddLogEntry(m, true)); return(true); }
/// <summary> /// Gets either a delimited string of email addresses or a list of recipients from an attribute value. /// </summary> /// <param name="recipientType">The recipient type.</param> /// <param name="attributeValue">The attribute value.</param> /// <param name="action">The action.</param> /// <param name="mergeFields">The merge fields.</param> /// <param name="rockContext">The rock context.</param> /// <param name="delimitedEmails">The delimited emails.</param> /// <param name="recipientList">The recipient list.</param> /// <returns></returns> private bool GetEmailsFromAttributeValue(RecipientType recipientType, string attributeValue, WorkflowAction action, Dictionary <string, object> mergeFields, RockContext rockContext, out string delimitedEmails, out List <RockEmailMessageRecipient> recipientList) { delimitedEmails = null; recipientList = null; Guid?guid = attributeValue.AsGuidOrNull(); if (guid.HasValue) { var attribute = AttributeCache.Get(guid.Value, rockContext); if (attribute != null) { var recipientTypePrefix = string.Empty; var groupRoleAttributeKey = AttributeKey.GroupRole; switch (recipientType) { case RecipientType.CC: recipientTypePrefix = "CC "; break; case RecipientType.BCC: recipientTypePrefix = "BCC "; break; } string toValue = action.GetWorkflowAttributeValue(guid.Value); if (!string.IsNullOrWhiteSpace(toValue)) { switch (attribute.FieldType.Class) { case "Rock.Field.Types.TextFieldType": case "Rock.Field.Types.EmailFieldType": { delimitedEmails = toValue; return(true); } case "Rock.Field.Types.PersonFieldType": { Guid personAliasGuid = toValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { var person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); if (person == null) { action.AddLogEntry($"Invalid {recipientTypePrefix}Recipient: Person not found", true); } else if (string.IsNullOrWhiteSpace(person.Email)) { action.AddLogEntry($"{recipientTypePrefix}Email was not sent: Recipient does not have an email address", true); } else if (!person.IsEmailActive) { action.AddLogEntry($"{recipientTypePrefix}Email was not sent: Recipient email is not active", true); } else if (person.EmailPreference == EmailPreference.DoNotEmail) { action.AddLogEntry($"{recipientTypePrefix}Email was not sent: Recipient has requested 'Do Not Email'", true); } else { var personDict = new Dictionary <string, object>(mergeFields) { { "Person", person } }; recipientList = new List <RockEmailMessageRecipient> { new RockEmailMessageRecipient(person, personDict) }; return(true); } } return(false); } case "Rock.Field.Types.GroupFieldType": case "Rock.Field.Types.SecurityRoleFieldType": { int? groupId = toValue.AsIntegerOrNull(); Guid?groupGuid = toValue.AsGuidOrNull(); /* * 2020-03-25 - JPH * * Per Jon, even though the user may select a Group or Security Role Attribute for the CC and BCC * Attributes, we only want to allow Group Role filtering for the 'Send To Email Addresses' Attribute. * Otherwise, the UI starts to become too overwhelming for the end user making the selections. */ Guid?groupRoleValueGuid = recipientType == RecipientType.SendTo ? GetGroupRoleValueGuid(action, groupRoleAttributeKey) : null; IQueryable <GroupMember> qry = null; // Handle situations where the attribute value is the ID if (groupId.HasValue) { qry = new GroupMemberService(rockContext).GetByGroupId(groupId.Value); } else if (groupGuid.HasValue) { // Handle situations where the attribute value stored is the Guid qry = new GroupMemberService(rockContext).GetByGroupGuid(groupGuid.Value); } else { action.AddLogEntry($"Invalid {recipientTypePrefix}Recipient: No valid group id or Guid", true); } if (groupRoleValueGuid.HasValue) { qry = qry.Where(m => m.GroupRole != null && m.GroupRole.Guid.Equals(groupRoleValueGuid.Value)); } if (qry != null) { recipientList = new List <RockEmailMessageRecipient>(); foreach (var person in qry .Where(m => m.GroupMemberStatus == GroupMemberStatus.Active) .Select(m => m.Person)) { if (person.IsEmailActive && person.EmailPreference != EmailPreference.DoNotEmail && !string.IsNullOrWhiteSpace(person.Email)) { var personDict = new Dictionary <string, object>(mergeFields) { { "Person", person } }; recipientList.Add(new RockEmailMessageRecipient(person, personDict)); } } return(true); } return(false); } } } } } else if (!string.IsNullOrWhiteSpace(attributeValue)) { delimitedEmails = attributeValue; return(true); } return(false); }
public override bool Execute(RockContext rockContext, WorkflowAction action, object entity, out List <string> errorMessages) { errorMessages = new List <string>(); StringBuilder sbErrorMessages = new StringBuilder(); if (!action.IsNotNull()) { action.AddLogEntry("ReferenceValidation: Input (action) is null."); return(false); } int refCount = action.Activity.Workflow.GetAttributeValue("ReferenceCount").AsInteger(); int maxRef = action.Activity.Workflow.GetAttributeValue("ReferenceLimit").AsInteger(); string firstName = action.Activity.GetAttributeValue("Firstname"); string lastName = action.Activity.GetAttributeValue("Lastname"); string phoneNumber = action.Activity.GetAttributeValue("Phone"); string phoneType = action.Activity.GetAttributeValue("PhoneType"); string email = action.Activity.GetAttributeValue("Email"); Guid? addressGuid = action.Activity.GetAttributeValue("Address").AsGuidOrNull(); if (refCount < maxRef) { validateName(firstName, lastName, sbErrorMessages); validatePhone(phoneNumber, phoneType, sbErrorMessages); validateEmail(email, sbErrorMessages); validateRelationships(action, refCount, maxRef, sbErrorMessages); LocationService locationService = new LocationService(new RockContext()); Location location = locationService.Get(addressGuid.Value); if (addressGuid.HasValue && addressGuid != new Guid()) { validateAddress(location, sbErrorMessages); } else { sbErrorMessages.AppendLine("<li> A valid address is required.</li>"); } if (sbErrorMessages.Length == 0) { ContactInfo userInfo = new ContactInfo(); userInfo.name = formatName(firstName, lastName); userInfo.address = formatAddress(location); userInfo.phoneNumber = formatPhone(phoneNumber); userInfo.email = email.Trim(); //if this is the 1st successful entry, //store in the list for future comparison. if (refCount == 0) { Reference.Clear(); Reference.Add(userInfo); } else if (refCount > 0 && refCount < maxRef) { for (var i = 0; i < Reference.Count; i++) { string fieldCorrectionStr = ""; if (checkForDuplicates(Reference[i], userInfo, out fieldCorrectionStr)) { if (!String.IsNullOrEmpty(fieldCorrectionStr)) { string[] words = fieldCorrectionStr.Trim().Split(' '); foreach (var word in words) { sbErrorMessages.AppendFormat("<li>This reference's {0} matches that of reference {1}, Please correct.</li>", word.Trim(), i + 1); } } else { action.AddLogEntry("ReferenceValidation: CheckForDuplicates returns true, but correction string is empty."); } } } if (sbErrorMessages.Length == 0) { Reference.Add(userInfo); } } } } Guid ErMsg = GetActionAttributeValue(action, "ErrorMessages").AsGuid(); if (sbErrorMessages.Length > 0) { // If we get here, validation has failed SetWorkflowAttributeValue(action, ErMsg, sbErrorMessages.ToString()); action.AddLogEntry("ReferenceValidation: Validation failed"); return(reactivateCurrentActions(rockContext, action)); } // If we get here, validation was successful SetWorkflowAttributeValue(action, ErMsg, string.Empty); action.AddLogEntry("ReferenceValidation: Validation successful"); return(true); }