/// <summary>
/// Handles the AddCheckinLabelClick event of the groupTypeEditor 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 groupTypeEditor_AddCheckinLabelClick(object sender, EventArgs e)
{
CheckinGroupTypeEditor checkinGroupTypeEditor = sender as CheckinGroupTypeEditor;
// set a hidden field value for the GroupType Guid so we know which GroupType to add the label to
hfAddCheckinLabelGroupTypeGuid.Value = checkinGroupTypeEditor.GroupTypeGuid.ToString();
Guid binaryFileTypeCheckinLabelGuid = new Guid(Rock.SystemGuid.BinaryFiletype.CHECKIN_LABEL);
var binaryFileService = new BinaryFileService(new RockContext());
ddlCheckinLabel.Items.Clear();
var list = binaryFileService.Queryable().Where(a => a.BinaryFileType.Guid.Equals(binaryFileTypeCheckinLabelGuid) && a.IsTemporary == false).OrderBy(a => a.FileName).ToList();
foreach (var item in list)
{
// add checkinlabels to dropdownlist if they aren't already a checkin label for this grouptype
if (!checkinGroupTypeEditor.CheckinLabels.Select(a => a.BinaryFileId).Contains(item.Id))
{
ddlCheckinLabel.Items.Add(new ListItem(item.FileName, item.Id.ToString()));
}
}
// only enable the Add button if there are labels that can be added
btnAddCheckinLabel.Enabled = ddlCheckinLabel.Items.Count > 0;
pnlCheckinLabelPicker.Visible = true;
pnlDetails.Visible = false;
}
/// <summary>
/// Creates the group type editor controls.
/// </summary>
/// <param name="groupType">Type of the group.</param>
private void CreateGroupTypeEditorControls(GroupType groupType, Control parentControl, bool forceGroupTypeEditorVisible = false)
{
CheckinGroupTypeEditor groupTypeEditor = new CheckinGroupTypeEditor();
groupTypeEditor.ID = "GroupTypeEditor_" + groupType.Guid.ToString("N");
groupTypeEditor.SetGroupType(groupType);
groupTypeEditor.AddGroupClick += groupTypeEditor_AddGroupClick;
groupTypeEditor.AddGroupTypeClick += groupTypeEditor_AddGroupTypeClick;
groupTypeEditor.DeleteCheckinLabelClick += groupTypeEditor_DeleteCheckinLabelClick;
groupTypeEditor.AddCheckinLabelClick += groupTypeEditor_AddCheckinLabelClick;
groupTypeEditor.DeleteGroupTypeClick += groupTypeEditor_DeleteGroupTypeClick;
groupTypeEditor.CheckinLabels = null;
groupTypeEditor.ForceContentVisible = forceGroupTypeEditorVisible;
if (GroupTypeCheckinLabelAttributesState.ContainsKey(groupType.Guid))
{
groupTypeEditor.CheckinLabels = GroupTypeCheckinLabelAttributesState[groupType.Guid];
}
if (groupTypeEditor.CheckinLabels == null)
{
// load CheckInLabels from Database if they haven't been set yet
groupTypeEditor.CheckinLabels = new List <CheckinGroupTypeEditor.CheckinLabelAttributeInfo>();
groupType.LoadAttributes();
List <string> labelAttributeKeys = CheckinGroupTypeEditor.GetCheckinLabelAttributes(groupType).Select(a => a.Key).ToList();
BinaryFileService binaryFileService = new BinaryFileService(new RockContext());
foreach (string key in labelAttributeKeys)
{
var attributeValue = groupType.GetAttributeValue(key);
int binaryFileId = attributeValue.AsInteger() ?? 0;
var binaryFile = binaryFileService.Get(binaryFileId);
if (binaryFile != null)
{
groupTypeEditor.CheckinLabels.Add(new CheckinGroupTypeEditor.CheckinLabelAttributeInfo {
AttributeKey = key, BinaryFileId = binaryFileId, FileName = binaryFile.FileName
});
}
}
}
parentControl.Controls.Add(groupTypeEditor);
foreach (var childGroup in groupType.Groups.OrderBy(a => a.Order).ThenBy(a => a.Name))
{
// get the GroupType from the control just in case it the InheritedFrom changed
childGroup.GroupType = groupTypeEditor.GetCheckinGroupType();
CreateGroupEditorControls(childGroup, groupTypeEditor, false);
}
foreach (var childGroupType in groupType.ChildGroupTypes.OrderBy(a => a.Order).ThenBy(a => a.Name))
{
CreateGroupTypeEditorControls(childGroupType, groupTypeEditor);
}
}
/// <summary>
/// Handles the DeleteCheckinLabelClick event of the groupTypeEditor 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 groupTypeEditor_DeleteCheckinLabelClick(object sender, RowEventArgs e)
{
CheckinGroupTypeEditor checkinGroupTypeEditor = sender as CheckinGroupTypeEditor;
string attributeKey = e.RowKeyValue as string;
var label = checkinGroupTypeEditor.CheckinLabels.FirstOrDefault(a => a.AttributeKey == attributeKey);
checkinGroupTypeEditor.CheckinLabels.Remove(label);
checkinGroupTypeEditor.ForceContentVisible = true;
}
/// <summary>
/// Handles the DeleteGroupTypeClick event of the groupTypeEditor 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 groupTypeEditor_DeleteGroupTypeClick(object sender, EventArgs e)
{
CheckinGroupTypeEditor groupTypeEditor = sender as CheckinGroupTypeEditor;
var groupType = GroupTypeCache.Read(groupTypeEditor.GroupTypeGuid);
if (groupType != null)
{
// Warn if this GroupType or any of its child grouptypes (recursive) is being used as an Inherited Group Type. Probably shouldn't happen, but just in case
if (IsInheritedGroupTypeRecursive(groupType))
{
nbDeleteWarning.Text = "WARNING - Cannot delete. This group type or one of its child group types is assigned as an inherited group type.";
nbDeleteWarning.Visible = true;
return;
}
}
groupTypeEditor.Parent.Controls.Remove(groupTypeEditor);
}
/// <summary>
/// Handles the AddGroupClick event of the groupTypeEditor 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 groupTypeEditor_AddGroupClick(object sender, EventArgs e)
{
CheckinGroupTypeEditor parentGroupTypeEditor = sender as CheckinGroupTypeEditor;
parentGroupTypeEditor.ForceContentVisible = true;
Group checkinGroup = new Group();
checkinGroup.Guid = Guid.NewGuid();
checkinGroup.IsActive = true;
checkinGroup.IsSystem = false;
// set GroupType by Guid (just in case the parent groupType hasn't been added to the database yet)
checkinGroup.GroupType = new GroupType {
Guid = parentGroupTypeEditor.GroupTypeGuid
};
CreateGroupEditorControls(checkinGroup, parentGroupTypeEditor);
}
/// <summary>
/// Handles the AddGroupTypeClick event of the groupTypeEditor 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 groupTypeEditor_AddGroupTypeClick(object sender, EventArgs e)
{
CheckinGroupTypeEditor parentEditor = sender as CheckinGroupTypeEditor;
parentEditor.ForceContentVisible = true;
// CheckinArea is GroupType entity
GroupType checkinArea = new GroupType();
checkinArea.Guid = Guid.NewGuid();
checkinArea.IsSystem = false;
checkinArea.TakesAttendance = true;
checkinArea.AttendanceRule = AttendanceRule.AddOnCheckIn;
checkinArea.AttendancePrintTo = PrintTo.Default;
checkinArea.ParentGroupTypes = new List <GroupType>();
checkinArea.ParentGroupTypes.Add(parentEditor.GetCheckinGroupType());
checkinArea.LoadAttributes();
CreateGroupTypeEditorControls(checkinArea, parentEditor);
}
/// <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>
/// Sorts the group type list contents.
/// </summary>
/// <param name="eventParam">The event parameter.</param>
/// <param name="values">The values.</param>
private void SortGroupTypeListContents(string eventParam, string[] values)
{
if (eventParam.Equals("re-order-grouptype"))
{
var allCheckinGroupTypeEditors = phCheckinGroupTypes.ControlsOfTypeRecursive <CheckinGroupTypeEditor>();
Guid groupTypeGuid = new Guid(values[0]);
int newIndex = int.Parse(values[1]);
CheckinGroupTypeEditor sortedGroupTypeEditor = allCheckinGroupTypeEditors.FirstOrDefault(a => a.GroupTypeGuid.Equals(groupTypeGuid));
if (sortedGroupTypeEditor != null)
{
var siblingGroupTypes = allCheckinGroupTypeEditors.Where(a => a.ParentGroupTypeEditor == sortedGroupTypeEditor.ParentGroupTypeEditor).ToList();
Control parentControl = sortedGroupTypeEditor.Parent;
parentControl.Controls.Remove(sortedGroupTypeEditor);
if (newIndex >= siblingGroupTypes.Count())
{
parentControl.Controls.Add(sortedGroupTypeEditor);
}
else
{
parentControl.Controls.AddAt(newIndex, sortedGroupTypeEditor);
}
}
}
else if (eventParam.Equals("re-order-group"))
{
var allCheckinGroupEditors = phCheckinGroupTypes.ControlsOfTypeRecursive <CheckinGroupEditor>();
Guid groupGuid = new Guid(values[0]);
int newIndex = int.Parse(values[1]);
CheckinGroupEditor sortedGroupEditor = allCheckinGroupEditors.FirstOrDefault(a => a.GroupGuid.Equals(groupGuid));
if (sortedGroupEditor != null)
{
var siblingGroupEditors = allCheckinGroupEditors.Where(a => a.GroupTypeId == sortedGroupEditor.GroupTypeId).ToList();
Control parentControl = sortedGroupEditor.Parent;
// parent control has other controls, so just just remove all the checkingroupeditors, sort them, and add them back in the new order
foreach (var item in siblingGroupEditors)
{
parentControl.Controls.Remove(item);
}
siblingGroupEditors.Remove(sortedGroupEditor);
if (newIndex >= siblingGroupEditors.Count())
{
siblingGroupEditors.Add(sortedGroupEditor);
}
else
{
siblingGroupEditors.Insert(newIndex, sortedGroupEditor);
}
foreach (var item in siblingGroupEditors)
{
parentControl.Controls.Add(item);
}
(sortedGroupEditor.Parent as CheckinGroupTypeEditor).ForceContentVisible = true;
}
}
}
