/// <summary>
/// Handles the Add actions event.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void gFilters_Add(object sender, EventArgs e)
{
var rockContext = new RockContext();
var attributeService = new AttributeService(rockContext);
// Reset attribute editor fields.
edtFilter.Name = string.Empty;
edtFilter.Key = string.Empty;
edtFilter.AbbreviatedName = "";
Rock.Model.Attribute attribute = new Rock.Model.Attribute();
// Set attribute fields to those from a new attribute to made sure the AttributeEditor / ViewState has no leftover values.
edtFilter.AttributeGuid = attribute.Guid;
edtFilter.AttributeId = attribute.Id;
edtFilter.IsFieldTypeEditable = true;
edtFilter.SetAttributeFieldType(FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT).Id, null);
edtFilter.ReservedKeyNames = AttributeCache.AllForEntityType(_blockTypeEntityId)
.Where(a =>
a.EntityTypeQualifierColumn == "Id" &&
a.EntityTypeQualifierValue == _block.Id.ToString())
.Select(a => a.Key)
.Distinct()
.ToList();
mdFilter.Title = "Add Filter";
mdFilter.Show();
}
/// <summary>
/// Gs the defined type attributes_ show edit.
/// </summary>
/// <param name="attributeGuid">The attribute GUID.</param>
protected void gDefinedTypeAttributes_ShowEdit(Guid attributeGuid)
{
pnlDetails.Visible = false;
vsDetails.Enabled = false;
pnlDefinedTypeAttributes.Visible = true;
Attribute attribute;
if (attributeGuid.Equals(Guid.Empty))
{
attribute = new Attribute();
attribute.FieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT).Id;
edtDefinedTypeAttributes.ActionTitle = ActionTitle.Add("attribute for defined type " + tbTypeName.Text);
}
else
{
AttributeService attributeService = new AttributeService(new RockContext());
attribute = attributeService.Get(attributeGuid);
edtDefinedTypeAttributes.ActionTitle = ActionTitle.Edit("attribute for defined type " + tbTypeName.Text);
}
edtDefinedTypeAttributes.ReservedKeyNames = new AttributeService(new RockContext())
.GetByEntityTypeId(new DefinedValue().TypeId, true).AsQueryable()
.Where(a =>
a.EntityTypeQualifierColumn.Equals("DefinedTypeId", StringComparison.OrdinalIgnoreCase) &&
a.EntityTypeQualifierValue.Equals(hfDefinedTypeId.Value) &&
!a.Guid.Equals(attributeGuid))
.Select(a => a.Key)
.Distinct()
.ToList();
edtDefinedTypeAttributes.SetAttributeProperties(attribute, typeof(DefinedValue));
this.HideSecondaryBlocks(true);
}
/// <summary>
/// Determines whether this instance can delete the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="checkAttributeUsage">if set to <c>true</c> [check attribute usage].</param>
/// <param name="errorMessage">The error message.</param>
/// <returns>
/// <c>true</c> if this instance can delete the specified item; otherwise, <c>false</c>.
/// </returns>
public bool CanDelete(AttributeMatrixTemplate item, bool checkAttributeUsage, out string errorMessage)
{
if (!this.CanDelete(item, out errorMessage))
{
return(false);
}
else
{
if (checkAttributeUsage)
{
// check if any MatrixAttributes are using this AttributeMatrixTemplate
var matrixFieldTypeId = FieldTypeCache.Get <MatrixFieldType>().Id;
var qualifierKey = MatrixFieldType.ATTRIBUTE_MATRIX_TEMPLATE;
var qualifierValue = item.Id.ToString();
var usedAsMatrixTemplate = new AttributeService(new RockContext()).Queryable()
.Where(a => a.FieldTypeId == matrixFieldTypeId)
.Any(a => a.AttributeQualifiers.Any(q => q.Key == qualifierKey && q.Value == qualifierValue));
if (usedAsMatrixTemplate)
{
errorMessage = string.Format("This {0} is assigned to an {1}.", AttributeMatrixTemplate.FriendlyTypeName, Rock.Model.Attribute.FriendlyTypeName);
return(false);
}
}
}
return(true);
}
public IQueryable <ContentChannelItem> GetFromPersonDataView(string guids)
{
RockContext rockContext = new RockContext();
// Turn the comma separated list of guids into a list of strings.
List <string> guidList = (guids ?? "").Split(',').ToList();
// Get the Id of the Rock.Model.ContentChannelItem Entity.
int contentChannelItemEntityTypeId = EntityTypeCache.Get("Rock.Model.ContentChannelItem").Id;
// Get the Field Type (Attribute Type) Id of the Data View Field Type.
int fieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.DATAVIEWS.AsGuid()).Id;
// Get the list of attributes that are of the Rock.Model.ContentChannelItem entity type
// and that are of the Data View field type.
List <int> attributeIdList = new AttributeService(rockContext)
.GetByEntityTypeId(contentChannelItemEntityTypeId)
.Where(item => item.FieldTypeId == fieldTypeId)
.Select(a => a.Id)
.ToList();
// I want a list of content channel items whose ids match up to attribute values that represent entity ids
IQueryable <ContentChannelItem> contentChannelItemList = new ContentChannelItemService(rockContext)
.Queryable()
.WhereAttributeValue(rockContext, av => attributeIdList.Contains(av.AttributeId) && guidList.Contains(av.Value));
// Return this list
return(contentChannelItemList);
}
/// <summary>
/// gs the item attributes show edit.
/// </summary>
/// <param name="attributeGuid">The attribute unique identifier.</param>
protected void gItemAttributes_ShowEdit(Guid attributeGuid)
{
Attribute attribute;
if (attributeGuid.Equals(Guid.Empty))
{
attribute = new Attribute();
attribute.FieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT).Id;
edtItemAttributes.ActionTitle = ActionTitle.Add(tbName.Text + " Item Attribute");
}
else
{
attribute = ItemAttributesState.First(a => a.Guid.Equals(attributeGuid));
edtItemAttributes.ActionTitle = ActionTitle.Edit(tbName.Text + " Item Attribute");
}
List <string> reservedKeys = ItemAttributesState.Where(a => !a.Guid.Equals(attributeGuid)).Select(a => a.Key).ToList();
reservedKeys.AddRange(ItemInheritedKey);
edtItemAttributes.ReservedKeyNames = reservedKeys;
edtItemAttributes.SetAttributeProperties(attribute, typeof(ContentChannelItem));
edtItemAttributes.IsIndexingEnabledVisible = cbIndexChannel.Visible && cbIndexChannel.Checked;
ShowDialog("ItemAttributes", true);
}
/// <summary>
/// gs the page attributes show edit.
/// </summary>
/// <param name="attributeGuid">The attribute unique identifier.</param>
protected void gPageAttributes_ShowEdit(Guid attributeGuid)
{
Attribute attribute;
if (attributeGuid.Equals(Guid.Empty))
{
attribute = new Attribute();
attribute.FieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT).Id;
edtPageAttributes.ActionTitle = ActionTitle.Add("attribute for pages of site " + tbSiteName.Text);
}
else
{
attribute = PageAttributesState.First(a => a.Guid.Equals(attributeGuid));
edtPageAttributes.ActionTitle = ActionTitle.Edit("attribute for pages of site " + tbSiteName.Text);
}
var reservedKeyNames = new List <string>();
PageAttributesState.Where(a => !a.Guid.Equals(attributeGuid)).Select(a => a.Key).ToList().ForEach(a => reservedKeyNames.Add(a));
edtPageAttributes.ReservedKeyNames = reservedKeyNames.ToList();
edtPageAttributes.SetAttributeProperties(attribute, typeof(Rock.Model.Page));
dlgPageAttribute.Show();
HideSecondaryBlocks(true);
}
/// <summary>
/// Sets the entity field from field type attribute.
/// </summary>
/// <param name="entityField">The entity field.</param>
/// <param name="fieldTypeAttribute">The field type attribute.</param>
/// <returns></returns>
private static bool SetEntityFieldFromFieldTypeAttribute(EntityField entityField, FieldTypeAttribute fieldTypeAttribute)
{
if (fieldTypeAttribute != null)
{
var fieldTypeCache = FieldTypeCache.Get(fieldTypeAttribute.FieldTypeGuid);
if (fieldTypeCache != null && fieldTypeCache.Field != null)
{
if (fieldTypeCache.Field.HasFilterControl())
{
if (entityField.Title.EndsWith(" Id"))
{
entityField.Title = entityField.Title.ReplaceLastOccurrence(" Id", string.Empty);
}
entityField.FieldType = fieldTypeCache;
if (fieldTypeAttribute.ConfigurationKey != null && fieldTypeAttribute.ConfigurationValue != null)
{
entityField.FieldConfig.Add(fieldTypeAttribute.ConfigurationKey, new ConfigurationValue(fieldTypeAttribute.ConfigurationValue));
}
return(true);
}
}
}
return(false);
}
/// <summary>
/// Creates a <see cref="Rock.Field.FieldVisibilityRule"/>
/// object from its view model representation.
/// </summary>
/// <param name="viewModel">The view model that represents the object.</param>
/// <returns>The object created from the view model.</returns>
internal static Rock.Field.FieldVisibilityRule FromViewModel(this FieldFilterRuleViewModel viewModel, List <FormFieldViewModel> formFields)
{
var rule = new Rock.Field.FieldVisibilityRule
{
Guid = viewModel.Guid,
ComparisonType = ( ComparisonType )viewModel.ComparisonType,
ComparedToFormFieldGuid = viewModel.AttributeGuid,
ComparedToValue = viewModel.Value
};
if (rule.ComparedToFormFieldGuid.HasValue)
{
var comparisonValue = new Rock.Reporting.ComparisonValue
{
ComparisonType = rule.ComparisonType,
Value = rule.ComparedToValue
};
var field = formFields.Where(f => f.Guid == rule.ComparedToFormFieldGuid.Value).FirstOrDefault();
if (field != null)
{
var fieldType = FieldTypeCache.Get(field.FieldTypeGuid);
if (fieldType?.Field != null)
{
var privateConfigurationValues = fieldType.Field.GetPrivateConfigurationValues(field.ConfigurationValues);
var filterValues = fieldType.Field.GetPrivateFilterValue(comparisonValue, privateConfigurationValues).FromJsonOrNull <List <string> >();
if (filterValues != null && filterValues.Count == 2)
{
rule.ComparedToValue = filterValues[1];
}
else if (filterValues != null && filterValues.Count == 1)
{
rule.ComparedToValue = filterValues[0];
}
}
}
else
{
var attribute = AttributeCache.Get(rule.ComparedToFormFieldGuid.Value);
if (attribute?.FieldType?.Field != null)
{
var filterValues = attribute.FieldType.Field.GetPrivateFilterValue(comparisonValue, attribute.ConfigurationValues).FromJsonOrNull <List <string> >();
if (filterValues != null && filterValues.Count == 2)
{
rule.ComparedToValue = filterValues[1];
}
else if (filterValues != null && filterValues.Count == 1)
{
rule.ComparedToValue = filterValues[0];
}
}
}
}
return(rule);
}
/// <summary>
/// Gs the group type attributes_ show edit.
/// </summary>
/// <param name="attributeGuid">The attribute GUID.</param>
protected void gAttributes_ShowEdit(Guid attributeGuid)
{
Attribute attribute;
if (attributeGuid.Equals(Guid.Empty))
{
attribute = new Attribute();
attribute.FieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT).Id;
edtAttributes.ActionTitle = ActionTitle.Add("attribute for matrix attributes that use matrix template " + tbName.Text);
}
else
{
attribute = AttributesState.First(a => a.Guid.Equals(attributeGuid));
edtAttributes.ActionTitle = ActionTitle.Edit("attribute for matrix attributes that use matrix template " + tbName.Text);
}
var reservedKeyNames = new List <string>();
AttributesState.Where(a => !a.Guid.Equals(attributeGuid)).Select(a => a.Key).ToList().ForEach(a => reservedKeyNames.Add(a));
edtAttributes.ReservedKeyNames = reservedKeyNames.ToList();
edtAttributes.ExcludedFieldTypes = new FieldTypeCache[] { FieldTypeCache.Get <MatrixFieldType>() };
edtAttributes.SetAttributeProperties(attribute, typeof(AttributeMatrixTemplate));
dlgAttribute.Show();
}
/// <summary>
/// gs the item attributes show edit.
/// </summary>
/// <param name="attributeGuid">The attribute unique identifier.</param>
protected void gItemAttributes_ShowEdit(Guid attributeGuid)
{
Attribute attribute;
if (attributeGuid.Equals(Guid.Empty))
{
attribute = new Attribute();
attribute.FieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT).Id;
edtItemAttributes.ActionTitle = ActionTitle.Add(tbName.Text + " Item Attribute");
}
else
{
attribute = ItemAttributesState.First(a => a.Guid.Equals(attributeGuid));
edtItemAttributes.ActionTitle = ActionTitle.Edit(tbName.Text + " Item Attribute");
}
edtItemAttributes.ReservedKeyNames = ItemAttributesState.Where(a => !a.Guid.Equals(attributeGuid)).Select(a => a.Key).ToList();
edtItemAttributes.SetAttributeProperties(attribute, typeof(ContentChannelItem));
// always enable the display of the indexing option as the channel decides whether or not to index not the type
edtItemAttributes.IsIndexingEnabledVisible = true;
ShowDialog("ItemAttributes", true);
}
/// <summary>
/// Gets the attribute value.
/// </summary>
/// <param name="action">The action.</param>
/// <param name="key">The key.</param>
/// <param name="checkWorkflowAttributeValue">if set to <c>true</c> and the returned value is a guid, check to see if the workflow
/// or activity contains an attribute with that guid. This is useful when using the WorkflowTextOrAttribute field types to get the
/// actual value or workflow value.</param>
/// <returns></returns>
protected string GetAttributeValue(WorkflowAction action, string key, bool checkWorkflowAttributeValue)
{
string value = GetActionAttributeValue(action, key);
if (checkWorkflowAttributeValue)
{
Guid?attributeGuid = value.AsGuidOrNull();
if (attributeGuid.HasValue)
{
var attribute = AttributeCache.Get(attributeGuid.Value);
if (attribute != null)
{
value = action.GetWorklowAttributeValue(attributeGuid.Value);
if (!string.IsNullOrWhiteSpace(value))
{
if (attribute.FieldTypeId == FieldTypeCache.Get(SystemGuid.FieldType.ENCRYPTED_TEXT.AsGuid()).Id)
{
value = Security.Encryption.DecryptString(value);
}
else if (attribute.FieldTypeId == FieldTypeCache.Get(SystemGuid.FieldType.SSN.AsGuid()).Id)
{
value = Rock.Field.Types.SSNFieldType.UnencryptAndClean(value);
}
}
}
}
}
return(value);
}
/// <summary>
/// Sets the form.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="workflowTypeAttributes">The workflow type attributes.</param>
public void SetForm(WorkflowActionForm value, Dictionary <Guid, Rock.Model.Attribute> workflowTypeAttributes)
{
EnsureChildControls();
if (value != null)
{
_hfFormGuid.Value = value.Guid.ToString();
_ddlNotificationSystemEmail.SetValue(value.NotificationSystemEmailId);
_cbIncludeActions.Checked = value.IncludeActionsInNotification;
_ceHeaderText.Text = value.Header;
_ceFooterText.Text = value.Footer;
_falActions.Value = value.Actions;
_cbAllowNotes.Checked = value.AllowNotes.HasValue && value.AllowNotes.Value;
// Remove any existing rows (shouldn't be any)
foreach (var attributeRow in Controls.OfType <WorkflowFormAttributeRow>())
{
Controls.Remove(attributeRow);
}
foreach (var formAttribute in value.FormAttributes.OrderBy(a => a.Order))
{
var row = new WorkflowFormAttributeRow();
row.AttributeGuid = formAttribute.Attribute.Guid;
row.AttributeName = formAttribute.Attribute.Name;
row.Guid = formAttribute.Guid;
row.IsVisible = formAttribute.IsVisible;
row.IsEditable = !formAttribute.IsReadOnly;
row.IsRequired = formAttribute.IsRequired;
row.HideLabel = formAttribute.HideLabel;
row.PreHtml = formAttribute.PreHtml;
row.PostHtml = formAttribute.PostHtml;
Controls.Add(row);
}
_ddlActionAttribute.Items.Clear();
_ddlActionAttribute.Items.Add(new ListItem());
foreach (var attributeItem in workflowTypeAttributes)
{
var fieldType = FieldTypeCache.Get(attributeItem.Value.FieldTypeId);
if (fieldType != null && fieldType.Field is Rock.Field.Types.TextFieldType)
{
var li = new ListItem(attributeItem.Value.Name, attributeItem.Key.ToString());
li.Selected = value.ActionAttributeGuid.HasValue && value.ActionAttributeGuid.Value.ToString() == li.Value;
_ddlActionAttribute.Items.Add(li);
}
}
}
else
{
_hfFormGuid.Value = string.Empty;
_ddlNotificationSystemEmail.SelectedIndex = 0;
_cbIncludeActions.Checked = true;
_ceHeaderText.Text = string.Empty;
_ceFooterText.Text = string.Empty;
_falActions.Value = "Submit^^^Your information has been submitted successfully.";
_ddlNotificationSystemEmail.SelectedIndex = 0;
_cbAllowNotes.Checked = false;
}
}
/// <summary>
/// Sets the value.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="value">The value.</param>
public static void SetValue(string key, string value)
{
var rockContext = new Rock.Data.RockContext();
var attributeService = new AttributeService(rockContext);
var attribute = attributeService.GetSystemSetting(key);
if (attribute == null)
{
attribute = new Rock.Model.Attribute();
attribute.FieldTypeId = FieldTypeCache.Get(new Guid(SystemGuid.FieldType.TEXT)).Id;
attribute.EntityTypeQualifierColumn = Rock.Model.Attribute.SYSTEM_SETTING_QUALIFIER;
attribute.EntityTypeQualifierValue = string.Empty;
attribute.Key = key;
attribute.Name = key.SplitCase();
attribute.DefaultValue = value;
attributeService.Add(attribute);
}
else
{
attribute.DefaultValue = value;
}
// NOTE: Service Layer will automatically update this Cache (see Attribute.cs UpdateCache)
rockContext.SaveChanges();
if (key == Rock.SystemKey.SystemSetting.START_DAY_OF_WEEK)
{
RockDateTime.FirstDayOfWeek = value.ConvertToEnumOrNull <DayOfWeek>() ?? RockDateTime.DefaultFirstDayOfWeek;
}
}
/// <summary>
/// Creates the control(s) necessary for prompting user for a new value
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="id"></param>
/// <returns>
/// The control
/// </returns>
public override Control EditControl(Dictionary <string, ConfigurationValue> configurationValues, string id)
{
var filteredFieldTypes = new List <string>();
if (configurationValues != null &&
configurationValues.ContainsKey(ATTRIBUTE_FIELD_TYPES_KEY))
{
filteredFieldTypes = configurationValues[ATTRIBUTE_FIELD_TYPES_KEY].Value
.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).ToList();
}
var editControl = new Rock.Web.UI.Controls.RockDropDownList {
ID = id
};
editControl.Items.Add(new ListItem());
var attributes = GetContextAttributes();
if (attributes != null)
{
foreach (var attribute in attributes)
{
var fieldType = FieldTypeCache.Get(attribute.Value.FieldTypeId);
if (!filteredFieldTypes.Any() || filteredFieldTypes.Contains(fieldType.Class, StringComparer.OrdinalIgnoreCase))
{
editControl.Items.Add(new ListItem(attribute.Value.Name, attribute.Key.ToString()));
}
}
}
return(editControl);
}
private void LoadRockGroup(Group group)
{
_rockGroup = group;
_rockGroupId = _rockGroup.Id;
var ebFieldType = FieldTypeCache.Get(rocks.kfs.Eventbrite.EBGuid.FieldType.EVENTBRITE_EVENT.AsGuid());
if (ebFieldType != null)
{
_rockGroup.LoadAttributes(_rockContext);
var attribute = _rockGroup.Attributes.Select(a => a.Value).FirstOrDefault(a => a.FieldTypeId == ebFieldType.Id);
if (attribute != null)
{
var attributeVal = _rockGroup.AttributeValues.Select(av => av.Value).FirstOrDefault(av => av.AttributeId == attribute.Id && av.Value != "");
if (attributeVal != null)
{
var splitVal = attributeVal.Value.SplitDelimitedValues("^");
if (splitVal.Length > 0)
{
_evntId = splitVal[0].AsLong();
}
if (splitVal.Length > 1)
{
_synced = splitVal[1];
}
}
}
}
}
/// <summary>
/// Sets the workflow RequestStatus attribute.
/// </summary>
/// <param name="workflow">The workflow.</param>
/// <param name="rockContext">The rock context.</param>
/// <param name="requestStatus">The request status.</param>
private void UpdateWorkflowRequestStatus(Model.Workflow workflow, RockContext rockContext, string requestStatus)
{
if (SaveAttributeValue(workflow, "RequestStatus", requestStatus,
FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT.AsGuid()), rockContext, null))
{
rockContext.SaveChanges();
}
}
/// <summary>
/// Displays the edit list.
/// </summary>
private void DisplayEditList()
{
lEditHeader.Text = GetAttributeValue("EditHeader");
lEditFooter.Text = GetAttributeValue("EditFooter");
if (_definedType != null)
{
using (var rockContext = new RockContext())
{
var entityType = EntityTypeCache.Get("Rock.Model.DefinedValue");
var definedType = new DefinedTypeService(rockContext).Get(_definedType.Id);
if (definedType != null && entityType != null)
{
var attributeService = new AttributeService(rockContext);
var attributes = new AttributeService(rockContext)
.GetByEntityTypeQualifier(entityType.Id, "DefinedTypeId", definedType.Id.ToString(), false)
.ToList();
// Verify (and create if necessary) the "Is Link" attribute
if (!attributes.Any(a => a.Key == "IsLink"))
{
var fieldType = FieldTypeCache.Get(Rock.SystemGuid.FieldType.BOOLEAN);
if (entityType != null && fieldType != null)
{
var attribute = new Rock.Model.Attribute();
attributeService.Add(attribute);
attribute.EntityTypeId = entityType.Id;
attribute.EntityTypeQualifierColumn = "DefinedTypeId";
attribute.EntityTypeQualifierValue = definedType.Id.ToString();
attribute.FieldTypeId = fieldType.Id;
attribute.Name = "Is Link";
attribute.Key = "IsLink";
attribute.Description = "Flag indicating if value is a link (vs Header)";
attribute.IsGridColumn = true;
attribute.DefaultValue = true.ToString();
var qualifier1 = new AttributeQualifier();
qualifier1.Key = "truetext";
qualifier1.Value = "Yes";
attribute.AttributeQualifiers.Add(qualifier1);
var qualifier2 = new AttributeQualifier();
qualifier2.Key = "falsetext";
qualifier2.Value = "No";
attribute.AttributeQualifiers.Add(qualifier2);
rockContext.SaveChanges();
}
}
}
}
BindGrid();
pnlView.Visible = false;
pnlEdit.Visible = 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, "Attribute").AsGuid();
if (!guid.IsEmpty())
{
// Get the attribute
var attribute = AttributeCache.Get(guid, rockContext);
if (attribute != null)
{
if (attribute.FieldTypeId == FieldTypeCache.Get(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.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);
}
}
}
else if (attribute.FieldTypeId == FieldTypeCache.Get(SystemGuid.FieldType.GROUP.AsGuid(), rockContext).Id)
{
// If attribute type is a group, value should be group guid
Guid?groupGuid = action.GetWorklowAttributeValue(guid).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>
/// Gets the list of view models that represent all the sections and fields
/// of a form.
/// </summary>
/// <param name="actionForm">The <see cref="WorkflowActionForm"/> to be represented.</param>
/// <returns>A collection of view models that represent that sections that will be edited.</returns>
private static List <FormSectionViewModel> GetFormSectionViewModels(WorkflowActionForm actionForm)
{
var sectionViewModels = new List <FormSectionViewModel>();
foreach (var workflowFormSection in actionForm.FormSections.OrderBy(s => s.Order))
{
// Create the basic section view model.
var sectionViewModel = new FormSectionViewModel
{
Guid = workflowFormSection.Guid,
Description = workflowFormSection.Description,
Fields = new List <FormFieldViewModel>(),
ShowHeadingSeparator = workflowFormSection.ShowHeadingSeparator,
Title = workflowFormSection.Title,
Type = Rock.Blocks.WorkFlow.FormBuilder.Utility.GetDefinedValueGuid(workflowFormSection.SectionTypeValueId),
VisibilityRule = workflowFormSection.SectionVisibilityRules?.ToViewModel()
};
// Get all the form attributes for this section.
var formAttributes = actionForm.FormAttributes
.Where(a => a.ActionFormSectionId == workflowFormSection.Id)
.ToList();
// Loop through each form attribute and make a view model out of it.
foreach (var formAttribute in formAttributes.OrderBy(a => a.Order))
{
var attribute = AttributeCache.Get(formAttribute.AttributeId);
var fieldType = FieldTypeCache.Get(attribute.FieldTypeId);
if (fieldType == null || fieldType.Field == null)
{
continue;
}
sectionViewModel.Fields.Add(new FormFieldViewModel
{
ConfigurationValues = fieldType.Field.GetPublicConfigurationValues(attribute.ConfigurationValues, Field.ConfigurationValueUsage.Configure, null),
DefaultValue = fieldType.Field.GetPublicEditValue(attribute.DefaultValue, attribute.ConfigurationValues),
Description = attribute.Description,
FieldTypeGuid = fieldType.Guid,
Guid = attribute.Guid,
IsHideLabel = formAttribute.HideLabel,
IsRequired = attribute.IsRequired,
IsShowOnGrid = attribute.IsGridColumn,
Key = attribute.Key,
Name = attribute.Name,
Size = formAttribute.ColumnSize ?? 12,
VisibilityRule = formAttribute.FieldVisibilityRules?.ToViewModel()
});
}
sectionViewModels.Add(sectionViewModel);
}
return(sectionViewModels);
}
/// <summary>
/// Gets the field type cache used for the given registration field type if it is supported
/// </summary>
/// <param name="fieldType"></param>
/// <returns></returns>
public static FieldTypeCache GetSupportedFieldTypeCache(RegistrationPersonFieldType fieldType)
{
switch (fieldType)
{
case RegistrationPersonFieldType.Gender:
return(FieldTypeCache.Get(SystemGuid.FieldType.GENDER));
default:
return(null);
}
}
/// <summary>
/// Gets the Guid for the FieldType that has the specified Id
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns></returns>
public override Guid?GetGuid(int id)
{
var cacheItem = FieldTypeCache.Get(id);
if (cacheItem != null)
{
return(cacheItem.Guid);
}
return(null);
}
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 '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.Get(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();
}
action.Activity.Attributes.Add(AttrKey, AttributeCache.Get(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' attribute
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);
}
/// <summary>
/// Applies the additional properties and security to view model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="viewModel">The view model.</param>
/// <param name="currentPerson">The current person.</param>
/// <param name="loadAttributes">if set to <c>true</c> [load attributes].</param>
public override void ApplyAdditionalPropertiesAndSecurityToViewModel(Attribute model, AttributeViewModel viewModel, Person currentPerson = null, bool loadAttributes = true)
{
var attributeCache = AttributeCache.Get(model.Id);
viewModel.FieldTypeGuid = FieldTypeCache.Get(attributeCache.FieldTypeId).Guid;
viewModel.CategoryGuids = attributeCache.Categories.Select(c => c.Guid).ToArray();
viewModel.QualifierValues = attributeCache.QualifierValues.ToDictionary(kvp => kvp.Key, kvp => new ViewModel.NonEntities.AttributeConfigurationValue
{
Name = kvp.Value.Name,
Value = kvp.Value.Value,
Description = kvp.Value.Description
});
}
public BlockActionResult GetFilterSources(List <FormFieldViewModel> formFields)
{
var fieldFilterSources = new List <FieldFilterSourceViewModel>();
foreach (var field in formFields)
{
var fieldType = FieldTypeCache.Get(field.FieldTypeGuid);
// If the field type or its C# component could not be found then
// we abort with a hard error. We need it to convert data.
if (fieldType == null || fieldType.Field == null)
{
throw new Exception($"Field type '{field.FieldTypeGuid}' not found.");
}
// Convert the attribute configuration into values that can be used
// for filtering a value.
var privateConfigurationValues = fieldType.Field.GetPrivateConfigurationValues(field.ConfigurationValues);
var publicConfigurationValues = fieldType.Field.GetPublicConfigurationValues(privateConfigurationValues, Field.ConfigurationValueUsage.Configure, null);
/*
* Daniel Hazelbaker - 3/17/2022
*
* This should be removed once the WorkflowEntry block has been converted
* into Obsidian. This filters out any form fields whose field type does
* not support change notification in WebForms.
*/
if (!fieldType.IsWebFormChangeNotificationSupported(privateConfigurationValues))
{
continue;
}
var source = new FieldFilterSourceViewModel
{
Guid = field.Guid,
Type = 0,
Attribute = new PublicFilterableAttributeViewModel
{
AttributeGuid = field.Guid,
ConfigurationValues = publicConfigurationValues,
Description = field.Description,
FieldTypeGuid = field.FieldTypeGuid,
Name = field.Name
}
};
fieldFilterSources.Add(source);
}
return(ActionOk(fieldFilterSources));
}
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 '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.Get(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();
}
action.Activity.Attributes.Add(AttrKey, AttributeCache.Get(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' attribute
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);
}
/// <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 group attribute
Guid groupAttributeGuid = GetAttributeValue(action, "Group").AsGuid();
if (!groupAttributeGuid.IsEmpty())
{
Guid?groupGuid = action.GetWorkflowAttributeValue(groupAttributeGuid).AsGuidOrNull();
if (groupGuid.HasValue)
{
var groupLeader = new GroupMemberService(rockContext).Queryable().AsNoTracking()
.Where(g => g.Group.Guid == groupGuid && g.GroupRole.IsLeader)
.Select(g => g.Person).FirstOrDefault();
if (groupLeader != null)
{
// Get the attribute to set
Guid leaderGuid = GetAttributeValue(action, "Leader").AsGuid();
if (!leaderGuid.IsEmpty())
{
var personAttribute = AttributeCache.Get(leaderGuid, rockContext);
if (personAttribute != null)
{
// If this is a person type attribute
if (personAttribute.FieldTypeId == FieldTypeCache.Get(SystemGuid.FieldType.PERSON.AsGuid(), rockContext).Id)
{
SetWorkflowAttributeValue(action, leaderGuid, groupLeader.PrimaryAlias.Guid.ToString());
}
else if (personAttribute.FieldTypeId == FieldTypeCache.Get(SystemGuid.FieldType.TEXT.AsGuid(), rockContext).Id)
{
SetWorkflowAttributeValue(action, leaderGuid, groupLeader.FullName);
}
}
}
}
}
else
{
errorMessages.Add("The group could not be found!");
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
/// <summary>
/// Handles the SaveClick event of the mdAttributeValue control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void mdAttributeValue_SaveClick(object sender, EventArgs e)
{
if (_displayValueEdit)
{
// If page is not valid, exit and allow validators to display error messages.
Page.Validate();
if (!Page.IsValid)
{
return;
}
int attributeId = 0;
if (hfIdValues.Value != string.Empty && !int.TryParse(hfIdValues.Value, out attributeId))
{
attributeId = 0;
}
if (attributeId != 0 && phEditControls.Controls.Count > 0)
{
var attribute = Rock.Web.Cache.AttributeCache.Get(attributeId);
var rockContext = new RockContext();
var attributeValueService = new AttributeValueService(rockContext);
var attributeValue = attributeValueService.GetByAttributeIdAndEntityId(attributeId, _entityId);
if (attributeValue == null)
{
attributeValue = new AttributeValue
{
AttributeId = attributeId,
EntityId = _entityId
};
attributeValueService.Add(attributeValue);
}
var fieldType = FieldTypeCache.Get(attribute.FieldType.Id);
attributeValue.Value = fieldType.Field.GetEditValue(attribute.GetControl(phEditControls.Controls[0]), attribute.QualifierValues);
rockContext.SaveChanges();
}
hfIdValues.Value = string.Empty;
HideDialog();
}
BindGrid();
}
/// <summary>
/// Handles the RowDataBound event of the rGrid control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="GridViewRowEventArgs" /> instance containing the event data.</param>
protected void gFilters_RowDataBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
int attributeId = ( int )gFilters.DataKeys[e.Row.RowIndex].Value;
var attribute = Rock.Web.Cache.AttributeCache.Get(attributeId);
var fieldType = FieldTypeCache.Get(attribute.FieldTypeId);
Literal lDefaultValue = e.Row.FindControl("lDefaultValue") as Literal;
if (lDefaultValue != null)
{
lDefaultValue.Text = fieldType.Field.FormatValueAsHtml(lDefaultValue, attribute.EntityTypeId, null, attribute.DefaultValue, attribute.QualifierValues, true);
}
}
}
public static Group GetGroupByEBEventId(long ebEventId, RockContext rockContext)
{
Group retVar = null;
var ebFieldType = FieldTypeCache.Get(EBGuid.FieldType.EVENTBRITE_EVENT.AsGuid());
if (ebFieldType != null)
{
var attributeVal = new AttributeValueService(rockContext).Queryable().FirstOrDefault(av => av.Attribute.FieldTypeId == ebFieldType.Id && av.Value.Contains(ebEventId.ToString()));
if (attributeVal != null)
{
retVar = new GroupService(rockContext).Get(attributeVal.EntityId ?? 0);
}
}
return(retVar);
}
