/// <summary>
/// Saves the registration.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="hasPayment">if set to <c>true</c> [has payment].</param>
/// <returns></returns>
private Registration SaveRegistration( RockContext rockContext, bool hasPayment )
{
var registrationService = new RegistrationService( rockContext );
var registrantService = new RegistrationRegistrantService( rockContext );
var personService = new PersonService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
// variables to keep track of the family that new people should be added to
int? singleFamilyId = null;
var multipleFamilyGroupIds = new Dictionary<Guid, int>();
var dvcConnectionStatus = DefinedValueCache.Read( GetAttributeValue( "ConnectionStatus" ).AsGuid() );
var dvcRecordStatus = DefinedValueCache.Read( GetAttributeValue( "RecordStatus" ).AsGuid() );
var familyGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY );
var adultRoleId = familyGroupType.Roles
.Where( r => r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid() ) )
.Select( r => r.Id )
.FirstOrDefault();
var childRoleId = familyGroupType.Roles
.Where( r => r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD.AsGuid() ) )
.Select( r => r.Id )
.FirstOrDefault();
var registration = new Registration();
registrationService.Add( registration );
registration.RegistrationInstanceId = RegistrationInstanceState.Id;
registration.GroupId = GroupId;
registration.FirstName = RegistrationState.FirstName;
registration.LastName = RegistrationState.LastName;
registration.ConfirmationEmail = RegistrationState.ConfirmationEmail;
registration.DiscountCode = RegistrationState.DiscountCode;
registration.DiscountAmount = RegistrationState.DiscountAmount;
registration.DiscountPercentage = RegistrationState.DiscountPercentage;
// If the 'your name' value equals the currently logged in person, use their person alias id
if ( CurrentPerson != null &&
( CurrentPerson.NickName.Trim().Equals( registration.FirstName.Trim(), StringComparison.OrdinalIgnoreCase ) ||
CurrentPerson.FirstName.Trim().Equals( registration.FirstName.Trim(), StringComparison.OrdinalIgnoreCase ) ) &&
CurrentPerson.LastName.Trim().Equals( registration.LastName.Trim(), StringComparison.OrdinalIgnoreCase ) )
{
registration.PersonAliasId = CurrentPerson.PrimaryAliasId;
}
else
{
// otherwise look for one and one-only match by name/email
var personMatches = personService.GetByMatch( registration.FirstName, registration.LastName, registration.ConfirmationEmail );
if ( personMatches.Count() == 1 )
{
registration.PersonAliasId = personMatches.First().PrimaryAliasId;
}
}
// If the registration includes a payment, make sure there's an actual person associated to registration
if ( hasPayment && !registration.PersonAliasId.HasValue )
{
// If a match was not found, create a new person
var person = new Person();
person.FirstName = registration.FirstName;
person.LastName = registration.LastName;
person.IsEmailActive = true;
person.Email = registration.ConfirmationEmail;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
if ( dvcConnectionStatus != null )
{
person.ConnectionStatusValueId = dvcConnectionStatus.Id;
}
if ( dvcRecordStatus != null )
{
person.RecordStatusValueId = dvcRecordStatus.Id;
}
registration.PersonAliasId = SavePerson( rockContext, person, Guid.NewGuid(), null, null, adultRoleId, childRoleId, multipleFamilyGroupIds, singleFamilyId );
}
// Save the registration ( so we can get an id )
rockContext.SaveChanges();
// If the Registration Instance linkage specified a group, load it now
Group group = null;
if ( GroupId.HasValue )
{
group = new GroupService( rockContext ).Get( GroupId.Value );
}
// Get each registrant
foreach ( var registrantInfo in RegistrationState.Registrants )
{
var changes = new List<string>();
var familyChanges = new List<string>();
Person person = null;
// Try to find a matching person based on name and email address
string firstName = registrantInfo.GetFirstName( RegistrationTemplate );
string lastName = registrantInfo.GetLastName( RegistrationTemplate );
string email = registrantInfo.GetEmail( RegistrationTemplate );
var personMatches = personService.GetByMatch( firstName, lastName, email );
if ( personMatches.Count() == 1 )
{
person = personMatches.First();
}
if ( person == null )
{
// If a match was not found, create a new person
person = new Person();
person.FirstName = firstName;
person.LastName = lastName;
person.IsEmailActive = true;
person.Email = email;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
if ( dvcConnectionStatus != null )
{
person.ConnectionStatusValueId = dvcConnectionStatus.Id;
}
if ( dvcRecordStatus != null )
{
person.RecordStatusValueId = dvcRecordStatus.Id;
}
}
int? campusId = null;
Location location = null;
// Set any of the template's person fields
foreach ( var field in RegistrationTemplate.Forms
.SelectMany( f => f.Fields
.Where( t => t.FieldSource == RegistrationFieldSource.PersonField ) ) )
{
// Find the registrant's value
var fieldValue = registrantInfo.FieldValues
.Where( f => f.Key == field.Id )
.Select( f => f.Value )
.FirstOrDefault();
if ( fieldValue != null )
{
switch ( field.PersonFieldType )
{
case RegistrationPersonFieldType.Campus:
{
if ( fieldValue != null )
{
campusId = fieldValue.ToString().AsIntegerOrNull();
}
break;
}
case RegistrationPersonFieldType.Address:
{
location = fieldValue.ToString().FromJsonOrNull<Location>();
break;
}
case RegistrationPersonFieldType.Birthdate:
{
var birthMonth = person.BirthMonth;
var birthDay = person.BirthDay;
var birthYear = person.BirthYear;
person.SetBirthDate( fieldValue as DateTime? );
History.EvaluateChange( changes, "Birth Month", birthMonth, person.BirthMonth );
History.EvaluateChange( changes, "Birth Day", birthDay, person.BirthDay );
History.EvaluateChange( changes, "Birth Year", birthYear, person.BirthYear );
break;
}
case RegistrationPersonFieldType.Gender:
{
var newGender = fieldValue.ToString().ConvertToEnumOrNull<Gender>() ?? Gender.Unknown;
History.EvaluateChange( changes, "Gender", person.Gender, newGender );
person.Gender = newGender;
break;
}
case RegistrationPersonFieldType.MaritalStatus:
{
if ( fieldValue != null )
{
int? newMaritalStatusId = fieldValue.ToString().AsIntegerOrNull();
History.EvaluateChange( changes, "Marital Status", DefinedValueCache.GetName( person.MaritalStatusValueId ), DefinedValueCache.GetName( newMaritalStatusId ) );
person.MaritalStatusValueId = newMaritalStatusId;
}
break;
}
case RegistrationPersonFieldType.MobilePhone:
{
SavePhone( fieldValue, person, Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE.AsGuid(), changes );
break;
}
case RegistrationPersonFieldType.HomePhone:
{
SavePhone( fieldValue, person, Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME.AsGuid(), changes );
break;
}
case RegistrationPersonFieldType.WorkPhone:
{
SavePhone( fieldValue, person, Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_WORK.AsGuid(), changes );
break;
}
}
}
}
// Save the person ( and family if needed )
SavePerson( rockContext, person, registrantInfo.FamilyGuid, campusId, location, adultRoleId, childRoleId, multipleFamilyGroupIds, singleFamilyId );
// Load the person's attributes
person.LoadAttributes();
// Set any of the template's person fields
foreach ( var field in RegistrationTemplate.Forms
.SelectMany( f => f.Fields
.Where( t =>
t.FieldSource == RegistrationFieldSource.PersonAttribute &&
t.AttributeId.HasValue ) ) )
{
// Find the registrant's value
var fieldValue = registrantInfo.FieldValues
.Where( f => f.Key == field.Id )
.Select( f => f.Value )
.FirstOrDefault();
if ( fieldValue != null )
{
var attribute = AttributeCache.Read( field.AttributeId.Value );
if ( attribute != null )
{
string originalValue = person.GetAttributeValue( attribute.Key );
string newValue = fieldValue.ToString();
person.SetAttributeValue( attribute.Key, fieldValue.ToString() );
if ( ( originalValue ?? string.Empty ).Trim() != ( newValue ?? string.Empty ).Trim() )
{
string formattedOriginalValue = string.Empty;
if ( !string.IsNullOrWhiteSpace( originalValue ) )
{
formattedOriginalValue = attribute.FieldType.Field.FormatValue( null, originalValue, attribute.QualifierValues, false );
}
string formattedNewValue = string.Empty;
if ( !string.IsNullOrWhiteSpace( newValue ) )
{
formattedNewValue = attribute.FieldType.Field.FormatValue( null, newValue, attribute.QualifierValues, false );
}
History.EvaluateChange( changes, attribute.Name, formattedOriginalValue, formattedNewValue );
}
}
}
}
person.SaveAttributeValues( rockContext );
GroupMember groupMember = null;
// If the registration instance linkage specified a group to add registrant to, add them if there not already
// part of that group
if ( group != null )
{
groupMember = group.Members.Where( m => m.PersonId == person.Id ).FirstOrDefault();
if ( groupMember == null && group.GroupType.DefaultGroupRoleId.HasValue )
{
groupMember = new GroupMember();
groupMemberService.Add( groupMember );
groupMember.GroupId = group.Id;
groupMember.PersonId = person.Id;
if ( RegistrationTemplate.GroupTypeId.HasValue &&
RegistrationTemplate.GroupTypeId == group.GroupTypeId &&
RegistrationTemplate.GroupMemberRoleId.HasValue )
{
groupMember.GroupRoleId = RegistrationTemplate.GroupMemberRoleId.Value;
groupMember.GroupMemberStatus = RegistrationTemplate.GroupMemberStatus;
}
else
{
groupMember.GroupRoleId = group.GroupType.DefaultGroupRoleId.Value;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
}
}
rockContext.SaveChanges();
// Set any of the template's group member attributes
groupMember.LoadAttributes();
foreach ( var field in RegistrationTemplate.Forms
.SelectMany( f => f.Fields
.Where( t =>
t.FieldSource == RegistrationFieldSource.GroupMemberAttribute &&
t.AttributeId.HasValue ) ) )
{
// Find the registrant's value
var fieldValue = registrantInfo.FieldValues
.Where( f => f.Key == field.Id )
.Select( f => f.Value )
.FirstOrDefault();
if ( fieldValue != null )
{
var attribute = AttributeCache.Read( field.AttributeId.Value );
if ( attribute != null )
{
groupMember.SetAttributeValue( attribute.Key, fieldValue.ToString() );
}
}
}
groupMember.SaveAttributeValues( rockContext );
}
var registrant = new RegistrationRegistrant();
registrantService.Add( registrant );
registrant.RegistrationId = registration.Id;
registrant.PersonAliasId = person.PrimaryAliasId;
registrant.Cost = registrantInfo.Cost;
registrant.GroupMemberId = groupMember != null ? groupMember.Id : (int?)null;
// Add or Update fees
foreach ( var feeValue in registrantInfo.FeeValues.Where( f => f.Value != null ) )
{
foreach ( var uiFee in feeValue.Value )
{
var fee = new RegistrationRegistrantFee();
registrant.Fees.Add( fee );
fee.RegistrationTemplateFeeId = feeValue.Key;
fee.Option = uiFee.Option;
fee.Quantity = uiFee.Quantity;
fee.Cost = uiFee.Cost;
}
}
rockContext.SaveChanges();
// Set any of the templat's registrant attributes
registrant.LoadAttributes();
foreach ( var field in RegistrationTemplate.Forms
.SelectMany( f => f.Fields
.Where( t =>
t.FieldSource == RegistrationFieldSource.RegistrationAttribute &&
t.AttributeId.HasValue ) ) )
{
// Find the registrant's value
var fieldValue = registrantInfo.FieldValues
.Where( f => f.Key == field.Id )
.Select( f => f.Value )
.FirstOrDefault();
if ( fieldValue != null )
{
var attribute = AttributeCache.Read( field.AttributeId.Value );
if ( attribute != null )
{
registrant.SetAttributeValue( attribute.Key, fieldValue.ToString() );
}
}
registrant.SaveAttributeValues( rockContext );
}
}
return registration;
}
/// <summary>
/// Gets the person.
/// </summary>
/// <param name="create">if set to <c>true</c> [create].</param>
/// <returns></returns>
private Person GetPerson( bool create )
{
Person person = null;
var rockContext = new RockContext();
var personService = new PersonService( rockContext );
Group familyGroup = null;
int personId = ViewState["PersonId"] as int? ?? 0;
if ( personId == 0 && _targetPerson != null )
{
personId = _targetPerson.Id;
}
if ( personId != 0 )
{
person = personService.Get( personId );
}
if ( create && ( !phGiveAsOption.Visible || tglGiveAsOption.Checked ) ) // If tglGiveOption is not checked, then person should not be null
{
if ( person == null )
{
// Check to see if there's only one person with same email, first name, and last name
if ( !string.IsNullOrWhiteSpace( txtEmail.Text ) &&
!string.IsNullOrWhiteSpace( txtFirstName.Text ) &&
!string.IsNullOrWhiteSpace( txtLastName.Text ) )
{
// Same logic as CreatePledge.ascx.cs
var personMatches = personService.GetByMatch( txtFirstName.Text, txtLastName.Text, txtEmail.Text );
if ( personMatches.Count() == 1 )
{
person = personMatches.FirstOrDefault();
}
else
{
person = null;
}
}
if ( person == null )
{
DefinedValueCache dvcConnectionStatus = DefinedValueCache.Read( GetAttributeValue( "ConnectionStatus" ).AsGuid() );
DefinedValueCache dvcRecordStatus = DefinedValueCache.Read( GetAttributeValue( "RecordStatus" ).AsGuid() );
// Create Person
person = new Person();
person.FirstName = txtFirstName.Text;
person.LastName = txtLastName.Text;
person.IsEmailActive = true;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
if ( dvcConnectionStatus != null )
{
person.ConnectionStatusValueId = dvcConnectionStatus.Id;
}
if ( dvcRecordStatus != null )
{
person.RecordStatusValueId = dvcRecordStatus.Id;
}
// Create Person/Family
familyGroup = PersonService.SaveNewPerson( person, rockContext, null, false );
}
ViewState["PersonId"] = person != null ? person.Id : 0;
}
}
if ( create && person != null ) // person should never be null at this point
{
person.Email = txtEmail.Text;
if ( GetAttributeValue( "DisplayPhone" ).AsBooleanOrNull() ?? false )
{
var numberTypeId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME ) ).Id;
var phone = person.PhoneNumbers.FirstOrDefault( p => p.NumberTypeValueId == numberTypeId );
if ( phone == null )
{
phone = new PhoneNumber();
person.PhoneNumbers.Add( phone );
phone.NumberTypeValueId = numberTypeId;
}
phone.CountryCode = PhoneNumber.CleanNumber( pnbPhone.CountryCode );
phone.Number = PhoneNumber.CleanNumber( pnbPhone.Number );
}
if ( familyGroup == null )
{
var groupLocationService = new GroupLocationService( rockContext );
if ( GroupLocationId.HasValue )
{
familyGroup = groupLocationService.Queryable()
.Where( gl => gl.Id == GroupLocationId.Value )
.Select( gl => gl.Group )
.FirstOrDefault();
}
else
{
familyGroup = personService.GetFamilies( person.Id ).FirstOrDefault();
}
}
rockContext.SaveChanges();
if ( familyGroup != null )
{
GroupService.AddNewGroupAddress(
rockContext,
familyGroup,
GetAttributeValue( "AddressType" ),
acAddress.Street1, acAddress.Street2, acAddress.City, acAddress.State, acAddress.PostalCode, acAddress.Country,
true );
}
}
return person;
}
/// <summary>
/// Gets the name of the facebook user.
/// </summary>
/// <param name="facebookUser">The facebook user.</param>
/// <param name="syncFriends">if set to <c>true</c> [synchronize friends].</param>
/// <param name="accessToken">The access token.</param>
/// <returns></returns>
public static string GetFacebookUserName( FacebookUser facebookUser, bool syncFriends = false, string accessToken = "" )
{
string username = string.Empty;
string facebookId = facebookUser.id;
string facebookLink = facebookUser.link;
string userName = "******" + facebookId;
UserLogin user = null;
using ( var rockContext = new RockContext() )
{
// Query for an existing user
var userLoginService = new UserLoginService( rockContext );
user = userLoginService.GetByUserName( userName );
// If no user was found, see if we can find a match in the person table
if ( user == null )
{
// Get name/email from Facebook login
string lastName = facebookUser.last_name.ToStringSafe();
string firstName = facebookUser.first_name.ToStringSafe();
string email = string.Empty;
try { email = facebookUser.email.ToStringSafe(); }
catch { }
Person person = null;
// If person had an email, get the first person with the same name and email address.
if ( !string.IsNullOrWhiteSpace( email ) )
{
var personService = new PersonService( rockContext );
var people = personService.GetByMatch( firstName, lastName, email );
if ( people.Count() == 1)
{
person = people.First();
}
}
var personRecordTypeId = DefinedValueCache.Read( SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
var personStatusPending = DefinedValueCache.Read( SystemGuid.DefinedValue.PERSON_RECORD_STATUS_PENDING.AsGuid() ).Id;
rockContext.WrapTransaction( () =>
{
if ( person == null )
{
person = new Person();
person.IsSystem = false;
person.RecordTypeValueId = personRecordTypeId;
person.RecordStatusValueId = personStatusPending;
person.FirstName = firstName;
person.LastName = lastName;
person.Email = email;
person.IsEmailActive = true;
person.EmailPreference = EmailPreference.EmailAllowed;
try
{
if ( facebookUser.gender.ToString() == "male" )
{
person.Gender = Gender.Male;
}
else if ( facebookUser.gender.ToString() == "female" )
{
person.Gender = Gender.Female;
}
else
{
person.Gender = Gender.Unknown;
}
}
catch { }
if ( person != null )
{
PersonService.SaveNewPerson( person, rockContext, null, false );
}
}
if ( person != null )
{
int typeId = EntityTypeCache.Read( typeof( Facebook ) ).Id;
user = UserLoginService.Create( rockContext, person, AuthenticationServiceType.External, typeId, userName, "fb", true );
}
} );
}
if ( user != null )
{
username = user.UserName;
if ( user.PersonId.HasValue )
{
var converter = new ExpandoObjectConverter();
var personService = new PersonService( rockContext );
var person = personService.Get( user.PersonId.Value );
if ( person != null )
{
// If person does not have a photo, try to get their Facebook photo
if ( !person.PhotoId.HasValue )
{
var restClient = new RestClient( string.Format( "https://graph.facebook.com/v2.2/{0}/picture?redirect=false&type=square&height=400&width=400", facebookId ) );
var restRequest = new RestRequest( Method.GET );
restRequest.RequestFormat = DataFormat.Json;
restRequest.AddHeader( "Accept", "application/json" );
var restResponse = restClient.Execute( restRequest );
if ( restResponse.StatusCode == HttpStatusCode.OK )
{
dynamic picData = JsonConvert.DeserializeObject<ExpandoObject>( restResponse.Content, converter );
bool isSilhouette = picData.data.is_silhouette;
string url = picData.data.url;
// If Facebook returned a photo url
if ( !isSilhouette && !string.IsNullOrWhiteSpace( url ) )
{
// Download the photo from the url provided
restClient = new RestClient( url );
restRequest = new RestRequest( Method.GET );
restResponse = restClient.Execute( restRequest );
if ( restResponse.StatusCode == HttpStatusCode.OK )
{
var bytes = restResponse.RawBytes;
// Create and save the image
BinaryFileType fileType = new BinaryFileTypeService( rockContext ).Get( Rock.SystemGuid.BinaryFiletype.PERSON_IMAGE.AsGuid() );
if ( fileType != null )
{
var binaryFileService = new BinaryFileService( rockContext );
var binaryFile = new BinaryFile();
binaryFileService.Add( binaryFile );
binaryFile.IsTemporary = false;
binaryFile.BinaryFileType = fileType;
binaryFile.MimeType = "image/jpeg";
binaryFile.FileName = user.Person.NickName + user.Person.LastName + ".jpg";
binaryFile.ContentStream = new MemoryStream( bytes );
rockContext.SaveChanges();
person.PhotoId = binaryFile.Id;
rockContext.SaveChanges();
}
}
}
}
}
// Save the facebook social media link
var facebookAttribute = AttributeCache.Read( Rock.SystemGuid.Attribute.PERSON_FACEBOOK.AsGuid() );
if ( facebookAttribute != null )
{
person.LoadAttributes( rockContext );
person.SetAttributeValue( facebookAttribute.Key, facebookLink );
person.SaveAttributeValues( rockContext );
}
if ( syncFriends && !string.IsNullOrWhiteSpace( accessToken ) )
{
// Get the friend list (only includes friends who have also authorized this app)
var restRequest = new RestRequest( Method.GET );
restRequest.AddParameter( "access_token", accessToken );
restRequest.RequestFormat = DataFormat.Json;
restRequest.AddHeader( "Accept", "application/json" );
var restClient = new RestClient( string.Format( "https://graph.facebook.com/v2.2/{0}/friends", facebookId ) );
var restResponse = restClient.Execute( restRequest );
if ( restResponse.StatusCode == HttpStatusCode.OK )
{
// Get a list of the facebook ids for each friend
dynamic friends = JsonConvert.DeserializeObject<ExpandoObject>( restResponse.Content, converter );
var facebookIds = new List<string>();
foreach ( var friend in friends.data )
{
facebookIds.Add( friend.id );
}
// Queue a transaction to add/remove friend relationships in Rock
var transaction = new Rock.Transactions.UpdateFacebookFriends( person.Id, facebookIds );
Rock.Transactions.RockQueue.TransactionQueue.Enqueue( transaction );
}
}
}
}
}
return username;
}
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute( RockContext rockContext, WorkflowAction action, Object entity, out List<string> errorMessages )
{
errorMessages = new List<string>();
string attributeValue = GetAttributeValue( action, "PersonAttribute" );
Guid? guid = attributeValue.AsGuidOrNull();
if (guid.HasValue)
{
var attribute = AttributeCache.Read( guid.Value, rockContext );
if ( attribute != null )
{
string firstName = GetAttributeValue( action, "FirstName", true );
string lastName = GetAttributeValue( action, "LastName", true );
string email = GetAttributeValue( action, "Email", true );
if ( string.IsNullOrWhiteSpace( firstName ) ||
string.IsNullOrWhiteSpace( lastName ) ||
string.IsNullOrWhiteSpace( email ) )
{
errorMessages.Add( "First Name, Last Name, and Email are required. One or more of these values was not provided!" );
}
else
{
Person person = null;
PersonAlias personAlias = null;
var personService = new PersonService( rockContext );
var people = personService.GetByMatch( firstName, lastName, email ).ToList();
if ( people.Count == 1 )
{
person = people.First();
personAlias = person.PrimaryAlias;
}
else
{
// Add New Person
person = new Person();
person.FirstName = firstName;
person.LastName = lastName;
person.IsEmailActive = true;
person.Email = email;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
var defaultConnectionStatus = DefinedValueCache.Read( GetAttributeValue( action, "DefaultConnectionStatus" ).AsGuid() );
if ( defaultConnectionStatus != null )
{
person.ConnectionStatusValueId = defaultConnectionStatus.Id;
}
var defaultRecordStatus = DefinedValueCache.Read( GetAttributeValue( action, "DefaultRecordStatus" ).AsGuid() );
if ( defaultRecordStatus != null )
{
person.RecordStatusValueId = defaultRecordStatus.Id;
}
var defaultCampus = CampusCache.Read( GetAttributeValue( action, "DefaultCampus", true ).AsGuid() );
var familyGroup = PersonService.SaveNewPerson( person, rockContext, ( defaultCampus != null ? defaultCampus.Id : (int?)null ), false );
if ( familyGroup != null && familyGroup.Members.Any() )
{
person = familyGroup.Members.Select( m => m.Person ).First();
personAlias = person.PrimaryAlias;
}
}
if ( person != null && personAlias != null )
{
action.Activity.Workflow.SetAttributeValue( attribute.Key, personAlias.Guid.ToString() );
action.AddLogEntry( string.Format( "Set '{0}' attribute to '{1}'.", attribute.Name, person.FullName ) );
return true;
}
else
{
errorMessages.Add( "Person or Primary Alias could not be determined!" );
}
}
}
else
{
errorMessages.Add( string.Format( "Person Attribute could not be found for selected attribute value ('{0}')!", guid.Value.ToString() ) );
}
}
else
{
errorMessages.Add( string.Format( "Selected Person Attribute value ('{0}') was not a valid Guid!", attributeValue ) );
}
if ( errorMessages.Any() )
{
errorMessages.ForEach( m => action.AddLogEntry( m, true ) );
return false;
}
return true;
}
/// <summary>
/// Finds the person if they're logged in, or by email and name. If not exactly one found, creates a new person (and family)
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <returns></returns>
private Person FindPerson( RockContext rockContext )
{
Person person;
var personService = new PersonService( rockContext );
if ( CurrentPerson != null )
{
person = CurrentPerson;
}
else
{
string firstName = tbFirstName.Text;
if ( GetAttributeValue( "EnableSmartNames" ).AsBooleanOrNull() ?? true )
{
// If they tried to specify first name as multiple first names, like "Steve and Judy" or "Bob & Sally", just take the first first name
var parts = firstName.Split( new string[] { " and ", " & " }, StringSplitOptions.RemoveEmptyEntries );
if ( parts.Length > 0 )
{
firstName = parts[0];
}
}
// Same logic as AddTransaction.ascx.cs
var personMatches = personService.GetByMatch( firstName, tbLastName.Text, tbEmail.Text );
if ( personMatches.Count() == 1 )
{
person = personMatches.FirstOrDefault();
}
else
{
person = null;
}
}
if ( person == null )
{
var definedValue = DefinedValueCache.Read( GetAttributeValue( "NewConnectionStatus" ).AsGuidOrNull() ?? Rock.SystemGuid.DefinedValue.PERSON_CONNECTION_STATUS_PARTICIPANT.AsGuid() );
person = new Person
{
FirstName = tbFirstName.Text,
LastName = tbLastName.Text,
Email = tbEmail.Text,
EmailPreference = Rock.Model.EmailPreference.EmailAllowed,
ConnectionStatusValueId = definedValue.Id,
};
person.IsSystem = false;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
person.RecordStatusValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_PENDING.AsGuid() ).Id;
PersonService.SaveNewPerson( person, rockContext, null, false );
}
return person;
}
/// <summary>
/// Handles the Click event of the btnRegister 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 btnRegister_Click( object sender, EventArgs e )
{
if ( Page.IsValid )
{
var rockContext = new RockContext();
var personService = new PersonService( rockContext );
Person person = null;
Person spouse = null;
Group family = null;
GroupLocation homeLocation = null;
var changes = new List<string>();
var spouseChanges = new List<string>();
var familyChanges = new List<string>();
// Only use current person if the name entered matches the current person's name and autofill mode is true
if ( _autoFill )
{
if ( CurrentPerson != null &&
tbFirstName.Text.Trim().Equals( CurrentPerson.FirstName.Trim(), StringComparison.OrdinalIgnoreCase ) &&
tbLastName.Text.Trim().Equals( CurrentPerson.LastName.Trim(), StringComparison.OrdinalIgnoreCase ) )
{
person = personService.Get( CurrentPerson.Id );
}
}
// Try to find person by name/email
if ( person == null )
{
var matches = personService.GetByMatch( tbFirstName.Text.Trim(), tbLastName.Text.Trim(), tbEmail.Text.Trim() );
if ( matches.Count() == 1 )
{
person = matches.First();
}
}
// Check to see if this is a new person
if ( person == null )
{
// If so, create the person and family record for the new person
person = new Person();
person.FirstName = tbFirstName.Text.Trim();
person.LastName = tbLastName.Text.Trim();
person.Email = tbEmail.Text.Trim();
person.IsEmailActive = true;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
person.ConnectionStatusValueId = _dvcConnectionStatus.Id;
person.RecordStatusValueId = _dvcRecordStatus.Id;
person.Gender = Gender.Unknown;
family = PersonService.SaveNewPerson( person, rockContext, _group.CampusId, false );
}
else
{
// updating current existing person
History.EvaluateChange( changes, "Email", person.Email, tbEmail.Text );
person.Email = tbEmail.Text;
// Get the current person's families
var families = person.GetFamilies( rockContext );
// If address can being entered, look for first family with a home location
if ( !IsSimple )
{
foreach ( var aFamily in families )
{
homeLocation = aFamily.GroupLocations
.Where( l =>
l.GroupLocationTypeValueId == _homeAddressType.Id &&
l.IsMappedLocation )
.FirstOrDefault();
if ( homeLocation != null )
{
family = aFamily;
break;
}
}
}
// If a family wasn't found with a home location, use the person's first family
if ( family == null )
{
family = families.FirstOrDefault();
}
}
// If using a 'Full' view, save the phone numbers and address
if ( !IsSimple )
{
SetPhoneNumber( rockContext, person, pnHome, null, Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME.AsGuid(), changes );
SetPhoneNumber( rockContext, person, pnCell, cbSms, Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE.AsGuid(), changes );
string oldLocation = homeLocation != null ? homeLocation.Location.ToString() : string.Empty;
string newLocation = string.Empty;
var location = new LocationService( rockContext ).Get( acAddress.Street1, acAddress.Street2, acAddress.City, acAddress.State, acAddress.PostalCode, acAddress.Country );
if ( location != null )
{
if ( homeLocation == null )
{
homeLocation = new GroupLocation();
homeLocation.GroupLocationTypeValueId = _homeAddressType.Id;
family.GroupLocations.Add( homeLocation );
}
else
{
oldLocation = homeLocation.Location.ToString();
}
homeLocation.Location = location;
newLocation = location.ToString();
}
else
{
if ( homeLocation != null )
{
homeLocation.Location = null;
family.GroupLocations.Remove( homeLocation );
new GroupLocationService( rockContext ).Delete( homeLocation );
}
}
History.EvaluateChange( familyChanges, "Home Location", oldLocation, newLocation );
// Check for the spouse
if ( IsFullWithSpouse && !string.IsNullOrWhiteSpace(tbSpouseFirstName.Text) && !string.IsNullOrWhiteSpace(tbSpouseLastName.Text) )
{
spouse = person.GetSpouse();
if ( spouse == null ||
!tbSpouseFirstName.Text.Trim().Equals( spouse.FirstName.Trim(), StringComparison.OrdinalIgnoreCase ) ||
!tbSpouseLastName.Text.Trim().Equals( spouse.LastName.Trim(), StringComparison.OrdinalIgnoreCase ) )
{
spouse = new Person();
spouse.FirstName = tbSpouseFirstName.Text;
History.EvaluateChange( spouseChanges, "First Name", string.Empty, spouse.FirstName );
spouse.LastName = tbSpouseLastName.Text;
History.EvaluateChange( spouseChanges, "Last Name", string.Empty, spouse.LastName );
spouse.ConnectionStatusValueId = _dvcConnectionStatus.Id;
spouse.RecordStatusValueId = _dvcRecordStatus.Id;
spouse.Gender = Gender.Unknown;
spouse.IsEmailActive = true;
spouse.EmailPreference = EmailPreference.EmailAllowed;
var groupMember = new GroupMember();
groupMember.GroupRoleId = _adultRole.Id;
groupMember.Person = spouse;
family.Members.Add( groupMember );
spouse.MaritalStatusValueId = _married.Id;
person.MaritalStatusValueId = _married.Id;
}
History.EvaluateChange( changes, "Email", person.Email, tbEmail.Text );
spouse.Email = tbSpouseEmail.Text;
SetPhoneNumber( rockContext, spouse, pnHome, null, Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME.AsGuid(), spouseChanges );
SetPhoneNumber( rockContext, spouse, pnSpouseCell, cbSpouseSms, Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE.AsGuid(), spouseChanges );
}
}
// Save the person/spouse and change history
rockContext.SaveChanges();
HistoryService.SaveChanges( rockContext, typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), person.Id, changes );
HistoryService.SaveChanges( rockContext, typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(), person.Id, familyChanges );
if ( spouse != null )
{
HistoryService.SaveChanges( rockContext, typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), spouse.Id, spouseChanges );
HistoryService.SaveChanges( rockContext, typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(), spouse.Id, familyChanges );
}
// Check to see if a workflow should be launched for each person
WorkflowType workflowType = null;
Guid? workflowTypeGuid = GetAttributeValue( "Workflow" ).AsGuidOrNull();
if ( workflowTypeGuid.HasValue )
{
var workflowTypeService = new WorkflowTypeService( rockContext );
workflowType = workflowTypeService.Get( workflowTypeGuid.Value );
}
// Save the registrations ( and launch workflows )
var newGroupMembers = new List<GroupMember>();
AddPersonToGroup( rockContext, person, workflowType, newGroupMembers );
AddPersonToGroup( rockContext, spouse, workflowType, newGroupMembers );
// Show the results
pnlView.Visible = false;
pnlResult.Visible = true;
// Show lava content
var mergeFields = new Dictionary<string, object>();
mergeFields.Add( "Group", _group );
mergeFields.Add( "GroupMembers", newGroupMembers );
bool showDebug = UserCanEdit && GetAttributeValue( "EnableDebug" ).AsBoolean();
lResultDebug.Visible = showDebug;
if ( showDebug )
{
lResultDebug.Text = mergeFields.lavaDebugInfo( _rockContext );
}
string template = GetAttributeValue( "ResultLavaTemplate" );
lResult.Text = template.ResolveMergeFields( mergeFields );
// Will only redirect if a value is specifed
NavigateToLinkedPage( "ResultPage" );
}
}
/// <summary>
/// Saves the registration.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="hasPayment">if set to <c>true</c> [has payment].</param>
/// <returns></returns>
private Registration SaveRegistration( RockContext rockContext, bool hasPayment )
{
var registrationService = new RegistrationService( rockContext );
var registrantService = new RegistrationRegistrantService( rockContext );
var registrantFeeService = new RegistrationRegistrantFeeService( rockContext );
var personService = new PersonService( rockContext );
var groupService = new GroupService( rockContext );
// variables to keep track of the family that new people should be added to
int? singleFamilyId = null;
var multipleFamilyGroupIds = new Dictionary<Guid, int>();
var dvcConnectionStatus = DefinedValueCache.Read( GetAttributeValue( "ConnectionStatus" ).AsGuid() );
var dvcRecordStatus = DefinedValueCache.Read( GetAttributeValue( "RecordStatus" ).AsGuid() );
var familyGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY );
var adultRoleId = familyGroupType.Roles
.Where( r => r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid() ) )
.Select( r => r.Id )
.FirstOrDefault();
var childRoleId = familyGroupType.Roles
.Where( r => r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD.AsGuid() ) )
.Select( r => r.Id )
.FirstOrDefault();
bool newRegistration = false;
Registration registration = null;
Person registrar = null;
var registrationChanges = new List<string>();
if ( RegistrationState.RegistrationId.HasValue )
{
registration = registrationService.Get( RegistrationState.RegistrationId.Value );
}
if ( registration == null )
{
newRegistration = true;
registration = new Registration();
registrationService.Add( registration );
registrationChanges.Add( "Created Registration" );
}
else
{
if ( registration.PersonAlias != null && registration.PersonAlias.Person != null )
{
registrar = registration.PersonAlias.Person;
}
}
registration.RegistrationInstanceId = RegistrationInstanceState.Id;
// If the Registration Instance linkage specified a group, load it now
Group group = null;
if ( GroupId.HasValue )
{
group = new GroupService( rockContext ).Get( GroupId.Value );
if ( group != null && ( !registration.GroupId.HasValue || registration.GroupId.Value != group.Id ) )
{
registration.GroupId = group.Id;
History.EvaluateChange( registrationChanges, "Group", string.Empty, group.Name );
}
}
bool newRegistrar = newRegistration ||
registration.FirstName == null || !registration.FirstName.Equals( RegistrationState.FirstName, StringComparison.OrdinalIgnoreCase ) ||
registration.LastName == null || !registration.LastName.Equals( RegistrationState.LastName, StringComparison.OrdinalIgnoreCase );
History.EvaluateChange( registrationChanges, "First Name", registration.FirstName, RegistrationState.FirstName );
registration.FirstName = RegistrationState.FirstName;
History.EvaluateChange( registrationChanges, "Last Name", registration.LastName, RegistrationState.LastName );
registration.LastName = RegistrationState.LastName;
History.EvaluateChange( registrationChanges, "Confirmation Email", registration.ConfirmationEmail, RegistrationState.ConfirmationEmail );
registration.ConfirmationEmail = RegistrationState.ConfirmationEmail;
History.EvaluateChange( registrationChanges, "Discount Code", registration.DiscountCode, RegistrationState.DiscountCode );
registration.DiscountCode = RegistrationState.DiscountCode;
History.EvaluateChange( registrationChanges, "Discount Percentage", registration.DiscountPercentage, RegistrationState.DiscountPercentage );
registration.DiscountPercentage = RegistrationState.DiscountPercentage;
History.EvaluateChange( registrationChanges, "Discount Amount", registration.DiscountAmount, RegistrationState.DiscountAmount );
registration.DiscountAmount = RegistrationState.DiscountAmount;
if ( newRegistrar )
{
if ( CurrentPerson != null && CurrentPerson.NickName == null )
{
CurrentPerson.NickName = CurrentPerson.FirstName;
}
// If the 'your name' value equals the currently logged in person, use their person alias id
if ( CurrentPerson != null &&
( CurrentPerson.NickName.Trim().Equals( registration.FirstName.Trim(), StringComparison.OrdinalIgnoreCase ) ||
CurrentPerson.FirstName.Trim().Equals( registration.FirstName.Trim(), StringComparison.OrdinalIgnoreCase ) ) &&
CurrentPerson.LastName.Trim().Equals( registration.LastName.Trim(), StringComparison.OrdinalIgnoreCase ) )
{
registrar = CurrentPerson;
registration.PersonAliasId = CurrentPerson.PrimaryAliasId;
// If email that logged in user used is different than their stored email address, update their stored value
if ( !string.IsNullOrWhiteSpace( registration.ConfirmationEmail ) &&
!registration.ConfirmationEmail.Trim().Equals( CurrentPerson.Email.Trim(), StringComparison.OrdinalIgnoreCase ) &&
( !cbUpdateEmail.Visible || cbUpdateEmail.Checked ) )
{
var person = personService.Get( CurrentPerson.Id );
if ( person != null )
{
var personChanges = new List<string>();
History.EvaluateChange( personChanges, "Email", person.Email, registration.ConfirmationEmail );
person.Email = registration.ConfirmationEmail;
HistoryService.SaveChanges(
new RockContext(),
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
person.Id,
personChanges, true, CurrentPersonAliasId );
}
}
}
else
{
// otherwise look for one and one-only match by name/email
var personMatches = personService.GetByMatch( registration.FirstName, registration.LastName, registration.ConfirmationEmail );
if ( personMatches.Count() == 1 )
{
registrar = personMatches.First();
registration.PersonAliasId = registrar.PrimaryAliasId;
}
else
{
registrar = null;
registration.PersonAlias = null;
registration.PersonAliasId = null;
}
}
}
// Set the family guid for any other registrants that were selected to be in the same family
if ( registrar != null )
{
var family = registrar.GetFamilies( rockContext ).FirstOrDefault();
if ( family != null )
{
multipleFamilyGroupIds.AddOrIgnore( RegistrationState.FamilyGuid, family.Id );
if ( !singleFamilyId.HasValue )
{
singleFamilyId = family.Id;
}
}
}
// Make sure there's an actual person associated to registration
if ( !registration.PersonAliasId.HasValue )
{
// If a match was not found, create a new person
var person = new Person();
person.FirstName = registration.FirstName;
person.LastName = registration.LastName;
person.IsEmailActive = true;
person.Email = registration.ConfirmationEmail;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
if ( dvcConnectionStatus != null )
{
person.ConnectionStatusValueId = dvcConnectionStatus.Id;
}
if ( dvcRecordStatus != null )
{
person.RecordStatusValueId = dvcRecordStatus.Id;
}
registrar = SavePerson( rockContext, person, RegistrationState.FamilyGuid, CampusId, null, adultRoleId, childRoleId, multipleFamilyGroupIds, ref singleFamilyId );
registration.PersonAliasId = registrar != null ? registrar.PrimaryAliasId : (int?)null;
History.EvaluateChange( registrationChanges, "Registrar", string.Empty, registrar.FullName );
}
else
{
if ( newRegistration )
{
History.EvaluateChange( registrationChanges, "Registrar", string.Empty, registration.ToString() );
}
}
// if this registration was marked as temporary (started from another page, then specified in the url), set IsTemporary to False now that we are done
if ( registration.IsTemporary )
{
registration.IsTemporary = false;
}
// Save the registration ( so we can get an id )
rockContext.SaveChanges();
RegistrationState.RegistrationId = registration.Id;
try
{
Task.Run( () =>
HistoryService.SaveChanges(
new RockContext(),
typeof( Registration ),
Rock.SystemGuid.Category.HISTORY_EVENT_REGISTRATION.AsGuid(),
registration.Id,
registrationChanges, true, CurrentPersonAliasId )
);
// Get each registrant
foreach ( var registrantInfo in RegistrationState.Registrants.ToList() )
{
var registrantChanges = new List<string>();
var personChanges = new List<string>();
var familyChanges = new List<string>();
RegistrationRegistrant registrant = null;
Person person = null;
string firstName = registrantInfo.GetFirstName( RegistrationTemplate );
string lastName = registrantInfo.GetLastName( RegistrationTemplate );
string email = registrantInfo.GetEmail( RegistrationTemplate );
if ( registrantInfo.Id > 0 )
{
registrant = registration.Registrants.FirstOrDefault( r => r.Id == registrantInfo.Id );
if ( registrant != null )
{
person = registrant.Person;
if ( person != null && (
( registrant.Person.FirstName.Equals( firstName, StringComparison.OrdinalIgnoreCase ) || registrant.Person.NickName.Equals( firstName, StringComparison.OrdinalIgnoreCase ) ) &&
registrant.Person.LastName.Equals( lastName, StringComparison.OrdinalIgnoreCase ) ) )
{
//
}
else
{
person = null;
registrant.PersonAlias = null;
registrant.PersonAliasId = null;
}
}
}
if ( person == null )
{
// Try to find a matching person based on name and email address
var personMatches = personService.GetByMatch( firstName, lastName, email );
if ( personMatches.Count() == 1 )
{
person = personMatches.First();
}
// Try to find a matching person based on name within same family as registrar
if ( person == null && registrar != null && registrantInfo.FamilyGuid == RegistrationState.FamilyGuid )
{
var familyMembers = registrar.GetFamilyMembers( true, rockContext )
.Where( m =>
( m.Person.FirstName == firstName || m.Person.NickName == firstName ) &&
m.Person.LastName == lastName )
.Select( m => m.Person )
.ToList();
if ( familyMembers.Count() == 1 )
{
person = familyMembers.First();
if ( !string.IsNullOrWhiteSpace( email ) )
{
person.Email = email;
}
}
if ( familyMembers.Count() > 1 && !string.IsNullOrWhiteSpace( email ) )
{
familyMembers = familyMembers
.Where( m =>
m.Email != null &&
m.Email.Equals( email, StringComparison.OrdinalIgnoreCase ) )
.ToList();
if ( familyMembers.Count() == 1 )
{
person = familyMembers.First();
}
}
}
}
if ( person == null )
{
// If a match was not found, create a new person
person = new Person();
person.FirstName = firstName;
person.LastName = lastName;
person.IsEmailActive = true;
person.Email = email;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
if ( dvcConnectionStatus != null )
{
person.ConnectionStatusValueId = dvcConnectionStatus.Id;
}
if ( dvcRecordStatus != null )
{
person.RecordStatusValueId = dvcRecordStatus.Id;
}
}
int? campusId = CampusId;
Location location = null;
// Set any of the template's person fields
foreach ( var field in RegistrationTemplate.Forms
.SelectMany( f => f.Fields
.Where( t => t.FieldSource == RegistrationFieldSource.PersonField ) ) )
{
// Find the registrant's value
var fieldValue = registrantInfo.FieldValues
.Where( f => f.Key == field.Id )
.Select( f => f.Value.FieldValue )
.FirstOrDefault();
if ( fieldValue != null )
{
switch ( field.PersonFieldType )
{
case RegistrationPersonFieldType.Campus:
{
if ( fieldValue != null )
{
campusId = fieldValue.ToString().AsIntegerOrNull();
}
break;
}
case RegistrationPersonFieldType.Address:
{
location = fieldValue as Location;
break;
}
case RegistrationPersonFieldType.Birthdate:
{
var birthMonth = person.BirthMonth;
var birthDay = person.BirthDay;
var birthYear = person.BirthYear;
person.SetBirthDate( fieldValue as DateTime? );
History.EvaluateChange( personChanges, "Birth Month", birthMonth, person.BirthMonth );
History.EvaluateChange( personChanges, "Birth Day", birthDay, person.BirthDay );
History.EvaluateChange( personChanges, "Birth Year", birthYear, person.BirthYear );
break;
}
case RegistrationPersonFieldType.Grade:
{
var newGraduationYear = fieldValue.ToString().AsIntegerOrNull();
History.EvaluateChange( personChanges, "Graduation Year", person.GraduationYear, newGraduationYear );
person.GraduationYear = newGraduationYear;
break;
}
case RegistrationPersonFieldType.Gender:
{
var newGender = fieldValue.ToString().ConvertToEnumOrNull<Gender>() ?? Gender.Unknown;
History.EvaluateChange( personChanges, "Gender", person.Gender, newGender );
person.Gender = newGender;
break;
}
case RegistrationPersonFieldType.MaritalStatus:
{
if ( fieldValue != null )
{
int? newMaritalStatusId = fieldValue.ToString().AsIntegerOrNull();
History.EvaluateChange( personChanges, "Marital Status", DefinedValueCache.GetName( person.MaritalStatusValueId ), DefinedValueCache.GetName( newMaritalStatusId ) );
person.MaritalStatusValueId = newMaritalStatusId;
}
break;
}
case RegistrationPersonFieldType.MobilePhone:
{
SavePhone( fieldValue, person, Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE.AsGuid(), personChanges );
break;
}
case RegistrationPersonFieldType.HomePhone:
{
SavePhone( fieldValue, person, Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME.AsGuid(), personChanges );
break;
}
case RegistrationPersonFieldType.WorkPhone:
{
SavePhone( fieldValue, person, Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_WORK.AsGuid(), personChanges );
break;
}
}
}
}
// Save the person ( and family if needed )
SavePerson( rockContext, person, registrantInfo.FamilyGuid, campusId, location, adultRoleId, childRoleId, multipleFamilyGroupIds, ref singleFamilyId );
// Load the person's attributes
person.LoadAttributes();
// Set any of the template's person fields
foreach ( var field in RegistrationTemplate.Forms
.SelectMany( f => f.Fields
.Where( t =>
t.FieldSource == RegistrationFieldSource.PersonAttribute &&
t.AttributeId.HasValue ) ) )
{
// Find the registrant's value
var fieldValue = registrantInfo.FieldValues
.Where( f => f.Key == field.Id )
.Select( f => f.Value.FieldValue )
.FirstOrDefault();
if ( fieldValue != null )
{
var attribute = AttributeCache.Read( field.AttributeId.Value );
if ( attribute != null )
{
string originalValue = person.GetAttributeValue( attribute.Key );
string newValue = fieldValue.ToString();
person.SetAttributeValue( attribute.Key, fieldValue.ToString() );
// DateTime values must be stored in ISO8601 format as http://www.rockrms.com/Rock/Developer/BookContent/16/16#datetimeformatting
if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DATE.AsGuid() ) ||
attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DATE_TIME.AsGuid() ) )
{
DateTime aDateTime;
if ( DateTime.TryParse( newValue, out aDateTime ) )
{
newValue = aDateTime.ToString( "o" );
}
}
if ( ( originalValue ?? string.Empty ).Trim() != ( newValue ?? string.Empty ).Trim() )
{
string formattedOriginalValue = string.Empty;
if ( !string.IsNullOrWhiteSpace( originalValue ) )
{
formattedOriginalValue = attribute.FieldType.Field.FormatValue( null, originalValue, attribute.QualifierValues, false );
}
string formattedNewValue = string.Empty;
if ( !string.IsNullOrWhiteSpace( newValue ) )
{
formattedNewValue = attribute.FieldType.Field.FormatValue( null, newValue, attribute.QualifierValues, false );
}
Helper.SaveAttributeValue( person, attribute, newValue, rockContext );
History.EvaluateChange( personChanges, attribute.Name, formattedOriginalValue, formattedNewValue );
}
}
}
}
string registrantName = person.FullName + ": ";
personChanges.ForEach( c => registrantChanges.Add( c ) );
if ( registrant == null )
{
registrant = new RegistrationRegistrant();
registrant.Guid = registrantInfo.Guid;
registrantService.Add( registrant );
registrant.RegistrationId = registration.Id;
}
registrant.PersonAliasId = person.PrimaryAliasId;
registrant.Cost = registrantInfo.Cost;
// Remove fees
// Remove/delete any registrant fees that are no longer in UI with quantity
foreach ( var dbFee in registrant.Fees.ToList() )
{
if ( !registrantInfo.FeeValues.Keys.Contains( dbFee.RegistrationTemplateFeeId ) ||
registrantInfo.FeeValues[dbFee.RegistrationTemplateFeeId] == null ||
!registrantInfo.FeeValues[dbFee.RegistrationTemplateFeeId]
.Any( f =>
f.Option == dbFee.Option &&
f.Quantity > 0 ) )
{
registrantChanges.Add( string.Format( "Removed '{0}' Fee (Quantity:{1:N0}, Cost:{2:C2}, Option:{3}",
dbFee.RegistrationTemplateFee.Name, dbFee.Quantity, dbFee.Cost, dbFee.Option ) );
registrant.Fees.Remove( dbFee );
registrantFeeService.Delete( dbFee );
}
}
// Add or Update fees
foreach ( var uiFee in registrantInfo.FeeValues.Where( f => f.Value != null ) )
{
foreach ( var uiFeeOption in uiFee.Value )
{
var dbFee = registrant.Fees
.Where( f =>
f.RegistrationTemplateFeeId == uiFee.Key &&
f.Option == uiFeeOption.Option )
.FirstOrDefault();
if ( dbFee == null )
{
dbFee = new RegistrationRegistrantFee();
dbFee.RegistrationTemplateFeeId = uiFee.Key;
dbFee.Option = uiFeeOption.Option;
registrant.Fees.Add( dbFee );
}
var templateFee = dbFee.RegistrationTemplateFee;
if ( templateFee == null )
{
templateFee = RegistrationTemplate.Fees.Where( f => f.Id == uiFee.Key ).FirstOrDefault();
}
string feeName = templateFee != null ? templateFee.Name : "Fee";
if ( !string.IsNullOrWhiteSpace( uiFeeOption.Option ) )
{
feeName = string.Format( "{0} ({1})", feeName, uiFeeOption.Option );
}
if ( dbFee.Id <= 0 )
{
registrantChanges.Add( feeName + " Fee Added" );
}
History.EvaluateChange( registrantChanges, feeName + " Quantity", dbFee.Quantity, uiFeeOption.Quantity );
dbFee.Quantity = uiFeeOption.Quantity;
History.EvaluateChange( registrantChanges, feeName + " Cost", dbFee.Cost, uiFeeOption.Cost );
dbFee.Cost = uiFeeOption.Cost;
}
}
rockContext.SaveChanges();
registrantInfo.Id = registrant.Id;
// Set any of the templat's registrant attributes
registrant.LoadAttributes();
foreach ( var field in RegistrationTemplate.Forms
.SelectMany( f => f.Fields
.Where( t =>
t.FieldSource == RegistrationFieldSource.RegistrationAttribute &&
t.AttributeId.HasValue ) ) )
{
// Find the registrant's value
var fieldValue = registrantInfo.FieldValues
.Where( f => f.Key == field.Id )
.Select( f => f.Value.FieldValue )
.FirstOrDefault();
if ( fieldValue != null )
{
var attribute = AttributeCache.Read( field.AttributeId.Value );
if ( attribute != null )
{
string originalValue = registrant.GetAttributeValue( attribute.Key );
string newValue = fieldValue.ToString();
registrant.SetAttributeValue( attribute.Key, fieldValue.ToString() );
// DateTime values must be stored in ISO8601 format as http://www.rockrms.com/Rock/Developer/BookContent/16/16#datetimeformatting
if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DATE.AsGuid() ) ||
attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DATE_TIME.AsGuid() ) )
{
DateTime aDateTime;
if ( DateTime.TryParse( fieldValue.ToString(), out aDateTime ) )
{
newValue = aDateTime.ToString( "o" );
}
}
if ( ( originalValue ?? string.Empty ).Trim() != ( newValue ?? string.Empty ).Trim() )
{
string formattedOriginalValue = string.Empty;
if ( !string.IsNullOrWhiteSpace( originalValue ) )
{
formattedOriginalValue = attribute.FieldType.Field.FormatValue( null, originalValue, attribute.QualifierValues, false );
}
string formattedNewValue = string.Empty;
if ( !string.IsNullOrWhiteSpace( newValue ) )
{
formattedNewValue = attribute.FieldType.Field.FormatValue( null, newValue, attribute.QualifierValues, false );
}
Helper.SaveAttributeValue( registrant, attribute, newValue, rockContext );
History.EvaluateChange( registrantChanges, attribute.Name, formattedOriginalValue, formattedNewValue );
}
}
}
}
Task.Run( () =>
HistoryService.SaveChanges(
new RockContext(),
typeof( Registration ),
Rock.SystemGuid.Category.HISTORY_EVENT_REGISTRATION.AsGuid(),
registration.Id,
registrantChanges,
"Registrant: " + person.FullName,
null, null, true, CurrentPersonAliasId )
);
// Clear this registran't family guid so it's not updated again
registrantInfo.FamilyGuid = Guid.Empty;
}
rockContext.SaveChanges();
}
catch ( Exception ex )
{
using ( var newRockContext = new RockContext() )
{
if ( newRegistration )
{
var newRegistrationService = new RegistrationService( newRockContext );
var savedRegistration = new RegistrationService( newRockContext ).Get( registration.Id );
if ( savedRegistration != null )
{
HistoryService.DeleteChanges( newRockContext, typeof( Registration ), savedRegistration.Id );
newRegistrationService.Delete( savedRegistration );
newRockContext.SaveChanges();
}
}
}
throw ex;
}
return registration;
}
/// <summary>
/// Finds the person if they're logged in, or by email and name. If not found, creates a new person.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <returns></returns>
private Person FindPerson(RockContext rockContext)
{
Person person;
var personService = new PersonService( rockContext );
if ( CurrentPerson != null )
{
person = CurrentPerson;
}
else
{
var people = personService.GetByMatch( tbFirstName.Text, tbLastName.Text, tbEmail.Text );
if ( people.Count() == 1 )
{
person = people.FirstOrDefault();
}
else
{
// TODO multiple matches, identify the correct person otherwise we're creating duplicates
// here.
person = null;
}
}
if ( person == null )
{
var definedValue = DefinedValueCache.Read( new Guid( GetAttributeValue( "DefaultConnectionStatus" ) ) );
person = new Person
{
FirstName = tbFirstName.Text,
LastName = tbLastName.Text,
Email = tbEmail.Text,
ConnectionStatusValueId = definedValue.Id,
};
GroupService.SaveNewFamily( rockContext, person, null, false );
}
return person;
}
/// <summary>
/// Gets the name of the Google user.
/// </summary>
/// <param name="googleUser">The Google user.</param>
/// <param name="accessToken">The access token.</param>
/// <returns></returns>
public static string GetGoogleUser( GoogleUser googleUser, string accessToken = "" )
{
string username = string.Empty;
string googleId = googleUser.id;
string googleLink = googleUser.link;
string userName = "******" + googleId;
UserLogin user = null;
using (var rockContext = new RockContext() )
{
// Query for an existing user
var userLoginService = new UserLoginService(rockContext);
user = userLoginService.GetByUserName(userName);
// If no user was found, see if we can find a match in the person table
if ( user == null )
{
// Get name/email from Google login
string lastName = googleUser.family_name.ToString();
string firstName = googleUser.given_name.ToString();
string email = string.Empty;
try { email = googleUser.email.ToString(); }
catch { }
Person person = null;
// If person had an email, get the first person with the same name and email address.
if ( !string.IsNullOrWhiteSpace(email) )
{
var personService = new PersonService(rockContext);
var people = personService.GetByMatch(firstName, lastName, email);
if ( people.Count() == 1 )
{
person = people.First();
}
}
var personRecordTypeId = DefinedValueCache.Read(SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid()).Id;
var personStatusPending = DefinedValueCache.Read(SystemGuid.DefinedValue.PERSON_RECORD_STATUS_PENDING.AsGuid()).Id;
rockContext.WrapTransaction(( ) =>
{
if ( person == null )
{
person = new Person();
person.IsSystem = false;
person.RecordTypeValueId = personRecordTypeId;
person.RecordStatusValueId = personStatusPending;
person.FirstName = firstName;
person.LastName = lastName;
person.Email = email;
person.IsEmailActive = true;
person.EmailPreference = EmailPreference.EmailAllowed;
try
{
if ( googleUser.gender.ToString() == "male" )
{
person.Gender = Gender.Male;
}
else if ( googleUser.gender.ToString() == "female" )
{
person.Gender = Gender.Female;
}
else
{
person.Gender = Gender.Unknown;
}
}
catch { }
if ( person != null )
{
PersonService.SaveNewPerson(person, rockContext, null, false);
}
}
if ( person != null )
{
int typeId = EntityTypeCache.Read(typeof(Google)).Id;
user = UserLoginService.Create(rockContext, person, AuthenticationServiceType.External, typeId, userName, "goog", true);
}
});
}
if ( user != null )
{
username = user.UserName;
if ( user.PersonId.HasValue )
{
var converter = new ExpandoObjectConverter();
var personService = new PersonService(rockContext);
var person = personService.Get(user.PersonId.Value);
}
}
return username;
}
}
/// <summary>
/// Gets the name of the Twitter user.
/// </summary>
/// <param name="twitterUser">The Twitter user.</param>
/// <param name="accessToken">The access token.</param>
/// <returns></returns>
public static string GetTwitterUser( dynamic twitterUser, string accessToken = "" )
{
string username = string.Empty;
string twitterId = twitterUser.id_str;
string twitterLink = "https://twitter.com/" + twitterUser.screen_name;
string userName = "******" + twitterId;
UserLogin user = null;
using ( var rockContext = new RockContext() )
{
// Query for an existing user
var userLoginService = new UserLoginService( rockContext );
user = userLoginService.GetByUserName( userName );
// If no user was found, see if we can find a match in the person table
if ( user == null )
{
// Get name and email from twitterUser object and then split the name
string fullName = twitterUser.name;
string firstName = null;
string lastName = null;
var personService = new PersonService( rockContext );
personService.SplitName( fullName, out firstName, out lastName );
string email = string.Empty;
try { email = twitterUser.email; }
catch { }
Person person = null;
// If person had an email, get the first person with the same name and email address.
if ( !string.IsNullOrWhiteSpace( email ) )
{
var people = personService.GetByMatch( firstName, lastName, email );
if ( people.Count() == 1 )
{
person = people.First();
}
}
var personRecordTypeId = DefinedValueCache.Read( SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
var personStatusPending = DefinedValueCache.Read( SystemGuid.DefinedValue.PERSON_RECORD_STATUS_PENDING.AsGuid() ).Id;
rockContext.WrapTransaction( () =>
{
// If not an existing person, create a new one
if ( person == null )
{
person = new Person();
person.IsSystem = false;
person.RecordTypeValueId = personRecordTypeId;
person.RecordStatusValueId = personStatusPending;
person.FirstName = firstName;
person.LastName = lastName;
person.Email = email;
person.IsEmailActive = true;
person.EmailPreference = EmailPreference.EmailAllowed;
person.Gender = Gender.Unknown;
if ( person != null )
{
PersonService.SaveNewPerson( person, rockContext, null, false );
}
}
if ( person != null )
{
int typeId = EntityTypeCache.Read( typeof( Facebook ) ).Id;
user = UserLoginService.Create( rockContext, person, AuthenticationServiceType.External, typeId, userName, "Twitter", true );
}
} );
}
if ( user != null )
{
username = user.UserName;
if ( user.PersonId.HasValue )
{
var converter = new ExpandoObjectConverter();
var personService = new PersonService( rockContext );
var person = personService.Get( user.PersonId.Value );
if ( person != null )
{
string twitterImageUrl = twitterUser.profile_image_url;
bool twitterImageDefault = twitterUser.default_profile_image;
twitterImageUrl = twitterImageUrl.Replace( "_normal", "" );
// If person does not have a photo, use their Twitter photo if it exists
if ( !person.PhotoId.HasValue && !twitterImageDefault && !string.IsNullOrWhiteSpace( twitterImageUrl ) )
{
// Download the photo from the url provided
var restClient = new RestClient( twitterImageUrl );
var restRequest = new RestRequest( Method.GET );
var restResponse = restClient.Execute( restRequest );
if ( restResponse.StatusCode == HttpStatusCode.OK )
{
var bytes = restResponse.RawBytes;
// Create and save the image
BinaryFileType fileType = new BinaryFileTypeService( rockContext ).Get( Rock.SystemGuid.BinaryFiletype.PERSON_IMAGE.AsGuid() );
if ( fileType != null )
{
var binaryFileService = new BinaryFileService( rockContext );
var binaryFile = new BinaryFile();
binaryFileService.Add( binaryFile );
binaryFile.IsTemporary = false;
binaryFile.BinaryFileType = fileType;
binaryFile.MimeType = "image/jpeg";
binaryFile.FileName = user.Person.NickName + user.Person.LastName + ".jpg";
binaryFile.ContentStream = new MemoryStream( bytes );
rockContext.SaveChanges();
person.PhotoId = binaryFile.Id;
rockContext.SaveChanges();
}
}
}
// Save the Twitter social media link
var twitterAttribute = AttributeCache.Read( Rock.SystemGuid.Attribute.PERSON_TWITTER.AsGuid() );
if ( twitterAttribute != null )
{
person.LoadAttributes( rockContext );
person.SetAttributeValue( twitterAttribute.Key, twitterLink );
person.SaveAttributeValues( rockContext );
}
}
}
}
return username;
}
}
/// <summary>
/// Get Method for logging the user in.
/// </summary>
/// <returns></returns>
public HttpResponseMessage Post(RegisterPost register)
{
//verify the token passed from the app is valid. Just an extra security measure tp make sure they're hitting from the app.
var isAuthed = MobileAppAPIHelper.ValidateAppToken(Request);
//if this check fails, return Unauthorized
if (!isAuthed)
return Request.CreateResponse(HttpStatusCode.Unauthorized);
try
{
var rockContext = new RockContext();
var personService = new PersonService(rockContext);
if (new UserLoginService(rockContext).GetByUserName(register.Username.Trim()) != null)
{
//check the username
return Request.CreateResponse(HttpStatusCode.BadRequest, "The selected username is already taken.");
}
if (!UserLoginService.IsPasswordValid(register.Password.Trim()))
{
//check the password.
return Request.CreateResponse(HttpStatusCode.BadRequest, "Password is invalid.");
}
Person person = null;
Person spouse = null;
Group family = null;
GroupLocation homeLocation = null;
var changes = new List<string>();
var spouseChanges = new List<string>();
var familyChanges = new List<string>();
// Try to find person by name/email
if (person == null)
{
var matches = personService.GetByMatch(register.FirstName.Trim(), register.LastName.Trim(), register.Email.Trim());
if (matches.Count() == 1)
{
person = matches.First();
}
}
// Check to see if this is a new person
if (person == null)
{
// If so, create the person and family record for the new person
person = new Person();
person.FirstName = register.FirstName.Trim();
person.LastName = register.LastName.Trim();
person.Email = register.Email.Trim();
person.IsEmailActive = true;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid()).Id;
// person.ConnectionStatusValueId = DefinedValueCache.Read(GetAttributeValue("ConnectionStatus").AsGuid()).Id;
// person.RecordStatusValueId = DefinedValueCache.Read(GetAttributeValue("RecordStatus").AsGuid());
person.Gender = Gender.Unknown;
family = PersonService.SaveNewPerson(person, rockContext, null, false);
}
if (person != null)
{
var user = UserLoginService.Create(
rockContext,
person,
Rock.Model.AuthenticationServiceType.Internal,
EntityTypeCache.Read(Rock.SystemGuid.EntityType.AUTHENTICATION_DATABASE.AsGuid()).Id,
register.Username.Trim(),
register.Password.Trim(),
true);
//var mergeObjects = Rock.Lava.LavaHelper.GetCommonMergeFields(RockPage);
//mergeObjects.Add("ConfirmAccountUrl", RootPath + "ConfirmAccount");
//var personDictionary = person.ToLiquid() as Dictionary<string, object>;
//mergeObjects.Add("Person", personDictionary);
//mergeObjects.Add("User", user);
//var recipients = new List<Rock.Communication.RecipientData>();
//recipients.Add(new Rock.Communication.RecipientData(person.Email,
// mergeObjects));
//Rock.Communication.Email.Send(GetAttributeValue("ConfirmAccountTemplate").AsGuid(),
// recipients, ResolveRockUrl("~/"), ResolveRockUrl("~~/"), false);
}
return Request.CreateResponse(HttpStatusCode.OK, "SUccess");
}
catch (Exception ex)
{
//todo: log the error somewhere.
return Request.CreateResponse(HttpStatusCode.InternalServerError);
}
}
/// <summary>
/// Handles the Click event of the btnEdit 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 btnConnect_Click( object sender, EventArgs e )
{
using ( var rockContext = new RockContext() )
{
var opportunityService = new ConnectionOpportunityService( rockContext );
var connectionRequestService = new ConnectionRequestService( rockContext );
var personService = new PersonService( rockContext );
// Get the opportunity and default status
int opportunityId = PageParameter( "OpportunityId" ).AsInteger();
var opportunity = opportunityService
.Queryable()
.Where( o => o.Id == opportunityId )
.FirstOrDefault();
int defaultStatusId = opportunity.ConnectionType.ConnectionStatuses
.Where( s => s.IsDefault )
.Select( s => s.Id )
.FirstOrDefault();
// If opportunity is valid and has a default status
if ( opportunity != null && defaultStatusId > 0 )
{
Person person = null;
string firstName = tbFirstName.Text.Trim();
string lastName = tbLastName.Text.Trim();
string email = tbEmail.Text.Trim();
int? campudId = cpCampus.SelectedCampusId;
if ( CurrentPerson != null &&
CurrentPerson.LastName.Equals( lastName, StringComparison.OrdinalIgnoreCase ) &&
CurrentPerson.NickName.Equals( firstName, StringComparison.OrdinalIgnoreCase ) &&
CurrentPerson.Email.Equals( email, StringComparison.OrdinalIgnoreCase ) )
{
// If the name and email entered are the same as current person (wasn't changed), use the current person
person = personService.Get( CurrentPerson.Id );
}
else
{
// Try to find matching person
var personMatches = personService.GetByMatch( firstName, lastName, email );
if ( personMatches.Count() == 1 )
{
// If one person with same name and email address exists, use that person
person = personMatches.First();
}
}
// If person was not found, create a new one
if ( person == null )
{
// If a match was not found, create a new person
var dvcConnectionStatus = DefinedValueCache.Read( GetAttributeValue( "ConnectionStatus" ).AsGuid() );
var dvcRecordStatus = DefinedValueCache.Read( GetAttributeValue( "RecordStatus" ).AsGuid() );
person = new Person();
person.FirstName = firstName;
person.LastName = lastName;
person.IsEmailActive = true;
person.Email = email;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
if ( dvcConnectionStatus != null )
{
person.ConnectionStatusValueId = dvcConnectionStatus.Id;
}
if ( dvcRecordStatus != null )
{
person.RecordStatusValueId = dvcRecordStatus.Id;
}
PersonService.SaveNewPerson( person, rockContext, campudId, false );
person = personService.Get( person.Id );
}
// If there is a valid person with a primary alias, continue
if ( person != null && person.PrimaryAliasId.HasValue )
{
var changes = new List<string>();
if ( pnHome.Visible )
{
SavePhone( pnHome, person, _homePhone.Guid, changes );
}
if ( pnMobile.Visible )
{
SavePhone( pnMobile, person, _cellPhone.Guid, changes );
}
if ( changes.Any() )
{
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
person.Id,
changes );
}
// Now that we have a person, we can create the connection request
var connectionRequest = new ConnectionRequest();
connectionRequest.PersonAliasId = person.PrimaryAliasId.Value;
connectionRequest.Comments = tbComments.Text.Trim();
connectionRequest.ConnectionOpportunityId = opportunity.Id;
connectionRequest.ConnectionState = ConnectionState.Active;
connectionRequest.ConnectionStatusId = defaultStatusId;
connectionRequest.CampusId = campudId;
if ( !connectionRequest.IsValid )
{
// Controls will show warnings
return;
}
connectionRequestService.Add( connectionRequest );
rockContext.SaveChanges();
var mergeFields = new Dictionary<string, object>();
mergeFields.Add( "Opportunity", new ConnectionOpportunityService( rockContext ).Get( PageParameter( "OpportunityId" ).AsInteger() ) );
mergeFields.Add( "CurrentPerson", CurrentPerson );
mergeFields.Add( "Person", person );
lResponseMessage.Text = GetAttributeValue( "LavaTemplate" ).ResolveMergeFields( mergeFields );
lResponseMessage.Visible = true;
pnlSignup.Visible = false;
}
}
}
}
/// <summary>
/// Gets the person.
/// </summary>
/// <param name="create">if set to <c>true</c> [create].</param>
/// <returns></returns>
private Person GetPerson( bool create )
{
Person person = null;
var rockContext = new RockContext();
var personService = new PersonService( rockContext );
Group familyGroup = null;
int personId = ViewState["PersonId"] as int? ?? 0;
if ( personId == 0 && TargetPerson != null )
{
person = TargetPerson;
}
else
{
if ( personId != 0 )
{
person = personService.Get( personId );
}
if ( person == null && create )
{
// Check to see if there's only one person with same email, first name, and last name
if ( !string.IsNullOrWhiteSpace( txtEmail.Text ) &&
!string.IsNullOrWhiteSpace( txtFirstName.Text ) &&
!string.IsNullOrWhiteSpace( txtLastName.Text ) )
{
// Same logic as CreatePledge.ascx.cs
var personMatches = personService.GetByMatch( txtFirstName.Text, txtLastName.Text, txtEmail.Text );
if ( personMatches.Count() == 1 )
{
person = personMatches.FirstOrDefault();
}
else
{
person = null;
}
}
if ( person == null )
{
// Create Person
person = new Person();
person.FirstName = txtFirstName.Text;
person.LastName = txtLastName.Text;
person.Email = txtEmail.Text;
person.EmailPreference = EmailPreference.EmailAllowed;
if ( GetAttributeValue( "DisplayPhone" ).AsBooleanOrNull() ?? false )
{
var phone = new PhoneNumber();
phone.CountryCode = PhoneNumber.CleanNumber( pnbPhone.CountryCode );
phone.Number = PhoneNumber.CleanNumber( pnbPhone.Number );
phone.NumberTypeValueId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME ) ).Id;
person.PhoneNumbers.Add( phone );
}
// Create Family
familyGroup = GroupService.SaveNewFamily( rockContext, person, null, false );
}
ViewState["PersonId"] = person != null ? person.Id : 0;
}
}
if ( create && person != null ) // person should never be null at this point
{
if ( familyGroup == null )
{
var groupLocationService = new GroupLocationService( rockContext );
if ( GroupLocationId.HasValue )
{
familyGroup = groupLocationService.Queryable()
.Where( gl => gl.Id == GroupLocationId.Value )
.Select( gl => gl.Group )
.FirstOrDefault();
}
else
{
familyGroup = personService.GetFamilies( person.Id ).FirstOrDefault();
}
}
if ( familyGroup != null )
{
GroupService.AddNewFamilyAddress(
rockContext,
familyGroup,
GetAttributeValue( "AddressType" ),
acAddress.Street1, acAddress.Street2, acAddress.City, acAddress.State, acAddress.PostalCode, acAddress.Country,
true );
}
}
return person;
}
