/// <summary>
/// Saves all family changes.
/// </summary>
private void SaveFamilies(List <Group> newFamilyList, Dictionary <GroupLocation, string> newGroupLocations)
{
var rockContext = new RockContext();
// First save any unsaved families
if (newFamilyList.Any())
{
rockContext.WrapTransaction(() =>
{
rockContext.Groups.AddRange(newFamilyList);
rockContext.SaveChanges(DisableAuditing);
});
// Add these new families to the global list
ImportedPeople.AddRange(newFamilyList);
}
// Now save locations
if (newGroupLocations.Any())
{
// Set updated family id on locations
foreach (var locationPair in newGroupLocations)
{
int?familyGroupId = ImportedPeople.Where(g => g.ForeignKey == locationPair.Value).Select(g => (int?)g.Id).FirstOrDefault();
if (familyGroupId != null)
{
locationPair.Key.GroupId = (int)familyGroupId;
}
}
// Save locations
rockContext.WrapTransaction(() =>
{
rockContext.Configuration.AutoDetectChangesEnabled = false;
rockContext.GroupLocations.AddRange(newGroupLocations.Keys);
rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges(DisableAuditing);
});
}
}
/// <summary>
/// Saves the people.
/// </summary>
/// <param name="familyList">The family list.</param>
/// <param name="visitorList">The visitor list.</param>
/// <param name="previousNamesList">The previous names list.</param>
private static void SavePeople(List <Group> familyList, List <Group> visitorList, Dictionary <Guid, string> previousNamesList)
{
var rockContext = new RockContext();
var groupMemberService = new GroupMemberService(rockContext);
rockContext.WrapTransaction(() =>
{
rockContext.Configuration.AutoDetectChangesEnabled = false;
rockContext.Groups.AddRange(familyList);
rockContext.SaveChanges(DisableAuditing);
foreach (var familyGroups in familyList.GroupBy(g => g.ForeignId))
{
var visitorsExist = familyGroups.Count() > 1;
foreach (var newFamilyGroup in familyGroups)
{
foreach (var groupMember in newFamilyGroup.Members)
{
// don't call LoadAttributes, it only rewrites existing cache objects
// groupMember.Person.LoadAttributes( rockContext );
var memberPersonAttributeValues = groupMember.Person.Attributes.Select(a => a.Value)
.Select(a => new AttributeValue
{
AttributeId = a.Id,
EntityId = groupMember.Person.Id,
Value = groupMember.Person.AttributeValues[a.Key].Value
}).ToList();
rockContext.AttributeValues.AddRange(memberPersonAttributeValues);
// add a default person alias
if (!groupMember.Person.Aliases.Any(a => a.AliasPersonId == groupMember.Person.Id))
{
groupMember.Person.Aliases.Add(new PersonAlias
{
AliasPersonId = groupMember.Person.Id,
AliasPersonGuid = groupMember.Person.Guid,
ForeignId = groupMember.Person.ForeignId,
ForeignKey = groupMember.Person.ForeignKey
});
}
// assign the previous name
if (previousNamesList.Any(l => l.Key.Equals(groupMember.Person.Guid)))
{
var newPreviousName = new PersonPreviousName
{
LastName = previousNamesList[groupMember.Person.Guid],
PersonAlias = groupMember.Person.Aliases.FirstOrDefault()
};
rockContext.PersonPreviousNames.Add(newPreviousName);
}
// assign the giving group
if (groupMember.GroupRoleId != FamilyChildRoleId)
{
groupMember.Person.GivingGroupId = newFamilyGroup.Id;
}
// Add known relationship group
var knownGroupMember = new GroupMember
{
PersonId = groupMember.Person.Id,
GroupRoleId = KnownRelationshipOwnerRoleId
};
var knownRelationshipGroup = new Group
{
Name = KnownRelationshipGroupType.Name,
GroupTypeId = KnownRelationshipGroupType.Id,
IsPublic = true
};
knownRelationshipGroup.Members.Add(knownGroupMember);
rockContext.Groups.Add(knownRelationshipGroup);
// Add implied relationship group
var impliedGroupMember = new GroupMember
{
PersonId = groupMember.Person.Id,
GroupRoleId = ImpliedRelationshipOwnerRoleId
};
var impliedGroup = new Group
{
Name = ImpliedRelationshipGroupType.Name,
GroupTypeId = ImpliedRelationshipGroupType.Id,
IsPublic = true
};
impliedGroup.Members.Add(impliedGroupMember);
rockContext.Groups.Add(impliedGroup);
if (visitorsExist)
{
// if this is a visitor, then add relationships to the family member(s)
if (visitorList.Where(v => v.ForeignId == newFamilyGroup.ForeignId)
.Any(v => v.Members.Any(m => m.Person.ForeignId.Equals(groupMember.Person.ForeignId))))
{
var familyMembers = familyGroups.Except(visitorList).SelectMany(g => g.Members);
foreach (var familyMember in familyMembers.Select(m => m.Person))
{
var invitedByMember = new GroupMember
{
PersonId = familyMember.Id,
GroupRoleId = InvitedByKnownRelationshipId
};
knownRelationshipGroup.Members.Add(invitedByMember);
if (groupMember.Person.Age < 18 && familyMember.Age > 18)
{
var allowCheckinMember = new GroupMember
{
PersonId = familyMember.Id,
GroupRoleId = AllowCheckInByKnownRelationshipId
};
knownRelationshipGroup.Members.Add(allowCheckinMember);
}
}
}
else
{ // not a visitor, add the visitors to the family member's known relationship
var visitors = visitorList.Where(v => v.ForeignId == newFamilyGroup.ForeignId)
.SelectMany(g => g.Members).ToList();
foreach (var visitor in visitors.Select(g => g.Person))
{
var inviteeMember = new GroupMember
{
PersonId = visitor.Id,
GroupRoleId = InviteeKnownRelationshipId
};
knownRelationshipGroup.Members.Add(inviteeMember);
// if visitor can be checked in and this person is considered an adult
if (visitor.Age < 18 && groupMember.Person.Age > 18)
{
var canCheckInMember = new GroupMember
{
PersonId = visitor.Id,
GroupRoleId = CanCheckInKnownRelationshipId
};
knownRelationshipGroup.Members.Add(canCheckInMember);
}
}
}
}
}
}
}
rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges(DisableAuditing);
}); // end wrap transaction
// add the new people to our tracking list
if (familyList.Any())
{
var familyMembers = familyList.SelectMany(gm => gm.Members);
ImportedPeople.AddRange(familyMembers.Select(m => new PersonKeys
{
PersonAliasId = (int)m.Person.PrimaryAliasId,
PersonId = m.Person.Id,
PersonForeignId = m.Person.ForeignId,
GroupForeignId = m.Group.ForeignId,
FamilyRoleId = m.Person.ReviewReasonNote.ConvertToEnum <FamilyRole>()
}).ToList()
);
}
if (visitorList.Any())
{
var visitors = visitorList.SelectMany(gm => gm.Members);
ImportedPeople.AddRange(visitors.Select(m => new PersonKeys
{
PersonAliasId = (int)m.Person.PrimaryAliasId,
PersonId = m.Person.Id,
PersonForeignId = m.Person.ForeignId,
GroupForeignId = m.Group.ForeignId,
FamilyRoleId = m.Person.ReviewReasonNote.ConvertToEnum <FamilyRole>()
}).ToList()
);
}
}
/// <summary>
/// Saves the companies.
/// </summary>
/// <param name="businessList">The business list.</param>
private static void SaveCompanies(List <Group> businessList)
{
var rockContext = new RockContext();
rockContext.WrapTransaction(() =>
{
rockContext.Configuration.AutoDetectChangesEnabled = false;
rockContext.Groups.AddRange(businessList);
rockContext.SaveChanges(DisableAuditing);
foreach (var newBusiness in businessList)
{
foreach (var groupMember in newBusiness.Members)
{
// don't call LoadAttributes, it only rewrites existing cache objects
// groupMember.Person.LoadAttributes( rockContext );
foreach (var attributeCache in groupMember.Person.Attributes.Select(a => a.Value))
{
var existingValue = rockContext.AttributeValues.FirstOrDefault(v => v.Attribute.Key == attributeCache.Key && v.EntityId == groupMember.Person.Id);
var newAttributeValue = groupMember.Person.AttributeValues[attributeCache.Key];
// set the new value and add it to the database
if (existingValue == null)
{
existingValue = new AttributeValue
{
AttributeId = newAttributeValue.AttributeId,
EntityId = groupMember.Person.Id,
Value = newAttributeValue.Value
};
rockContext.AttributeValues.Add(existingValue);
}
else
{
existingValue.Value = newAttributeValue.Value;
rockContext.Entry(existingValue).State = EntityState.Modified;
}
}
if (!groupMember.Person.Aliases.Any(a => a.AliasPersonId == groupMember.Person.Id))
{
groupMember.Person.Aliases.Add(new PersonAlias {
AliasPersonId = groupMember.Person.Id, AliasPersonGuid = groupMember.Person.Guid
});
}
groupMember.Person.GivingGroupId = newBusiness.Id;
}
}
rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges(DisableAuditing);
if (businessList.Any())
{
var groupMembers = businessList.SelectMany(gm => gm.Members);
ImportedPeople.AddRange(groupMembers.Select(m => new PersonKeys
{
PersonAliasId = (int)m.Person.PrimaryAliasId,
PersonId = m.Person.Id,
PersonForeignId = null,
GroupForeignId = m.Group.ForeignId,
FamilyRoleId = FamilyRole.Adult
}).ToList()
);
}
});
}
/// <summary>
/// Saves the individuals.
/// </summary>
/// <param name="newFamilyList">The family list.</param>
/// <param name="visitorList">The optional visitor list.</param>
private void SaveIndividuals(List <Group> newFamilyList, List <Group> visitorList = null)
{
if (newFamilyList.Any())
{
var rockContext = new RockContext();
rockContext.WrapTransaction(() =>
{
rockContext.Groups.AddRange(newFamilyList);
rockContext.SaveChanges(true);
ImportedPeople.AddRange(newFamilyList);
foreach (var familyGroups in newFamilyList.GroupBy <Group, string>(g => g.ForeignId))
{
bool visitorsExist = visitorList.Any() && familyGroups.Count() > 1;
foreach (var newFamilyGroup in familyGroups)
{
foreach (var person in newFamilyGroup.Members.Select(m => m.Person))
{
foreach (var attributeCache in person.Attributes.Select(a => a.Value))
{
var newAttributeValue = person.AttributeValues[attributeCache.Key];
if (newAttributeValue != null)
{
newAttributeValue.EntityId = person.Id;
rockContext.AttributeValues.Add(newAttributeValue);
}
}
if (!person.Aliases.Any(a => a.AliasPersonId == person.Id))
{
person.Aliases.Add(new PersonAlias
{
AliasPersonId = person.Id,
AliasPersonGuid = person.Guid
});
}
person.GivingGroupId = newFamilyGroup.Id;
if (visitorsExist)
{
var groupTypeRoleService = new GroupTypeRoleService(rockContext);
var ownerRole = groupTypeRoleService.Get(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER));
int inviteeRoleId = groupTypeRoleService.Get(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_INVITED)).Id;
int invitedByRoleId = groupTypeRoleService.Get(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_INVITED_BY)).Id;
int canCheckInRoleId = groupTypeRoleService.Get(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_CAN_CHECK_IN)).Id;
int allowCheckInByRoleId = groupTypeRoleService.Get(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_ALLOW_CHECK_IN_BY)).Id;
// Retrieve or create the group this person is an owner of
var ownerGroup = new GroupMemberService(rockContext).Queryable()
.Where(m => m.PersonId == person.Id && m.GroupRoleId == ownerRole.Id)
.Select(m => m.Group).FirstOrDefault();
if (ownerGroup == null)
{
var ownerGroupMember = new GroupMember();
ownerGroupMember.PersonId = person.Id;
ownerGroupMember.GroupRoleId = ownerRole.Id;
ownerGroup = new Group();
ownerGroup.Name = ownerRole.GroupType.Name;
ownerGroup.GroupTypeId = ownerRole.GroupTypeId.Value;
ownerGroup.Members.Add(ownerGroupMember);
rockContext.Groups.Add(ownerGroup);
}
// Visitor, add relationships to the family members
if (visitorList.Where(v => v.ForeignId == newFamilyGroup.ForeignId)
.Any(v => v.Members.Any(m => m.Person.ForeignId.Equals(person.ForeignId))))
{
var familyMembers = familyGroups.Except(visitorList).SelectMany(g => g.Members);
foreach (var familyMember in familyMembers)
{
// Add visitor invitedBy relationship
var invitedByMember = new GroupMember();
invitedByMember.PersonId = familyMember.Person.Id;
invitedByMember.GroupRoleId = invitedByRoleId;
ownerGroup.Members.Add(invitedByMember);
if (person.Age < 18 && familyMember.Person.Age > 15)
{
// Add visitor allowCheckInBy relationship
var allowCheckinMember = new GroupMember();
allowCheckinMember.PersonId = familyMember.Person.Id;
allowCheckinMember.GroupRoleId = allowCheckInByRoleId;
ownerGroup.Members.Add(allowCheckinMember);
}
}
}
else
{ // Family member, add relationships to the visitor(s)
var familyVisitors = visitorList.Where(v => v.ForeignId == newFamilyGroup.ForeignId).SelectMany(g => g.Members).ToList();
foreach (var visitor in familyVisitors)
{
// Add invited visitor relationship
var inviteeMember = new GroupMember();
inviteeMember.PersonId = visitor.Person.Id;
inviteeMember.GroupRoleId = inviteeRoleId;
ownerGroup.Members.Add(inviteeMember);
if (visitor.Person.Age < 18 && person.Age > 15)
{
// Add canCheckIn visitor relationship
var canCheckInMember = new GroupMember();
canCheckInMember.PersonId = visitor.Person.Id;
canCheckInMember.GroupRoleId = canCheckInRoleId;
ownerGroup.Members.Add(canCheckInMember);
}
}
}
}
}
}
}
rockContext.SaveChanges(true);
});
}
}
