/// <summary>
/// Loads the group data.
/// </summary>
/// <param name="csvData">The CSV data.</param>
private int LoadGroup(CSVInstance csvData)
{
// Required variables
var lookupContext = new RockContext();
var locationService = new LocationService(lookupContext);
var groupTypeService = new GroupTypeService(lookupContext);
var topicTypes = DefinedTypeCache.Get(new Guid(Rock.SystemGuid.DefinedType.SMALL_GROUP_TOPIC), lookupContext).DefinedValues;
var numImportedGroups = ImportedGroups.Count();
var newGroupLocations = new Dictionary <GroupLocation, string>();
var currentGroup = new Group();
// Look for custom attributes in the Individual file
var allFields = csvData.TableNodes.FirstOrDefault().Children.Select((node, index) => new { node = node, index = index }).ToList();
var customAttributes = allFields
.Where(f => f.index > GroupCapacity)
.ToDictionary(f => f.index, f => f.node.Name);
var groupAttributes = new AttributeService(lookupContext).GetByEntityTypeId(new Group().TypeId).ToList();
var completed = 0;
ReportProgress(0, $"Starting group import ({numImportedGroups:N0} already exist).");
string[] row;
// Uses a look-ahead enumerator: this call will move to the next record immediately
while ((row = csvData.Database.FirstOrDefault()) != null)
{
var rowGroupKey = row[GroupId];
//
// Determine if we are still working with the same group or not.
//
if (rowGroupKey != null && rowGroupKey != currentGroup.ForeignKey)
{
currentGroup = LoadGroupBasic(lookupContext, rowGroupKey, row[GroupName], row[GroupCreatedDate], row[GroupType], row[GroupParentGroupId], row[GroupActive], row[GroupDescription]);
//
// Set the group campus
//
var campusName = row[GroupCampus];
if (!string.IsNullOrWhiteSpace(campusName))
{
var groupCampus = CampusList.FirstOrDefault(c => c.Name.Equals(campusName, StringComparison.OrdinalIgnoreCase) ||
c.ShortCode.Equals(campusName, StringComparison.OrdinalIgnoreCase));
if (groupCampus == null)
{
groupCampus = new Campus
{
IsSystem = false,
Name = campusName,
ShortCode = campusName.RemoveWhitespace(),
IsActive = true
};
lookupContext.Campuses.Add(groupCampus);
lookupContext.SaveChanges(DisableAuditing);
CampusList.Add(groupCampus);
}
currentGroup.CampusId = groupCampus.Id;
}
//
// If the group type has one or more location types defined then import the
// primary address as the first location type.
//
var existingLocationIds = new GroupLocationService(lookupContext).Queryable().AsNoTracking().Where(gl => gl.GroupId == currentGroup.Id).Select(gl => gl.LocationId).ToList();
var groupType = groupTypeService.Get(currentGroup.GroupTypeId);
if (groupType.LocationTypes.Count > 0 && (!string.IsNullOrWhiteSpace(row[GroupAddress]) || !string.IsNullOrWhiteSpace(row[GroupNamedLocation])) && currentGroup.GroupLocations.Count == 0)
{
var primaryLocationTypeId = groupType.LocationTypes.ToList()[0].LocationTypeValueId;
var grpAddress = row[GroupAddress];
var grpAddress2 = row[GroupAddress2];
var grpCity = row[GroupCity];
var grpState = row[GroupState];
var grpZip = row[GroupZip];
var grpCountry = row[GroupCountry];
var namedLocation = row[GroupNamedLocation];
if (string.IsNullOrWhiteSpace(namedLocation))
{
var primaryAddress = locationService.Get(grpAddress, grpAddress2, grpCity, grpState, grpZip, grpCountry, verifyLocation: false);
if (primaryAddress != null && !existingLocationIds.Contains(primaryAddress.Id))
{
var primaryLocation = new GroupLocation
{
LocationId = primaryAddress.Id,
IsMailingLocation = true,
IsMappedLocation = true,
GroupLocationTypeValueId = primaryLocationTypeId
};
newGroupLocations.Add(primaryLocation, rowGroupKey);
}
}
else
{
var primaryAddress = locationService.Queryable().AsNoTracking().FirstOrDefault(l => l.Name.Equals(namedLocation) || l.ForeignKey.Equals(namedLocation));
if (primaryAddress != null && !existingLocationIds.Contains(primaryAddress.Id))
{
var primaryLocation = new GroupLocation
{
LocationId = primaryAddress.Id,
IsMailingLocation = true,
IsMappedLocation = true,
GroupLocationTypeValueId = primaryLocationTypeId
};
newGroupLocations.Add(primaryLocation, rowGroupKey);
}
else
{
LogException("Group Import", string.Format("The named location {0} was not found and will not be mapped.", namedLocation));
}
}
}
//
// If the group type has two or more location types defined then import the
// secondary address as the group type's second location type.
//
if (groupType.LocationTypes.Count > 1 && !string.IsNullOrWhiteSpace(row[GroupSecondaryAddress]) && currentGroup.GroupLocations.Count < 2)
{
var secondaryLocationTypeId = groupType.LocationTypes.ToList()[1].LocationTypeValueId;
var grpSecondAddress = row[GroupSecondaryAddress];
var grpSecondAddress2 = row[GroupSecondaryAddress2];
var grpSecondCity = row[GroupSecondaryCity];
var grpSecondState = row[GroupSecondaryState];
var grpSecondZip = row[GroupSecondaryZip];
var grpSecondCountry = row[GroupSecondaryCountry];
var secondaryAddress = locationService.Get(grpSecondAddress, grpSecondAddress2, grpSecondCity, grpSecondState, grpSecondZip, grpSecondCountry, verifyLocation: false);
if (secondaryAddress != null && !existingLocationIds.Contains(secondaryAddress.Id))
{
var secondaryLocation = new GroupLocation
{
LocationId = secondaryAddress.Id,
IsMailingLocation = true,
IsMappedLocation = true,
GroupLocationTypeValueId = secondaryLocationTypeId
};
newGroupLocations.Add(secondaryLocation, rowGroupKey);
}
}
//
// Set the group's sorting order.
//
var groupOrder = 9999;
int.TryParse(row[GroupOrder], out groupOrder);
currentGroup.Order = groupOrder;
//
// Set the group's capacity
//
var capacity = row[GroupCapacity].AsIntegerOrNull();
if (capacity.HasValue)
{
currentGroup.GroupCapacity = capacity;
if (groupType.GroupCapacityRule == GroupCapacityRule.None)
{
groupType.GroupCapacityRule = GroupCapacityRule.Hard;
}
}
//
// Set the group's schedule
//
if (!string.IsNullOrWhiteSpace(row[GroupDayOfWeek]))
{
DayOfWeek dayEnum;
if (Enum.TryParse(row[GroupDayOfWeek], true, out dayEnum))
{
if (groupType.AllowedScheduleTypes != ScheduleType.Weekly)
{
groupType.AllowedScheduleTypes = ScheduleType.Weekly;
}
var day = dayEnum;
var time = row[GroupTime].AsDateTime();
currentGroup.ScheduleId = AddNamedSchedule(lookupContext, string.Empty, string.Empty, day, time, null, rowGroupKey).Id;
}
}
//
// Assign Attributes
//
if (customAttributes.Any())
{
lookupContext.SaveChanges();
foreach (var attributePair in customAttributes)
{
var pairs = attributePair.Value.Split('^');
var categoryName = string.Empty;
var attributeName = string.Empty;
var attributeTypeString = string.Empty;
var attributeForeignKey = string.Empty;
var definedValueForeignKey = string.Empty;
var fieldTypeId = TextFieldTypeId;
if (pairs.Length == 1)
{
attributeName = pairs[0];
}
else if (pairs.Length == 2)
{
attributeName = pairs[0];
attributeTypeString = pairs[1];
}
else if (pairs.Length >= 3)
{
categoryName = pairs[1];
attributeName = pairs[2];
if (pairs.Length >= 4)
{
attributeTypeString = pairs[3];
}
if (pairs.Length >= 5)
{
attributeForeignKey = pairs[4];
}
if (pairs.Length >= 6)
{
definedValueForeignKey = pairs[5];
}
}
var definedValueForeignId = definedValueForeignKey.AsType <int?>();
//
// Translate the provided attribute type into one we know about.
//
fieldTypeId = GetAttributeFieldType(attributeTypeString);
Rock.Model.Attribute currentAttribute = null;
if (string.IsNullOrEmpty(attributeName))
{
LogException("Group Attribute", string.Format("Group Attribute Name cannot be blank '{0}'.", attributePair.Value));
}
else
{
if (string.IsNullOrWhiteSpace(attributeForeignKey))
{
attributeForeignKey = string.Format("Bulldozer_{0}_{1}_{2}", groupType.Id, categoryName.RemoveWhitespace(), attributeName.RemoveWhitespace()).Left(100);
}
currentAttribute = groupAttributes.FirstOrDefault(a =>
a.Name.Equals(attributeName, StringComparison.OrdinalIgnoreCase) &&
a.FieldTypeId == fieldTypeId &&
a.EntityTypeId == currentGroup.TypeId &&
a.EntityTypeQualifierValue == groupType.Id.ToString()
);
if (currentAttribute == null)
{
currentAttribute = AddEntityAttribute(lookupContext, currentGroup.TypeId, "GroupTypeId", groupType.Id.ToString(), attributeForeignKey, categoryName, attributeName, string.Empty, fieldTypeId, true, definedValueForeignId, definedValueForeignKey, attributeTypeString: attributeTypeString);
groupAttributes.Add(currentAttribute);
}
var attributeValue = row[attributePair.Key];
if (!string.IsNullOrEmpty(attributeValue))
{
AddEntityAttributeValue(lookupContext, currentAttribute, currentGroup, row[attributePair.Key], null, true);
}
}
}
}
//
// Changes to groups need to be saved right away since one group
// will reference another group.
//
lookupContext.SaveChanges();
//
// Keep the user informed as to what is going on and save in batches.
//
completed++;
if (completed % (ReportingNumber * 10) < 1)
{
ReportProgress(0, $"{completed:N0} groups imported.");
}
if (completed % ReportingNumber < 1)
{
SaveGroupLocations(newGroupLocations);
ReportPartialProgress();
// Reset lookup context
lookupContext.SaveChanges();
lookupContext = new RockContext();
locationService = new LocationService(lookupContext);
groupTypeService = new GroupTypeService(lookupContext);
newGroupLocations.Clear();
}
}
}
//
// Check to see if any rows didn't get saved to the database
//
if (newGroupLocations.Any())
{
SaveGroupLocations(newGroupLocations);
}
lookupContext.SaveChanges();
lookupContext.Dispose();
ReportProgress(0, $"Finished group import: {completed:N0} groups added or updated.");
return(completed);
}
/// <summary>
/// Updates the list of group locations for the selected group
/// </summary>
private void UpdateGroupLocationList()
{
Group group = GetSelectedGroup();
if (group == null)
{
pnlScheduler.Visible = false;
return;
}
if (group != null)
{
bool canSchedule = group.IsAuthorized(Authorization.EDIT, this.CurrentPerson) || group.IsAuthorized(Authorization.SCHEDULE, this.CurrentPerson);
if (!canSchedule)
{
nbNotice.Heading = "Sorry";
nbNotice.Text = "<p>You're not authorized to schedule resources for the selected group.</p>";
nbNotice.NotificationBoxType = NotificationBoxType.Warning;
nbNotice.Visible = true;
pnlScheduler.Visible = false;
return;
}
else
{
nbNotice.Visible = false;
}
pnlScheduler.Visible = true;
int scheduleId = rblSchedule.SelectedValue.AsInteger();
var rockContext = new RockContext();
var groupLocationsQuery = new GroupLocationService(rockContext).Queryable()
.Where(a => a.GroupId == group.Id && a.Schedules.Any(s => s.Id == scheduleId))
.OrderBy(a => new { a.Order, a.Location.Name })
.AsNoTracking();
var groupLocationsList = groupLocationsQuery.ToList();
if (!groupLocationsList.Any() && scheduleId != 0)
{
nbGroupWarning.Text = "Group does not have any locations for the selected schedule";
nbGroupWarning.Visible = true;
}
else if (scheduleId != 0)
{
nbGroupWarning.Visible = false;
}
// get the location ids of the selected group locations so that we can keep the selected locations even if the group changes
var allSelectedLocationIds = hfAllSelectedLocationIds.Value.SplitDelimitedValues().AsIntegerList();
var selectedGroupLocationIds = allSelectedLocationIds;
var selectedLocationIds = new GroupLocationService(new RockContext()).GetByIds(selectedGroupLocationIds).Select(a => a.LocationId).ToList();
cblGroupLocations.Items.Clear();
foreach (var groupLocation in groupLocationsList)
{
var groupLocationItem = new ListItem(groupLocation.Location.ToString(), groupLocation.Id.ToString());
groupLocationItem.Selected = selectedLocationIds.Contains(groupLocation.LocationId);
cblGroupLocations.Items.Add(groupLocationItem);
}
// if there aren't any locations select, default to selecting all
if (!cblGroupLocations.SelectedValues.Any())
{
foreach (var item in cblGroupLocations.Items.OfType <ListItem>())
{
item.Selected = true;
}
}
}
}