/// <summary>
/// Set the value for RegistrationRegistrantFee.RegistrationTemplateFeeItemId to the IDs of the RegistrationTemplateFeeItem objects just created.
/// </summary>
private void PopulateRegistrationRegistrantFee()
{
List <int> registrationRegistrantFeeIds;
using (var rockContext = new RockContext())
{
var registrationRegistrantFeeService = new RegistrationRegistrantFeeService(rockContext);
registrationRegistrantFeeIds = registrationRegistrantFeeService.Queryable().AsNoTracking().Where(a => a.RegistrationTemplateFeeItemId == null).Select(a => a.Id).ToList();
}
foreach (var registrationRegistrantFeeId in registrationRegistrantFeeIds)
{
// Create a new context each time to keep change tracking from bogging it down.
using (var rockContext = new RockContext())
{
var registrationRegistrantFee = new RegistrationRegistrantFeeService(rockContext).Get(registrationRegistrantFeeId);
var registrationTemplateFeeItemService = new RegistrationTemplateFeeItemService(rockContext);
if (registrationRegistrantFee.RegistrationTemplateFee.FeeType == RegistrationFeeType.Single)
{
// For Single Fee Types set the RegistrationTemplateFeeItemId by matching the RegistrationTemplateFeeId
registrationRegistrantFee.RegistrationTemplateFeeItemId = registrationTemplateFeeItemService
.Queryable()
.Where(a => a.RegistrationTemplateFeeId == registrationRegistrantFee.RegistrationTemplateFeeId)
.Select(a => (int?)a.Id)
.FirstOrDefault();
}
else if (registrationRegistrantFee.RegistrationTemplateFee.FeeType == RegistrationFeeType.Multiple)
{
// For multiple Fee Types also have to match the name of the FeeItem to the Option of the RegistrantFee.
registrationRegistrantFee.RegistrationTemplateFeeItemId = registrationTemplateFeeItemService
.Queryable()
.Where(a => a.RegistrationTemplateFeeId == registrationRegistrantFee.RegistrationTemplateFeeId)
.Where(a => a.Name == registrationRegistrantFee.Option)
.Select(a => (int?)a.Id)
.FirstOrDefault();
}
rockContext.SaveChanges();
}
}
}
/// <summary>
/// Populates cblFeeOptions with fee options.
/// </summary>
private void Populate_cblFeeOptions()
{
cblFeeOptions.Items.Clear();
int?feeId = ddlFeeName.SelectedValue.AsIntegerOrNull();
if (feeId.HasValue)
{
var feeItems = new RegistrationTemplateFeeItemService(new RockContext()).Queryable().Where(a => a.RegistrationTemplateFeeId == feeId);
foreach (var feeItem in feeItems)
{
cblFeeOptions.Items.Add(new ListItem(feeItem.Name, feeItem.Guid.ToString()));
}
string feeOptionValues = fFees.GetUserPreference(UserPreferenceKeyBase.GridFilter_FeeOptions);
if (!string.IsNullOrWhiteSpace(feeOptionValues))
{
cblFeeOptions.SetValues(feeOptionValues.Split(';').ToList());
}
cblFeeOptions.Visible = true;
}
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click(object sender, EventArgs e)
{
if (RegistrantState != null)
{
RockContext rockContext = new RockContext();
var personService = new PersonService(rockContext);
var registrantService = new RegistrationRegistrantService(rockContext);
var registrantFeeService = new RegistrationRegistrantFeeService(rockContext);
var registrationTemplateFeeService = new RegistrationTemplateFeeService(rockContext);
var registrationTemplateFeeItemService = new RegistrationTemplateFeeItemService(rockContext);
RegistrationRegistrant registrant = null;
if (RegistrantState.Id > 0)
{
registrant = registrantService.Get(RegistrantState.Id);
}
var previousRegistrantPersonIds = registrantService.Queryable().Where(a => a.RegistrationId == RegistrantState.RegistrationId)
.Where(r => r.PersonAlias != null)
.Select(r => r.PersonAlias.PersonId)
.ToList();
bool newRegistrant = false;
var registrantChanges = new History.HistoryChangeList();
if (registrant == null)
{
newRegistrant = true;
registrant = new RegistrationRegistrant();
registrant.RegistrationId = RegistrantState.RegistrationId;
registrantService.Add(registrant);
registrantChanges.AddChange(History.HistoryVerb.Add, History.HistoryChangeType.Record, "Registrant");
}
if (!registrant.PersonAliasId.Equals(ppPerson.PersonAliasId))
{
string prevPerson = (registrant.PersonAlias != null && registrant.PersonAlias.Person != null) ?
registrant.PersonAlias.Person.FullName : string.Empty;
string newPerson = ppPerson.PersonName;
newRegistrant = true;
History.EvaluateChange(registrantChanges, "Person", prevPerson, newPerson);
}
int?personId = ppPerson.PersonId.Value;
registrant.PersonAliasId = ppPerson.PersonAliasId.Value;
// Get the name of registrant for history
string registrantName = "Unknown";
if (ppPerson.PersonId.HasValue)
{
var person = personService.Get(ppPerson.PersonId.Value);
if (person != null)
{
registrantName = person.FullName;
}
}
// set their status (wait list / registrant)
registrant.OnWaitList = !tglWaitList.Checked;
History.EvaluateChange(registrantChanges, "Cost", registrant.Cost, cbCost.Text.AsDecimal());
registrant.Cost = cbCost.Text.AsDecimal();
History.EvaluateChange(registrantChanges, "Discount Applies", registrant.DiscountApplies, cbDiscountApplies.Checked);
registrant.DiscountApplies = cbDiscountApplies.Checked;
if (!Page.IsValid)
{
return;
}
// Remove/delete any registrant fees that are no longer in UI with quantity
foreach (var dbFee in registrant.Fees.ToList())
{
if (!RegistrantState.FeeValues.Keys.Contains(dbFee.RegistrationTemplateFeeId) ||
RegistrantState.FeeValues[dbFee.RegistrationTemplateFeeId] == null ||
!RegistrantState.FeeValues[dbFee.RegistrationTemplateFeeId]
.Any(f =>
f.RegistrationTemplateFeeItemId == dbFee.RegistrationTemplateFeeItemId &&
f.Quantity > 0))
{
var feeOldValue = string.Format("'{0}' Fee (Quantity:{1:N0}, Cost:{2:C2}, Option:{3}",
dbFee.RegistrationTemplateFee.Name, dbFee.Quantity, dbFee.Cost, dbFee.Option);
registrantChanges.AddChange(History.HistoryVerb.Delete, History.HistoryChangeType.Record, "Fee").SetOldValue(feeOldValue);
registrant.Fees.Remove(dbFee);
registrantFeeService.Delete(dbFee);
}
}
// Add/Update any of the fees from UI
foreach (var uiFee in RegistrantState.FeeValues.Where(f => f.Value != null))
{
foreach (var uiFeeOption in uiFee.Value)
{
var dbFee = registrant.Fees
.Where(f =>
f.RegistrationTemplateFeeId == uiFee.Key &&
f.RegistrationTemplateFeeItemId == uiFeeOption.RegistrationTemplateFeeItemId)
.FirstOrDefault();
if (dbFee == null)
{
dbFee = new RegistrationRegistrantFee();
dbFee.RegistrationTemplateFeeId = uiFee.Key;
var registrationTemplateFeeItem = uiFeeOption.RegistrationTemplateFeeItemId != null?registrationTemplateFeeItemService.GetNoTracking(uiFeeOption.RegistrationTemplateFeeItemId.Value) : null;
if (registrationTemplateFeeItem != null)
{
dbFee.Option = registrationTemplateFeeItem.Name;
}
dbFee.RegistrationTemplateFeeItemId = uiFeeOption.RegistrationTemplateFeeItemId;
registrant.Fees.Add(dbFee);
}
var templateFee = dbFee.RegistrationTemplateFee;
if (templateFee == null)
{
templateFee = registrationTemplateFeeService.Get(uiFee.Key);
}
string feeName = templateFee != null ? templateFee.Name : "Fee";
if (!string.IsNullOrWhiteSpace(uiFeeOption.FeeLabel))
{
feeName = string.Format("{0} ({1})", feeName, uiFeeOption.FeeLabel);
}
if (dbFee.Id <= 0)
{
registrantChanges.AddChange(History.HistoryVerb.Add, History.HistoryChangeType.Record, "Fee").SetNewValue(feeName);
}
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;
}
}
if (this.RegistrationTemplate.RequiredSignatureDocumentTemplate != null)
{
var person = new PersonService(rockContext).Get(personId.Value);
var documentService = new SignatureDocumentService(rockContext);
var binaryFileService = new BinaryFileService(rockContext);
SignatureDocument document = null;
int?signatureDocumentId = hfSignedDocumentId.Value.AsIntegerOrNull();
int?binaryFileId = fuSignedDocument.BinaryFileId;
if (signatureDocumentId.HasValue)
{
document = documentService.Get(signatureDocumentId.Value);
}
if (document == null && binaryFileId.HasValue)
{
var instance = new RegistrationInstanceService(rockContext).Get(RegistrationInstanceId);
document = new SignatureDocument();
document.SignatureDocumentTemplateId = this.RegistrationTemplate.RequiredSignatureDocumentTemplate.Id;
document.AppliesToPersonAliasId = registrant.PersonAliasId.Value;
document.AssignedToPersonAliasId = registrant.PersonAliasId.Value;
document.Name = string.Format(
"{0}_{1}",
instance != null ? instance.Name : this.RegistrationTemplate.Name,
person != null ? person.FullName.RemoveSpecialCharacters() : string.Empty);
document.Status = SignatureDocumentStatus.Signed;
document.LastStatusDate = RockDateTime.Now;
documentService.Add(document);
}
if (document != null)
{
int?origBinaryFileId = document.BinaryFileId;
document.BinaryFileId = binaryFileId;
if (origBinaryFileId.HasValue && origBinaryFileId.Value != document.BinaryFileId)
{
// if a new the binaryFile was uploaded, mark the old one as Temporary so that it gets cleaned up
var oldBinaryFile = binaryFileService.Get(origBinaryFileId.Value);
if (oldBinaryFile != null && !oldBinaryFile.IsTemporary)
{
oldBinaryFile.IsTemporary = true;
}
}
// ensure the IsTemporary is set to false on binaryFile associated with this document
if (document.BinaryFileId.HasValue)
{
var binaryFile = binaryFileService.Get(document.BinaryFileId.Value);
if (binaryFile != null && binaryFile.IsTemporary)
{
binaryFile.IsTemporary = false;
}
}
}
}
if (!registrant.IsValid)
{
// Controls will render the error messages
return;
}
// use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges()
rockContext.WrapTransaction(() =>
{
rockContext.SaveChanges();
registrant.LoadAttributes();
// NOTE: We will only have Registration Attributes displayed and editable on Registrant Detail.
// To Edit Person or GroupMember Attributes, they will have to go the PersonDetail or GroupMemberDetail blocks
foreach (var field in this.RegistrationTemplate.Forms
.SelectMany(f => f.Fields
.Where(t =>
t.FieldSource == RegistrationFieldSource.RegistrantAttribute &&
t.AttributeId.HasValue)))
{
var attribute = AttributeCache.Get(field.AttributeId.Value);
if (attribute != null)
{
string originalValue = registrant.GetAttributeValue(attribute.Key);
var fieldValue = RegistrantState.FieldValues
.Where(f => f.Key == field.Id)
.Select(f => f.Value.FieldValue)
.FirstOrDefault();
string newValue = fieldValue != null ? fieldValue.ToString() : string.Empty;
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(registrantChanges, attribute.Name, formattedOriginalValue, formattedNewValue);
}
if (fieldValue != null)
{
registrant.SetAttributeValue(attribute.Key, fieldValue.ToString());
}
}
}
registrant.SaveAttributeValues(rockContext);
});
if (newRegistrant && this.RegistrationTemplate.GroupTypeId.HasValue && ppPerson.PersonId.HasValue)
{
using (var newRockContext = new RockContext())
{
var reloadedRegistrant = new RegistrationRegistrantService(newRockContext).Get(registrant.Id);
if (reloadedRegistrant != null &&
reloadedRegistrant.Registration != null &&
reloadedRegistrant.Registration.Group != null &&
reloadedRegistrant.Registration.Group.GroupTypeId == this.RegistrationTemplate.GroupTypeId.Value)
{
int?groupRoleId = this.RegistrationTemplate.GroupMemberRoleId.HasValue ?
this.RegistrationTemplate.GroupMemberRoleId.Value :
reloadedRegistrant.Registration.Group.GroupType.DefaultGroupRoleId;
if (groupRoleId.HasValue)
{
var groupMemberService = new GroupMemberService(newRockContext);
var groupMember = groupMemberService
.Queryable().AsNoTracking()
.Where(m =>
m.GroupId == reloadedRegistrant.Registration.Group.Id &&
m.PersonId == reloadedRegistrant.PersonId &&
m.GroupRoleId == groupRoleId.Value)
.FirstOrDefault();
if (groupMember == null)
{
groupMember = new GroupMember();
groupMember.GroupId = reloadedRegistrant.Registration.Group.Id;
groupMember.PersonId = ppPerson.PersonId.Value;
groupMember.GroupRoleId = groupRoleId.Value;
groupMember.GroupMemberStatus = this.RegistrationTemplate.GroupMemberStatus;
groupMemberService.Add(groupMember);
newRockContext.SaveChanges();
registrantChanges.AddChange(History.HistoryVerb.Add, History.HistoryChangeType.Record, string.Format("Registrant to {0} group", reloadedRegistrant.Registration.Group.Name));
}
else
{
registrantChanges.AddChange(History.HistoryVerb.Modify, History.HistoryChangeType.Record, string.Format("Registrant to existing person in {0} group", reloadedRegistrant.Registration.Group.Name));
}
if (reloadedRegistrant.GroupMemberId.HasValue && reloadedRegistrant.GroupMemberId.Value != groupMember.Id)
{
groupMemberService.Delete(reloadedRegistrant.GroupMember);
newRockContext.SaveChanges();
registrantChanges.AddChange(History.HistoryVerb.Delete, History.HistoryChangeType.Record, string.Format("Registrant to previous person in {0} group", reloadedRegistrant.Registration.Group.Name));
}
// Record this to the Person's and Registrants Notes and History...
reloadedRegistrant.GroupMemberId = groupMember.Id;
}
}
if (reloadedRegistrant.Registration.FirstName.IsNotNullOrWhiteSpace() && reloadedRegistrant.Registration.LastName.IsNotNullOrWhiteSpace())
{
reloadedRegistrant.Registration.SavePersonNotesAndHistory(reloadedRegistrant.Registration.FirstName, reloadedRegistrant.Registration.LastName, this.CurrentPersonAliasId, previousRegistrantPersonIds);
}
newRockContext.SaveChanges();
}
}
HistoryService.SaveChanges(
rockContext,
typeof(Registration),
Rock.SystemGuid.Category.HISTORY_EVENT_REGISTRATION.AsGuid(),
registrant.RegistrationId,
registrantChanges,
"Registrant: " + registrantName,
null,
null);
}
NavigateToRegistration();
}