/// <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 AttributeService(rockContext);
var attribute = attributeService.Get(e.RowKeyId);
if (attribute != null)
{
if ((!_entityTypeId.HasValue || _entityTypeId.Value == 0) &&
_entityQualifierColumn == string.Empty &&
_entityQualifierValue == string.Empty &&
(!_entityId.HasValue || _entityId.Value == 0)
)
{
GlobalAttributesCache.Remove();
}
attributeService.Delete(attribute);
rockContext.SaveChanges();
}
BindGrid();
}
/// <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();
}
AttributeCache.FlushEntityAttributes();
BindDefinedTypeAttributesGrid();
}
/// <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.GetByEntityTypeQualifier(entityTypeId, qualifierColumn, qualifierValue, true);
// 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)))
{
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);
}
}
/// <summary>
/// Handles the Delete event of the gWorkflowTypeAttributes 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 gWorkflowTypeAttributes_Delete(object sender, RowEventArgs e)
{
Guid attributeGuid = (Guid)e.RowKeyValue;
AttributeService attributeService = new AttributeService();
Attribute attribute = attributeService.Get(attributeGuid);
if (attribute != null)
{
string errorMessage;
if (!attributeService.CanDelete(attribute, out errorMessage))
{
mdGridWarningAttributes.Show(errorMessage, ModalAlertType.Information);
return;
}
Rock.Web.Cache.AttributeCache.Flush(attribute.Id);
attributeService.Delete(attribute, CurrentPersonId);
attributeService.Save(attribute, CurrentPersonId);
}
// reload page so that other blocks respond to any data that was changed
var qryParams = new Dictionary <string, string>();
qryParams["workflowTypeId"] = hfWorkflowTypeId.Value;
NavigateToPage(this.CurrentPage.Guid, qryParams);
}
/// <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);
}
}
public BlockActionResult DeleteAttribute(Guid attributeGuid)
{
using (var rockContext = new RockContext())
{
var attributeService = new AttributeService(rockContext);
var attribute = attributeService.Get(attributeGuid);
if (attribute == null)
{
return(ActionBadRequest("Attribute not found."));
}
if (attribute.IsSystem)
{
return(ActionBadRequest("System attributes cannot be deleted."));
}
if (!attribute.EntityTypeId.HasValue && attribute.EntityTypeQualifierColumn == string.Empty && attribute.EntityTypeQualifierValue == string.Empty && !GetEntityId().HasValue)
{
GlobalAttributesCache.Remove();
}
attributeService.Delete(attribute);
rockContext.SaveChanges();
return(ActionOk());
}
}
public void DeleteAttribute(int id)
{
using (ServiceDB serviceDB = new ServiceDB())
{
IUnitOfWork uow = new UnitOfWork(serviceDB);
IAttributeService service = new AttributeService(uow);
service.Delete(id);
}
}
/// <summary>
/// Handles the Delete event of the rGridAttribute 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 rGridAttribute_Delete(object sender, RowEventArgs e)
{
var attributeService = new AttributeService();
Rock.Model.Attribute attribute = attributeService.Get((int)rGridAttribute.DataKeys[e.RowIndex]["id"]);
if (attribute != null)
{
attributeService.Delete(attribute, CurrentPersonId);
attributeService.Save(attribute, CurrentPersonId);
}
rGridAttribute_Bind(hfIdType.Value);
}
/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <exception cref="System.NotImplementedException"></exception>
public void Execute(IJobExecutionContext context)
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
int howMany = dataMap.GetString("HowMany").AsIntegerOrNull() ?? 500000;
var commandTimeout = dataMap.GetString("CommandTimeout").AsIntegerOrNull() ?? 3600;
bool anyRemaining = UpdateSearchValueRecords(context, howMany, commandTimeout);
if (!anyRemaining)
{
// Verify that there are not any history records that haven't been migrated
using (var rockContext = new RockContext())
{
rockContext.Database.CommandTimeout = commandTimeout;
var attributeService = new AttributeService(rockContext);
var attribute = attributeService.Get("8F528431-A438-4488-8DC3-CA42E66C1B37".AsGuid());
bool valuesExist = attribute != null;
if (valuesExist)
{
valuesExist = new AttributeValueService(rockContext)
.Queryable().AsNoTracking()
.Where(a => a.AttributeId == attribute.Id)
.Any();
}
if (!valuesExist)
{
// Delete the attribute
if (attribute != null)
{
attributeService.Delete(attribute);
}
// delete job if there are no un-migrated history rows left
var jobId = context.GetJobId();
var jobService = new ServiceJobService(rockContext);
var job = jobService.Get(jobId);
if (job != null)
{
jobService.Delete(job);
rockContext.SaveChanges();
return;
}
}
}
}
}
/// <summary>
/// Handes the Delete filters event.
/// </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 gFilters_Delete(object sender, RowEventArgs e)
{
var rockContext = new RockContext();
var attributeService = new AttributeService(rockContext);
var attribute = attributeService.Get(e.RowKeyId);
if (attribute != null)
{
attributeService.Delete(attribute);
rockContext.SaveChanges();
}
BindGrid();
LoadFilters();
}
/// <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="rockContext">The rock context.</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 attributes = attributeService.GetByEntityTypeQualifier(entityTypeId, qualifierColumn, qualifierValue, true);
// 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();
}
// Update the Attributes that were assigned in the UI
foreach (var attributeState in viewStateAttributes)
{
Helper.SaveAttributeEdits(attributeState, entityTypeId, qualifierColumn, qualifierValue, rockContext);
}
}
/// <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;
AttributeService attributeService = new AttributeService();
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, CurrentPersonId);
attributeService.Save(attribute, CurrentPersonId);
}
BindDefinedTypeAttributesGrid();
}
/// <summary>
/// Handles the DeleteClick event of the gBlockTypeAttributes control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Rock.Web.UI.Controls.RowEventArgs"/> instance containing the event data.</param>
protected void gBlockTypeAttributes_DeleteClick(object sender, Rock.Web.UI.Controls.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;
}
attributeService.Delete(attribute);
rockContext.SaveChanges();
}
BindBlockTypeAttributesGrid();
}
/// <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.CacheToServerFileSystem = cbCacheToServerFileSystem.Checked;
binaryFileType.CacheControlHeaderSettings = cpCacheSettings.CurrentCacheablity.ToJson();
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 = EntityTypeCache.Get(typeof(BinaryFile)).Id;
// delete BinaryFileAttributes that are no longer configured in the UI
var attributes = attributeService.GetByEntityTypeQualifier(entityTypeId, "BinaryFileTypeId", binaryFileType.Id.ToString(), true);
var selectedAttributeGuids = BinaryFileAttributesState.Select(a => a.Guid);
foreach (var attr in attributes.Where(a => !selectedAttributeGuids.Contains(a.Guid)))
{
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);
});
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)
{
MarketingCampaignAdType marketingCampaignAdType;
MarketingCampaignAdTypeService marketingCampaignAdTypeService = new MarketingCampaignAdTypeService();
int marketingCampaignAdTypeId = int.Parse(hfMarketingCampaignAdTypeId.Value);
if (marketingCampaignAdTypeId == 0)
{
marketingCampaignAdType = new MarketingCampaignAdType();
marketingCampaignAdTypeService.Add(marketingCampaignAdType, CurrentPersonId);
}
else
{
marketingCampaignAdType = marketingCampaignAdTypeService.Get(marketingCampaignAdTypeId);
}
marketingCampaignAdType.Name = tbName.Text;
marketingCampaignAdType.DateRangeType = (DateRangeTypeEnum)int.Parse(ddlDateRangeType.SelectedValue);
// check for duplicates
if (marketingCampaignAdTypeService.Queryable().Count(a => a.Name.Equals(marketingCampaignAdType.Name, StringComparison.OrdinalIgnoreCase) && !a.Id.Equals(marketingCampaignAdType.Id)) > 0)
{
tbName.ShowErrorMessage(WarningMessage.DuplicateFoundMessage("name", MarketingCampaignAdType.FriendlyTypeName));
return;
}
if (!marketingCampaignAdType.IsValid)
{
// Controls will render the error messages
return;
}
RockTransactionScope.WrapTransaction(() =>
{
marketingCampaignAdTypeService.Save(marketingCampaignAdType, CurrentPersonId);
// get it back to make sure we have a good Id for it for the Attributes
marketingCampaignAdType = marketingCampaignAdTypeService.Get(marketingCampaignAdType.Guid);
// delete AdTypeAttributes that are no longer configured in the UI
AttributeService attributeService = new AttributeService();
var qry = attributeService.GetByEntityTypeId(new MarketingCampaignAd().TypeId).AsQueryable()
.Where(a => a.EntityTypeQualifierColumn.Equals("MarketingCampaignAdTypeId", StringComparison.OrdinalIgnoreCase) &&
a.EntityTypeQualifierValue.Equals(marketingCampaignAdType.Id.ToString()));
var deletedAttributes = from attr in qry
where !(from d in AttributesState
select d.Guid).Contains(attr.Guid)
select attr;
deletedAttributes.ToList().ForEach(a =>
{
var attr = attributeService.Get(a.Guid);
attributeService.Delete(attr, CurrentPersonId);
attributeService.Save(attr, CurrentPersonId);
});
// add/update the AdTypes that are assigned in the UI
foreach (var attributeState in AttributesState)
{
Attribute attribute = qry.FirstOrDefault(a => a.Guid.Equals(attributeState.Guid));
if (attribute == null)
{
attribute = attributeState.ToModel();
attributeService.Add(attribute, CurrentPersonId);
}
else
{
attributeState.Id = attribute.Id;
attributeState.CopyToModel(attribute);
}
attribute.EntityTypeQualifierColumn = "MarketingCampaignAdTypeId";
attribute.EntityTypeQualifierValue = marketingCampaignAdType.Id.ToString();
attribute.EntityTypeId = Rock.Web.Cache.EntityTypeCache.Read(new MarketingCampaignAd().TypeName).Id;
attributeService.Save(attribute, CurrentPersonId);
}
});
BindGrid();
pnlDetails.Visible = false;
pnlList.Visible = 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)
{
AttributeMatrixTemplate attributeMatrixTemplate;
var rockContext = new RockContext();
var attributeMatrixTemplateService = new AttributeMatrixTemplateService(rockContext);
int attributeMatrixTemplateId = int.Parse(hfAttributeMatrixTemplateId.Value);
if (attributeMatrixTemplateId == 0)
{
attributeMatrixTemplate = new AttributeMatrixTemplate();
attributeMatrixTemplateService.Add(attributeMatrixTemplate);
}
else
{
attributeMatrixTemplate = attributeMatrixTemplateService.Get(attributeMatrixTemplateId);
}
attributeMatrixTemplate.Name = tbName.Text;
attributeMatrixTemplate.IsActive = cbIsActive.Checked;
attributeMatrixTemplate.Description = tbDescription.Text;
attributeMatrixTemplate.MinimumRows = tbMinimumRows.Text.AsIntegerOrNull();
attributeMatrixTemplate.MaximumRows = tbMaximumRows.Text.AsIntegerOrNull();
attributeMatrixTemplate.FormattedLava = ceFormattedLava.Text;
// need WrapTransaction due to Attribute saves
rockContext.WrapTransaction(() =>
{
rockContext.SaveChanges();
/* Save Attributes */
var entityTypeIdAttributeMatrix = EntityTypeCache.GetId <AttributeMatrixItem>();
// 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(entityTypeIdAttributeMatrix, "AttributeMatrixTemplateId", attributeMatrixTemplate.Id.ToString());
// 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)))
{
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 AttributesState)
{
Helper.SaveAttributeEdits(attributeState, entityTypeIdAttributeMatrix, "AttributeMatrixTemplateId", attributeMatrixTemplate.Id.ToString(), rockContext);
}
Rock.Web.Cache.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)
{
using (new UnitOfWorkScope())
{
MarketingCampaignAdType marketingCampaignAdType;
MarketingCampaignAdTypeService marketingCampaignAdTypeService = new MarketingCampaignAdTypeService();
int marketingCampaignAdTypeId = int.Parse(hfMarketingCampaignAdTypeId.Value);
if (marketingCampaignAdTypeId == 0)
{
marketingCampaignAdType = new MarketingCampaignAdType();
marketingCampaignAdTypeService.Add(marketingCampaignAdType, CurrentPersonId);
}
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(() =>
{
marketingCampaignAdTypeService.Save(marketingCampaignAdType, CurrentPersonId);
// get it back to make sure we have a good Id for it for the Attributes
marketingCampaignAdType = marketingCampaignAdTypeService.Get(marketingCampaignAdType.Guid);
// delete AdTypeAttributes that are no longer configured in the UI
AttributeService attributeService = new AttributeService();
string qualifierValue = marketingCampaignAdType.Id.ToString();
int typeId = new MarketingCampaignAd().TypeId;
var qry = attributeService.GetByEntityTypeId(typeId).AsQueryable()
.Where(a => a.EntityTypeQualifierColumn == "MarketingCampaignAdTypeId" &&
a.EntityTypeQualifierValue.Equals(qualifierValue));
var deletedAttributes = from attr in qry.ToList()
where !(from d in AttributesState
select d.Guid).Contains(attr.Guid)
select attr;
deletedAttributes.ToList().ForEach(a =>
{
var attr = attributeService.Get(a.Guid);
if (attr != null)
{
Rock.Web.Cache.AttributeCache.Flush(attr.Id);
attributeService.Delete(attr, CurrentPersonId);
attributeService.Save(attr, CurrentPersonId);
}
});
// add/update the AdTypes that are assigned in the UI
foreach (var attributeState in AttributesState)
{
// remove old qualifiers in case they changed
var qualifierService = new AttributeQualifierService();
foreach (var oldQualifier in qualifierService.GetByAttributeId(attributeState.Id).ToList())
{
qualifierService.Delete(oldQualifier, CurrentPersonId);
qualifierService.Save(oldQualifier, CurrentPersonId);
}
Attribute attribute = qry.FirstOrDefault(a => a.Guid.Equals(attributeState.Guid));
if (attribute == null)
{
attribute = attributeState.Clone() as Rock.Model.Attribute;
attributeService.Add(attribute, CurrentPersonId);
}
else
{
attributeState.Id = attribute.Id;
attribute.FromDictionary(attributeState.ToDictionary());
foreach (var qualifier in attributeState.AttributeQualifiers)
{
attribute.AttributeQualifiers.Add(qualifier.Clone() as AttributeQualifier);
}
}
attribute.EntityTypeQualifierColumn = "MarketingCampaignAdTypeId";
attribute.EntityTypeQualifierValue = marketingCampaignAdType.Id.ToString();
attribute.EntityTypeId = Rock.Web.Cache.EntityTypeCache.Read(typeof(MarketingCampaignAd)).Id;
Rock.Web.Cache.AttributeCache.Flush(attribute.Id);
attributeService.Save(attribute, CurrentPersonId);
}
});
}
NavigateToParentPage();
}
/// <summary>
/// Handles logic for updating all the form sections as well as attributes.
/// This will create any new items and delete any removed items as well.
/// </summary>
/// <param name="formSettings">The form settings that contain all the configuration information.</param>
/// <param name="actionForm">The <see cref="WorkflowActionForm"/> entity being updated.</param>
/// <param name="workflowType">The <see cref="WorkflowType"/> that is being updated.</param>
/// <param name="rockContext">The database context to operate in.</param>
private static void UpdateFormSections(FormSettingsViewModel formSettings, WorkflowActionForm actionForm, WorkflowType workflowType, RockContext rockContext)
{
var attributeService = new AttributeService(rockContext);
var formAttributeService = new WorkflowActionFormAttributeService(rockContext);
var formSectionService = new WorkflowActionFormSectionService(rockContext);
var nextAttributeOrder = actionForm.FormAttributes != null && actionForm.FormAttributes.Any()
? actionForm.FormAttributes.Select(a => a.Order).Max() + 1
: 0;
if (formSettings.Sections != null)
{
// Get all the section identifiers that are sticking around.
var allValidSectionGuids = formSettings.Sections
.Select(s => s.Guid)
.ToList();
// Get all the attribute identifiers that are sticking around.
var allValidAttributeGuids = formSettings.Sections
.SelectMany(s => s.Fields)
.Select(f => f.Guid)
.ToList();
// Find all sections that no longer exist in this form.
var sectionsToDelete = actionForm.FormSections
.Where(s => !allValidSectionGuids.Contains(s.Guid))
.ToList();
// Find all form attributes that no longer exist in this form.
var formAttributesToDelete = actionForm.FormAttributes
.Where(a => !allValidAttributeGuids.Contains(a.Attribute.Guid))
.ToList();
var allFormFields = formSettings.Sections.SelectMany(s => s.Fields).ToList();
// Delete all sections that no longer exist in this form.
sectionsToDelete.ForEach(s =>
{
formSectionService.Delete(s);
});
// Delete all form attributes that no longer exist in this form.
formAttributesToDelete.ForEach(a =>
{
if (a.Attribute.IsSystem)
{
attributeService.Delete(a.Attribute);
}
formAttributeService.Delete(a);
});
// Loop through all sections that need to be either added or updated.
for (int sectionOrder = 0; sectionOrder < formSettings.Sections.Count; sectionOrder++)
{
var section = formSettings.Sections[sectionOrder];
var formSection = AddOrUpdateFormSection(actionForm, workflowType, attributeService, formAttributeService, formSectionService, section, allFormFields, ref nextAttributeOrder);
formSection.Order = sectionOrder;
}
}
else
{
// Remove all form attributes and sections.
var nonUserAttributes = actionForm.FormAttributes
.Select(a => a.Attribute)
.Where(a => a.IsSystem)
.ToList();
attributeService.DeleteRange(nonUserAttributes);
formAttributeService.DeleteRange(actionForm.FormAttributes);
formSectionService.DeleteRange(actionForm.FormSections);
}
}
/// <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();
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.IconSmallFileId = imgIconSmall.ImageId;
binaryFileType.IconLargeFileId = imgIconLarge.ImageId;
if (!string.IsNullOrWhiteSpace(cpStorageType.SelectedValue))
{
var entityTypeService = new EntityTypeService();
var storageEntityType = entityTypeService.Get(new Guid(cpStorageType.SelectedValue));
if (storageEntityType != null)
{
binaryFileType.StorageEntityTypeId = storageEntityType.Id;
}
}
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 */
// delete BinaryFileAttributes that are no longer configured in the UI
string qualifierValue = binaryFileType.Id.ToString();
var BinaryFileAttributesQry = attributeService.GetByEntityTypeId(new BinaryFile().TypeId).AsQueryable()
.Where(a => a.EntityTypeQualifierColumn.Equals("BinaryFileTypeId", StringComparison.OrdinalIgnoreCase) &&
a.EntityTypeQualifierValue.Equals(qualifierValue));
var deletedBinaryFileAttributes = from attr in BinaryFileAttributesQry
where !(from d in BinaryFileAttributesState
select d.Guid).Contains(attr.Guid)
select attr;
deletedBinaryFileAttributes.ToList().ForEach(a =>
{
var attr = attributeService.Get(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)
{
// remove old qualifiers in case they changed
var qualifierService = new AttributeQualifierService();
foreach (var oldQualifier in qualifierService.GetByAttributeId(attributeState.Id).ToList())
{
qualifierService.Delete(oldQualifier, CurrentPersonId);
qualifierService.Save(oldQualifier, CurrentPersonId);
}
Attribute attribute = BinaryFileAttributesQry.FirstOrDefault(a => a.Guid.Equals(attributeState.Guid));
if (attribute == null)
{
attribute = attributeState.Clone() as Rock.Model.Attribute;
attributeService.Add(attribute, CurrentPersonId);
}
else
{
attributeState.Id = attribute.Id;
attribute.FromDictionary(attributeState.ToDictionary());
foreach (var qualifier in attributeState.AttributeQualifiers)
{
attribute.AttributeQualifiers.Add(qualifier.Clone() as AttributeQualifier);
}
}
attribute.EntityTypeQualifierColumn = "BinaryFileTypeId";
attribute.EntityTypeQualifierValue = binaryFileType.Id.ToString();
attribute.EntityTypeId = Rock.Web.Cache.EntityTypeCache.Read(typeof(BinaryFile)).Id;
Rock.Web.Cache.AttributeCache.Flush(attribute.Id);
attributeService.Save(attribute, 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)
{
using (new UnitOfWorkScope())
{
MarketingCampaignAdType marketingCampaignAdType;
MarketingCampaignAdTypeService marketingCampaignAdTypeService = new MarketingCampaignAdTypeService();
int marketingCampaignAdTypeId = int.Parse(hfMarketingCampaignAdTypeId.Value);
if (marketingCampaignAdTypeId == 0)
{
marketingCampaignAdType = new MarketingCampaignAdType();
marketingCampaignAdTypeService.Add(marketingCampaignAdType, CurrentPersonId);
}
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();
AttributeQualifierService attributeQualifierService = new AttributeQualifierService();
CategoryService categoryService = new CategoryService();
marketingCampaignAdTypeService.Save(marketingCampaignAdType, CurrentPersonId);
// 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, CurrentPersonId);
attributeService.Save(attr, CurrentPersonId);
}
// Update the Attributes that were assigned in the UI
foreach (var attributeState in AttributesState)
{
Rock.Attribute.Helper.SaveAttributeEdits(attributeState, attributeService, attributeQualifierService, categoryService,
entityTypeId, qualifierColumn, qualifierValue, CurrentPersonId);
}
});
}
NavigateToParentPage();
}
protected void btnSave_Click(object sender, EventArgs e)
{
RockContext rockContext = new RockContext();
rockContext.WrapTransaction(() =>
{
WidgityTypeService widgityTypeService = new WidgityTypeService(rockContext);
AttributeService attributeService = new AttributeService(rockContext);
WidgityType widgityType = GetWidgityType(widgityTypeService);
if (widgityType.Id == 0)
{
widgityTypeService.Add(widgityType);
}
widgityType.Name = tbName.Text;
widgityType.Description = tbDescription.Text;
widgityType.EnabledLavaCommands = lcCommands.SelectedValue;
widgityType.Icon = tbIcon.Text;
widgityType.Markdown = ceMarkup.Text;
widgityType.HasItems = cbHasItems.Checked;
var _ = widgityType.EntityTypes.ToList(); //Attach the entity types to context
widgityType.EntityTypes = new EntityTypeService(rockContext).GetByIds(lbEntityTypes.SelectedValuesAsInt).ToList();
widgityType.CategoryId = pCategory.SelectedValueAsId();
rockContext.SaveChanges();
//Widgity Attributes
var widgityEntityTypeId = EntityTypeCache.Get(typeof(Widgity)).Id;
var actualAttributes = attributeService.Queryable()
.Where(a => a.EntityTypeId == widgityEntityTypeId && a.EntityTypeQualifierValue == widgityType.Id.ToString())
.OrderBy(a => a.Order)
.ToList();
//Remove deleted attributes
foreach (var attribute in actualAttributes)
{
if (!WidgityAttributes.Where(a => a.Guid == attribute.Guid).Any())
{
attributeService.Delete(attribute);
}
}
//Update db from viewstate
foreach (var attribute in WidgityAttributes)
{
if (attribute.Id == 0)
{
attribute.Order = WidgityAttributes.IndexOf(attribute);
attribute.EntityTypeQualifierValue = widgityType.Id.ToString();
attributeService.Add(attribute);
}
else
{
var trackedAttribute = actualAttributes.Where(a => a.Guid == attribute.Guid).FirstOrDefault();
trackedAttribute.CopyPropertiesFrom(attribute);
foreach (var qualifier in trackedAttribute.AttributeQualifiers)
{
var value = attribute.AttributeQualifiers.Where(q => q.Key == qualifier.Key).FirstOrDefault();
if (value != null)
{
qualifier.Value = value.Value;
}
}
trackedAttribute.Order = WidgityAttributes.IndexOf(attribute);
}
}
rockContext.SaveChanges();
//Widgity Item Attributes
var widgityItemEntityTypeId = EntityTypeCache.Get(typeof(WidgityItem)).Id;
var actualItemAttributes = attributeService.Queryable()
.Where(a => a.EntityTypeId == widgityItemEntityTypeId && a.EntityTypeQualifierValue == widgityType.Id.ToString())
.OrderBy(a => a.Order)
.ToList();
//Remove deleted attributes
foreach (var attribute in actualItemAttributes)
{
if (!WidgityItemAttributes.Where(a => a.Guid == attribute.Guid).Any())
{
attributeService.Delete(attribute);
}
}
//Update db from viewstate
foreach (var attribute in WidgityItemAttributes)
{
if (attribute.Id == 0)
{
attribute.Order = WidgityItemAttributes.IndexOf(attribute);
attribute.EntityTypeQualifierValue = widgityType.Id.ToString();
attributeService.Add(attribute);
}
else
{
var trackedAttribute = actualItemAttributes.Where(a => a.Guid == attribute.Guid).FirstOrDefault();
trackedAttribute.CopyPropertiesFrom(attribute);
foreach (var qualifier in trackedAttribute.AttributeQualifiers)
{
var value = attribute.AttributeQualifiers.Where(q => q.Key == qualifier.Key).FirstOrDefault();
if (value != null)
{
qualifier.Value = value.Value;
}
}
trackedAttribute.Order = WidgityItemAttributes.IndexOf(attribute);
}
}
rockContext.SaveChanges();
});
WidgityTypeCache.Clear();
WidgityCache.Clear();
WidgityItemCache.Clear();
NavigateToParentPage();
}
/// <summary>
/// Adds test data for Events that can be used to test inherited attributes.
/// </summary>
private static void InitializeInheritedAttributesTestData()
{
var rockContext = new RockContext();
var EventCalendarPublicId = EventCalendarCache.All().First(x => x.Name == "Public").Id;
var EventCalendarInternalId = EventCalendarCache.All().First(x => x.Name == "Internal").Id;
// Add Attributes for Calendars.
// EventItem Attributes are defined per Calendar, so they are directly associated with the EventCalendarItem entity.
// The Attributes collection for the EventItem shows the collection of attributes inherited from the EventCalendarItems associated with the event.
var attributeService = new AttributeService(rockContext);
var textFieldTypeId = FieldTypeCache.GetId(SystemGuid.FieldType.TEXT.AsGuid()).GetValueOrDefault();
// Add Attribute A for Internal Calendar.
var attributeAInternal = attributeService.Get(InternalCalendarAttribute1Guid.AsGuid());
if (attributeAInternal != null)
{
attributeService.Delete(attributeAInternal);
rockContext.SaveChanges();
}
attributeAInternal = new Rock.Model.Attribute();
attributeAInternal.EntityTypeId = EntityTypeCache.GetId(typeof(EventCalendarItem));
attributeAInternal.EntityTypeQualifierColumn = "EventCalendarId";
attributeAInternal.EntityTypeQualifierValue = EventCalendarInternalId.ToString();
attributeAInternal.Name = InternalCalendarAttribute1Key;
attributeAInternal.Key = InternalCalendarAttribute1Key;
attributeAInternal.Guid = InternalCalendarAttribute1Guid.AsGuid();
attributeAInternal.FieldTypeId = textFieldTypeId;
attributeService.Add(attributeAInternal);
rockContext.SaveChanges();
// Add Attribute A for Public Calendar.
var attributeAPublic = attributeService.Get(PublicCalendarAttribute1Guid.AsGuid());
if (attributeAPublic != null)
{
attributeService.Delete(attributeAPublic);
rockContext.SaveChanges();
}
attributeAPublic = new Rock.Model.Attribute();
attributeAPublic.EntityTypeId = EntityTypeCache.GetId(typeof(EventCalendarItem));
attributeAPublic.EntityTypeQualifierColumn = "EventCalendarId";
attributeAPublic.EntityTypeQualifierValue = EventCalendarPublicId.ToString();
attributeAPublic.Name = PublicCalendarAttribute1Key;
attributeAPublic.Key = PublicCalendarAttribute1Key;
attributeAPublic.Guid = PublicCalendarAttribute1Guid.AsGuid();
attributeAPublic.FieldTypeId = textFieldTypeId;
attributeService.Add(attributeAPublic);
rockContext.SaveChanges();
// Create a new Event: "Event A".
// This event exists in the Internal and Public calendars.
var eventItemService = new EventItemService(rockContext);
var eventA = eventItemService.Get(EventAGuid.AsGuid());
if (eventA != null)
{
eventItemService.Delete(eventA);
rockContext.SaveChanges();
}
eventA = new EventItem();
eventA.Name = "Event A";
eventA.Guid = EventAGuid.AsGuid();
var eventACalendarInternal = new EventCalendarItem {
EventCalendarId = EventCalendarInternalId, Guid = EventACalendarInternalGuid.AsGuid()
};
var eventACalendarPublic = new EventCalendarItem {
EventCalendarId = EventCalendarPublicId, Guid = EventACalendarPublicGuid.AsGuid()
};
eventA.EventCalendarItems.Add(eventACalendarInternal);
eventA.EventCalendarItems.Add(eventACalendarPublic);
eventItemService.Add(eventA);
rockContext.SaveChanges();
// Create a new Event: "Event B".
// This event exists in the Internal calendar only.
// This event is created manually, to set the ID of Event B to match an Event Calendar Item associated with Event A.
// The purpose is to create an EventItem and an EventCalendarItem that have an identical ID,
// so we can verify that Attribute values for parent and child entities are correctly differentiated
// by Entity Type when they are collated for inherited attributes.
var eventB = eventItemService.Get(EventBGuid.AsGuid());
if (eventB != null)
{
eventItemService.Delete(eventB);
rockContext.SaveChanges();
}
var matchedID = eventACalendarInternal.Id;
var sql = @"
SET IDENTITY_INSERT [EventItem] ON
;
INSERT INTO [EventItem] (Id, Name, Guid, IsActive)
VALUES (@p0, @p1, @p2, 1)
;
SET IDENTITY_INSERT [EventItem] OFF
;
";
rockContext.Database.ExecuteSqlCommand(sql, matchedID, "Event B", EventBGuid.AsGuid());
eventB = eventItemService.Get(EventBGuid.AsGuid());
var eventBCalendarInternal = new EventCalendarItem {
EventCalendarId = EventCalendarInternalId, Guid = EventBCalendarInternalGuid.AsGuid()
};
var eventBCalendarPublic = new EventCalendarItem {
EventCalendarId = EventCalendarPublicId, Guid = EventBCalendarPublicGuid.AsGuid()
};
eventB.EventCalendarItems.Add(eventBCalendarInternal);
eventB.EventCalendarItems.Add(eventBCalendarPublic);
rockContext.SaveChanges();
// Set Attribute Values.
rockContext = new RockContext();
AttributeCache.Clear();
// Set Attribute Values for Event B.
eventBCalendarPublic.LoadAttributes(rockContext);
eventBCalendarPublic.SetAttributeValue(PublicCalendarAttribute1Key, "Event B Public");
eventBCalendarPublic.SaveAttributeValues(rockContext);
rockContext.SaveChanges();
// Set Attribute Values for Event A
eventACalendarInternal.LoadAttributes(rockContext);
eventACalendarInternal.SetAttributeValue(InternalCalendarAttribute1Key, "Event A Internal");
eventACalendarInternal.SaveAttributeValues(rockContext);
eventACalendarPublic.LoadAttributes(rockContext);
eventACalendarPublic.SetAttributeValue(PublicCalendarAttribute1Key, "Event A Public");
eventACalendarPublic.SaveAttributeValues(rockContext);
rockContext.SaveChanges();
}
public IHttpActionResult Delete(int id)
{
AttributeService.Delete(id);
return(Ok());
}
/// <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.RequiresSecurity = cbRequiresSecurity.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;
}
RockTransactionScope.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);
});
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();
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;
int binaryFileTypeId = new BinaryFileTypeService(rockContext).Get(new Guid(Rock.SystemGuid.BinaryFiletype.CHECKIN_LABEL)).Id;
RockTransactionScope.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.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.ForceContentVisible = true;
return;
}
rockContext.SaveChanges();
groupTypeDB.SaveAttributeValues();
// 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))
{
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 = binaryFileTypeId.ToString()
});
attribute.Guid = Guid.NewGuid();
attribute.FieldTypeId = binaryFileFieldTypeID;
attribute.EntityTypeId = EntityTypeCache.GetId(typeof(GroupType));
attribute.EntityTypeQualifierColumn = "Id";
attribute.EntityTypeQualifierValue = groupTypeDB.Id.ToString();
attribute.DefaultValue = checkinLabelAttributeInfo.BinaryFileId.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.ForceContentVisible = 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.ForceContentVisible = 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;
using (new UnitOfWorkScope())
{
GroupService groupService = new GroupService();
AttributeService attributeService = new AttributeService();
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;
}
if ((ddlGroupType.SelectedValueAsInt() ?? 0) == 0)
{
ddlGroupType.ShowErrorMessage(Rock.Constants.WarningMessage.CannotBeBlank(GroupType.FriendlyTypeName));
return;
}
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;
}
RockTransactionScope.WrapTransaction(() =>
{
if (group.Id.Equals(0))
{
groupService.Add(group, CurrentPersonId);
}
groupService.Save(group, CurrentPersonId);
Rock.Attribute.Helper.SaveAttributeValues(group, CurrentPersonId);
/* Take care of Group Member Attributes */
// delete GroupMemberAttributes that are no longer configured in the UI
string qualifierValue = group.Id.ToString();
var groupMemberAttributesQry = attributeService.GetByEntityTypeId(new GroupMember().TypeId).AsQueryable()
.Where(a => a.EntityTypeQualifierColumn.Equals("GroupId", StringComparison.OrdinalIgnoreCase) &&
a.EntityTypeQualifierValue.Equals(qualifierValue));
var deletedGroupMemberAttributes = from attr in groupMemberAttributesQry
where !(from d in GroupMemberAttributesState
select d.Guid).Contains(attr.Guid)
select attr;
deletedGroupMemberAttributes.ToList().ForEach(a =>
{
var attr = attributeService.Get(a.Guid);
Rock.Web.Cache.AttributeCache.Flush(attr.Id);
attributeService.Delete(attr, CurrentPersonId);
attributeService.Save(attr, CurrentPersonId);
});
// add/update the GroupMemberAttributes that are assigned in the UI
foreach (var attributeState in GroupMemberAttributesState)
{
// remove old qualifiers in case they changed
var qualifierService = new AttributeQualifierService();
foreach (var oldQualifier in qualifierService.GetByAttributeId(attributeState.Id).ToList())
{
qualifierService.Delete(oldQualifier, CurrentPersonId);
qualifierService.Save(oldQualifier, CurrentPersonId);
}
Attribute attribute = groupMemberAttributesQry.FirstOrDefault(a => a.Guid.Equals(attributeState.Guid));
if (attribute == null)
{
attribute = attributeState.Clone() as Rock.Model.Attribute;
attributeService.Add(attribute, CurrentPersonId);
}
else
{
attributeState.Id = attribute.Id;
attribute.FromDictionary(attributeState.ToDictionary());
foreach (var qualifier in attributeState.AttributeQualifiers)
{
attribute.AttributeQualifiers.Add(qualifier.Clone() as AttributeQualifier);
}
}
attribute.EntityTypeQualifierColumn = "GroupId";
attribute.EntityTypeQualifierValue = group.Id.ToString();
attribute.EntityTypeId = Rock.Web.Cache.EntityTypeCache.Read(typeof(GroupMember)).Id;
Rock.Web.Cache.AttributeCache.Flush(attribute.Id);
attributeService.Save(attribute, CurrentPersonId);
}
});
}
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(this.CurrentPage.Guid, qryParams);
}
/// <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())
{
GroupType groupType;
GroupTypeService groupTypeService = new GroupTypeService();
AttributeService attributeService = new AttributeService();
int groupTypeId = int.Parse(hfGroupTypeId.Value);
if (groupTypeId == 0)
{
groupType = new GroupType();
groupTypeService.Add(groupType, CurrentPersonId);
}
else
{
groupType = groupTypeService.Get(groupTypeId);
}
groupType.Name = tbName.Text;
groupType.Description = tbDescription.Text;
groupType.GroupTerm = tbGroupTerm.Text;
groupType.GroupMemberTerm = tbGroupMemberTerm.Text;
groupType.DefaultGroupRoleId = ddlDefaultGroupRole.SelectedValueAsInt();
groupType.ShowInGroupList = cbShowInGroupList.Checked;
groupType.ShowInNavigation = cbShowInNavigation.Checked;
groupType.IconCssClass = tbIconCssClass.Text;
groupType.IconSmallFileId = imgIconSmall.BinaryFileId;
groupType.IconLargeFileId = imgIconLarge.BinaryFileId;
groupType.TakesAttendance = cbTakesAttendance.Checked;
groupType.AttendanceRule = ddlAttendanceRule.SelectedValueAsEnum <AttendanceRule>();
groupType.AttendancePrintTo = ddlAttendancePrintTo.SelectedValueAsEnum <PrintTo>();
groupType.LocationSelectionMode = ddlLocationSelectionMode.SelectedValueAsEnum <LocationPickerMode>();
groupType.GroupTypePurposeValueId = ddlGroupTypePurpose.SelectedValueAsInt();
groupType.AllowMultipleLocations = cbAllowMultipleLocations.Checked;
groupType.InheritedGroupTypeId = gtpInheritedGroupType.SelectedGroupTypeId;
groupType.ChildGroupTypes = new List <GroupType>();
groupType.ChildGroupTypes.Clear();
foreach (var item in ChildGroupTypesDictionary)
{
var childGroupType = groupTypeService.Get(item.Key);
if (childGroupType != null)
{
groupType.ChildGroupTypes.Add(childGroupType);
}
}
DefinedValueService definedValueService = new DefinedValueService();
groupType.LocationTypes = new List <GroupTypeLocationType>();
groupType.LocationTypes.Clear();
foreach (var item in LocationTypesDictionary)
{
var locationType = definedValueService.Get(item.Key);
if (locationType != null)
{
groupType.LocationTypes.Add(new GroupTypeLocationType {
LocationTypeValueId = locationType.Id
});
}
}
if (!groupType.IsValid)
{
// Controls will render the error messages
return;
}
RockTransactionScope.WrapTransaction(() =>
{
groupTypeService.Save(groupType, CurrentPersonId);
// get it back to make sure we have a good Id for it for the Attributes
groupType = groupTypeService.Get(groupType.Guid);
/* Take care of Group Type Attributes */
// delete GroupTypeAttributes that are no longer configured in the UI
var groupTypeAttributesQry = attributeService.Get(new GroupType().TypeId, "Id", groupType.Id.ToString());
var selectedAttributes = GroupTypeAttributesState.Select(a => a.Guid);
foreach (var attr in groupTypeAttributesQry.Where(a => !selectedAttributes.Contains(a.Guid)))
{
Rock.Web.Cache.AttributeCache.Flush(attr.Id);
attributeService.Delete(attr, CurrentPersonId);
attributeService.Save(attr, CurrentPersonId);
}
string qualifierValue = groupType.Id.ToString();
// add/update the GroupTypeAttributes that are assigned in the UI
foreach (var attributeState in GroupTypeAttributesState
.Where(a =>
a.EntityTypeQualifierValue == null ||
a.EntityTypeQualifierValue.Trim() == string.Empty ||
a.EntityTypeQualifierValue.Equals(qualifierValue)))
{
// remove old qualifiers in case they changed
var qualifierService = new AttributeQualifierService();
foreach (var oldQualifier in qualifierService.GetByAttributeId(attributeState.Id).ToList())
{
qualifierService.Delete(oldQualifier, CurrentPersonId);
qualifierService.Save(oldQualifier, CurrentPersonId);
}
Attribute attribute = groupTypeAttributesQry.FirstOrDefault(a => a.Guid.Equals(attributeState.Guid));
if (attribute == null)
{
attribute = attributeState.Clone() as Rock.Model.Attribute;
attributeService.Add(attribute, CurrentPersonId);
}
else
{
attributeState.Id = attribute.Id;
attribute.FromDictionary(attributeState.ToDictionary());
foreach (var qualifier in attributeState.AttributeQualifiers)
{
attribute.AttributeQualifiers.Add(qualifier.Clone() as AttributeQualifier);
}
}
attribute.EntityTypeQualifierColumn = "Id";
attribute.EntityTypeQualifierValue = qualifierValue;
attribute.EntityTypeId = Rock.Web.Cache.EntityTypeCache.Read(typeof(GroupType)).Id;
Rock.Web.Cache.AttributeCache.Flush(attribute.Id);
attributeService.Save(attribute, CurrentPersonId);
}
/* Take care of Group Attributes */
// delete GroupAttributes that are no longer configured in the UI
var groupAttributesQry = attributeService.Get(new Group().TypeId, "GroupTypeId", groupType.Id.ToString());
selectedAttributes = GroupAttributesState.Select(a => a.Guid);
foreach (var attr in groupAttributesQry.Where(a => !selectedAttributes.Contains(a.Guid)))
{
Rock.Web.Cache.AttributeCache.Flush(attr.Id);
attributeService.Delete(attr, CurrentPersonId);
attributeService.Save(attr, CurrentPersonId);
}
// add/update the GroupAttributes that are assigned in the UI
foreach (var attributeState in GroupAttributesState
.Where(a =>
a.EntityTypeQualifierValue == null ||
a.EntityTypeQualifierValue.Trim() == string.Empty ||
a.EntityTypeQualifierValue.Equals(qualifierValue)))
{
// remove old qualifiers in case they changed
var qualifierService = new AttributeQualifierService();
foreach (var oldQualifier in qualifierService.GetByAttributeId(attributeState.Id).ToList())
{
qualifierService.Delete(oldQualifier, CurrentPersonId);
qualifierService.Save(oldQualifier, CurrentPersonId);
}
Attribute attribute = groupAttributesQry.FirstOrDefault(a => a.Guid.Equals(attributeState.Guid));
if (attribute == null)
{
attribute = attributeState.Clone() as Rock.Model.Attribute;
attributeService.Add(attribute, CurrentPersonId);
}
else
{
attributeState.Id = attribute.Id;
attribute.FromDictionary(attributeState.ToDictionary());
foreach (var qualifier in attributeState.AttributeQualifiers)
{
attribute.AttributeQualifiers.Add(qualifier.Clone() as AttributeQualifier);
}
}
attribute.EntityTypeQualifierColumn = "GroupTypeId";
attribute.EntityTypeQualifierValue = qualifierValue;
attribute.EntityTypeId = Rock.Web.Cache.EntityTypeCache.Read(typeof(Group)).Id;
Rock.Web.Cache.AttributeCache.Flush(attribute.Id);
attributeService.Save(attribute, CurrentPersonId);
}
});
}
NavigateToParentPage();
}
/// <summary>
/// Maps the communication data.
/// </summary>
/// <param name="tableData">The table data.</param>
/// <returns></returns>
private void MapCommunication(IQueryable <Row> tableData)
{
var lookupContext = new RockContext();
var personService = new PersonService(lookupContext);
var attributeService = new AttributeService(lookupContext);
var numberTypeValues = DefinedTypeCache.Read(new Guid(Rock.SystemGuid.DefinedType.PERSON_PHONE_TYPE), lookupContext).DefinedValues;
// Look up additional Person attributes (existing)
var personAttributes = attributeService.GetByEntityTypeId(PersonEntityTypeId).ToList();
// Remove previously defined Excavator social attributes & categories if they exist
var oldFacebookAttribute = personAttributes.Where(a => a.Key == "FacebookUsername").FirstOrDefault();
if (oldFacebookAttribute != null)
{
Rock.Web.Cache.AttributeCache.Flush(oldFacebookAttribute.Id);
attributeService.Delete(oldFacebookAttribute);
lookupContext.SaveChanges(true);
}
var oldTwitterAttribute = personAttributes.Where(a => a.Key == "TwitterUsername").FirstOrDefault();
if (oldTwitterAttribute != null)
{
Rock.Web.Cache.AttributeCache.Flush(oldTwitterAttribute.Id);
attributeService.Delete(oldTwitterAttribute);
lookupContext.SaveChanges(true);
}
int attributeEntityTypeId = EntityTypeCache.Read("Rock.Model.Attribute").Id;
var socialMediaCategory = new CategoryService(lookupContext).GetByEntityTypeId(attributeEntityTypeId)
.Where(c => c.Name == "Social Media" &&
c.EntityTypeQualifierValue == PersonEntityTypeId.ToString() &&
c.IconCssClass == "fa fa-twitter")
.FirstOrDefault();
if (socialMediaCategory != null)
{
lookupContext.Categories.Remove(socialMediaCategory);
lookupContext.SaveChanges(true);
}
// Cached Rock attributes: Facebook, Twitter, Instagram
var twitterAttribute = AttributeCache.Read(personAttributes.FirstOrDefault(a => a.Key == "Twitter"));
var facebookAttribute = AttributeCache.Read(personAttributes.FirstOrDefault(a => a.Key == "Facebook"));
var instagramAttribute = AttributeCache.Read(personAttributes.FirstOrDefault(a => a.Key == "Instagram"));
var secondaryEmailAttribute = AttributeCache.Read(SecondaryEmailAttributeId);
var existingNumbers = new PhoneNumberService(lookupContext).Queryable().ToList();
var newNumberList = new List <PhoneNumber>();
var updatedPersonList = new List <Person>();
int completed = 0;
int totalRows = tableData.Count();
int percentage = (totalRows - 1) / 100 + 1;
ReportProgress(0, string.Format("Verifying communication import ({0:N0} found, {1:N0} already exist).", totalRows, existingNumbers.Count()));
foreach (var row in tableData)
{
string value = row["Communication_Value"] as string;
int? individualId = row["Individual_ID"] as int?;
int? householdId = row["Household_ID"] as int?;
var personList = new List <int?>();
if (individualId != null)
{
int?personId = GetPersonAliasId(individualId, householdId);
if (personId != null)
{
personList.Add(personId);
}
}
else
{
List <int?> personIds = GetFamilyByHouseholdId(householdId);
if (personIds.Any())
{
personList.AddRange(personIds);
}
}
if (personList.Any() && !string.IsNullOrWhiteSpace(value))
{
DateTime?lastUpdated = row["LastUpdatedDate"] as DateTime?;
string communicationComment = row["Communication_Comment"] as string;
string type = row["Communication_Type"] as string;
bool isListed = (bool)row["Listed"];
value = value.RemoveWhitespace();
// Communication value is a number
if (type.Contains("Phone") || type.Contains("Mobile"))
{
var extension = string.Empty;
var countryCode = Rock.Model.PhoneNumber.DefaultCountryCode();
var normalizedNumber = string.Empty;
var countryIndex = value.IndexOf('+');
int extensionIndex = value.LastIndexOf('x') > 0 ? value.LastIndexOf('x') : value.Length;
if (countryIndex >= 0)
{
countryCode = value.Substring(countryIndex, countryIndex + 3).AsNumeric();
normalizedNumber = value.Substring(countryIndex + 3, extensionIndex - 3).AsNumeric();
extension = value.Substring(extensionIndex);
}
else if (extensionIndex > 0)
{
normalizedNumber = value.Substring(0, extensionIndex).AsNumeric();
extension = value.Substring(extensionIndex).AsNumeric();
}
else
{
normalizedNumber = value.AsNumeric();
}
if (!string.IsNullOrWhiteSpace(normalizedNumber))
{
foreach (var familyPersonId in personList)
{
bool numberExists = existingNumbers.Any(n => n.PersonId == familyPersonId && n.Number.Equals(value));
if (!numberExists)
{
var newNumber = new PhoneNumber();
newNumber.CreatedByPersonAliasId = ImportPersonAlias.Id;
newNumber.ModifiedDateTime = lastUpdated;
newNumber.PersonId = (int)familyPersonId;
newNumber.IsMessagingEnabled = false;
newNumber.CountryCode = countryCode;
newNumber.IsUnlisted = !isListed;
newNumber.Extension = extension.Left(20);
newNumber.Number = normalizedNumber.Left(20);
newNumber.Description = communicationComment;
newNumber.NumberTypeValueId = numberTypeValues.Where(v => type.StartsWith(v.Value))
.Select(v => (int?)v.Id).FirstOrDefault();
newNumberList.Add(newNumber);
existingNumbers.Add(newNumber);
}
}
completed++;
}
}
else
{
var person = personService.Queryable(includeDeceased: true).FirstOrDefault(p => p.Id == personList.FirstOrDefault());
person.Attributes = new Dictionary <string, AttributeCache>();
person.AttributeValues = new Dictionary <string, AttributeValue>();
if (value.IsValidEmail())
{
string secondaryEmail = string.Empty;
if (string.IsNullOrWhiteSpace(person.Email))
{
secondaryEmail = person.Email;
person.Email = value.Left(75);
person.IsEmailActive = isListed;
person.ModifiedDateTime = lastUpdated;
person.EmailNote = communicationComment;
lookupContext.SaveChanges(true);
}
else if (!person.Email.Equals(value))
{
secondaryEmail = value;
}
var existingSecondaryEmail = new AttributeValueService(lookupContext).Queryable().Where(av => av.AttributeId == SecondaryEmailAttributeId && av.EntityId == person.Id).FirstOrDefault();
if (!string.IsNullOrWhiteSpace(secondaryEmail) && existingSecondaryEmail == null)
{
person.Attributes.Add(secondaryEmailAttribute.Key, secondaryEmailAttribute);
person.AttributeValues.Add(secondaryEmailAttribute.Key, new AttributeValue()
{
AttributeId = secondaryEmailAttribute.Id,
Value = secondaryEmail
});
}
}
else if (type.Contains("Twitter"))
{
person.Attributes.Add(twitterAttribute.Key, twitterAttribute);
person.AttributeValues.Add(twitterAttribute.Key, new AttributeValue()
{
AttributeId = twitterAttribute.Id,
Value = value
});
}
else if (type.Contains("Facebook"))
{
var existingFacebook = new AttributeValueService(lookupContext).Queryable().Where(av => av.AttributeId == facebookAttribute.Id && av.EntityId == person.Id).FirstOrDefault();
if (existingFacebook == null)
{
person.Attributes.Add(facebookAttribute.Key, facebookAttribute);
person.AttributeValues.Add(facebookAttribute.Key, new AttributeValue()
{
AttributeId = facebookAttribute.Id,
Value = value
});
}
}
else if (type.Contains("Instagram"))
{
person.Attributes.Add(instagramAttribute.Key, instagramAttribute);
person.AttributeValues.Add(instagramAttribute.Key, new AttributeValue()
{
AttributeId = instagramAttribute.Id,
Value = value
});
}
updatedPersonList.Add(person);
completed++;
}
if (completed % percentage < 1)
{
int percentComplete = completed / percentage;
ReportProgress(percentComplete, string.Format("{0:N0} records imported ({1}% complete).", completed, percentComplete));
}
else if (completed % ReportingNumber < 1)
{
SaveCommunication(newNumberList, updatedPersonList);
// reset so context doesn't bloat
lookupContext = new RockContext();
personService = new PersonService(lookupContext);
updatedPersonList.Clear();
newNumberList.Clear();
ReportPartialProgress();
}
}
}
if (newNumberList.Any() || updatedPersonList.Any())
{
SaveCommunication(newNumberList, updatedPersonList);
}
ReportProgress(100, string.Format("Finished communication import: {0:N0} records imported.", completed));
}
protected void btnSave_Click(object sender, EventArgs e)
{
hfAreaGroupClicked.Value = "true";
using (var rockContext = new RockContext())
{
var attributeService = new AttributeService(rockContext);
if (checkinArea.Visible)
{
var groupTypeService = new GroupTypeService(rockContext);
var groupType = groupTypeService.Get(checkinArea.GroupTypeGuid);
if (groupType != null)
{
groupType.LoadAttributes(rockContext);
checkinArea.GetGroupTypeValues(groupType);
if (groupType.IsValid)
{
rockContext.SaveChanges();
groupType.SaveAttributeValues(rockContext);
// rebuild the CheckinLabel attributes from the UI (brute-force)
foreach (var labelAttribute in CheckinArea.GetCheckinLabelAttributes(groupType.Attributes))
{
var attribute = attributeService.Get(labelAttribute.Value.Guid);
attributeService.Delete(attribute);
}
// Make sure default role is set
if (!groupType.DefaultGroupRoleId.HasValue && groupType.Roles.Any())
{
groupType.DefaultGroupRoleId = groupType.Roles.First().Id;
}
rockContext.SaveChanges();
int labelOrder = 0;
int binaryFileFieldTypeID = FieldTypeCache.Get(Rock.SystemGuid.FieldType.LABEL.AsGuid()).Id;
foreach (var checkinLabelAttributeInfo in checkinArea.CheckinLabels)
{
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 = groupType.Id.ToString();
attribute.DefaultValue = checkinLabelAttributeInfo.BinaryFileGuid.ToString();
attribute.Key = checkinLabelAttributeInfo.AttributeKey;
attribute.Name = checkinLabelAttributeInfo.FileName;
attribute.Order = labelOrder++;
if (!attribute.IsValid)
{
return;
}
attributeService.Add(attribute);
}
rockContext.SaveChanges();
Rock.CheckIn.KioskDevice.Clear();
nbSaveSuccess.Visible = true;
BuildRows();
}
else
{
ShowInvalidResults(groupType.ValidationResults);
}
}
}
if (checkinGroup.Visible)
{
var groupService = new GroupService(rockContext);
var groupLocationService = new GroupLocationService(rockContext);
var group = groupService.Get(checkinGroup.GroupGuid);
if (group != null)
{
group.LoadAttributes(rockContext);
checkinGroup.GetGroupValues(group);
// populate groupLocations with whatever is currently in the grid, with just enough info to repopulate it and save it later
var newLocationIds = checkinGroup.Locations.Select(l => l.LocationId).ToList();
foreach (var groupLocation in group.GroupLocations.Where(l => !newLocationIds.Contains(l.LocationId)).ToList())
{
groupLocation.GroupLocationScheduleConfigs.Clear();
groupLocationService.Delete(groupLocation);
group.GroupLocations.Remove(groupLocation);
}
var existingLocationIds = group.GroupLocations.Select(g => g.LocationId).ToList();
foreach (var item in checkinGroup.Locations.Where(l => !existingLocationIds.Contains(l.LocationId)).ToList())
{
var groupLocation = new GroupLocation();
groupLocation.LocationId = item.LocationId;
group.GroupLocations.Add(groupLocation);
}
// Set the new order
foreach (var item in checkinGroup.Locations.OrderBy(l => l.Order).ToList())
{
var groupLocation = group.GroupLocations.FirstOrDefault(gl => gl.LocationId == item.LocationId);
groupLocation.Order = item.Order ?? 0;
}
if (group.IsValid)
{
rockContext.SaveChanges();
group.SaveAttributeValues(rockContext);
Rock.CheckIn.KioskDevice.Clear();
nbSaveSuccess.Visible = true;
BuildRows();
}
else
{
ShowInvalidResults(group.ValidationResults);
}
}
}
}
hfIsDirty.Value = "false";
}