/// <summary>
/// Handles the Delete event of the gRegistrations control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RowEventArgs"/> instance containing the event data.</param>
protected void gRegistrations_Delete( object sender, RowEventArgs e )
{
using ( var rockContext = new RockContext() )
{
var registrationService = new RegistrationService( rockContext );
var registration = registrationService.Get( e.RowKeyId );
if ( registration != null )
{
int registrationInstanceId = registration.RegistrationInstanceId;
if ( !registration.IsAuthorized( Authorization.EDIT, this.CurrentPerson ) )
{
mdDeleteWarning.Show( "You are not authorized to delete this registration.", ModalAlertType.Information );
return;
}
string errorMessage;
if ( !registrationService.CanDelete( registration, out errorMessage ) )
{
mdRegistrationsGridWarning.Show( errorMessage, ModalAlertType.Information );
return;
}
registrationService.Delete( registration );
rockContext.SaveChanges();
SetHasPayments( registrationInstanceId, rockContext );
}
}
BindRegistrationsGrid();
}
/// <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>
/// Handles the Delete event of the gRegistrations control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RowEventArgs"/> instance containing the event data.</param>
protected void gRegistrations_Delete( object sender, RowEventArgs e )
{
using ( var rockContext = new RockContext() )
{
var registrationService = new RegistrationService( rockContext );
var registration = registrationService.Get( e.RowKeyId );
if ( registration != null )
{
int registrationInstanceId = registration.RegistrationInstanceId;
if ( !UserCanEdit &&
!registration.IsAuthorized( Authorization.EDIT, this.CurrentPerson ) &&
!registration.IsAuthorized( Authorization.ADMINISTRATE, this.CurrentPerson ) )
{
mdDeleteWarning.Show( "You are not authorized to delete this registration.", ModalAlertType.Information );
return;
}
string errorMessage;
if ( !registrationService.CanDelete( registration, out errorMessage ) )
{
mdRegistrationsGridWarning.Show( errorMessage, ModalAlertType.Information );
return;
}
var changes = new List<string>();
changes.Add( "Deleted registration" );
rockContext.WrapTransaction( () =>
{
HistoryService.SaveChanges(
rockContext,
typeof( Registration ),
Rock.SystemGuid.Category.HISTORY_EVENT_REGISTRATION.AsGuid(),
registration.Id,
changes );
registrationService.Delete( registration );
rockContext.SaveChanges();
} );
SetHasPayments( registrationInstanceId, rockContext );
}
}
BindRegistrationsGrid();
}
/// <summary>
/// Saves the changes.
/// </summary>
/// <returns></returns>
private int? SaveChanges()
{
if ( !string.IsNullOrWhiteSpace( TransactionCode ) )
{
ShowError( string.Empty, "You have already completed this " + RegistrationTerm.ToLower() );
return null;
}
Registration registration = null;
if ( RegistrationState != null && RegistrationState.Registrants.Any() && RegistrationTemplate != null )
{
var rockContext = new RockContext();
var registrationService = new RegistrationService( rockContext );
bool isNewRegistration = true;
var previousRegistrantIds = new List<int>();
if ( RegistrationState.RegistrationId.HasValue )
{
var previousRegistration = registrationService.Get( RegistrationState.RegistrationId.Value );
if ( previousRegistration != null )
{
isNewRegistration = false;
previousRegistrantIds = previousRegistration.Registrants
.Where( r => r.PersonAlias != null )
.Select( r => r.PersonAlias.PersonId )
.ToList();
}
}
try
{
bool hasPayment = ( RegistrationState.PaymentAmount ?? 0.0m ) > 0.0m;
// Save the registration
registration = SaveRegistration( rockContext, hasPayment );
if ( registration != null )
{
// If there is a payment being made, process the payment
if ( hasPayment )
{
string errorMessage = string.Empty;
if ( Using3StepGateway )
{
if ( !ProcessStep3( rockContext, registration, hfStep2ReturnQueryString.Value, out errorMessage ) )
{
throw new Exception( errorMessage );
}
}
else
{
if ( !ProcessPayment( rockContext, registration, out errorMessage ) )
{
throw new Exception( errorMessage );
}
}
}
// If there is a valid registration, and nothing went wrong processing the payment, add registrants to group and send the notifications
if ( registration != null && !registration.IsTemporary )
{
ProcessPostSave( registrationService, registration, previousRegistrantIds, rockContext );
}
}
}
catch ( Exception ex )
{
ExceptionLogService.LogException( ex, Context, this.RockPage.PageId, this.RockPage.Site.Id, CurrentPersonAlias );
string message = ex.Message;
while ( ex.InnerException != null )
{
ex = ex.InnerException;
message = ex.Message;
}
ShowError( "An Error Occurred Processing Your " + RegistrationTerm, ex.Message );
// Try to delete the registration if it was just created
try
{
if ( isNewRegistration && registration != null && registration.Id > 0 )
{
RegistrationState.RegistrationId = null;
using ( var newRockContext = new RockContext() )
{
HistoryService.DeleteChanges( newRockContext, typeof( Registration ), registration.Id );
var newRegistrationService = new RegistrationService( newRockContext );
var newRegistration = newRegistrationService.Get( registration.Id );
if ( newRegistration != null )
{
newRegistrationService.Delete( newRegistration );
newRockContext.SaveChanges();
}
}
}
}
catch { }
return (int?)null;
}
}
return registration != null ? registration.Id : (int?)null;
}
/// <summary>
/// Handles the Click event of the btnDelete 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 btnDelete_Click( object sender, EventArgs e )
{
RockContext rockContext = new RockContext();
if ( RegistrationId.HasValue )
{
var registrationService = new RegistrationService( rockContext );
Registration registration = registrationService.Get( RegistrationId.Value );
if ( registration != null )
{
if ( !registration.IsAuthorized( Authorization.EDIT, this.CurrentPerson ) )
{
mdDeleteWarning.Show( "You are not authorized to delete this registration.", ModalAlertType.Information );
return;
}
string errorMessage;
if ( !registrationService.CanDelete( registration, out errorMessage ) )
{
mdDeleteWarning.Show( errorMessage, ModalAlertType.Information );
return;
}
registrationService.Delete( registration );
rockContext.SaveChanges();
}
var pageParams = new Dictionary<string, string>();
pageParams.Add( "RegistrationInstanceId", RegistrationInstanceId.ToString() );
NavigateToParentPage( pageParams );
}
}
/// <summary>
/// Cleans up temporary registrations.
/// </summary>
private int CleanUpTemporaryRegistrations()
{
var registrationRockContext = new Rock.Data.RockContext();
int totalRowsDeleted = 0;
// clean out any temporary registrations
RegistrationService registrationService = new RegistrationService( registrationRockContext );
foreach ( var registration in registrationService.Queryable().Where( bf => bf.IsTemporary == true ).ToList() )
{
if ( registration.ModifiedDateTime < RockDateTime.Now.AddHours( -1 ) )
{
string errorMessage;
if ( registrationService.CanDelete( registration, out errorMessage ) )
{
registrationService.Delete( registration );
registrationRockContext.SaveChanges();
totalRowsDeleted++;
}
}
}
return totalRowsDeleted;
}
/// <summary>
/// Handles the Click event of the btnDelete 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 btnDelete_Click( object sender, EventArgs e )
{
RockContext rockContext = new RockContext();
if ( RegistrationId.HasValue )
{
var registrationService = new RegistrationService( rockContext );
Registration registration = registrationService.Get( RegistrationId.Value );
if ( registration != null )
{
if ( !UserCanEdit &&
!registration.IsAuthorized( Authorization.EDIT, this.CurrentPerson ) )
{
mdDeleteWarning.Show( "You are not authorized to delete this registration.", ModalAlertType.Information );
return;
}
string errorMessage;
if ( !registrationService.CanDelete( registration, out errorMessage ) )
{
mdDeleteWarning.Show( errorMessage, ModalAlertType.Information );
return;
}
var changes = new List<string>();
changes.Add( "Deleted registration" );
rockContext.WrapTransaction( () =>
{
HistoryService.SaveChanges(
rockContext,
typeof( Registration ),
Rock.SystemGuid.Category.HISTORY_EVENT_REGISTRATION.AsGuid(),
registration.Id,
changes );
registrationService.Delete( registration );
rockContext.SaveChanges();
} );
}
var pageParams = new Dictionary<string, string>();
pageParams.Add( "RegistrationInstanceId", RegistrationInstanceId.ToString() );
NavigateToParentPage( pageParams );
}
}
/// <summary>
/// Saves the changes.
/// </summary>
/// <returns></returns>
private int? SaveChanges()
{
if ( !string.IsNullOrWhiteSpace( TransactionCode ) )
{
ShowError( string.Empty, "You have already completed this " + RegistrationTerm.ToLower() );
return null;
}
Registration registration = null;
if ( RegistrationState != null && RegistrationState.Registrants.Any() && RegistrationTemplate != null )
{
var rockContext = new RockContext();
var registrationService = new RegistrationService( rockContext );
bool isNewRegistration = true;
var previousRegistrants = new List<int>();
if ( RegistrationState.RegistrationId.HasValue )
{
var previousRegistration = registrationService.Get( RegistrationState.RegistrationId.Value );
if ( previousRegistration != null )
{
isNewRegistration = false;
previousRegistrants = previousRegistration.Registrants
.Where( r => r.PersonAlias != null )
.Select( r => r.PersonAlias.PersonId )
.ToList();
}
}
try
{
bool hasPayment = ( RegistrationState.PaymentAmount ?? 0.0m ) > 0.0m;
// Save the registration
registration = SaveRegistration( rockContext, hasPayment );
if ( registration != null )
{
// If there is a payment being made, process the payment
if ( hasPayment )
{
string errorMessage = string.Empty;
if ( !ProcessPayment( rockContext, registration, out errorMessage ) )
{
throw new Exception( errorMessage );
}
}
try
{
// If there is a valid registration, and nothing went wrong processing the payment, add registrants to group and send the notifications
if ( registration != null )
{
SavePersonNotes( rockContext, previousRegistrants, registration );
AddRegistrantsToGroup( rockContext, registration );
string appRoot = ResolveRockUrl( "~/" );
string themeRoot = ResolveRockUrl( "~~/" );
var confirmation = new Rock.Transactions.SendRegistrationConfirmationTransaction();
confirmation.RegistrationId = registration.Id;
confirmation.AppRoot = appRoot;
confirmation.ThemeRoot = themeRoot;
Rock.Transactions.RockQueue.TransactionQueue.Enqueue( confirmation );
var notification = new Rock.Transactions.SendRegistrationNotificationTransaction();
notification.RegistrationId = registration.Id;
notification.AppRoot = appRoot;
notification.ThemeRoot = themeRoot;
Rock.Transactions.RockQueue.TransactionQueue.Enqueue( notification );
var newRegistration = registrationService
.Queryable( "Registrants.PersonAlias.Person,Registrants.GroupMember,RegistrationInstance.Account,RegistrationInstance.RegistrationTemplate.Fees,RegistrationInstance.RegistrationTemplate.Discounts,RegistrationInstance.RegistrationTemplate.Forms.Fields.Attribute,RegistrationInstance.RegistrationTemplate.FinancialGateway" )
.Where( r => r.Id == registration.Id )
.FirstOrDefault();
if ( newRegistration != null )
{
RegistrationInstanceState = newRegistration.RegistrationInstance;
RegistrationState = new RegistrationInfo( newRegistration, rockContext );
RegistrationState.PreviousPaymentTotal = registrationService.GetTotalPayments( registration.Id );
}
}
}
catch ( Exception postSaveEx )
{
ShowWarning( "The following occurred after processing your " + RegistrationTerm, postSaveEx.Message );
ExceptionLogService.LogException( postSaveEx, Context, RockPage.PageId, RockPage.Layout.SiteId, CurrentPersonAlias );
}
}
}
catch ( Exception ex )
{
ExceptionLogService.LogException( ex, Context, this.RockPage.PageId, this.RockPage.Site.Id, CurrentPersonAlias );
string message = ex.Message;
while ( ex.InnerException != null )
{
ex = ex.InnerException;
message = ex.Message;
}
ShowError( "An Error Occurred Processing Your " + RegistrationTerm, ex.Message );
// Try to delete the registration if it was just created
try
{
if ( isNewRegistration && registration != null && registration.Id > 0 )
{
RegistrationState.RegistrationId = null;
using ( var newRockContext = new RockContext() )
{
HistoryService.DeleteChanges( newRockContext, typeof( Registration ), registration.Id );
var newRegistrationService = new RegistrationService( newRockContext );
var newRegistration = newRegistrationService.Get( registration.Id );
if ( newRegistration != null )
{
newRegistrationService.Delete( newRegistration );
newRockContext.SaveChanges();
}
}
}
}
catch { }
return (int?)null;
}
}
return registration != null ? registration.Id : (int?)null;
}