|
public Get ( int entityTypeId, string entityQualifierColumn, string entityQualifierValue, string key ) : |
||
| entityTypeId | int | A |
| entityQualifierColumn | string | A |
| entityQualifierValue | string | A |
| key | string | A |
| return | ||
/// <summary>
/// Returns Attribute object from cache. If attribute does not already exist in cache, it
/// will be read and added to cache
/// </summary>
/// <param name="id">The id of the Attribute to read</param>
/// <returns></returns>
public static AttributeCache Read(int id)
{
string cacheKey = AttributeCache.CacheKey(id);
ObjectCache cache = MemoryCache.Default;
AttributeCache attribute = cache[cacheKey] as AttributeCache;
if (attribute != null)
{
return(attribute);
}
else
{
var attributeService = new Rock.Model.AttributeService();
var attributeModel = attributeService.Get(id);
if (attributeModel != null)
{
attribute = new AttributeCache(attributeModel);
cache.Set(cacheKey, attribute, new CacheItemPolicy());
return(attribute);
}
else
{
return(null);
}
}
}
private static AttributeCache LoadById2(int id, RockContext rockContext)
{
var attributeService = new Rock.Model.AttributeService(rockContext);
var attributeModel = attributeService.Get(id);
if (attributeModel != null)
{
return(new AttributeCache(attributeModel));
}
return(null);
}
/// <summary>
/// Handles the Delete event of the rGrid control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RowEventArgs" /> instance containing the event data.</param>
protected void rGrid_Delete(object sender, RowEventArgs e)
{
var attributeService = new Rock.Model.AttributeService();
Rock.Model.Attribute attribute = attributeService.Get((int)rGrid.DataKeys[e.RowIndex]["id"]);
if (attribute != null)
{
Rock.Web.Cache.AttributeCache.Flush(attribute.Id);
attributeService.Delete(attribute, CurrentPersonId);
attributeService.Save(attribute, CurrentPersonId);
}
BindGrid();
}
/// <summary>
/// Handles the Delete event of the rGrid control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RowEventArgs" /> instance containing the event data.</param>
protected void rGrid_Delete(object sender, RowEventArgs e)
{
var rockContext = new RockContext();
var attributeService = new Rock.Model.AttributeService(rockContext);
Rock.Model.Attribute attribute = attributeService.Get((int)rGrid.DataKeys[e.RowIndex]["id"]);
if (attribute != null)
{
Rock.Web.Cache.AttributeCache.Flush(attribute.Id);
attributeService.Delete(attribute);
rockContext.SaveChanges();
}
BindGrid();
}
/// <summary>
/// Returns a <see cref="Rock.Model.Person"/> user preference value by preference setting's key.
/// </summary>
/// <param name="person">The <see cref="Rock.Model.Person"/> to retrieve the preference value for.</param>
/// <param name="key">A <see cref="System.String"/> representing the key name of the preference setting.</param>
/// <returns>A list of <see cref="System.String"/> containing the values associated with the user's preference setting.</returns>
public static List<string> GetUserPreference( Person person, string key )
{
int? PersonEntityTypeId = Rock.Web.Cache.EntityTypeCache.Read( Person.USER_VALUE_ENTITY ).Id;
var rockContext = new Rock.Data.RockContext();
var attributeService = new Model.AttributeService( rockContext );
var attribute = attributeService.Get( PersonEntityTypeId, string.Empty, string.Empty, key );
if (attribute != null)
{
var attributeValueService = new Model.AttributeValueService( rockContext );
var attributeValues = attributeValueService.GetByAttributeIdAndEntityId(attribute.Id, person.Id);
if (attributeValues != null && attributeValues.Count() > 0)
return attributeValues.Select( v => v.Value).ToList();
}
return null;
}
/// <summary>
/// Handles the Delete event of the rGrid control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RowEventArgs" /> instance containing the event data.</param>
protected void rGrid_Delete(object sender, RowEventArgs e)
{
var rockContext = new RockContext();
var attributeService = new Rock.Model.AttributeService(rockContext);
Rock.Model.Attribute attribute = attributeService.Get(e.RowKeyId);
if (attribute != null)
{
Rock.Web.Cache.AttributeCache.Flush(attribute.Id);
attributeService.Delete(attribute);
rockContext.SaveChanges();
}
AttributeCache.FlushEntityAttributes();
BindGrid();
}
/// <summary>
/// Saves the attributes.
/// </summary>
/// <param name="contentTypeId">The content type identifier.</param>
/// <param name="entityTypeId">The entity type identifier.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="rockContext">The rock context.</param>
private void SaveAttributes( int contentTypeId, int entityTypeId, List<Attribute> attributes, RockContext rockContext )
{
string qualifierColumn = "ContentChannelTypeId";
string qualifierValue = contentTypeId.ToString();
AttributeService attributeService = new AttributeService( rockContext );
// Get the existing attributes for this entity type and qualifier value
var existingAttributes = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
// Delete any of those attributes that were removed in the UI
var selectedAttributeGuids = attributes.Select( a => a.Guid );
foreach ( var attr in existingAttributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
attributeService.Delete( attr );
}
rockContext.SaveChanges();
// Update the Attributes that were assigned in the UI
foreach ( var attr in attributes )
{
Rock.Attribute.Helper.SaveAttributeEdits( attr, entityTypeId, qualifierColumn, qualifierValue, rockContext );
}
AttributeCache.FlushEntityAttributes();
}
/// <summary>
/// Handles the Delete event of the rGrid control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RowEventArgs" /> instance containing the event data.</param>
protected void rGrid_Delete( object sender, RowEventArgs e )
{
var rockContext = new RockContext();
var attributeService = new Rock.Model.AttributeService( rockContext );
Rock.Model.Attribute attribute = attributeService.Get( e.RowKeyId );
if ( attribute != null )
{
Rock.Web.Cache.AttributeCache.Flush( attribute.Id );
attributeService.Delete( attribute );
rockContext.SaveChanges();
}
AttributeCache.FlushEntityAttributes();
BindGrid();
}
/// <summary>
/// Handles the Delete event of the rGrid control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RowEventArgs" /> instance containing the event data.</param>
protected void rGrid_Delete( object sender, RowEventArgs e )
{
var attributeService = new Rock.Model.AttributeService();
Rock.Model.Attribute attribute = attributeService.Get( (int)rGrid.DataKeys[e.RowIndex]["id"] );
if ( attribute != null )
{
Rock.Web.Cache.AttributeCache.Flush( attribute.Id );
attributeService.Delete( attribute, CurrentPersonId );
attributeService.Save( attribute, CurrentPersonId );
}
BindGrid();
}
/// <summary>
/// Saves the attributes.
/// </summary>
/// <param name="entityTypeId">The entity type identifier.</param>
/// <param name="qualifierColumn">The qualifier column.</param>
/// <param name="qualifierValue">The qualifier value.</param>
/// <param name="viewStateAttributes">The view state attributes.</param>
/// <param name="attributeService">The attribute service.</param>
/// <param name="qualifierService">The qualifier service.</param>
/// <param name="categoryService">The category service.</param>
private void SaveAttributes( int entityTypeId, string qualifierColumn, string qualifierValue, List<Attribute> viewStateAttributes, RockContext rockContext )
{
// Get the existing attributes for this entity type and qualifier value
var attributeService = new AttributeService( rockContext );
var regFieldService = new RegistrationTemplateFormFieldService( rockContext );
var attributes = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
// Delete any of those attributes that were removed in the UI
var selectedAttributeGuids = viewStateAttributes.Select( a => a.Guid );
foreach ( var attr in attributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
foreach( var field in regFieldService.Queryable().Where( f => f.AttributeId.HasValue && f.AttributeId.Value == attr.Id ).ToList() )
{
regFieldService.Delete( field );
}
attributeService.Delete( attr );
rockContext.SaveChanges();
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
}
// Update the Attributes that were assigned in the UI
foreach ( var attributeState in viewStateAttributes )
{
Helper.SaveAttributeEdits( attributeState, entityTypeId, qualifierColumn, qualifierValue, rockContext );
}
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
ParseControls( true );
var rockContext = new RockContext();
var service = new RegistrationTemplateService( rockContext );
RegistrationTemplate RegistrationTemplate = null;
int? RegistrationTemplateId = hfRegistrationTemplateId.Value.AsIntegerOrNull();
if ( RegistrationTemplateId.HasValue )
{
RegistrationTemplate = service.Get( RegistrationTemplateId.Value );
}
if ( RegistrationTemplate == null )
{
RegistrationTemplate = new RegistrationTemplate();
}
RegistrationNotify notify = RegistrationNotify.None;
foreach( ListItem li in cblNotify.Items )
{
if ( li.Selected )
{
notify = notify | (RegistrationNotify)li.Value.AsInteger();
}
}
RegistrationTemplate.IsActive = cbIsActive.Checked;
RegistrationTemplate.Name = tbName.Text;
RegistrationTemplate.CategoryId = cpCategory.SelectedValueAsInt();
RegistrationTemplate.GroupTypeId = gtpGroupType.SelectedGroupTypeId;
RegistrationTemplate.GroupMemberRoleId = rpGroupTypeRole.GroupRoleId;
RegistrationTemplate.GroupMemberStatus = ddlGroupMemberStatus.SelectedValueAsEnum<GroupMemberStatus>();
RegistrationTemplate.Notify = notify;
RegistrationTemplate.LoginRequired = cbLoginRequired.Checked;
RegistrationTemplate.AllowMultipleRegistrants = cbMultipleRegistrants.Checked;
RegistrationTemplate.MaxRegistrants = nbMaxRegistrants.Text.AsInteger();
RegistrationTemplate.RegistrantsSameFamily = rblRegistrantsInSameFamily.SelectedValueAsEnum<RegistrantsSameFamily>();
RegistrationTemplate.Cost = cbCost.Text.AsDecimal();
RegistrationTemplate.MinimumInitialPayment = cbMinimumInitialPayment.Text.AsDecimalOrNull();
RegistrationTemplate.FinancialGatewayId = fgpFinancialGateway.SelectedValueAsInt();
RegistrationTemplate.ConfirmationFromName = tbConfirmationFromName.Text;
RegistrationTemplate.ConfirmationFromEmail = tbConfirmationFromEmail.Text;
RegistrationTemplate.ConfirmationSubject = tbConfirmationSubject.Text;
RegistrationTemplate.ConfirmationEmailTemplate = ceConfirmationEmailTemplate.Text;
RegistrationTemplate.ReminderFromName = tbReminderFromName.Text;
RegistrationTemplate.ReminderFromEmail = tbReminderFromEmail.Text;
RegistrationTemplate.ReminderSubject = tbReminderSubject.Text;
RegistrationTemplate.ReminderEmailTemplate = ceReminderEmailTemplate.Text;
RegistrationTemplate.RegistrationTerm = string.IsNullOrWhiteSpace( tbRegistrationTerm.Text ) ? "Registration" : tbRegistrationTerm.Text;
RegistrationTemplate.RegistrantTerm = string.IsNullOrWhiteSpace( tbRegistrantTerm.Text ) ? "Registrant" : tbRegistrantTerm.Text;
RegistrationTemplate.FeeTerm = string.IsNullOrWhiteSpace( tbFeeTerm.Text ) ? "Additional Options" : tbFeeTerm.Text;
RegistrationTemplate.DiscountCodeTerm = string.IsNullOrWhiteSpace( tbDiscountCodeTerm.Text ) ? "Discount Code" : tbDiscountCodeTerm.Text;
RegistrationTemplate.SuccessTitle = tbSuccessTitle.Text;
RegistrationTemplate.SuccessText = ceSuccessText.Text;
if ( !Page.IsValid || !RegistrationTemplate.IsValid )
{
return;
}
foreach ( var form in FormState )
{
if ( !form.IsValid )
{
return;
}
if ( FormFieldsState.ContainsKey( form.Guid ) )
{
foreach( var formField in FormFieldsState[ form.Guid ])
{
if ( !formField.IsValid )
{
return;
}
}
}
}
// Get the valid group member attributes
var group = new Group();
group.GroupTypeId = gtpGroupType.SelectedGroupTypeId ?? 0;
var groupMember = new GroupMember();
groupMember.Group = group;
groupMember.LoadAttributes();
var validGroupMemberAttributeIds = groupMember.Attributes.Select( a => a.Value.Id ).ToList();
// Remove any group member attributes that are not valid based on selected group type
foreach( var fieldList in FormFieldsState.Select( s => s.Value ) )
{
foreach( var formField in fieldList
.Where( a =>
a.FieldSource == RegistrationFieldSource.GroupMemberAttribute &&
a.AttributeId.HasValue &&
!validGroupMemberAttributeIds.Contains( a.AttributeId.Value ) )
.ToList() )
{
fieldList.Remove( formField );
}
}
// Perform Validation
var validationErrors = new List<string>();
if ( ( RegistrationTemplate.Cost > 0 || FeeState.Any() ) && !RegistrationTemplate.FinancialGatewayId.HasValue )
{
validationErrors.Add( "A Financial Gateway is required when the registration has a cost or additional fees." );
}
if ( validationErrors.Any() )
{
nbValidationError.Visible = true;
nbValidationError.Text = "<ul class='list-unstyled'><li>" + validationErrors.AsDelimited( "</li><li>" ) + "</li></ul>";
}
else
{
rockContext.WrapTransaction( () =>
{
// Save the entity field changes to registration template
if ( RegistrationTemplate.Id.Equals( 0 ) )
{
service.Add( RegistrationTemplate );
}
rockContext.SaveChanges();
var attributeService = new AttributeService( rockContext );
var registrationTemplateFormService = new RegistrationTemplateFormService( rockContext );
var registrationTemplateFormFieldService = new RegistrationTemplateFormFieldService( rockContext );
var registrationTemplateDiscountService = new RegistrationTemplateDiscountService( rockContext );
var registrationTemplateFeeService = new RegistrationTemplateFeeService( rockContext );
// delete forms that aren't assigned in the UI anymore
var formUiGuids = FormState.Select( f => f.Guid ).ToList();
foreach ( var form in registrationTemplateFormService
.Queryable()
.Where( f =>
f.RegistrationTemplateId == RegistrationTemplate.Id &&
!formUiGuids.Contains( f.Guid ) ) )
{
registrationTemplateFormService.Delete( form );
}
// delete discounts that aren't assigned in the UI anymore
var discountUiGuids = DiscountState.Select( u => u.Guid ).ToList();
foreach ( var discount in registrationTemplateDiscountService
.Queryable()
.Where( d =>
d.RegistrationTemplateId == RegistrationTemplate.Id &&
!discountUiGuids.Contains( d.Guid ) ) )
{
registrationTemplateDiscountService.Delete( discount );
}
// delete fees that aren't assigned in the UI anymore
var feeUiGuids = FeeState.Select( u => u.Guid ).ToList();
foreach ( var fee in registrationTemplateFeeService
.Queryable()
.Where( d =>
d.RegistrationTemplateId == RegistrationTemplate.Id &&
!feeUiGuids.Contains( d.Guid ) ) )
{
registrationTemplateFeeService.Delete( fee );
}
var attributesUI = FormFieldsState
.SelectMany( s =>
s.Value.Where( a =>
a.FieldSource == RegistrationFieldSource.RegistrationAttribute &&
a.Attribute != null ) )
.Select( f => f.Attribute );
int? entityTypeId = EntityTypeCache.Read( typeof( Rock.Model.RegistrationRegistrant ) ).Id;
var qualifierColumn = "RegistrationTemplateId";
var qualifierValue = RegistrationTemplate.Id.ToString();
// Get the existing registration attributes for this entity type and qualifier value
var attributesDB = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
// Delete any of the registration attributes that were removed in the UI
var selectedAttributeGuids = attributesUI.Select( a => a.Guid );
foreach ( var attr in attributesDB.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
attributeService.Delete( attr );
rockContext.SaveChanges();
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
}
// Update the registration attributes that were assigned in the UI
foreach ( var attr in attributesUI )
{
Helper.SaveAttributeEdits( attr, entityTypeId, qualifierColumn, qualifierValue, rockContext );
}
// add/updated forms/fields
foreach ( var formUI in FormState )
{
var form = RegistrationTemplate.Forms.FirstOrDefault( f => f.Guid.Equals( formUI.Guid ) );
if ( form == null )
{
form = new RegistrationTemplateForm();
form.Guid = formUI.Guid;
RegistrationTemplate.Forms.Add( form );
}
form.Name = formUI.Name;
form.Order = formUI.Order;
if ( FormFieldsState.ContainsKey( form.Guid ) )
{
var fieldUiGuids = FormFieldsState[form.Guid].Select( a => a.Guid ).ToList();
foreach ( var formField in registrationTemplateFormFieldService
.Queryable()
.Where( a =>
a.RegistrationTemplateForm.Guid.Equals( form.Guid ) &&
!fieldUiGuids.Contains( a.Guid ) ) )
{
registrationTemplateFormFieldService.Delete( formField );
}
foreach ( var formFieldUI in FormFieldsState[form.Guid] )
{
var formField = form.Fields.FirstOrDefault( a => a.Guid.Equals( formFieldUI.Guid ) );
if ( formField == null )
{
formField = new RegistrationTemplateFormField();
formField.Guid = formFieldUI.Guid;
form.Fields.Add( formField );
}
formField.AttributeId = formFieldUI.AttributeId;
if ( !formField.AttributeId.HasValue &&
formFieldUI.FieldSource == RegistrationFieldSource.RegistrationAttribute &&
formFieldUI.Attribute != null )
{
var attr = AttributeCache.Read( formFieldUI.Attribute.Guid, rockContext );
if ( attr != null )
{
formField.AttributeId = attr.Id;
}
}
formField.FieldSource = formFieldUI.FieldSource;
formField.PersonFieldType = formFieldUI.PersonFieldType;
formField.IsSharedValue = formFieldUI.IsSharedValue;
formField.ShowCurrentValue = formFieldUI.ShowCurrentValue;
formField.PreText = formFieldUI.PreText;
formField.PostText = formFieldUI.PostText;
formField.IsGridField = formFieldUI.IsGridField;
formField.IsRequired = formFieldUI.IsRequired;
formField.Order = formFieldUI.Order;
}
}
}
// add/updated discounts
foreach ( var discountUI in DiscountState )
{
var discount = RegistrationTemplate.Discounts.FirstOrDefault( a => a.Guid.Equals( discountUI.Guid ) );
if ( discount == null )
{
discount = new RegistrationTemplateDiscount();
discount.Guid = discountUI.Guid;
RegistrationTemplate.Discounts.Add( discount );
}
discount.Code = discountUI.Code;
discount.DiscountPercentage = discountUI.DiscountPercentage;
discount.DiscountAmount = discountUI.DiscountAmount;
discount.Order = discountUI.Order;
}
// add/updated fees
foreach ( var feeUI in FeeState )
{
var fee = RegistrationTemplate.Fees.FirstOrDefault( a => a.Guid.Equals( feeUI.Guid ) );
if ( fee == null )
{
fee = new RegistrationTemplateFee();
fee.Guid = feeUI.Guid;
RegistrationTemplate.Fees.Add( fee );
}
fee.Name = feeUI.Name;
fee.FeeType = feeUI.FeeType;
fee.CostValue = feeUI.CostValue;
fee.DiscountApplies = feeUI.DiscountApplies;
fee.AllowMultiple = feeUI.AllowMultiple;
fee.Order = feeUI.Order;
}
rockContext.SaveChanges();
} );
var qryParams = new Dictionary<string, string>();
qryParams["RegistrationTemplateId"] = RegistrationTemplate.Id.ToString();
NavigateToPage( RockPage.Guid, qryParams );
}
}
/// <summary>
/// Handles the Delete event of the gDefinedTypeAttributes control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RowEventArgs" /> instance containing the event data.</param>
protected void gDefinedTypeAttributes_Delete( object sender, RowEventArgs e )
{
Guid attributeGuid = (Guid)e.RowKeyValue;
var rockContext = new RockContext();
AttributeService attributeService = new AttributeService( rockContext );
Attribute attribute = attributeService.Get( attributeGuid );
if ( attribute != null )
{
string errorMessage;
if ( !attributeService.CanDelete( attribute, out errorMessage ) )
{
mdGridWarningAttributes.Show( errorMessage, ModalAlertType.Information );
return;
}
AttributeCache.Flush( attribute.Id );
attributeService.Delete( attribute );
rockContext.SaveChanges();
}
BindDefinedTypeAttributesGrid();
}
/// <summary>
/// Adds or Updates a <see cref="Rock.Model.Attribute" /> item for the attribute.
/// </summary>
/// <param name="property">The property.</param>
/// <param name="entityTypeId">The entity type id.</param>
/// <param name="entityQualifierColumn">The entity qualifier column.</param>
/// <param name="entityQualifierValue">The entity qualifier value.</param>
/// <param name="rockContext">The rock context.</param>
/// <returns></returns>
/// <remarks>
/// If a rockContext value is included, this method will save any previous changes made to the context
/// </remarks>
private static bool UpdateAttribute( FieldAttribute property, int? entityTypeId, string entityQualifierColumn, string entityQualifierValue, RockContext rockContext = null )
{
bool updated = false;
rockContext = rockContext ?? new RockContext();
var attributeService = new AttributeService( rockContext );
var attributeQualifierService = new AttributeQualifierService( rockContext );
var fieldTypeService = new FieldTypeService(rockContext);
var categoryService = new CategoryService( rockContext );
var propertyCategories = property.Category.SplitDelimitedValues( false ).ToList();
// Look for an existing attribute record based on the entity, entityQualifierColumn and entityQualifierValue
Model.Attribute attribute = attributeService.Get( entityTypeId, entityQualifierColumn, entityQualifierValue, property.Key );
if ( attribute == null )
{
// If an existing attribute record doesn't exist, create a new one
updated = true;
attribute = new Model.Attribute();
attribute.EntityTypeId = entityTypeId;
attribute.EntityTypeQualifierColumn = entityQualifierColumn;
attribute.EntityTypeQualifierValue = entityQualifierValue;
attribute.Key = property.Key;
attribute.IconCssClass = string.Empty;
attribute.IsGridColumn = false;
}
else
{
// Check to see if the existing attribute record needs to be updated
if ( attribute.Name != property.Name ||
attribute.DefaultValue != property.DefaultValue ||
attribute.Description != property.Description ||
attribute.Order != property.Order ||
attribute.FieldType.Assembly != property.FieldTypeAssembly ||
attribute.FieldType.Class != property.FieldTypeClass ||
attribute.IsRequired != property.IsRequired )
{
updated = true;
}
// Check category
else if ( attribute.Categories.Select( c => c.Name ).Except( propertyCategories ).Any() ||
propertyCategories.Except( attribute.Categories.Select( c => c.Name ) ).Any() )
{
updated = true;
}
// Check the qualifier values
else if ( attribute.AttributeQualifiers.Select( q => q.Key ).Except( property.FieldConfigurationValues.Select( c => c.Key ) ).Any() ||
property.FieldConfigurationValues.Select( c => c.Key ).Except( attribute.AttributeQualifiers.Select( q => q.Key ) ).Any() )
{
updated = true;
}
else
{
foreach ( var attributeQualifier in attribute.AttributeQualifiers )
{
if ( !property.FieldConfigurationValues.ContainsKey( attributeQualifier.Key ) ||
property.FieldConfigurationValues[attributeQualifier.Key].Value != attributeQualifier.Value )
{
updated = true;
break;
}
}
}
}
if ( updated )
{
// Update the attribute
attribute.Name = property.Name;
attribute.Description = property.Description;
attribute.DefaultValue = property.DefaultValue;
attribute.Order = property.Order;
attribute.IsRequired = property.IsRequired;
attribute.Categories.Clear();
if ( propertyCategories.Any() )
{
foreach ( string propertyCategory in propertyCategories )
{
int attributeEntityTypeId = EntityTypeCache.Read( typeof( Rock.Model.Attribute ) ).Id;
var category = categoryService.Get( propertyCategory, attributeEntityTypeId, "EntityTypeId", entityTypeId.ToString() ).FirstOrDefault();
if ( category == null )
{
category = new Category();
category.Name = propertyCategory;
category.EntityTypeId = attributeEntityTypeId;
category.EntityTypeQualifierColumn = "EntityTypeId";
category.EntityTypeQualifierValue = entityTypeId.ToString();
category.Order = 0;
}
attribute.Categories.Add( category );
}
}
foreach ( var qualifier in attribute.AttributeQualifiers.ToList() )
{
attributeQualifierService.Delete( qualifier );
}
attribute.AttributeQualifiers.Clear();
foreach ( var configValue in property.FieldConfigurationValues )
{
var qualifier = new Model.AttributeQualifier();
qualifier.Key = configValue.Key;
qualifier.Value = configValue.Value.Value;
attribute.AttributeQualifiers.Add( qualifier );
}
// Try to set the field type by searching for an existing field type with the same assembly and class name
if ( attribute.FieldType == null || attribute.FieldType.Assembly != property.FieldTypeAssembly ||
attribute.FieldType.Class != property.FieldTypeClass )
{
attribute.FieldType = fieldTypeService.Queryable().FirstOrDefault( f =>
f.Assembly == property.FieldTypeAssembly &&
f.Class == property.FieldTypeClass );
}
// If this is a new attribute, add it, otherwise remove the exiting one from the cache
if ( attribute.Id == 0 )
{
attributeService.Add( attribute );
}
else
{
AttributeCache.Flush( attribute.Id );
}
rockContext.SaveChanges();
return true;
}
else
{
return false;
}
}
/// <summary>
/// Saves any attribute edits made to an attribute
/// </summary>
/// <param name="newAttribute">The new attribute.</param>
/// <param name="entityTypeId">The entity type identifier.</param>
/// <param name="entityTypeQualifierColumn">The entity type qualifier column.</param>
/// <param name="entityTypeQualifierValue">The entity type qualifier value.</param>
/// <param name="rockContext">The rock context.</param>
/// <returns></returns>
/// <remarks>
/// If a rockContext value is included, this method will save any previous changes made to the context
/// </remarks>
public static Rock.Model.Attribute SaveAttributeEdits( Rock.Model.Attribute newAttribute, int? entityTypeId, string entityTypeQualifierColumn, string entityTypeQualifierValue, RockContext rockContext = null )
{
rockContext = rockContext ?? new RockContext();
var internalAttributeService = new AttributeService( rockContext );
var attributeQualifierService = new AttributeQualifierService( rockContext );
var categoryService = new CategoryService( rockContext );
// If attribute is not valid, return null
if (!newAttribute.IsValid)
{
return null;
}
// Create a attribute model that will be saved
Rock.Model.Attribute attribute = null;
// Check to see if this was an existing or new attribute
if (newAttribute.Id > 0)
{
// If editing an existing attribute, remove all the old qualifiers in case they were changed
foreach ( var oldQualifier in attributeQualifierService.GetByAttributeId( newAttribute.Id ).ToList() )
{
attributeQualifierService.Delete( oldQualifier );
}
rockContext.SaveChanges();
// Then re-load the existing attribute
attribute = internalAttributeService.Get( newAttribute.Id );
}
if ( attribute == null )
{
// If the attribute didn't exist, create it
attribute = new Rock.Model.Attribute();
internalAttributeService.Add( attribute );
}
else
{
// If it did exist, set the new attribute ID and GUID since we're copying all properties in the next step
newAttribute.Id = attribute.Id;
newAttribute.Guid = attribute.Guid;
}
// Copy all the properties from the new attribute to the attribute model
attribute.CopyPropertiesFrom( newAttribute );
// Add any qualifiers
foreach ( var qualifier in newAttribute.AttributeQualifiers )
{
attribute.AttributeQualifiers.Add( new AttributeQualifier { Key = qualifier.Key, Value = qualifier.Value, IsSystem = qualifier.IsSystem } );
}
// Add any categories
attribute.Categories.Clear();
foreach ( var category in newAttribute.Categories )
{
attribute.Categories.Add( categoryService.Get( category.Id ) );
}
attribute.EntityTypeId = entityTypeId;
attribute.EntityTypeQualifierColumn = entityTypeQualifierColumn;
attribute.EntityTypeQualifierValue = entityTypeQualifierValue;
rockContext.SaveChanges();
if ( attribute != null )
{
Rock.Web.Cache.AttributeCache.Flush( attribute.Id );
// If this is a global attribute, flush all global attributes
if ( !entityTypeId.HasValue && entityTypeQualifierColumn == string.Empty && entityTypeQualifierValue == string.Empty )
{
Rock.Web.Cache.GlobalAttributesCache.Flush();
}
}
return attribute;
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
using ( new UnitOfWorkScope() )
{
BinaryFileType binaryFileType;
BinaryFileTypeService binaryFileTypeService = new BinaryFileTypeService();
AttributeService attributeService = new AttributeService();
AttributeQualifierService attributeQualifierService = new AttributeQualifierService();
CategoryService categoryService = new CategoryService();
int binaryFileTypeId = int.Parse( hfBinaryFileTypeId.Value );
if ( binaryFileTypeId == 0 )
{
binaryFileType = new BinaryFileType();
binaryFileTypeService.Add( binaryFileType, CurrentPersonId );
}
else
{
binaryFileType = binaryFileTypeService.Get( binaryFileTypeId );
}
binaryFileType.Name = tbName.Text;
binaryFileType.Description = tbDescription.Text;
binaryFileType.IconCssClass = tbIconCssClass.Text;
binaryFileType.AllowCaching = cbAllowCaching.Checked;
if ( !string.IsNullOrWhiteSpace( cpStorageType.SelectedValue ) )
{
var entityTypeService = new EntityTypeService();
var storageEntityType = entityTypeService.Get( new Guid( cpStorageType.SelectedValue ) );
if ( storageEntityType != null )
{
binaryFileType.StorageEntityTypeId = storageEntityType.Id;
}
}
binaryFileType.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phAttributes, binaryFileType );
if ( !binaryFileType.IsValid )
{
// Controls will render the error messages
return;
}
RockTransactionScope.WrapTransaction( () =>
{
binaryFileTypeService.Save( binaryFileType, CurrentPersonId );
// get it back to make sure we have a good Id for it for the Attributes
binaryFileType = binaryFileTypeService.Get( binaryFileType.Guid );
/* Take care of Binary File Attributes */
var entityTypeId = Rock.Web.Cache.EntityTypeCache.Read( typeof( BinaryFile ) ).Id;
// delete BinaryFileAttributes that are no longer configured in the UI
var attributes = attributeService.Get( entityTypeId, "BinaryFileTypeId", binaryFileType.Id.ToString() );
var selectedAttributeGuids = BinaryFileAttributesState.Select( a => a.Guid );
foreach ( var attr in attributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
attributeService.Delete( attr, CurrentPersonId );
attributeService.Save( attr, CurrentPersonId );
}
// add/update the BinaryFileAttributes that are assigned in the UI
foreach ( var attributeState in BinaryFileAttributesState )
{
Rock.Attribute.Helper.SaveAttributeEdits( attributeState, attributeService, attributeQualifierService, categoryService,
entityTypeId, "BinaryFileTypeId", binaryFileType.Id.ToString(), CurrentPersonId );
}
// SaveAttributeValues for the BinaryFileType
Rock.Attribute.Helper.SaveAttributeValues( binaryFileType, CurrentPersonId );
} );
}
NavigateToParentPage();
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
bool hasValidationErrors = false;
var rockContext = new RockContext();
GroupTypeService groupTypeService = new GroupTypeService( rockContext );
GroupService groupService = new GroupService( rockContext );
AttributeService attributeService = new AttributeService( rockContext );
GroupLocationService groupLocationService = new GroupLocationService( rockContext );
int parentGroupTypeId = hfParentGroupTypeId.ValueAsInt();
var groupTypeUIList = new List<GroupType>();
foreach ( var checkinGroupTypeEditor in phCheckinGroupTypes.Controls.OfType<CheckinGroupTypeEditor>().ToList() )
{
var groupType = checkinGroupTypeEditor.GetCheckinGroupType( rockContext );
groupTypeUIList.Add( groupType );
}
var groupTypeDBList = new List<GroupType>();
var groupTypesToDelete = new List<GroupType>();
var groupsToDelete = new List<Group>();
var groupTypesToAddUpdate = new List<GroupType>();
var groupsToAddUpdate = new List<Group>();
GroupType parentGroupTypeDB = groupTypeService.Get( parentGroupTypeId );
GroupType parentGroupTypeUI = parentGroupTypeDB.Clone( false );
parentGroupTypeUI.ChildGroupTypes = groupTypeUIList;
PopulateDeleteLists( groupTypesToDelete, groupsToDelete, parentGroupTypeDB, parentGroupTypeUI );
PopulateAddUpdateLists( groupTypesToAddUpdate, groupsToAddUpdate, parentGroupTypeUI );
int binaryFileFieldTypeID = FieldTypeCache.Read( Rock.SystemGuid.FieldType.BINARY_FILE.AsGuid() ).Id;
rockContext.WrapTransaction( () =>
{
// delete in reverse order to get deepest child items first
groupsToDelete.Reverse();
foreach ( var groupToDelete in groupsToDelete )
{
groupService.Delete( groupToDelete );
}
// delete in reverse order to get deepest child items first
groupTypesToDelete.Reverse();
foreach ( var groupTypeToDelete in groupTypesToDelete )
{
groupTypeService.Delete( groupTypeToDelete );
}
rockContext.SaveChanges();
// Add/Update grouptypes and groups that are in the UI
// Note: We'll have to save all the groupTypes without changing the DB value of ChildGroupTypes, then come around again and save the ChildGroupTypes
// since the ChildGroupTypes may not exist in the database yet
foreach ( GroupType groupTypeUI in groupTypesToAddUpdate )
{
GroupType groupTypeDB = groupTypeService.Get( groupTypeUI.Guid );
if ( groupTypeDB == null )
{
groupTypeDB = new GroupType();
groupTypeDB.Id = 0;
groupTypeDB.Guid = groupTypeUI.Guid;
groupTypeDB.IsSystem = false;
groupTypeDB.ShowInNavigation = false;
groupTypeDB.ShowInGroupList = false;
groupTypeDB.TakesAttendance = true;
groupTypeDB.AttendanceRule = AttendanceRule.None;
groupTypeDB.AttendancePrintTo = PrintTo.Default;
groupTypeDB.AllowMultipleLocations = true;
groupTypeDB.EnableLocationSchedules = true;
}
groupTypeDB.Name = groupTypeUI.Name;
groupTypeDB.Order = groupTypeUI.Order;
groupTypeDB.InheritedGroupTypeId = groupTypeUI.InheritedGroupTypeId;
groupTypeDB.Attributes = groupTypeUI.Attributes;
groupTypeDB.AttributeValues = groupTypeUI.AttributeValues;
if ( groupTypeDB.Id == 0 )
{
groupTypeService.Add( groupTypeDB );
}
if ( !groupTypeDB.IsValid )
{
hasValidationErrors = true;
CheckinGroupTypeEditor groupTypeEditor = phCheckinGroupTypes.ControlsOfTypeRecursive<CheckinGroupTypeEditor>().First( a => a.GroupTypeGuid == groupTypeDB.Guid );
groupTypeEditor.Expanded = true;
return;
}
rockContext.SaveChanges();
groupTypeDB.SaveAttributeValues( rockContext );
// get fresh from database to make sure we have Id so we can update the CheckinLabel Attributes
groupTypeDB = groupTypeService.Get( groupTypeDB.Guid );
// rebuild the CheckinLabel attributes from the UI (brute-force)
foreach ( var labelAttributeDB in CheckinGroupTypeEditor.GetCheckinLabelAttributes( groupTypeDB.Attributes, rockContext ) )
{
var attribute = attributeService.Get( labelAttributeDB.Value.Guid );
Rock.Web.Cache.AttributeCache.Flush( attribute.Id );
attributeService.Delete( attribute );
}
rockContext.SaveChanges();
foreach ( var checkinLabelAttributeInfo in GroupTypeCheckinLabelAttributesState[groupTypeUI.Guid] )
{
var attribute = new Rock.Model.Attribute();
attribute.AttributeQualifiers.Add( new AttributeQualifier { Key = "binaryFileType", Value = Rock.SystemGuid.BinaryFiletype.CHECKIN_LABEL } );
attribute.Guid = Guid.NewGuid();
attribute.FieldTypeId = binaryFileFieldTypeID;
attribute.EntityTypeId = EntityTypeCache.GetId( typeof( GroupType ) );
attribute.EntityTypeQualifierColumn = "Id";
attribute.EntityTypeQualifierValue = groupTypeDB.Id.ToString();
attribute.DefaultValue = checkinLabelAttributeInfo.BinaryFileGuid.ToString();
attribute.Key = checkinLabelAttributeInfo.AttributeKey;
attribute.Name = checkinLabelAttributeInfo.FileName;
if ( !attribute.IsValid )
{
hasValidationErrors = true;
CheckinGroupTypeEditor groupTypeEditor = phCheckinGroupTypes.ControlsOfTypeRecursive<CheckinGroupTypeEditor>().First( a => a.GroupTypeGuid == groupTypeDB.Guid );
groupTypeEditor.Expanded = true;
return;
}
attributeService.Add( attribute );
}
rockContext.SaveChanges();
}
// Add/Update Groups
foreach ( var groupUI in groupsToAddUpdate )
{
Group groupDB = groupService.Get( groupUI.Guid );
if ( groupDB == null )
{
groupDB = new Group();
groupDB.Guid = groupUI.Guid;
}
groupDB.Name = groupUI.Name;
// delete any GroupLocations that were removed in the UI
foreach ( var groupLocationDB in groupDB.GroupLocations.ToList() )
{
if ( !groupUI.GroupLocations.Select( a => a.LocationId ).Contains( groupLocationDB.LocationId ) )
{
groupLocationService.Delete( groupLocationDB );
}
}
// add any GroupLocations that were added in the UI
foreach ( var groupLocationUI in groupUI.GroupLocations )
{
if ( !groupDB.GroupLocations.Select( a => a.LocationId ).Contains( groupLocationUI.LocationId ) )
{
GroupLocation groupLocationDB = new GroupLocation { LocationId = groupLocationUI.LocationId };
groupDB.GroupLocations.Add( groupLocationDB );
}
}
groupDB.Order = groupUI.Order;
// get GroupTypeId from database in case the groupType is new
groupDB.GroupTypeId = groupTypeService.Get( groupUI.GroupType.Guid ).Id;
groupDB.Attributes = groupUI.Attributes;
groupDB.AttributeValues = groupUI.AttributeValues;
if ( groupDB.Id == 0 )
{
groupService.Add( groupDB );
}
if ( !groupDB.IsValid )
{
hasValidationErrors = true;
hasValidationErrors = true;
CheckinGroupEditor groupEditor = phCheckinGroupTypes.ControlsOfTypeRecursive<CheckinGroupEditor>().First( a => a.GroupGuid == groupDB.Guid );
groupEditor.Expanded = true;
return;
}
rockContext.SaveChanges();
groupDB.SaveAttributeValues();
}
/* now that we have all the grouptypes saved, now lets go back and save them again with the current UI ChildGroupTypes */
// save main parentGroupType with current UI ChildGroupTypes
parentGroupTypeDB.ChildGroupTypes = new List<GroupType>();
parentGroupTypeDB.ChildGroupTypes.Clear();
foreach ( var childGroupTypeUI in parentGroupTypeUI.ChildGroupTypes )
{
var childGroupTypeDB = groupTypeService.Get( childGroupTypeUI.Guid );
parentGroupTypeDB.ChildGroupTypes.Add( childGroupTypeDB );
}
rockContext.SaveChanges();
// loop thru all the other GroupTypes in the UI and save their childgrouptypes
foreach ( var groupTypeUI in groupTypesToAddUpdate )
{
var groupTypeDB = groupTypeService.Get( groupTypeUI.Guid );
groupTypeDB.ChildGroupTypes = new List<GroupType>();
groupTypeDB.ChildGroupTypes.Clear();
foreach ( var childGroupTypeUI in groupTypeUI.ChildGroupTypes )
{
var childGroupTypeDB = groupTypeService.Get( childGroupTypeUI.Guid );
groupTypeDB.ChildGroupTypes.Add( childGroupTypeDB );
}
}
rockContext.SaveChanges();
} );
if ( !hasValidationErrors )
{
NavigateToParentPage();
}
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
Group group;
bool wasSecurityRole = false;
RockContext rockContext = new RockContext();
GroupService groupService = new GroupService( rockContext );
GroupLocationService groupLocationService = new GroupLocationService( rockContext );
ScheduleService scheduleService = new ScheduleService( rockContext );
AttributeService attributeService = new AttributeService( rockContext );
AttributeQualifierService attributeQualifierService = new AttributeQualifierService( rockContext );
CategoryService categoryService = new CategoryService( rockContext );
if ( ( ddlGroupType.SelectedValueAsInt() ?? 0 ) == 0 )
{
ddlGroupType.ShowErrorMessage( Rock.Constants.WarningMessage.CannotBeBlank( GroupType.FriendlyTypeName ) );
return;
}
int groupId = int.Parse( hfGroupId.Value );
if ( groupId == 0 )
{
group = new Group();
group.IsSystem = false;
group.Name = string.Empty;
}
else
{
group = groupService.Queryable( "Schedule,GroupLocations.Schedules" ).Where( g => g.Id == groupId ).FirstOrDefault();
wasSecurityRole = group.IsSecurityRole;
var selectedLocations = GroupLocationsState.Select( l => l.Guid );
foreach ( var groupLocation in group.GroupLocations.Where( l => !selectedLocations.Contains( l.Guid ) ).ToList() )
{
group.GroupLocations.Remove( groupLocation );
groupLocationService.Delete( groupLocation );
}
}
foreach ( var groupLocationState in GroupLocationsState )
{
GroupLocation groupLocation = group.GroupLocations.Where( l => l.Guid == groupLocationState.Guid ).FirstOrDefault();
if ( groupLocation == null )
{
groupLocation = new GroupLocation();
group.GroupLocations.Add( groupLocation );
}
else
{
groupLocationState.Id = groupLocation.Id;
groupLocationState.Guid = groupLocation.Guid;
var selectedSchedules = groupLocationState.Schedules.Select( s => s.Guid ).ToList();
foreach( var schedule in groupLocation.Schedules.Where( s => !selectedSchedules.Contains( s.Guid)).ToList())
{
groupLocation.Schedules.Remove( schedule );
}
}
groupLocation.CopyPropertiesFrom( groupLocationState );
var existingSchedules = groupLocation.Schedules.Select( s => s.Guid ).ToList();
foreach ( var scheduleState in groupLocationState.Schedules.Where( s => !existingSchedules.Contains( s.Guid )).ToList())
{
var schedule = scheduleService.Get( scheduleState.Guid );
if ( schedule != null )
{
groupLocation.Schedules.Add( schedule );
}
}
}
group.Name = tbName.Text;
group.Description = tbDescription.Text;
group.CampusId = ddlCampus.SelectedValue.Equals( None.IdValue ) ? (int?)null : int.Parse( ddlCampus.SelectedValue );
group.GroupTypeId = int.Parse( ddlGroupType.SelectedValue );
group.ParentGroupId = gpParentGroup.SelectedValue.Equals( None.IdValue ) ? (int?)null : int.Parse( gpParentGroup.SelectedValue );
group.IsSecurityRole = cbIsSecurityRole.Checked;
group.IsActive = cbIsActive.Checked;
string iCalendarContent = string.Empty;
// If unique schedule option was selected, but a schedule was not defined, set option to 'None'
var scheduleType = rblScheduleSelect.SelectedValueAsEnum<ScheduleType>( ScheduleType.None );
if ( scheduleType == ScheduleType.Custom )
{
iCalendarContent = sbSchedule.iCalendarContent;
var calEvent = ScheduleICalHelper.GetCalenderEvent( iCalendarContent );
if ( calEvent == null || calEvent.DTStart == null )
{
scheduleType = ScheduleType.None;
}
}
if ( scheduleType == ScheduleType.Weekly )
{
if ( !dowWeekly.SelectedDayOfWeek.HasValue )
{
scheduleType = ScheduleType.None;
}
}
int? oldScheduleId = hfUniqueScheduleId.Value.AsIntegerOrNull();
if ( scheduleType == ScheduleType.Custom || scheduleType == ScheduleType.Weekly )
{
if ( !oldScheduleId.HasValue || group.Schedule == null )
{
group.Schedule = new Schedule();
}
if ( scheduleType == ScheduleType.Custom )
{
group.Schedule.iCalendarContent = iCalendarContent;
group.Schedule.WeeklyDayOfWeek = null;
group.Schedule.WeeklyTimeOfDay = null;
}
else
{
group.Schedule.iCalendarContent = null;
group.Schedule.WeeklyDayOfWeek = dowWeekly.SelectedDayOfWeek;
group.Schedule.WeeklyTimeOfDay = timeWeekly.SelectedTime;
}
}
else
{
// If group did have a unique schedule, delete that schedule
if ( oldScheduleId.HasValue )
{
var schedule = scheduleService.Get( oldScheduleId.Value );
if ( schedule != null && string.IsNullOrEmpty(schedule.Name) )
{
scheduleService.Delete(schedule);
}
}
if ( scheduleType == ScheduleType.Named )
{
group.ScheduleId = spSchedule.SelectedValueAsId();
}
else
{
group.ScheduleId = null;
}
}
if ( group.ParentGroupId == group.Id )
{
gpParentGroup.ShowErrorMessage( "Group cannot be a Parent Group of itself." );
return;
}
group.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phGroupAttributes, group );
group.GroupType = new GroupTypeService( rockContext ).Get( group.GroupTypeId );
if ( group.ParentGroupId.HasValue )
{
group.ParentGroup = groupService.Get( group.ParentGroupId.Value );
}
// Check to see if user is still allowed to edit with selected group type and parent group
if ( !group.IsAuthorized( Authorization.EDIT, CurrentPerson ))
{
nbNotAllowedToEdit.Visible = true;
return;
}
if ( !Page.IsValid )
{
return;
}
if ( !group.IsValid )
{
// Controls will render the error messages
return;
}
// use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges()
rockContext.WrapTransaction( () =>
{
var adding = group.Id.Equals( 0 );
if ( adding )
{
groupService.Add( group );
}
rockContext.SaveChanges();
if (adding)
{
// add ADMINISTRATE to the person who added the group
Rock.Security.Authorization.AllowPerson( group, Authorization.ADMINISTRATE, this.CurrentPerson, rockContext );
}
group.SaveAttributeValues( rockContext );
/* Take care of Group Member Attributes */
var entityTypeId = EntityTypeCache.Read( typeof( GroupMember ) ).Id;
string qualifierColumn = "GroupId";
string qualifierValue = group.Id.ToString();
// Get the existing attributes for this entity type and qualifier value
var attributes = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
// Delete any of those attributes that were removed in the UI
var selectedAttributeGuids = GroupMemberAttributesState.Select( a => a.Guid );
foreach ( var attr in attributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
attributeService.Delete( attr );
}
// Update the Attributes that were assigned in the UI
foreach ( var attributeState in GroupMemberAttributesState )
{
Rock.Attribute.Helper.SaveAttributeEdits( attributeState, entityTypeId, qualifierColumn, qualifierValue, rockContext );
}
rockContext.SaveChanges();
} );
if ( group != null && wasSecurityRole )
{
if ( !group.IsSecurityRole )
{
// if this group was a SecurityRole, but no longer is, flush
Rock.Security.Role.Flush( group.Id );
Rock.Security.Authorization.Flush();
}
}
else
{
if ( group.IsSecurityRole )
{
// new security role, flush
Rock.Security.Authorization.Flush();
}
}
var qryParams = new Dictionary<string, string>();
qryParams["GroupId"] = group.Id.ToString();
qryParams["ExpandedIds"] = PageParameter( "ExpandedIds" );
NavigateToPage( RockPage.Guid, qryParams );
}
/// <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.Read( Rock.SystemGuid.FieldType.TEXT ).Id;
edtDefinedTypeAttributes.ActionTitle = ActionTitle.Add( "attribute for defined type " + tbTypeName.Text );
}
else
{
AttributeService attributeService = new AttributeService();
attribute = attributeService.Get( attributeGuid );
edtDefinedTypeAttributes.ActionTitle = ActionTitle.Edit( "attribute for defined type " + tbTypeName.Text );
}
edtDefinedTypeAttributes.SetAttributeProperties( attribute, typeof( DefinedValue ) );
this.HideSecondaryBlocks( true );
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
using ( new UnitOfWorkScope() )
{
var attributeService = new AttributeService();
var attributeQualifierService = new AttributeQualifierService();
Rock.Model.Attribute attribute;
int attributeId = 0;
if ( hfId.Value != string.Empty && !int.TryParse( hfId.Value, out attributeId ) )
{
attributeId = 0;
}
if ( attributeId == 0 )
{
attribute = new Rock.Model.Attribute();
attribute.IsSystem = false;
attribute.EntityTypeId = _entityTypeId;
attribute.EntityTypeQualifierColumn = _entityQualifierColumn;
attribute.EntityTypeQualifierValue = _entityQualifierValue;
attributeService.Add( attribute, CurrentPersonId );
}
else
{
AttributeCache.Flush( attributeId );
attribute = attributeService.Get( attributeId );
}
attribute.Key = tbKey.Text;
attribute.Name = tbName.Text;
attribute.Category = tbCategory.Text;
attribute.Description = tbDescription.Text;
attribute.FieldTypeId = int.Parse( ddlFieldType.SelectedValue );
var fieldType = FieldTypeCache.Read( attribute.FieldTypeId );
foreach ( var oldQualifier in attribute.AttributeQualifiers.ToList() )
{
attributeQualifierService.Delete( oldQualifier, CurrentPersonId );
}
attribute.AttributeQualifiers.Clear();
List<Control> configControls = new List<Control>();
foreach ( var key in fieldType.Field.ConfigurationKeys() )
{
configControls.Add( phFieldTypeQualifiers.FindControl( "configControl_" + key ) );
}
foreach ( var configValue in fieldType.Field.ConfigurationValues( configControls ) )
{
AttributeQualifier qualifier = new AttributeQualifier();
qualifier.IsSystem = false;
qualifier.Key = configValue.Key;
qualifier.Value = configValue.Value.Value ?? string.Empty;
attribute.AttributeQualifiers.Add( qualifier );
}
attribute.DefaultValue = tbDefaultValue.Text;
attribute.IsMultiValue = cbMultiValue.Checked;
attribute.IsRequired = cbRequired.Checked;
attributeService.Save( attribute, CurrentPersonId );
}
BindGrid();
pnlDetails.Visible = false;
pnlList.Visible = true;
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
AttributeService attributeService = new AttributeService();
var queryable = attributeService.Get( _entityTypeId, _entityQualifierColumn, _entityQualifierValue );
if ( ddlCategoryFilter.SelectedValue != "[All]" )
{
queryable = queryable.
Where( a => a.Category == ddlCategoryFilter.SelectedValue );
}
SortProperty sortProperty = rGrid.SortProperty;
if ( sortProperty != null )
{
queryable = queryable.
Sort( sortProperty );
}
else
{
queryable = queryable.
OrderBy( a => a.Category ).
ThenBy( a => a.Key );
}
rGrid.DataSource = queryable.ToList();
rGrid.DataBind();
}
/// <summary>
/// Binds the filter.
/// </summary>
private void BindFilter()
{
ddlCategoryFilter.Items.Clear();
ddlCategoryFilter.Items.Add( "[All]" );
AttributeService attributeService = new AttributeService();
var items = attributeService.Get( _entityTypeId, _entityQualifierColumn, _entityQualifierValue )
.Where( a => a.Category != string.Empty && a.Category != null )
.OrderBy( a => a.Category )
.Select( a => a.Category )
.Distinct()
.ToList();
foreach ( var item in items )
{
ListItem li = new ListItem( item );
li.Selected = ( !Page.IsPostBack && rFilter.GetUserValue( "Category" ) == item );
ddlCategoryFilter.Items.Add( li );
}
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
Group group;
bool wasSecurityRole = false;
RockContext rockContext = new RockContext();
GroupService groupService = new GroupService( rockContext );
GroupLocationService groupLocationService = new GroupLocationService( rockContext );
AttributeService attributeService = new AttributeService( rockContext );
AttributeQualifierService attributeQualifierService = new AttributeQualifierService( rockContext );
CategoryService categoryService = new CategoryService( rockContext );
if ( ( ddlGroupType.SelectedValueAsInt() ?? 0 ) == 0 )
{
ddlGroupType.ShowErrorMessage( Rock.Constants.WarningMessage.CannotBeBlank( GroupType.FriendlyTypeName ) );
return;
}
int groupId = int.Parse( hfGroupId.Value );
if ( groupId == 0 )
{
group = new Group();
group.IsSystem = false;
group.Name = string.Empty;
}
else
{
group = groupService.Get( groupId );
wasSecurityRole = group.IsSecurityRole;
var selectedLocations = GroupLocationsState.Select( l => l.Guid );
foreach ( var groupLocation in group.GroupLocations.Where( l => !selectedLocations.Contains( l.Guid ) ).ToList() )
{
group.GroupLocations.Remove( groupLocation );
groupLocationService.Delete( groupLocation );
}
}
foreach ( var groupLocationState in GroupLocationsState )
{
GroupLocation groupLocation = group.GroupLocations.Where( l => l.Guid == groupLocationState.Guid ).FirstOrDefault();
if ( groupLocation == null )
{
groupLocation = new GroupLocation();
group.GroupLocations.Add( groupLocation );
}
else
{
groupLocationState.Id = groupLocation.Id;
groupLocationState.Guid = groupLocation.Guid;
}
groupLocation.CopyPropertiesFrom( groupLocationState );
}
group.Name = tbName.Text;
group.Description = tbDescription.Text;
group.CampusId = ddlCampus.SelectedValue.Equals( None.IdValue ) ? (int?)null : int.Parse( ddlCampus.SelectedValue );
group.GroupTypeId = int.Parse( ddlGroupType.SelectedValue );
group.ParentGroupId = gpParentGroup.SelectedValue.Equals( None.IdValue ) ? (int?)null : int.Parse( gpParentGroup.SelectedValue );
group.IsSecurityRole = cbIsSecurityRole.Checked;
group.IsActive = cbIsActive.Checked;
if ( group.ParentGroupId == group.Id )
{
gpParentGroup.ShowErrorMessage( "Group cannot be a Parent Group of itself." );
return;
}
group.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phGroupAttributes, group );
if ( !Page.IsValid )
{
return;
}
if ( !group.IsValid )
{
// Controls will render the error messages
return;
}
// use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges()
RockTransactionScope.WrapTransaction( () =>
{
if ( group.Id.Equals( 0 ) )
{
groupService.Add( group );
}
rockContext.SaveChanges();
group.SaveAttributeValues( rockContext );
/* Take care of Group Member Attributes */
var entityTypeId = EntityTypeCache.Read( typeof( GroupMember ) ).Id;
string qualifierColumn = "GroupId";
string qualifierValue = group.Id.ToString();
// Get the existing attributes for this entity type and qualifier value
var attributes = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
// Delete any of those attributes that were removed in the UI
var selectedAttributeGuids = GroupMemberAttributesState.Select( a => a.Guid );
foreach ( var attr in attributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
attributeService.Delete( attr );
}
// Update the Attributes that were assigned in the UI
foreach ( var attributeState in GroupMemberAttributesState )
{
Rock.Attribute.Helper.SaveAttributeEdits( attributeState, entityTypeId, qualifierColumn, qualifierValue, rockContext );
}
rockContext.SaveChanges();
} );
if ( group != null && wasSecurityRole )
{
if ( !group.IsSecurityRole )
{
// if this group was a SecurityRole, but no longer is, flush
Rock.Security.Role.Flush( group.Id );
Rock.Security.Authorization.Flush();
}
}
else
{
if ( group.IsSecurityRole )
{
// new security role, flush
Rock.Security.Authorization.Flush();
}
}
var qryParams = new Dictionary<string, string>();
qryParams["GroupId"] = group.Id.ToString();
NavigateToPage( RockPage.Guid, qryParams );
}
/// <summary>
/// Shows the edit.
/// </summary>
/// <param name="attributeId">The attribute id.</param>
protected void ShowEdit( int attributeId )
{
var rockContext = new RockContext();
var attributeService = new AttributeService( rockContext );
var attributeModel = attributeService.Get( attributeId );
if ( attributeModel == null )
{
mdAttribute.Title = "Add Attribute".FormatAsHtmlTitle();
attributeModel = new Rock.Model.Attribute();
attributeModel.FieldTypeId = FieldTypeCache.Read( Rock.SystemGuid.FieldType.TEXT ).Id;
if ( !_configuredType )
{
int entityTypeId = int.MinValue;
if ( int.TryParse( rFilter.GetUserPreference( "Entity Type" ), out entityTypeId ) && entityTypeId > 0 )
{
attributeModel.EntityTypeId = entityTypeId;
}
}
else
{
attributeModel.EntityTypeId = _entityTypeId;
attributeModel.EntityTypeQualifierColumn = _entityQualifierColumn;
attributeModel.EntityTypeQualifierValue = _entityQualifierValue;
}
List<int> selectedCategoryIds = cpCategoriesFilter.SelectedValuesAsInt().ToList();
new CategoryService( rockContext ).Queryable().Where( c => selectedCategoryIds.Contains( c.Id ) ).ToList().ForEach( c =>
attributeModel.Categories.Add( c ) );
edtAttribute.ActionTitle = Rock.Constants.ActionTitle.Add( Rock.Model.Attribute.FriendlyTypeName );
}
else
{
if ( attributeModel.EntityType != null && attributeModel.EntityType.IsIndexingSupported == true && attributeModel.EntityType.IsIndexingEnabled )
{
edtAttribute.IsIndexingEnabledVisible = true;
}
edtAttribute.ActionTitle = Rock.Constants.ActionTitle.Edit( Rock.Model.Attribute.FriendlyTypeName );
mdAttribute.Title = ( "Edit " + attributeModel.Name ).FormatAsHtmlTitle();
edtAttribute.IsIndexingEnabled = attributeModel.IsIndexEnabled;
}
Type type = null;
if ( attributeModel.EntityTypeId.HasValue )
{
type = EntityTypeCache.Read( attributeModel.EntityTypeId.Value ).GetEntityType();
edtAttribute.ReservedKeyNames = attributeService.Get( attributeModel.EntityTypeId, attributeModel.EntityTypeQualifierColumn, attributeModel.EntityTypeQualifierValue )
.Where( a => a.Id != attributeId )
.Select( a => a.Key )
.Distinct()
.ToList();
}
edtAttribute.SetAttributeProperties( attributeModel, type );
edtAttribute.AttributeEntityTypeId = attributeModel.EntityTypeId;
if ( _configuredType )
{
pnlEntityTypeQualifier.Visible = false;
}
else
{
pnlEntityTypeQualifier.Visible = true;
ddlAttrEntityType.SetValue( attributeModel.EntityTypeId.HasValue ? attributeModel.EntityTypeId.Value.ToString() : "0" );
tbAttrQualifierField.Text = attributeModel.EntityTypeQualifierColumn;
tbAttrQualifierValue.Text = attributeModel.EntityTypeQualifierValue;
}
ShowDialog( "Attribute", true );
}
/// <summary>
/// Saves any attribute edits made using an Attribute Editor control
/// </summary>
/// <param name="edtAttribute">The edt attribute.</param>
/// <param name="entityTypeId">The entity type identifier.</param>
/// <param name="entityTypeQualifierColumn">The entity type qualifier column.</param>
/// <param name="entityTypeQualifierValue">The entity type qualifier value.</param>
/// <param name="rockContext">The rock context.</param>
/// <returns></returns>
/// <remarks>
/// If a rockContext value is included, this method will save any previous changes made to the context
/// </remarks>
public static Rock.Model.Attribute SaveAttributeEdits( AttributeEditor edtAttribute, int? entityTypeId, string entityTypeQualifierColumn, string entityTypeQualifierValue, RockContext rockContext = null )
{
// Create and update a new attribute object with new values
var newAttribute = new Rock.Model.Attribute();
edtAttribute.GetAttributeProperties( newAttribute );
rockContext = rockContext ?? new RockContext();
var internalAttributeService = new AttributeService( rockContext );
Rock.Model.Attribute attribute = null;
if ( newAttribute.Id > 0 )
{
attribute = internalAttributeService.Get( newAttribute.Id );
}
if ( attribute == null )
{
newAttribute.Order = internalAttributeService.Queryable().Max( a => a.Order ) + 1;
}
else
{
newAttribute.Order = attribute.Order;
}
return SaveAttributeEdits( newAttribute, entityTypeId, entityTypeQualifierColumn, entityTypeQualifierValue, rockContext );
}
private IQueryable<Rock.Model.Attribute> GetData( RockContext rockContext )
{
IQueryable<Rock.Model.Attribute> query = null;
AttributeService attributeService = new AttributeService( rockContext );
if ( _configuredType )
{
query = attributeService.Get( _entityTypeId, _entityQualifierColumn, _entityQualifierValue );
}
else
{
int? entityTypeId = rFilter.GetUserPreference( "Entity Type" ).AsIntegerOrNull();
if ( entityTypeId.HasValue )
{
if ( entityTypeId.Value == 0 )
{
// Global Attributes
query = attributeService.GetByEntityTypeId( null );
}
else
{
query = attributeService.GetByEntityTypeId( entityTypeId );
}
}
else
{
// All entity attribute
query = attributeService.Queryable()
.Where( a =>
( a.EntityType != null && a.EntityType.IsEntity ) || // Entity Attributes
( a.EntityType == null && a.EntityTypeQualifierColumn == "" && a.EntityTypeQualifierValue == "" ) // Global Attributes
);
}
}
// if filtering by block setting of categories
if (!string.IsNullOrWhiteSpace( GetAttributeValue( "CategoryFilter" ) ) )
{
try {
var categoryGuids = GetAttributeValue( "CategoryFilter" ).Split( ',' ).Select( Guid.Parse ).ToList();
query = query.Where( a => a.Categories.Any( c => categoryGuids.Contains( c.Guid ) ) );
}
catch { }
}
var selectedCategoryIds = new List<int>();
rFilter.GetUserPreference( "Categories" ).SplitDelimitedValues().ToList().ForEach( s => selectedCategoryIds.Add( int.Parse( s ) ) );
if ( selectedCategoryIds.Any() )
{
query = query.Where( a => a.Categories.Any( c => selectedCategoryIds.Contains( c.Id ) ) );
}
if ( _enableOrdering )
{
query = query.OrderBy( a => a.Order );
}
else
{
SortProperty sortProperty = rGrid.SortProperty;
if ( sortProperty != null )
{
query = query.Sort( sortProperty );
}
else
{
query = query.OrderBy( a => a.Key );
}
}
return query;
}
/// <summary>
/// Deletes the registration templates.
/// </summary>
/// <param name="elemRegistrationTemplate">The elem registration template.</param>
/// <param name="rockContext">The rock context.</param>
private void DeleteRegistrationTemplates( XElement elemRegistrationTemplates, RockContext rockContext )
{
if ( elemRegistrationTemplates == null )
{
return;
}
var service = new RegistrationTemplateService( rockContext );
foreach ( var elemRegistrationTemplate in elemRegistrationTemplates.Elements( "registrationTemplate" ) )
{
Guid guid = elemRegistrationTemplate.Attribute( "guid" ).Value.Trim().AsGuid();
var registrationTemplate = service.Get( guid );
rockContext.WrapTransaction( () =>
{
if ( registrationTemplate != null )
{
if ( registrationTemplate.Instances != null )
{
AttributeService attributeService = new AttributeService( rockContext );
if ( registrationTemplate.Forms != null )
{
foreach ( var id in registrationTemplate.Forms.SelectMany( f => f.Fields ).Where( ff => ff.FieldSource == RegistrationFieldSource.RegistrationAttribute ).Select( f => f.AttributeId ) )
{
if ( id != null )
{
Rock.Model.Attribute attribute = attributeService.Get( id ?? -1 );
if ( attribute != null )
{
attributeService.Delete( attribute );
}
}
}
}
var registrations = registrationTemplate.Instances.SelectMany( i => i.Registrations );
new RegistrationService( rockContext ).DeleteRange( registrations );
new RegistrationInstanceService( rockContext ).DeleteRange( registrationTemplate.Instances );
}
service.Delete( registrationTemplate );
rockContext.SaveChanges();
}
} );
}
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
BinaryFileType binaryFileType;
var rockContext = new RockContext();
BinaryFileTypeService binaryFileTypeService = new BinaryFileTypeService( rockContext );
AttributeService attributeService = new AttributeService( rockContext );
AttributeQualifierService attributeQualifierService = new AttributeQualifierService( rockContext );
CategoryService categoryService = new CategoryService( rockContext );
int binaryFileTypeId = int.Parse( hfBinaryFileTypeId.Value );
if ( binaryFileTypeId == 0 )
{
binaryFileType = new BinaryFileType();
binaryFileTypeService.Add( binaryFileType );
}
else
{
binaryFileType = binaryFileTypeService.Get( binaryFileTypeId );
}
binaryFileType.Name = tbName.Text;
binaryFileType.Description = tbDescription.Text;
binaryFileType.IconCssClass = tbIconCssClass.Text;
binaryFileType.AllowCaching = cbAllowCaching.Checked;
binaryFileType.RequiresViewSecurity = cbRequiresViewSecurity.Checked;
binaryFileType.MaxWidth = nbMaxWidth.Text.AsInteger();
binaryFileType.MaxHeight = nbMaxHeight.Text.AsInteger();
binaryFileType.PreferredFormat = ddlPreferredFormat.SelectedValueAsEnum<Format>();
binaryFileType.PreferredResolution = ddlPreferredResolution.SelectedValueAsEnum<Resolution>();
binaryFileType.PreferredColorDepth = ddlPreferredColorDepth.SelectedValueAsEnum<ColorDepth>();
binaryFileType.PreferredRequired = cbPreferredRequired.Checked;
if ( !string.IsNullOrWhiteSpace( cpStorageType.SelectedValue ) )
{
var entityTypeService = new EntityTypeService( rockContext );
var storageEntityType = entityTypeService.Get( new Guid( cpStorageType.SelectedValue ) );
if ( storageEntityType != null )
{
binaryFileType.StorageEntityTypeId = storageEntityType.Id;
}
}
binaryFileType.LoadAttributes( rockContext );
Rock.Attribute.Helper.GetEditValues( phAttributes, binaryFileType );
if ( !binaryFileType.IsValid )
{
// Controls will render the error messages
return;
}
rockContext.WrapTransaction( () =>
{
rockContext.SaveChanges();
// get it back to make sure we have a good Id for it for the Attributes
binaryFileType = binaryFileTypeService.Get( binaryFileType.Guid );
/* Take care of Binary File Attributes */
var entityTypeId = Rock.Web.Cache.EntityTypeCache.Read( typeof( BinaryFile ) ).Id;
// delete BinaryFileAttributes that are no longer configured in the UI
var attributes = attributeService.Get( entityTypeId, "BinaryFileTypeId", binaryFileType.Id.ToString() );
var selectedAttributeGuids = BinaryFileAttributesState.Select( a => a.Guid );
foreach ( var attr in attributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
attributeService.Delete( attr );
}
rockContext.SaveChanges();
// add/update the BinaryFileAttributes that are assigned in the UI
foreach ( var attributeState in BinaryFileAttributesState )
{
Rock.Attribute.Helper.SaveAttributeEdits( attributeState, entityTypeId, "BinaryFileTypeId", binaryFileType.Id.ToString(), rockContext );
}
// SaveAttributeValues for the BinaryFileType
binaryFileType.SaveAttributeValues( rockContext );
} );
AttributeCache.FlushEntityAttributes();
NavigateToParentPage();
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
var rockContext = new RockContext();
MarketingCampaignAdType marketingCampaignAdType;
MarketingCampaignAdTypeService marketingCampaignAdTypeService = new MarketingCampaignAdTypeService( rockContext );
int marketingCampaignAdTypeId = int.Parse( hfMarketingCampaignAdTypeId.Value );
if ( marketingCampaignAdTypeId == 0 )
{
marketingCampaignAdType = new MarketingCampaignAdType();
marketingCampaignAdTypeService.Add( marketingCampaignAdType );
}
else
{
marketingCampaignAdType = marketingCampaignAdTypeService.Get( marketingCampaignAdTypeId );
}
marketingCampaignAdType.Name = tbName.Text;
marketingCampaignAdType.DateRangeType = (DateRangeTypeEnum)int.Parse( ddlDateRangeType.SelectedValue );
if ( !marketingCampaignAdType.IsValid )
{
// Controls will render the error messages
return;
}
RockTransactionScope.WrapTransaction( () =>
{
AttributeService attributeService = new AttributeService( rockContext );
AttributeQualifierService attributeQualifierService = new AttributeQualifierService( rockContext );
CategoryService categoryService = new CategoryService( rockContext );
rockContext.SaveChanges();
// get it back to make sure we have a good Id for it for the Attributes
marketingCampaignAdType = marketingCampaignAdTypeService.Get( marketingCampaignAdType.Guid );
var entityTypeId = EntityTypeCache.Read( typeof( MarketingCampaignAd ) ).Id;
string qualifierColumn = "MarketingCampaignAdTypeId";
string qualifierValue = marketingCampaignAdType.Id.ToString();
// Get the existing attributes for this entity type and qualifier value
var attributes = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
// Delete any of those attributes that were removed in the UI
var selectedAttributeGuids = AttributesState.Select( a => a.Guid );
foreach ( var attr in attributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
attributeService.Delete( attr );
}
rockContext.SaveChanges();
// Update the Attributes that were assigned in the UI
foreach ( var attributeState in AttributesState )
{
Rock.Attribute.Helper.SaveAttributeEdits( attributeState, entityTypeId, qualifierColumn, qualifierValue, rockContext );
}
} );
NavigateToParentPage();
}
private void SaveAttributes( int entityTypeId, string qualifierColumn, string qualifierValue, ViewStateList<Attribute> viewStateAttributes, RockContext rockContext )
{
// Get the existing attributes for this entity type and qualifier value
var attributeService = new AttributeService( rockContext );
var attributes = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
// Delete any of those attributes that were removed in the UI
var selectedAttributeGuids = viewStateAttributes.Select( a => a.Guid );
foreach ( var attr in attributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
attributeService.Delete( attr );
rockContext.SaveChanges();
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
}
// Update the Attributes that were assigned in the UI
foreach ( var attributeState in viewStateAttributes )
{
Helper.SaveAttributeEdits( attributeState, entityTypeId, qualifierColumn, qualifierValue, rockContext );
}
}
/// <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.Read( 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 ).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 );
}
private void SaveAttributes( int entityTypeId, string qualifierColumn, string qualifierValue, ViewStateList<Attribute> viewStateAttributes,
AttributeService attributeService, AttributeQualifierService qualifierService, CategoryService categoryService )
{
// Get the existing attributes for this entity type and qualifier value
var attributes = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
// Delete any of those attributes that were removed in the UI
var selectedAttributeGuids = viewStateAttributes.Select( a => a.Guid );
foreach ( var attr in attributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
attributeService.Delete( attr, CurrentPersonId );
attributeService.Save( attr, CurrentPersonId );
}
// Update the Attributes that were assigned in the UI
foreach ( var attributeState in viewStateAttributes )
{
Helper.SaveAttributeEdits( attributeState, attributeService, qualifierService, categoryService,
entityTypeId, qualifierColumn, qualifierValue, CurrentPersonId );
}
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
ParseControls( true );
var rockContext = new RockContext();
var service = new RegistrationTemplateService( rockContext );
RegistrationTemplate RegistrationTemplate = null;
int? RegistrationTemplateId = hfRegistrationTemplateId.Value.AsIntegerOrNull();
if ( RegistrationTemplateId.HasValue )
{
RegistrationTemplate = service.Get( RegistrationTemplateId.Value );
}
bool newTemplate = false;
if ( RegistrationTemplate == null )
{
newTemplate = true;
RegistrationTemplate = new RegistrationTemplate();
}
RegistrationNotify notify = RegistrationNotify.None;
foreach( ListItem li in cblNotify.Items )
{
if ( li.Selected )
{
notify = notify | (RegistrationNotify)li.Value.AsInteger();
}
}
RegistrationTemplate.IsActive = cbIsActive.Checked;
RegistrationTemplate.Name = tbName.Text;
RegistrationTemplate.CategoryId = cpCategory.SelectedValueAsInt();
RegistrationTemplate.GroupTypeId = gtpGroupType.SelectedGroupTypeId;
RegistrationTemplate.GroupMemberRoleId = rpGroupTypeRole.GroupRoleId;
RegistrationTemplate.GroupMemberStatus = ddlGroupMemberStatus.SelectedValueAsEnum<GroupMemberStatus>();
RegistrationTemplate.RequiredSignatureDocumentTemplateId = ddlSignatureDocumentTemplate.SelectedValueAsInt();
RegistrationTemplate.SignatureDocumentAction = cbDisplayInLine.Checked ? SignatureDocumentAction.Embed : SignatureDocumentAction.Email;
RegistrationTemplate.RegistrationWorkflowTypeId = wtpRegistrationWorkflow.SelectedValueAsInt();
RegistrationTemplate.Notify = notify;
RegistrationTemplate.AddPersonNote = cbAddPersonNote.Checked;
RegistrationTemplate.LoginRequired = cbLoginRequired.Checked;
RegistrationTemplate.AllowExternalRegistrationUpdates = cbAllowExternalUpdates.Checked;
RegistrationTemplate.AllowGroupPlacement = cbAllowGroupPlacement.Checked;
RegistrationTemplate.AllowMultipleRegistrants = cbMultipleRegistrants.Checked;
RegistrationTemplate.MaxRegistrants = nbMaxRegistrants.Text.AsInteger();
RegistrationTemplate.RegistrantsSameFamily = rblRegistrantsInSameFamily.SelectedValueAsEnum<RegistrantsSameFamily>();
RegistrationTemplate.ShowCurrentFamilyMembers = cbShowCurrentFamilyMembers.Checked;
RegistrationTemplate.SetCostOnInstance = !tglSetCostOnTemplate.Checked;
RegistrationTemplate.Cost = cbCost.Text.AsDecimal();
RegistrationTemplate.MinimumInitialPayment = cbMinimumInitialPayment.Text.AsDecimalOrNull();
RegistrationTemplate.FinancialGatewayId = fgpFinancialGateway.SelectedValueAsInt();
RegistrationTemplate.BatchNamePrefix = txtBatchNamePrefix.Text;
RegistrationTemplate.ConfirmationFromName = tbConfirmationFromName.Text;
RegistrationTemplate.ConfirmationFromEmail = tbConfirmationFromEmail.Text;
RegistrationTemplate.ConfirmationSubject = tbConfirmationSubject.Text;
RegistrationTemplate.ConfirmationEmailTemplate = ceConfirmationEmailTemplate.Text;
RegistrationTemplate.ReminderFromName = tbReminderFromName.Text;
RegistrationTemplate.ReminderFromEmail = tbReminderFromEmail.Text;
RegistrationTemplate.ReminderSubject = tbReminderSubject.Text;
RegistrationTemplate.ReminderEmailTemplate = ceReminderEmailTemplate.Text;
RegistrationTemplate.PaymentReminderFromName = tbPaymentReminderFromName.Text;
RegistrationTemplate.PaymentReminderFromEmail = tbPaymentReminderFromEmail.Text;
RegistrationTemplate.PaymentReminderSubject = tbPaymentReminderSubject.Text;
RegistrationTemplate.PaymentReminderEmailTemplate = cePaymentReminderEmailTemplate.Text;
RegistrationTemplate.PaymentReminderTimeSpan = nbPaymentReminderTimeSpan.Text.AsInteger();
RegistrationTemplate.RegistrationTerm = string.IsNullOrWhiteSpace( tbRegistrationTerm.Text ) ? "Registration" : tbRegistrationTerm.Text;
RegistrationTemplate.RegistrantTerm = string.IsNullOrWhiteSpace( tbRegistrantTerm.Text ) ? "Registrant" : tbRegistrantTerm.Text;
RegistrationTemplate.FeeTerm = string.IsNullOrWhiteSpace( tbFeeTerm.Text ) ? "Additional Options" : tbFeeTerm.Text;
RegistrationTemplate.DiscountCodeTerm = string.IsNullOrWhiteSpace( tbDiscountCodeTerm.Text ) ? "Discount Code" : tbDiscountCodeTerm.Text;
RegistrationTemplate.SuccessTitle = tbSuccessTitle.Text;
RegistrationTemplate.SuccessText = ceSuccessText.Text;
if ( !Page.IsValid || !RegistrationTemplate.IsValid )
{
return;
}
foreach ( var form in FormState )
{
if ( !form.IsValid )
{
return;
}
if ( FormFieldsState.ContainsKey( form.Guid ) )
{
foreach( var formField in FormFieldsState[ form.Guid ])
{
if ( !formField.IsValid )
{
return;
}
}
}
}
// Get the valid group member attributes
var group = new Group();
group.GroupTypeId = gtpGroupType.SelectedGroupTypeId ?? 0;
var groupMember = new GroupMember();
groupMember.Group = group;
groupMember.LoadAttributes();
var validGroupMemberAttributeIds = groupMember.Attributes.Select( a => a.Value.Id ).ToList();
// Remove any group member attributes that are not valid based on selected group type
foreach( var fieldList in FormFieldsState.Select( s => s.Value ) )
{
foreach( var formField in fieldList
.Where( a =>
a.FieldSource == RegistrationFieldSource.GroupMemberAttribute &&
a.AttributeId.HasValue &&
!validGroupMemberAttributeIds.Contains( a.AttributeId.Value ) )
.ToList() )
{
fieldList.Remove( formField );
}
}
// Perform Validation
var validationErrors = new List<string>();
if ( ( ( RegistrationTemplate.SetCostOnInstance ?? false ) || RegistrationTemplate.Cost > 0 || FeeState.Any() ) && !RegistrationTemplate.FinancialGatewayId.HasValue )
{
validationErrors.Add( "A Financial Gateway is required when the registration has a cost or additional fees or is configured to allow instances to set a cost." );
}
if ( validationErrors.Any() )
{
nbValidationError.Visible = true;
nbValidationError.Text = "<ul class='list-unstyled'><li>" + validationErrors.AsDelimited( "</li><li>" ) + "</li></ul>";
}
else
{
// Save the entity field changes to registration template
if ( RegistrationTemplate.Id.Equals( 0 ) )
{
service.Add( RegistrationTemplate );
}
rockContext.SaveChanges();
var attributeService = new AttributeService( rockContext );
var registrationTemplateFormService = new RegistrationTemplateFormService( rockContext );
var registrationTemplateFormFieldService = new RegistrationTemplateFormFieldService( rockContext );
var registrationTemplateDiscountService = new RegistrationTemplateDiscountService( rockContext );
var registrationTemplateFeeService = new RegistrationTemplateFeeService( rockContext );
var registrationRegistrantFeeService = new RegistrationRegistrantFeeService( rockContext );
var groupService = new GroupService( rockContext );
// delete forms that aren't assigned in the UI anymore
var formUiGuids = FormState.Select( f => f.Guid ).ToList();
foreach ( var form in registrationTemplateFormService
.Queryable()
.Where( f =>
f.RegistrationTemplateId == RegistrationTemplate.Id &&
!formUiGuids.Contains( f.Guid ) ) )
{
foreach( var formField in form.Fields.ToList() )
{
form.Fields.Remove( formField );
registrationTemplateFormFieldService.Delete( formField );
}
registrationTemplateFormService.Delete( form );
}
// delete fields that aren't assigned in the UI anymore
var fieldUiGuids = FormFieldsState.SelectMany( a => a.Value).Select( f => f.Guid ).ToList();
foreach ( var formField in registrationTemplateFormFieldService
.Queryable()
.Where( a =>
formUiGuids.Contains( a.RegistrationTemplateForm.Guid ) &&
!fieldUiGuids.Contains( a.Guid ) ) )
{
registrationTemplateFormFieldService.Delete( formField );
}
// delete discounts that aren't assigned in the UI anymore
var discountUiGuids = DiscountState.Select( u => u.Guid ).ToList();
foreach ( var discount in registrationTemplateDiscountService
.Queryable()
.Where( d =>
d.RegistrationTemplateId == RegistrationTemplate.Id &&
!discountUiGuids.Contains( d.Guid ) ) )
{
registrationTemplateDiscountService.Delete( discount );
}
// delete fees that aren't assigned in the UI anymore
var feeUiGuids = FeeState.Select( u => u.Guid ).ToList();
var deletedfees = registrationTemplateFeeService
.Queryable()
.Where( d =>
d.RegistrationTemplateId == RegistrationTemplate.Id &&
!feeUiGuids.Contains( d.Guid ) )
.ToList();
var deletedFeeIds = deletedfees.Select( f => f.Id ).ToList();
foreach ( var registrantFee in registrationRegistrantFeeService
.Queryable()
.Where( f => deletedFeeIds.Contains( f.RegistrationTemplateFeeId ) )
.ToList() )
{
registrationRegistrantFeeService.Delete( registrantFee );
}
foreach ( var fee in deletedfees )
{
registrationTemplateFeeService.Delete( fee );
}
int? entityTypeId = EntityTypeCache.Read( typeof( Rock.Model.RegistrationRegistrant ) ).Id;
var qualifierColumn = "RegistrationTemplateId";
var qualifierValue = RegistrationTemplate.Id.ToString();
// Get the registration attributes still in the UI
var attributesUI = FormFieldsState
.SelectMany( s =>
s.Value.Where( a =>
a.FieldSource == RegistrationFieldSource.RegistrationAttribute &&
a.Attribute != null ) )
.Select( f => f.Attribute )
.ToList();
var selectedAttributeGuids = attributesUI.Select( a => a.Guid );
// Delete the registration attributes that were removed from the UI
var attributesDB = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
foreach ( var attr in attributesDB.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ).ToList() )
{
attributeService.Delete( attr );
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
}
rockContext.SaveChanges();
// Save all of the registration attributes still in the UI
foreach ( var attr in attributesUI )
{
Helper.SaveAttributeEdits( attr, entityTypeId, qualifierColumn, qualifierValue, rockContext );
}
// add/updated forms/fields
foreach ( var formUI in FormState )
{
var form = RegistrationTemplate.Forms.FirstOrDefault( f => f.Guid.Equals( formUI.Guid ) );
if ( form == null )
{
form = new RegistrationTemplateForm();
form.Guid = formUI.Guid;
RegistrationTemplate.Forms.Add( form );
}
form.Name = formUI.Name;
form.Order = formUI.Order;
if ( FormFieldsState.ContainsKey( form.Guid ) )
{
foreach ( var formFieldUI in FormFieldsState[form.Guid] )
{
var formField = form.Fields.FirstOrDefault( a => a.Guid.Equals( formFieldUI.Guid ) );
if ( formField == null )
{
formField = new RegistrationTemplateFormField();
formField.Guid = formFieldUI.Guid;
form.Fields.Add( formField );
}
formField.AttributeId = formFieldUI.AttributeId;
if ( !formField.AttributeId.HasValue &&
formFieldUI.FieldSource == RegistrationFieldSource.RegistrationAttribute &&
formFieldUI.Attribute != null )
{
var attr = AttributeCache.Read( formFieldUI.Attribute.Guid, rockContext );
if ( attr != null )
{
formField.AttributeId = attr.Id;
}
}
formField.FieldSource = formFieldUI.FieldSource;
formField.PersonFieldType = formFieldUI.PersonFieldType;
formField.IsInternal = formFieldUI.IsInternal;
formField.IsSharedValue = formFieldUI.IsSharedValue;
formField.ShowCurrentValue = formFieldUI.ShowCurrentValue;
formField.PreText = formFieldUI.PreText;
formField.PostText = formFieldUI.PostText;
formField.IsGridField = formFieldUI.IsGridField;
formField.IsRequired = formFieldUI.IsRequired;
formField.Order = formFieldUI.Order;
}
}
}
// add/updated discounts
foreach ( var discountUI in DiscountState )
{
var discount = RegistrationTemplate.Discounts.FirstOrDefault( a => a.Guid.Equals( discountUI.Guid ) );
if ( discount == null )
{
discount = new RegistrationTemplateDiscount();
discount.Guid = discountUI.Guid;
RegistrationTemplate.Discounts.Add( discount );
}
discount.Code = discountUI.Code;
discount.DiscountPercentage = discountUI.DiscountPercentage;
discount.DiscountAmount = discountUI.DiscountAmount;
discount.Order = discountUI.Order;
}
// add/updated fees
foreach ( var feeUI in FeeState )
{
var fee = RegistrationTemplate.Fees.FirstOrDefault( a => a.Guid.Equals( feeUI.Guid ) );
if ( fee == null )
{
fee = new RegistrationTemplateFee();
fee.Guid = feeUI.Guid;
RegistrationTemplate.Fees.Add( fee );
}
fee.Name = feeUI.Name;
fee.FeeType = feeUI.FeeType;
fee.CostValue = feeUI.CostValue;
fee.DiscountApplies = feeUI.DiscountApplies;
fee.AllowMultiple = feeUI.AllowMultiple;
fee.Order = feeUI.Order;
}
rockContext.SaveChanges();
AttributeCache.FlushEntityAttributes();
// If this is a new template, give the current user and the Registration Administrators role administrative
// rights to this template, and staff, and staff like roles edit rights
if ( newTemplate )
{
RegistrationTemplate.AllowPerson( Authorization.ADMINISTRATE, CurrentPerson, rockContext );
var registrationAdmins = groupService.Get( Rock.SystemGuid.Group.GROUP_EVENT_REGISTRATION_ADMINISTRATORS.AsGuid() );
RegistrationTemplate.AllowSecurityRole( Authorization.ADMINISTRATE, registrationAdmins, rockContext );
var staffLikeUsers = groupService.Get( Rock.SystemGuid.Group.GROUP_STAFF_LIKE_MEMBERS.AsGuid() );
RegistrationTemplate.AllowSecurityRole( Authorization.EDIT, staffLikeUsers, rockContext );
var staffUsers = groupService.Get( Rock.SystemGuid.Group.GROUP_STAFF_MEMBERS.AsGuid() );
RegistrationTemplate.AllowSecurityRole( Authorization.EDIT, staffUsers, rockContext );
}
var qryParams = new Dictionary<string, string>();
qryParams["RegistrationTemplateId"] = RegistrationTemplate.Id.ToString();
NavigateToPage( RockPage.Guid, qryParams );
}
}
/// <summary>
/// Saves a <see cref="Rock.Model.Person">Person's</see> user preference setting by key.
/// </summary>
/// <param name="person">The <see cref="Rock.Model.Person"/> who the preference value belongs to.</param>
/// <param name="key">A <see cref="System.String"/> representing the key (name) of the preference setting.</param>
/// <param name="value">The value.</param>
public static void SaveUserPreference( Person person, string key, string value )
{
int? PersonEntityTypeId = Rock.Web.Cache.EntityTypeCache.Read( Person.USER_VALUE_ENTITY ).Id;
using ( var rockContext = new RockContext() )
{
var attributeService = new Model.AttributeService( rockContext );
var attribute = attributeService.Get( PersonEntityTypeId, string.Empty, string.Empty, key );
if ( attribute == null )
{
var fieldTypeService = new Model.FieldTypeService( rockContext );
var fieldType = FieldTypeCache.Read( Rock.SystemGuid.FieldType.TEXT.AsGuid() );
attribute = new Model.Attribute();
attribute.IsSystem = false;
attribute.EntityTypeId = PersonEntityTypeId;
attribute.EntityTypeQualifierColumn = string.Empty;
attribute.EntityTypeQualifierValue = string.Empty;
attribute.Key = key;
attribute.Name = key;
attribute.IconCssClass = string.Empty;
attribute.DefaultValue = string.Empty;
attribute.IsMultiValue = false;
attribute.IsRequired = false;
attribute.Description = string.Empty;
attribute.FieldTypeId = fieldType.Id;
attribute.Order = 0;
attributeService.Add( attribute );
rockContext.SaveChanges();
}
var attributeValueService = new Model.AttributeValueService( rockContext );
var attributeValue = attributeValueService.GetByAttributeIdAndEntityId( attribute.Id, person.Id );
if ( string.IsNullOrWhiteSpace( value ) )
{
// Delete existing value if no existing value
if ( attributeValue != null )
{
attributeValueService.Delete( attributeValue );
}
}
else
{
if ( attributeValue == null )
{
attributeValue = new Model.AttributeValue();
attributeValue.AttributeId = attribute.Id;
attributeValue.EntityId = person.Id;
attributeValueService.Add( attributeValue );
}
attributeValue.Value = value;
}
rockContext.SaveChanges();
}
}
/// <summary>
/// Saves the attributes.
/// </summary>
/// <param name="channelId">The channel identifier.</param>
/// <param name="entityTypeId">The entity type identifier.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="rockContext">The rock context.</param>
private void SaveAttributes( int channelId, int entityTypeId, List<Attribute> attributes, RockContext rockContext )
{
string qualifierColumn = "ContentChannelId";
string qualifierValue = channelId.ToString();
AttributeService attributeService = new AttributeService( rockContext );
// Get the existing attributes for this entity type and qualifier value
var existingAttributes = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
// Delete any of those attributes that were removed in the UI
var selectedAttributeGuids = attributes.Select( a => a.Guid );
foreach ( var attr in existingAttributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
attributeService.Delete( attr );
}
rockContext.SaveChanges();
int newOrder = 1000;
// Update the Attributes that were assigned in the UI
foreach ( var attr in attributes.OrderBy( a => a.Order ) )
{
// Artificially exaggerate the order so that all channel specific attributes are displayed after the content-type specific attributes (unless categorized)
attr.Order = newOrder++;
Rock.Attribute.Helper.SaveAttributeEdits( attr, entityTypeId, qualifierColumn, qualifierValue, rockContext );
}
AttributeCache.FlushEntityAttributes();
}
/// <summary>
/// Returns a <see cref="Rock.Model.Person"/> user preference value by preference setting's key.
/// </summary>
/// <param name="person">The <see cref="Rock.Model.Person"/> to retrieve the preference value for.</param>
/// <param name="key">A <see cref="System.String"/> representing the key name of the preference setting.</param>
/// <returns>A list of <see cref="System.String"/> containing the values associated with the user's preference setting.</returns>
public static string GetUserPreference( Person person, string key )
{
int? PersonEntityTypeId = Rock.Web.Cache.EntityTypeCache.Read( Person.USER_VALUE_ENTITY ).Id;
using ( var rockContext = new Rock.Data.RockContext() )
{
var attributeService = new Model.AttributeService( rockContext );
var attribute = attributeService.Get( PersonEntityTypeId, string.Empty, string.Empty, key );
if ( attribute != null )
{
var attributeValueService = new Model.AttributeValueService( rockContext );
var attributeValue = attributeValueService.GetByAttributeIdAndEntityId( attribute.Id, person.Id );
if ( attributeValue != null )
{
return attributeValue.Value;
}
}
}
return null;
}