/// <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 AttributeValueCache();
attributeValue.Value = sb.ToString();
binaryFile.AttributeValues["MergeCodes"] = attributeValue;
binaryFile.SaveAttributeValues(rockContext);
}
return(true);
}
private DateTime GetDateTimeActivated(WorkflowAction action)
{
var dateActivated = RockDateTime.Now;
// Use the current action type' guid as the key for a 'Delay Activated' attribute
string AttrKey = action.ActionTypeCache.Guid.ToString();
// Check to see if the action's activity does not yet have the the 'Delay Activated' attribute.
// The first time this action runs on any workflow instance using this action instance, the
// attribute will not exist and need to be created
if (!action.Activity.Attributes.ContainsKey(AttrKey))
{
var attribute = new Rock.Model.Attribute();
attribute.EntityTypeId = action.Activity.TypeId;
attribute.EntityTypeQualifierColumn = "ActivityTypeId";
attribute.EntityTypeQualifierValue = action.Activity.ActivityTypeId.ToString();
attribute.Name = "Delay Activated";
attribute.Key = AttrKey;
attribute.FieldTypeId = FieldTypeCache.Read(Rock.SystemGuid.FieldType.TEXT.AsGuid()).Id;
// Need to save the attribute now (using different context) so that an attribute id is returned.
using (var newRockContext = new RockContext())
{
new AttributeService(newRockContext).Add(attribute);
newRockContext.SaveChanges();
AttributeCache.FlushEntityAttributes();
WorkflowActivityTypeCache.Flush(action.Activity.ActivityTypeId);
}
action.Activity.Attributes.Add(AttrKey, AttributeCache.Read(attribute));
var attributeValue = new AttributeValueCache();
attributeValue.AttributeId = attribute.Id;
attributeValue.Value = dateActivated.ToString("o");
action.Activity.AttributeValues.Add(AttrKey, attributeValue);
action.AddLogEntry(string.Format("Delay Activated at {0}", dateActivated), true);
}
else
{
// Check to see if this action instance has a value for the 'Delay Activated' attrbute
DateTime?activated = action.Activity.GetAttributeValue(AttrKey).AsDateTime();
if (activated.HasValue)
{
return(activated.Value);
}
else
{
// If no value exists, set the value to the current time
action.Activity.SetAttributeValue(AttrKey, dateActivated.ToString("o"));
action.AddLogEntry(string.Format("Delay Activated at {0}", dateActivated), true);
}
}
return(dateActivated);
}
private double HoursElapsed(WorkflowAction action)
{
// Use the current action type' guid as the key for a 'DateTime Sent' attribute
string AttrKey = action.ActionTypeCache.Guid.ToString() + "_DateTimeSent";
// Check to see if the action's activity does not yet have the the 'DateTime Sent' attribute.
// The first time this action runs on any workflow instance using this action instance, the
// attribute will not exist and need to be created
if (!action.Activity.Attributes.ContainsKey(AttrKey))
{
var attribute = new Rock.Model.Attribute();
attribute.EntityTypeId = action.Activity.TypeId;
attribute.EntityTypeQualifierColumn = "ActivityTypeId";
attribute.EntityTypeQualifierValue = action.Activity.ActivityTypeId.ToString();
attribute.Name = "DateTime Sent";
attribute.Key = AttrKey;
attribute.FieldTypeId = FieldTypeCache.Read(Rock.SystemGuid.FieldType.TEXT.AsGuid()).Id;
// Need to save the attribute now (using different context) so that an attribute id is returned.
using (var newRockContext = new RockContext())
{
new AttributeService(newRockContext).Add(attribute);
newRockContext.SaveChanges();
AttributeCache.FlushEntityAttributes();
WorkflowActivityTypeCache.Flush(action.Activity.ActivityTypeId);
}
action.Activity.Attributes.Add(AttrKey, AttributeCache.Read(attribute));
var attributeValue = new AttributeValueCache();
attributeValue.AttributeId = attribute.Id;
attributeValue.Value = RockDateTime.Now.ToString("o");
action.Activity.AttributeValues.Add(AttrKey, attributeValue);
}
else
{
// Check to see if this action instance has a value for the 'Delay Activated' attrbute
DateTime?dateSent = action.Activity.GetAttributeValue(AttrKey).AsDateTime();
if (dateSent.HasValue)
{
// If a value does exist, check to see if the number of minutes to delay has passed
// since the value was saved
return(RockDateTime.Now.Subtract(dateSent.Value).TotalHours);
}
else
{
// If no value exists, set the value to the current time
action.Activity.SetAttributeValue(AttrKey, RockDateTime.Now.ToString("o"));
}
}
return(0.0D);
}
private DateTime GetDateTimeActivated(WorkflowAction action)
{
var dateActivated = RockDateTime.Now;
string AttrKey = action.ActionTypeCache.Guid.ToString();
if (!action.Activity.Attributes.ContainsKey(AttrKey))
{
var attribute = new Rock.Model.Attribute
{
EntityTypeId = action.Activity.TypeId,
EntityTypeQualifierColumn = "ActivityTypeId",
EntityTypeQualifierValue = action.Activity.ActivityTypeId.ToString(),
Name = "Process Signature Activated",
Key = AttrKey,
FieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT.AsGuid()).Id
};
using (var newRockContext = new RockContext())
{
new AttributeService(newRockContext).Add(attribute);
newRockContext.SaveChanges();
}
action.Activity.Attributes.Add(AttrKey, AttributeCache.Get(attribute));
var attributeValue = new AttributeValueCache
{
AttributeId = attribute.Id,
Value = dateActivated.ToString("o")
};
action.Activity.AttributeValues.Add(AttrKey, attributeValue);
action.AddLogEntry(string.Format("Process Signature Activated at {0}", dateActivated), true);
}
else
{
DateTime?activated = action.Activity.GetAttributeValue(AttrKey).AsDateTime();
if (activated.HasValue)
{
return(activated.Value);
}
else
{
action.Activity.SetAttributeValue(AttrKey, dateActivated.ToString("o"));
action.AddLogEntry(string.Format("Process Signature Activated at {0}", dateActivated), true);
}
}
return(dateActivated);
}
public void AddEntityItemListToAttributeValueCache(string entityName, Guid entityID, List<AttributeValue> entityItemList)
{
var foundEntity = AttributeValueCacheList.SingleOrDefault(obj => obj.Name.ToLower() == entityName.ToLower());
if (foundEntity == null)
{
var attributeValueCache = new AttributeValueCache(entityName);
attributeValueCache.AddAttributeValues(entityID, entityItemList);
AttributeValueCacheList.Add(attributeValueCache);
}
else
{
foundEntity.AddAttributeValues(entityID, entityItemList);
}
}
/// <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);
}
if (binaryFile.Attributes == null)
{
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);
}
// looks up an attribute by it's handle, if none is found a new manaeged wrapper is created
// The factory as a Func<> allows for the constructor to remain private so that the only
// way to create an AttributeValue is via the containing context. This ensures that the
// proper ownership is maintained. (LLVM has no method of retrieving the context that owns an attribute)
internal AttributeValue GetAttributeFor(LLVMAttributeRef handle, Func <Context, LLVMAttributeRef, AttributeValue> factory)
{
if (handle.Pointer.IsNull( ))
{
return(default(AttributeValue));
}
if (AttributeValueCache.TryGetValue(handle.Pointer, out AttributeValue retVal))
{
return(retVal);
}
retVal = factory(this, handle);
AttributeValueCache.Add(handle.Pointer, retVal);
return(retVal);
}
private static AttributeValueCache GetGroupEBEventId(Group group)
{
AttributeValueCache retVar = null;
var ebFieldType = FieldTypeCache.Get(EBGuid.FieldType.EVENTBRITE_EVENT.AsGuid());
if (ebFieldType != null)
{
group.LoadAttributes();
var attribute = group.Attributes.Select(a => a.Value).FirstOrDefault(a => a.FieldTypeId == ebFieldType.Id);
if (attribute != null)
{
retVar = group.AttributeValues.Select(av => av.Value).FirstOrDefault(av => av.AttributeId == attribute.Id && av.Value != "");
}
}
return(retVar);
}
private string EmailStatus(WorkflowAction action)
{
// Use the current action type' guid as the key for a 'Email Status' attribute
string AttrKey = action.ActionTypeCache.Guid.ToString() + "_EmailStatus";
// Check to see if the action's activity does not yet have the the 'Email Status' attribute.
// The first time this action runs on any workflow instance using this action instance, the
// attribute will not exist and need to be created
if (!action.Activity.Attributes.ContainsKey(AttrKey))
{
var attribute = new Rock.Model.Attribute();
attribute.EntityTypeId = action.Activity.TypeId;
attribute.EntityTypeQualifierColumn = "ActivityTypeId";
attribute.EntityTypeQualifierValue = action.Activity.ActivityTypeId.ToString();
attribute.Name = "Email Status";
attribute.Key = AttrKey;
attribute.FieldTypeId = FieldTypeCache.Read(Rock.SystemGuid.FieldType.TEXT.AsGuid()).Id;
// Need to save the attribute now (using different context) so that an attribute id is returned.
using (var newRockContext = new RockContext())
{
new AttributeService(newRockContext).Add(attribute);
newRockContext.SaveChanges();
AttributeCache.FlushEntityAttributes();
WorkflowActivityTypeCache.Flush(action.Activity.ActivityTypeId);
}
action.Activity.Attributes.Add(AttrKey, AttributeCache.Read(attribute));
var attributeValue = new AttributeValueCache();
attributeValue.AttributeId = attribute.Id;
attributeValue.Value = string.Empty;
action.Activity.AttributeValues.Add(AttrKey, attributeValue);
}
else
{
return(action.Activity.GetAttributeValue(AttrKey));
}
return(string.Empty);
}
/// <summary>
/// Converts an Attribute Value to a view model that can be sent to the client.
/// </summary>
/// <param name="attributeValue">The attribute value.</param>
/// <returns>A <see cref="ClientAttributeValueViewModel"/> instance.</returns>
/// <remarks>Internal until this is moved to a permanent location.</remarks>
internal static ClientAttributeValueViewModel ToClientAttributeValue(AttributeValueCache attributeValue)
{
var attribute = AttributeCache.Get(attributeValue.AttributeId);
var fieldType = _fieldTypes.GetOrAdd(attribute.FieldType.Guid, GetFieldType);
return(new ClientAttributeValueViewModel
{
FieldTypeGuid = attribute.FieldType.Guid,
AttributeGuid = attribute.Guid,
Name = attributeValue.AttributeName,
Categories = attribute.Categories.Select(c => new ClientAttributeValueCategoryViewModel
{
Guid = c.Guid,
Name = c.Name,
Order = c.Order
}).ToList(),
Order = attribute.Order,
TextValue = fieldType.GetTextValue(attributeValue.Value, attribute.ConfigurationValues),
Value = fieldType.GetClientValue(attributeValue.Value, attribute.ConfigurationValues)
});
}
/// <summary>
/// Converts an Attribute Value to a view model that can be sent to a
/// public device for the purpose of viewing the value.
/// </summary>
/// <param name="attributeValue">The attribute value.</param>
/// <returns>A <see cref="PublicAttributeViewModel"/> instance that contains details about the attribute but not the value.</returns>
internal static PublicAttributeViewModel GetPublicAttributeForView(AttributeValueCache attributeValue)
{
var attribute = AttributeCache.Get(attributeValue.AttributeId);
return(GetPublicAttributeForView(attribute, attributeValue.Value));
}
/// <summary>
/// Converts an Attribute Value to a view model that can be sent to the client.
/// </summary>
/// <param name="attributeValue">The attribute value.</param>
/// <returns>A <see cref="ClientEditableAttributeValueViewModel"/> instance.</returns>
/// <remarks>Internal until this is moved to a permanent location.</remarks>
internal static ClientEditableAttributeValueViewModel ToClientEditableAttributeValue(AttributeValueCache attributeValue)
{
var attribute = AttributeCache.Get(attributeValue.AttributeId);
return(ToClientEditableAttributeValue(attribute, attributeValue.Value));
}
/// <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>();
// Get the number of minutes to delay
int?minutes = GetAttributeValue(action, "MinutesToDelay").AsIntegerOrNull();
if (!minutes.HasValue || minutes.Value <= 0)
{
return(true);
}
// Use the current action type' guid as the key for a 'Delay Activated' attribute
string AttrKey = action.ActionType.Guid.ToString();
// Check to see if the action's activity does not yet have the the 'Delay Activated' attribute.
// The first time this action runs on any workflow instance using this action instance, the
// attribute will not exist and need to be created
if (!action.Activity.Attributes.ContainsKey(AttrKey))
{
var attribute = new Rock.Model.Attribute();
attribute.EntityTypeId = action.Activity.TypeId;
attribute.EntityTypeQualifierColumn = "ActivityTypeId";
attribute.EntityTypeQualifierValue = action.Activity.ActivityTypeId.ToString();
attribute.Name = "Delay Activated";
attribute.Key = AttrKey;
attribute.FieldTypeId = FieldTypeCache.Read(Rock.SystemGuid.FieldType.TEXT.AsGuid()).Id;
// Need to save the attribute now (using different context) so that an attribute id is returned.
var newRockContext = new RockContext();
new AttributeService(newRockContext).Add(attribute);
newRockContext.SaveChanges();
action.Activity.Attributes.Add(AttrKey, AttributeCache.Read(attribute));
var attributeValue = new AttributeValueCache();
attributeValue.AttributeId = attribute.Id;
attributeValue.Value = RockDateTime.Now.ToString("o");
action.Activity.AttributeValues.Add(AttrKey, attributeValue);
action.AddLogEntry(string.Format("{0:N0} Minute Delay Activated.", minutes.Value), true);
}
else
{
// Check to see if this action instance has a value for the 'Delay Activated' attrbute
DateTime?activated = action.Activity.GetAttributeValue(AttrKey).AsDateTime();
if (!activated.HasValue)
{
// If no value exists, set the value to the current time
action.Activity.SetAttributeValue(AttrKey, RockDateTime.Now.ToString("o"));
action.AddLogEntry(string.Format("{0:N0} Minute Delay Activated.", minutes.Value), true);
}
else
{
// If a value does exist, check to see if the number of minutes to delay has passed
// since the value was saved
if (activated.Value.AddMinutes(minutes.Value).CompareTo(RockDateTime.Now) < 0)
{
// If delay has elapsed, return True ( so that processing of activity will continue )
action.AddLogEntry(string.Format("{0:N0} Minute Delay Completed.", minutes.Value), true);
return(true);
}
}
}
// If delay has not elapsed, return false so that processing of activity stops
return(false);
}
/// <summary>
/// Get the next person for the action and group.
/// </summary>
/// <param name="action">The action that needs the next round robin person picked.</param>
/// <param name="groupId">The identifier of the group to load the next person from.</param>
/// <returns>A person object that represents the next person in the round robin selection process.</returns>
private Person GetNextPerson(WorkflowAction action, int groupId)
{
Person person = null;
//
// Lock so that only one thread can do this at a time. This is to ensure that
// we don't have two workflows processing at the same time and trying to get
// the next person in the round robin and overwriting each others changes.
//
lock ( _lockObject )
{
var attrKey = action.ActionType.Guid.ToString();
//
// Load attributes if we need to.
//
if (action.Activity.Workflow.WorkflowType.Attributes == null)
{
action.Activity.Workflow.WorkflowType.LoadAttributes();
}
//
// Check if we already have an attribute.
//
if (!action.Activity.Workflow.WorkflowType.Attributes.ContainsKey(attrKey))
{
var attribute = new Rock.Model.Attribute
{
EntityTypeId = action.Activity.Workflow.WorkflowType.TypeId,
Name = string.Format("Last Round Robin Person ({0})", action.ActionType.Name),
Key = attrKey,
FieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT.AsGuid()).Id
};
using (var newRockContext = new RockContext())
{
new AttributeService(newRockContext).Add(attribute);
newRockContext.SaveChanges();
AttributeCache.RemoveEntityAttributes();
}
action.Activity.Workflow.WorkflowType.Attributes.Add(attrKey, AttributeCache.Get(attribute));
var attributeValue = new AttributeValueCache
{
AttributeId = attribute.Id,
Value = string.Empty
};
action.Activity.Workflow.WorkflowType.AttributeValues.Add(attrKey, attributeValue);
}
//
// Get the last person selected.
//
var lastPersonId = action.Activity.Workflow.WorkflowType.GetAttributeValue(attrKey).AsIntegerOrNull();
var rockContext = new RockContext();
//
// Get the list of group members to pick from.
//
var groupMemberService = new GroupMemberService(rockContext);
var statuses = this.GetAttributeValue(action, "GroupMemberStatus")
.SplitDelimitedValues()
.Select(s => ( GroupMemberStatus )Enum.Parse(typeof(GroupMemberStatus), s))
.ToList();
var groupMembers = groupMemberService.Queryable()
.Where(m => m.GroupId == groupId && statuses.Contains(m.GroupMemberStatus))
.DistinctBy(m => m.PersonId)
.OrderBy(m => m.Person.LastName)
.ThenBy(m => m.Person.FirstName)
.ToList();
//
// Filter by the group role.
//
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();
}
//
// Find the next person.
//
if (groupMembers.Count > 0)
{
int lastMemberIndex = -1;
//
// Find the index of the last person picked.
//
if (lastPersonId.HasValue)
{
var lastMember = groupMembers
.Where(m => !lastPersonId.HasValue || m.PersonId == lastPersonId)
.FirstOrDefault();
if (lastMember != null)
{
lastMemberIndex = groupMembers.IndexOf(lastMember);
}
}
//
// Pick either the next or the first person.
//
if (lastMemberIndex < 0 || (lastMemberIndex + 1) >= groupMembers.Count)
{
person = groupMembers.First().Person;
}
else
{
person = groupMembers[lastMemberIndex + 1].Person;
}
}
//
// Update the attribute value.
//
action.Activity.Workflow.WorkflowType.SetAttributeValue(attrKey, person != null ? person.Id.ToString() : string.Empty);
action.Activity.Workflow.WorkflowType.SaveAttributeValues(rockContext);
}
return(person);
}
public void AddEntityItemToAttributeValueCache(string entityName, AttributeValue entityItem)
{
var foundEntity = AttributeValueCacheList.SingleOrDefault(obj => obj.Name.ToLower() == entityName.ToLower());
if (foundEntity == null)
{
var attributeValueCache = new AttributeValueCache(entityName);
var avList = new List<AttributeValue>();
avList.Add(entityItem);
attributeValueCache.AddAttributeValues(entityItem.EntityID, avList);
//attributeValueCache.AddAttribute(entityItem);
AttributeValueCacheList.Add(attributeValueCache);
}
else
{
var avList = new List<AttributeValue>();
avList.Add(entityItem);
foundEntity.AddAttributeValues(entityItem.EntityID, avList);
//foundEntity.AddAttribute(entityItem);
}
}
private void SetSpecialAttribute(SpecialAttribute special)
{
_specAttr = special;
if (State.Attribute == _currentState)
_currentState = State.SpecialAttr;
else if (State.RootLevelAttr == _currentState)
_currentState = State.RootLevelSpecAttr;
else
Debug.Assert(false, "State.Attribute == currentState || State.RootLevelAttr == currentState");
if (_attrValueCache == null)
{
_attrValueCache = new AttributeValueCache();
}
}
private void SetSpecialAttribute(SpecialAttribute special)
{
this.specAttr = special;
if (State.Attribute == this.currentState)
{
this.currentState = State.SpecialAttr;
}
else if (State.RootLevelAttr == this.currentState)
{
this.currentState = State.RootLevelSpecAttr;
}
if (this.attrValueCache == null)
{
this.attrValueCache = new AttributeValueCache();
}
}
