public void AddOrIgnoreTest()
{
var dic = new Dictionary <string, string>();
dic.AddOrIgnore("test", "test");
Assert.AreEqual("test", dic["test"]);
dic.AddOrIgnore("test", "Jonas");
Assert.AreEqual("test", dic["test"]);
Assert.AreNotEqual("Jonas", dic["test"]);
}
/// <summary>
/// Creates the entity value lookups.
/// </summary>
/// <param name="metricID">The metric identifier.</param>
private void CreateEntityValueLookups(int?metricID)
{
Metric metric = new MetricService(new RockContext()).Get(metricID ?? 0);
if (metric != null)
{
var rockContext = new RockContext();
_entityTypeEntityNameLookup = new Dictionary <int, Dictionary <int, string> >();
_entityTypeEntityLookupQry = new Dictionary <int, IQueryable <IEntity> >();
foreach (var metricPartition in metric.MetricPartitions.Where(a => a.EntityTypeId.HasValue))
{
var entityTypeCache = EntityTypeCache.Get(metricPartition.EntityTypeId ?? 0);
_entityTypeEntityNameLookup.AddOrIgnore(entityTypeCache.Id, new Dictionary <int, string>());
_entityTypeEntityLookupQry.AddOrIgnore(entityTypeCache.Id, null);
if (entityTypeCache != null)
{
if (entityTypeCache.GetEntityType() == typeof(Rock.Model.Group))
{
_entityTypeEntityLookupQry[entityTypeCache.Id] = new GroupService(rockContext).Queryable();
}
else
{
Type[] modelType = { entityTypeCache.GetEntityType() };
Type genericServiceType = typeof(Rock.Data.Service <>);
Type modelServiceType = genericServiceType.MakeGenericType(modelType);
var serviceInstance = Activator.CreateInstance(modelServiceType, new object[] { rockContext }) as IService;
MethodInfo qryMethod = serviceInstance.GetType().GetMethod("Queryable", new Type[] { });
_entityTypeEntityLookupQry[entityTypeCache.Id] = qryMethod.Invoke(serviceInstance, new object[] { }) as IQueryable <IEntity>;
}
}
}
}
}
/// <summary>
/// Gets the device group types.
/// </summary>
/// <param name="deviceId">The device identifier.</param>
/// <returns></returns>
private List <GroupType> GetDeviceGroupTypes(int deviceId, RockContext rockContext)
{
var groupTypes = new Dictionary <int, GroupType>();
var locationService = new LocationService(rockContext);
// Get all locations (and their children) associated with device
var locationIds = locationService
.GetByDevice(deviceId, true)
.Select(l => l.Id)
.ToList();
// Requery using EF
foreach (var groupType in locationService
.Queryable().AsNoTracking()
.Where(l => locationIds.Contains(l.Id))
.SelectMany(l => l.GroupLocations)
.Where(gl => gl.Group.GroupType.TakesAttendance)
.Select(gl => gl.Group.GroupType)
.ToList())
{
groupTypes.AddOrIgnore(groupType.Id, groupType);
}
return(groupTypes
.Select(g => g.Value)
.OrderBy(g => g.Order)
.ToList());
}
/// <summary>
/// Handles the ApplyFilterClick event of the gfMetricValues 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 gfMetricValues_ApplyFilterClick(object sender, EventArgs e)
{
gfMetricValues.SaveUserPreference("Date Range", drpDates.DelimitedValues);
gfMetricValues.SaveUserPreference("Goal/Measure", ddlGoalMeasure.SelectedValue);
var metric = new MetricService(new RockContext()).Get(hfMetricId.Value.AsInteger());
var entityTypeEntityFilters = new Dictionary <int, int?>();
foreach (var metricPartition in metric.MetricPartitions)
{
var metricPartitionEntityType = EntityTypeCache.Get(metricPartition.EntityTypeId ?? 0);
var controlId = string.Format("metricPartition{0}_entityTypeEditControl", metricPartition.Id);
Control entityTypeEditControl = phMetricValuePartitions.FindControl(controlId);
int?entityId;
if (metricPartitionEntityType != null && metricPartitionEntityType.SingleValueFieldType != null && metricPartitionEntityType.SingleValueFieldType.Field is IEntityFieldType)
{
entityId = (metricPartitionEntityType.SingleValueFieldType.Field as IEntityFieldType).GetEditValueAsEntityId(entityTypeEditControl, new Dictionary <string, ConfigurationValue>());
entityTypeEntityFilters.AddOrIgnore(metricPartitionEntityType.Id, entityId);
}
}
var entityTypeEntityUserPreferenceValue = entityTypeEntityFilters
.Select(a => new { EntityTypeId = a.Key, EntityId = a.Value })
.Select(a => string.Format("{0}|{1}", a.EntityTypeId, a.EntityId))
.ToList().AsDelimited(",");
gfMetricValues.SaveUserPreference(this.EntityTypeEntityPreferenceKey, entityTypeEntityUserPreferenceValue);
BindGrid();
}
/// <summary>
/// Gets the categorized actions.
/// </summary>
/// <returns></returns>
private Dictionary <string, List <EntityTypeCache> > GetCategorizedActions()
{
var categorizedActions = new Dictionary <string, List <EntityTypeCache> >();
foreach (var action in ActionContainer.Instance.Dictionary.Select(d => d.Value.Value))
{
string categoryName = "Uncategorized";
var actionType = action.GetType();
var obj = actionType.GetCustomAttributes(typeof(ActionCategoryAttribute), true).FirstOrDefault();
if (obj != null)
{
var actionCategory = obj as ActionCategoryAttribute;
if (actionCategory != null)
{
categoryName = actionCategory.CategoryName;
}
}
// "HideFromUser" is a special category name that is used to hide
// workflow actions from showing up to the user. System user only.
if (!categoryName.Equals("HideFromUser", System.StringComparison.OrdinalIgnoreCase))
{
categorizedActions.AddOrIgnore(categoryName, new List <EntityTypeCache>());
categorizedActions[categoryName].Add(action.EntityType);
}
}
return(categorizedActions);
}
/// <summary>
/// Run any custom startup methods
/// </summary>
public void RunStartups()
{
try
{
var startups = new Dictionary <int, List <IRockStartup> >();
foreach (var startupType in Rock.Reflection.FindTypes(typeof(IRockStartup)).Select(a => a.Value).ToList())
{
var startup = Activator.CreateInstance(startupType) as IRockStartup;
startups.AddOrIgnore(startup.StartupOrder, new List <IRockStartup>());
startups[startup.StartupOrder].Add(startup);
}
foreach (var startupList in startups.OrderBy(s => s.Key).Select(s => s.Value))
{
foreach (var startup in startupList)
{
startup.OnStartup();
}
}
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
}
}
/// <summary>
/// Gets the custom block renderers registered in the system.
/// </summary>
/// <returns>A dictionary of <see cref="IStructuredContentBlockRenderer"/> instances.</returns>
public virtual IReadOnlyDictionary <string, IStructuredContentBlockRenderer> GetCustomRenderers()
{
if (_customRenderers == null)
{
var blockRendererTypes = Reflection.FindTypes(typeof(IStructuredContentBlockRenderer))
.Where(a => a.Value.Assembly != typeof(BlockTypes.ParagraphRenderer).Assembly)
.Where(t => t.Value.GetCustomAttribute <StructuredContentBlockAttribute>() != null)
.Select(a => a.Value);
var blockRenderers = new Dictionary <string, IStructuredContentBlockRenderer>();
foreach (var type in blockRendererTypes)
{
try
{
var renderer = ( IStructuredContentBlockRenderer )Activator.CreateInstance(type);
blockRenderers.AddOrIgnore(type.GetCustomAttribute <StructuredContentBlockAttribute>().BlockType, renderer);
}
catch
{
/* Exception intentionally ignored. */
}
}
_customRenderers = blockRenderers;
}
return(_customRenderers);
}
/// <summary>
/// Handles the DataBinding event of the lOutputText control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void lOutputText_DataBinding(object sender, EventArgs e)
{
Literal lOutputText = sender as Literal;
GridViewRow gridViewRow = lOutputText.NamingContainer as GridViewRow;
if (gridViewRow.DataItem != null)
{
Dictionary <string, object> mergeValues = new Dictionary <string, object>();
if (LavaField.ConvertToItemDictionary)
{
// in the case of a Report, the MergeKeys are determined by the ColumnHeader, so add those as merge fields instead the Row object
foreach (var keyValue in this.ToGridItemsDictionary(gridViewRow, gridViewRow.DataItem))
{
mergeValues.AddOrIgnore(keyValue.Key, keyValue.Value);
}
}
else
{
mergeValues.Add("Row", gridViewRow.DataItem);
}
lOutputText.Text = this.LavaField.LavaTemplate.ResolveMergeFields(mergeValues);
// Resolve any dynamic url references
string appRoot = (( RockPage )lOutputText.Page).ResolveRockUrl("~/");
string themeRoot = (( RockPage )lOutputText.Page).ResolveRockUrl("~~/");
lOutputText.Text = lOutputText.Text.Replace("~~/", themeRoot).Replace("~/", appRoot);
}
}
/// <summary>
/// Configurations the specified application.
/// </summary>
/// <param name="app">The application.</param>
public void Configuration(IAppBuilder app)
{
app.MapSignalR();
ReactSiteConfiguration.Configuration = new ReactSiteConfiguration()
.AddScript("~/Scripts/React/dist/server.blocks.bundle.js");
// Find any plugins that implement IRockOwinStartup
try
{
var startups = new Dictionary <int, List <IRockOwinStartup> >();
foreach (var startupType in Rock.Reflection.FindTypes(typeof(IRockOwinStartup)).Select(a => a.Value).ToList())
{
var startup = Activator.CreateInstance(startupType) as IRockOwinStartup;
startups.AddOrIgnore(startup.StartupOrder, new List <IRockOwinStartup>());
startups[startup.StartupOrder].Add(startup);
}
foreach (var startupList in startups.OrderBy(s => s.Key).Select(s => s.Value))
{
foreach (var startup in startupList)
{
startup.OnStartup(app);
}
}
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
}
}
/// <summary>
/// Gets schedules associated with the group to be displayed in the filter selections.
/// </summary>
/// <returns></returns>
private Dictionary <int, string> Getschedules(Dictionary <int, string> locations)
{
var schedules = new Dictionary <int, string>();
int?groupId = PageParameter(PageParameterKey.GroupId).AsIntegerOrNull();
if (groupId != null)
{
using (var rockContext = new RockContext())
{
var groupLocations = new GroupLocationService(rockContext).Queryable()
.Where(l => l.GroupId == groupId)
.AsNoTracking();
groupLocations.SelectMany(l => l.Schedules).OrderBy(s => s.Name).ToList()
.ForEach(s => schedules.AddOrIgnore(s.Id, s.Name));
if (schedules.Any())
{
ddlSchedule.Visible = true;
ddlSchedule.DataSource = schedules;
ddlSchedule.DataBind();
ddlSchedule.SetValue(rFilter.GetUserPreference(MakeKeyUniqueToGroup(UserPreferenceKey.Schedule)));
}
else
{
ddlSchedule.Visible = false;
}
}
}
return(schedules);
}
protected string FormatRating(int ratings)
{
var mergeValues = new Dictionary <string, object>();
mergeValues.AddOrIgnore("Rating", ratings);
return("{{ Rating | RatingMarkup }}".ResolveMergeFields(mergeValues));
}
/// <summary>
/// Gets the categorized actions.
/// </summary>
/// <returns></returns>
private Dictionary <string, List <EntityTypeCache> > GetCategorizedActions()
{
var categorizedActions = new Dictionary <string, List <EntityTypeCache> >();
foreach (var action in ActionContainer.Instance.Dictionary.Select(d => d.Value.Value))
{
string categoryName = "Uncategorized";
var actionType = action.GetType();
var obj = actionType.GetCustomAttributes(typeof(ActionCategoryAttribute), true).FirstOrDefault();
if (obj != null)
{
var actionCategory = obj as ActionCategoryAttribute;
if (actionCategory != null)
{
categoryName = actionCategory.CategoryName;
}
}
categorizedActions.AddOrIgnore(categoryName, new List <EntityTypeCache>());
categorizedActions[categoryName].Add(action.EntityType);
}
return(categorizedActions);
}
/// <summary>
/// Handles the Click event of the btnAddCampaignRequests 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 btnAddCampaignRequests_Click(object sender, EventArgs e)
{
var campaignConnectionItems = Rock.Web.SystemSettings.GetValue(CampaignConnectionKey.CAMPAIGN_CONNECTION_CONFIGURATION).FromJsonOrNull <List <CampaignItem> >() ?? new List <CampaignItem>();
campaignConnectionItems = campaignConnectionItems.Where(c => c.IsActive).OrderBy(a => a.Name).ToList();
var rockContext = new RockContext();
// limit to campaigns that the current person is a connector in
campaignConnectionItems = campaignConnectionItems.Where(a => CampaignConnectionHelper.GetConnectorCampusIds(a, CurrentPerson).Any()).ToList();
ddlCampaignConnectionItemsMultiple.Items.Clear();
var campaignConnectionItemsPendingCount = new Dictionary <CampaignItem, int>();
foreach (var campaignConnectionItem in campaignConnectionItems)
{
int pendingCount = CampaignConnectionHelper.GetPendingConnectionCount(campaignConnectionItem, CurrentPerson);
campaignConnectionItemsPendingCount.AddOrIgnore(campaignConnectionItem, pendingCount);
var listItem = new ListItem();
listItem.Text = string.Format("{0} ({1} pending connections)", campaignConnectionItem.Name, pendingCount);
listItem.Value = campaignConnectionItem.Guid.ToString();
ddlCampaignConnectionItemsMultiple.Items.Add(listItem);
}
nbAddConnectionRequestsMessage.Visible = false;
nbNumberOfRequests.Visible = true;
if (campaignConnectionItems.Count() == 0)
{
nbAddConnectionRequestsMessage.Text = "There are no campaigns available for you to request connections for.";
nbAddConnectionRequestsMessage.NotificationBoxType = Rock.Web.UI.Controls.NotificationBoxType.Warning;
nbAddConnectionRequestsMessage.Visible = true;
ddlCampaignConnectionItemsMultiple.Visible = false;
lCampaignConnectionItemSingle.Visible = false;
nbNumberOfRequests.Visible = false;
}
else if (campaignConnectionItems.Count() == 1)
{
var campaignConnectionItem = campaignConnectionItems[0];
lCampaignConnectionItemSingle.Visible = true;
int pendingCount = campaignConnectionItemsPendingCount.GetValueOrNull(campaignConnectionItem) ?? 0;
lCampaignConnectionItemSingle.Text = string.Format("{0} ({1} pending connections)", campaignConnectionItem.Name, pendingCount);
ddlCampaignConnectionItemsMultiple.Visible = false;
}
else
{
lCampaignConnectionItemSingle.Visible = false;
ddlCampaignConnectionItemsMultiple.Visible = true;
}
if (campaignConnectionItems.Count > 0)
{
var firstCampaignConnectionItem = campaignConnectionItems.First();
SetDefaultNumberOfRequests(firstCampaignConnectionItem.Guid, campaignConnectionItemsPendingCount.GetValueOrNull(firstCampaignConnectionItem) ?? 0);
}
mdAddCampaignRequests.Show();
}
/// <summary>
/// Posts to gateway.
/// </summary>
/// <param name="financialGateway">The financial gateway.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
/// <exception cref="System.Exception"></exception>
private Dictionary <string, string> PostToGateway(FinancialGateway financialGateway, XDocument data)
{
var restClient = new RestClient(GetAttributeValue(financialGateway, "APIUrl"));
var restRequest = new RestRequest(Method.POST);
restRequest.RequestFormat = DataFormat.Xml;
restRequest.AddParameter("text/xml", data.ToString(), ParameterType.RequestBody);
try
{
var response = restClient.Execute(restRequest);
var xdocResult = GetXmlResponse(response);
if (xdocResult != null)
{
// Convert XML result to a dictionary
var result = new Dictionary <string, string>();
foreach (XElement element in xdocResult.Root.Elements())
{
if (element.HasElements)
{
string prefix = element.Name.LocalName;
foreach (XElement childElement in element.Elements())
{
result.AddOrIgnore(prefix + "_" + childElement.Name.LocalName, childElement.Value.Trim());
}
}
else
{
result.AddOrIgnore(element.Name.LocalName, element.Value.Trim());
}
}
return(result);
}
}
catch (WebException webException)
{
string message = GetResponseMessage(webException.Response.GetResponseStream());
throw new Exception(webException.Message + " - " + message);
}
catch (Exception ex)
{
throw ex;
}
return(null);
}
/// <summary>
/// Gets the values.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <returns></returns>
public static Dictionary<string, string> GetConfiguredValues( Dictionary<string, ConfigurationValue> configurationValues )
{
var items = new Dictionary<string, string>();
if ( configurationValues.ContainsKey( "values" ) )
{
string listSource = configurationValues["values"].Value;
var options = new Lava.CommonMergeFieldsOptions();
options.GetLegacyGlobalMergeFields = false;
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields( null, null, options );
listSource = listSource.ResolveMergeFields( mergeFields );
if ( listSource.ToUpper().Contains( "SELECT" ) && listSource.ToUpper().Contains( "FROM" ) )
{
var tableValues = new List<string>();
DataTable dataTable = Rock.Data.DbService.GetDataTable( listSource, CommandType.Text, null );
if ( dataTable != null && dataTable.Columns.Contains( "Value" ) && dataTable.Columns.Contains( "Text" ) )
{
foreach ( DataRow row in dataTable.Rows )
{
items.AddOrIgnore( row["value"].ToString(), row["text"].ToString() );
}
}
}
else
{
foreach ( string keyvalue in listSource.Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ) )
{
var keyValueArray = keyvalue.Split( new char[] { '^' }, StringSplitOptions.RemoveEmptyEntries );
if ( keyValueArray.Length > 0 )
{
items.AddOrIgnore( keyValueArray[0].Trim(), keyValueArray.Length > 1 ? keyValueArray[1].Trim() : keyValueArray[0].Trim() );
}
}
}
}
return items;
}
/// <summary>
/// Gets the values.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <returns></returns>
public static Dictionary <string, string> GetConfiguredValues(Dictionary <string, ConfigurationValue> configurationValues)
{
var items = new Dictionary <string, string>();
if (configurationValues.ContainsKey("values"))
{
string listSource = configurationValues["values"].Value;
var options = new Lava.CommonMergeFieldsOptions();
options.GetLegacyGlobalMergeFields = false;
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null, null, options);
listSource = listSource.ResolveMergeFields(mergeFields);
if (listSource.ToUpper().Contains("SELECT") && listSource.ToUpper().Contains("FROM"))
{
var tableValues = new List <string>();
DataTable dataTable = Rock.Data.DbService.GetDataTable(listSource, CommandType.Text, null);
if (dataTable != null && dataTable.Columns.Contains("Value") && dataTable.Columns.Contains("Text"))
{
foreach (DataRow row in dataTable.Rows)
{
items.AddOrIgnore(row["value"].ToString(), row["text"].ToString());
}
}
}
else
{
foreach (string keyvalue in listSource.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
var keyValueArray = keyvalue.Split(new char[] { '^' }, StringSplitOptions.RemoveEmptyEntries);
if (keyValueArray.Length > 0)
{
items.AddOrIgnore(keyValueArray[0].Trim(), keyValueArray.Length > 1 ? keyValueArray[1].Trim() : keyValueArray[0].Trim());
}
}
}
}
return(items);
}
public void AddOrIgnoreTestIgnore()
{
IDictionary <string, string> dic = new Dictionary <string, string>
{
{ "key1", "item1" }, { "key2", "item2" }, { "key3", "item3" }, { "key4", "item4" }
};
dic.AddOrIgnore("key3", "item5");
Assert.Equal("item3", dic["key3"]);
Assert.Equal(4, dic.Count);
}
protected void btnNext_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
if (CurrentPageIndex == 0)
{
string locationKey = GetLocationKey();
if (!string.IsNullOrEmpty(locationKey) && !_verifiedLocations.ContainsKey(locationKey))
{
using (var rockContext = new RockContext())
{
var location = new LocationService(rockContext).Get(acAddress.Street1, acAddress.Street2, acAddress.City, acAddress.State, acAddress.PostalCode, acAddress.Country);
_verifiedLocations.AddOrIgnore(locationKey, (location != null ? location.Id : (int?)null));
}
}
}
if (CurrentPageIndex < (attributeControls.Count + 1))
{
CurrentPageIndex++;
CreateControls(true);
}
else
{
if (FamilyMembers.Any())
{
if (CurrentPageIndex == (attributeControls.Count + 1) && FindDuplicates())
{
CurrentPageIndex++;
CreateControls(true);
}
else
{
var rockContext = new RockContext();
rockContext.WrapTransaction(() =>
{
var familyGroup = GroupService.SaveNewFamily(rockContext, FamilyMembers, cpCampus.SelectedValueAsInt(), true);
if (familyGroup != null)
{
string locationKey = GetLocationKey();
if (!string.IsNullOrEmpty(locationKey) && _verifiedLocations.ContainsKey(locationKey))
{
GroupService.AddNewFamilyAddress(rockContext, familyGroup, GetAttributeValue("LocationType"), _verifiedLocations[locationKey]);
}
}
});
Response.Redirect(string.Format("~/Person/{0}", FamilyMembers[0].Person.Id), false);
}
}
}
}
}
public Dictionary <string, string> GetParsedFeeOptionsWithNameAndValueString(int registrationTemplateFeeId)
{
RegistrationTemplateFee registrationTemplateFee = this.Get(registrationTemplateFeeId);
var options = new Dictionary <string, string>();
string[] nameValues = registrationTemplateFee.CostValue.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string nameValue in nameValues)
{
string[] nameAndValue = nameValue.Split(new char[] { '^' }, StringSplitOptions.RemoveEmptyEntries);
if (nameAndValue.Length == 1)
{
options.AddOrIgnore(nameAndValue[0], nameAndValue[0]);
}
else if (nameAndValue.Length == 2)
{
options.AddOrIgnore(nameAndValue[0], string.Format("{0} ({1})", nameAndValue[0], nameAndValue[1].AsDecimal().FormatAsCurrency()));
}
}
return(options);
}
private void LoadCategories()
{
var entityCategories = new List <MCategory>();
var categoryIcons = new Dictionary <string, string>();
var categoryIconValues = GetAttributeValue("CategoryIcons");
if (!string.IsNullOrWhiteSpace(categoryIconValues))
{
categoryIconValues = categoryIconValues.TrimEnd('|');
foreach (var keyVal in categoryIconValues.Split('|')
.Select(s => s.Split('^'))
.Where(s => s.Length == 2))
{
categoryIcons.AddOrIgnore(keyVal[0], keyVal[1]);
}
}
foreach (var entity in EntityTypeCache.All().Where(t => t.IsEntity))
{
var type = entity.GetEntityType();
if (type != null && type.InheritsOrImplements(typeof(Rock.Data.Entity <>)))
{
string category = "Other";
var domainAttr = type.GetCustomAttribute <RockDomainAttribute>(false);
if (domainAttr != null && domainAttr.Name.IsNotNullOrWhitespace())
{
category = domainAttr.Name;
}
var entityCategory = entityCategories
.Where(c => c.Name == category)
.FirstOrDefault();
if (entityCategory == null)
{
entityCategory = new MCategory {
Guid = Guid.NewGuid(), Name = category, RockEntities = new List <MEntity>()
};
entityCategory.IconCssClass = categoryIcons.ContainsKey(category) ? categoryIcons[category] : string.Empty;
entityCategories.Add(entityCategory);
}
entityCategory.RockEntities.Add(new MEntity {
Id = entity.Id, AssemblyName = entity.AssemblyName, FriendlyName = entity.FriendlyName
});
}
}
EntityCategories = new List <MCategory>(entityCategories.Where(c => c.Name != "Other").OrderBy(c => c.Name));
EntityCategories.AddRange(entityCategories.Where(c => c.Name == "Other"));
}
/// <summary>
/// Gets the options that should be available for additional registrants to specify the family they belong to
/// </summary>
/// <param name="template">The template.</param>
/// <param name="currentRegistrantIndex">Index of the current registrant.</param>
/// <returns></returns>
public Dictionary <Guid, string> GetFamilyOptions(RegistrationTemplate template, int currentRegistrantIndex)
{
// Return a dictionary of family group guid, and the formated name (i.e. "Ted & Cindy Decker" )
var result = new Dictionary <Guid, string>();
// Get all the registrants prior to the current registrant
var familyRegistrants = new Dictionary <Guid, List <RegistrantInfo> >();
for (int i = 0; i < currentRegistrantIndex; i++)
{
if (Registrants != null && Registrants.Count > i)
{
var registrant = Registrants[i];
familyRegistrants.AddOrIgnore(registrant.FamilyGuid, new List <RegistrantInfo>());
familyRegistrants[registrant.FamilyGuid].Add(registrant);
}
else
{
break;
}
}
// Loop through those registrants
foreach (var keyVal in familyRegistrants)
{
// Find all the people and group them by same last name
var lastNames = new Dictionary <string, List <string> >();
foreach (var registrant in keyVal.Value)
{
string firstName = registrant.GetFirstName(template);
string lastName = registrant.GetLastName(template);
lastNames.AddOrIgnore(lastName, new List <string>());
lastNames[lastName].Add(firstName);
}
// Build a formated output for each unique last name
var familyNames = new List <string>();
foreach (var lastName in lastNames)
{
familyNames.Add(string.Format("{0} {1}", lastName.Value.AsDelimited(" & "), lastName.Key));
}
// Join each of the formated values for each unique last name for the current family
result.Add(keyVal.Key, familyNames.AsDelimited(" and "));
}
return(result);
}
/// <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>();
if (entity is Model.BinaryFile)
{
var binaryFile = (Model.BinaryFile)entity;
if (binaryFile.BinaryFileType.Guid != new Guid(SystemGuid.BinaryFiletype.CHECKIN_LABEL))
{
errorMessages.Add("Binary file is not a check-in label");
action.AddLogEntry("Binary file is not a check-in label", true);
return(false);
}
if (binaryFile.Attributes == null)
{
binaryFile.LoadAttributes();
}
// Get the existing merge fields
var existingMergeFields = new Dictionary <string, string>();
foreach (var keyAndVal in binaryFile.GetAttributeValue("MergeCodes").Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries))
{
var keyVal = keyAndVal.Split(new char[] { '^' });
if (keyVal.Length == 2)
{
existingMergeFields.AddOrIgnore(keyVal[0], keyVal[1]);
}
}
// Build new merge fields
var newMergeFields = new List <string>();
foreach (Match match in Regex.Matches(binaryFile.ContentsToString(), @"(?<=\^FD)((?!\^FS).)*(?=\^FS)"))
{
string value = existingMergeFields.ContainsKey(match.Value) ? existingMergeFields[match.Value] : "";
newMergeFields.Add(string.Format("{0}^{1}", match.Value, value));
}
// Save attribute value
var attributeValue = new AttributeValueCache();
attributeValue.Value = newMergeFields.AsDelimited("|");
binaryFile.AttributeValues["MergeCodes"] = attributeValue;
binaryFile.SaveAttributeValues(rockContext);
}
return(true);
}
/// <summary>
/// Configurations the specified application.
/// </summary>
/// <param name="app">The application.</param>
public void Configuration(IAppBuilder app)
{
app.MapSignalR();
/* 02/18/2022 MDP
* By default, Signal R will use reflection to find classes that inherit from Microsoft.AspNet.SignalR.
* It looks in *all* DLLs in RockWeb/bin. It does this on the first page that includes <script src="/SignalR/hubs"></script>.
* This initial hit can take 30-60 seconds, so we'll register our own assembly locator to only look in Rock and Rock Plugins.
* RockWeb.RockMessageHub will be the only Hub. So it doesn't make sense to look in all DLL for any more.
*/
Microsoft.AspNet.SignalR.GlobalHost.DependencyResolver.Register(typeof(IAssemblyLocator), () => new RockHubAssemblyLocator());
try
{
// This is for OIDC Connect
Rock.Oidc.Startup.OnStartup(app);
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
}
try
{
// Find any plugins that implement IRockOwinStartup
var startups = new Dictionary <int, List <IRockOwinStartup> >();
foreach (var startupType in Rock.Reflection.FindTypes(typeof(IRockOwinStartup)).Select(a => a.Value).ToList())
{
var startup = Activator.CreateInstance(startupType) as IRockOwinStartup;
startups.AddOrIgnore(startup.StartupOrder, new List <IRockOwinStartup>());
startups[startup.StartupOrder].Add(startup);
}
foreach (var startupList in startups.OrderBy(s => s.Key).Select(s => s.Value))
{
foreach (var startup in startupList)
{
startup.OnStartup(app);
}
}
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
}
}
/// <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>();
if ( entity is Model.BinaryFile )
{
var binaryFile = (Model.BinaryFile) entity;
if ( binaryFile.BinaryFileType.Guid != new Guid( SystemGuid.BinaryFiletype.CHECKIN_LABEL ) )
{
errorMessages.Add( "Binary file is not a check-in label" );
action.AddLogEntry( "Binary file is not a check-in label", true );
return false;
}
binaryFile.LoadAttributes();
// Get the existing merge fields
var existingMergeFields = new Dictionary<string, string>();
foreach ( var keyAndVal in binaryFile.GetAttributeValue( "MergeCodes" ).Split( new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries ) )
{
var keyVal = keyAndVal.Split( new char[] { '^' } );
if ( keyVal.Length == 2 )
{
existingMergeFields.AddOrIgnore( keyVal[0], keyVal[1] );
}
}
// Build new merge fields
var newMergeFields = new List<string>();
foreach ( Match match in Regex.Matches( binaryFile.ContentsToString(), @"(?<=\^FD)((?!\^FS).)*(?=\^FS)" ) )
{
string value = existingMergeFields.ContainsKey( match.Value ) ? existingMergeFields[match.Value] : "";
newMergeFields.Add( string.Format( "{0}^{1}", match.Value, value ) );
}
// Save attribute value
var attributeValue = new AttributeValueCache();
attributeValue.Value = newMergeFields.AsDelimited( "|" );
binaryFile.AttributeValues["MergeCodes"] = attributeValue;
binaryFile.SaveAttributeValues( rockContext );
}
return true;
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Load" /> event.
/// </summary>
/// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnLoad(EventArgs e)
{
if (!Page.IsPostBack)
{
var rockContext = new RockContext();
OccurrenceId = PageParameter("EventItemOccurrenceId").AsIntegerOrNull();
ContentChannels = new List <ContentChannel>();
ExpandedPanels = new List <int>();
if (OccurrenceId.HasValue && OccurrenceId.Value != 0)
{
var channels = new Dictionary <int, ContentChannel>();
var eventItemOccurrence = new EventItemOccurrenceService(rockContext).Get(OccurrenceId.Value);
if (eventItemOccurrence != null && eventItemOccurrence.EventItem != null && eventItemOccurrence.EventItem.EventCalendarItems != null)
{
eventItemOccurrence.EventItem.EventCalendarItems
.SelectMany(i => i.EventCalendar.ContentChannels)
.Select(c => c.ContentChannel)
.ToList()
.ForEach(c => channels.AddOrIgnore(c.Id, c));
ExpandedPanels = eventItemOccurrence.ContentChannelItems
.Where(i => i.ContentChannelItem != null)
.Select(i => i.ContentChannelItem.ContentChannelId)
.Distinct()
.ToList();
}
foreach (var channel in channels)
{
if (channel.Value.IsAuthorized(Authorization.VIEW, CurrentPerson))
{
ContentChannels.Add(channel.Value);
}
}
}
CreateGrids(rockContext);
BindGrids();
}
base.OnLoad(e);
}
/// <summary>
/// Gets an aggregated set of key/value pairs for variables in the current scope and outer scopes.
/// </summary>
/// <param name="scope"></param>
/// <returns></returns>
private Dictionary <string, object> GetScopeAggregatedValues(Scope scope, bool includeInternalFields)
{
var dictionary = new Dictionary <string, object>();
while (scope != null)
{
var properties = GetScopeDefinedValues(scope, includeInternalFields);
foreach (var key in properties.Keys)
{
dictionary.AddOrIgnore(key, properties[key]);
}
scope = scope.Parent;
}
return(dictionary);
}
/// <summary>
/// Gets an aggregated set of key/value pairs for variables in the current scope and outer scopes.
/// </summary>
/// <param name="scope"></param>
/// <returns></returns>
private Dictionary <string, object> GetScopeAggregatedValues(Scope scope)
{
var dictionary = new Dictionary <string, object>();
while (scope != null)
{
var properties = GetScopeDefinedValues(scope);
foreach (var key in properties.Keys)
{
dictionary.AddOrIgnore(key, properties[key]);
}
scope = _scopeParentInternalField.GetValue(scope) as Scope;
}
return(dictionary);
}
/// <summary>
/// Gets the queue types.
/// </summary>
/// <returns></returns>
public static List <Type> GetQueueTypes()
{
var queueTypes = new Dictionary <string, Type>();
var assemblies = Reflection.GetRockAndPluginAssemblies();
var types = assemblies
.SelectMany(a => a.GetTypesSafe()
.Where(t => t.IsClass && !t.IsNestedPrivate && !t.IsAbstract));
foreach (var type in types)
{
if (IsRockQueue(type))
{
queueTypes.AddOrIgnore(type.FullName, type);
}
}
var queueTypeList = queueTypes.Select(kvp => kvp.Value).ToList();
return(queueTypeList);
}
/// <summary>
/// Configurations the specified application.
/// </summary>
/// <param name="app">The application.</param>
public void Configuration(IAppBuilder app)
{
app.MapSignalR();
try
{
// This is for OIDC Connect
Rock.Oidc.Startup.OnStartup(app);
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
}
try
{
// Find any plugins that implement IRockOwinStartup
var startups = new Dictionary <int, List <IRockOwinStartup> >();
foreach (var startupType in Rock.Reflection.FindTypes(typeof(IRockOwinStartup)).Select(a => a.Value).ToList())
{
var startup = Activator.CreateInstance(startupType) as IRockOwinStartup;
startups.AddOrIgnore(startup.StartupOrder, new List <IRockOwinStartup>());
startups[startup.StartupOrder].Add(startup);
}
foreach (var startupList in startups.OrderBy(s => s.Key).Select(s => s.Value))
{
foreach (var startup in startupList)
{
startup.OnStartup(app);
}
}
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
}
}
private void BindSchedules(int?locationId)
{
var schedules = new Dictionary <int, string> {
{ 0, "" }
};
if (_group != null && locationId.HasValue)
{
_group.GroupLocations
.Where(l => l.LocationId == locationId.Value)
.SelectMany(l => l.Schedules)
.OrderBy(s => s.Name)
.ToList()
.ForEach(s => schedules.AddOrIgnore(s.Id, s.Name));
}
if (schedules.Any())
{
ddlSchedule.DataSource = schedules;
ddlSchedule.DataBind();
}
ddlSchedule.Visible = ddlSchedule.Items.Count > 1;
}
/// <summary>
/// Gets the name of the series.
/// </summary>
/// <param name="metricId">The metric identifier.</param>
/// <param name="seriesId">The series identifier.</param>
/// <returns></returns>
private string GetSeriesName(int?seriesId)
{
if (_entityNameLookup != null && seriesId.HasValue)
{
if (!_entityNameLookup.ContainsKey(seriesId.Value))
{
string value = string.Empty;
if (seriesId.HasValue)
{
var entityItem = entityLookupQry.Where(a => a.Id == seriesId.Value).FirstOrDefault();
if (entityItem != null)
{
value = entityItem.ToString();
}
}
_entityNameLookup.AddOrIgnore(seriesId.Value, value);
}
return(_entityNameLookup[seriesId.Value]);
}
return(null);
}
/// <summary>
/// Processes the payments.
/// </summary>
/// <param name="gateway">The gateway.</param>
/// <param name="batchNamePrefix">The batch name prefix.</param>
/// <param name="payments">The payments.</param>
/// <param name="batchUrlFormat">The batch URL format.</param>
/// <param name="receiptEmail">The receipt email.</param>
/// <returns></returns>
public static string ProcessPayments( FinancialGateway gateway, string batchNamePrefix, List<Payment> payments, string batchUrlFormat = "", Guid? receiptEmail = null )
{
int totalPayments = 0;
int totalAlreadyDownloaded = 0;
int totalNoScheduledTransaction = 0;
int totalAdded = 0;
int totalReversals = 0;
int totalStatusChanges = 0;
var batches = new List<FinancialBatch>();
var batchSummary = new Dictionary<Guid, List<Decimal>>();
var initialControlAmounts = new Dictionary<Guid, decimal>();
var txnPersonNames = new Dictionary<Guid, string>();
var gatewayComponent = gateway.GetGatewayComponent();
var newTransactions = new List<FinancialTransaction>();
using ( var rockContext = new RockContext() )
{
var accountService = new FinancialAccountService( rockContext );
var txnService = new FinancialTransactionService( rockContext );
var batchService = new FinancialBatchService( rockContext );
var scheduledTxnService = new FinancialScheduledTransactionService( rockContext );
var contributionTxnType = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid() );
var defaultAccount = accountService.Queryable()
.Where( a =>
a.IsActive &&
!a.ParentAccountId.HasValue &&
( !a.StartDate.HasValue || a.StartDate.Value <= RockDateTime.Now ) &&
( !a.EndDate.HasValue || a.EndDate.Value >= RockDateTime.Now )
)
.OrderBy( a => a.Order )
.FirstOrDefault();
var batchTxnChanges = new Dictionary<Guid, List<string>>();
var batchBatchChanges = new Dictionary<Guid, List<string>>();
var scheduledTransactionIds = new List<int>();
foreach ( var payment in payments.Where( p => p.Amount > 0.0M ) )
{
totalPayments++;
var scheduledTransaction = scheduledTxnService.GetByScheduleId( payment.GatewayScheduleId );
if ( scheduledTransaction != null )
{
// Find existing payments with same transaction code
var txns = txnService
.Queryable( "TransactionDetails" )
.Where( t => t.TransactionCode == payment.TransactionCode )
.ToList();
// Calculate whether a transaction needs to be added
var txnAmount = CalculateTransactionAmount( payment, txns );
if ( txnAmount != 0.0M )
{
scheduledTransactionIds.Add( scheduledTransaction.Id );
if ( payment.ScheduleActive.HasValue )
{
scheduledTransaction.IsActive = payment.ScheduleActive.Value;
}
var transaction = new FinancialTransaction();
transaction.FinancialPaymentDetail = new FinancialPaymentDetail();
transaction.Guid = Guid.NewGuid();
transaction.TransactionCode = payment.TransactionCode;
transaction.TransactionDateTime = payment.TransactionDateTime;
transaction.Status = payment.Status;
transaction.StatusMessage = payment.StatusMessage;
transaction.ScheduledTransactionId = scheduledTransaction.Id;
transaction.AuthorizedPersonAliasId = scheduledTransaction.AuthorizedPersonAliasId;
transaction.SourceTypeValueId = scheduledTransaction.SourceTypeValueId;
txnPersonNames.Add( transaction.Guid, scheduledTransaction.AuthorizedPersonAlias.Person.FullName );
transaction.FinancialGatewayId = gateway.Id;
transaction.TransactionTypeValueId = contributionTxnType.Id;
if ( txnAmount < 0.0M )
{
transaction.Summary = "Reversal for previous transaction that failed during processing." + Environment.NewLine;
}
var currencyTypeValue = payment.CurrencyTypeValue;
var creditCardTypevalue = payment.CreditCardTypeValue;
if ( scheduledTransaction.FinancialPaymentDetail != null )
{
if ( currencyTypeValue == null && scheduledTransaction.FinancialPaymentDetail.CurrencyTypeValueId.HasValue )
{
currencyTypeValue = DefinedValueCache.Read( scheduledTransaction.FinancialPaymentDetail.CurrencyTypeValueId.Value );
}
if ( creditCardTypevalue == null && scheduledTransaction.FinancialPaymentDetail.CreditCardTypeValueId.HasValue )
{
creditCardTypevalue = DefinedValueCache.Read( scheduledTransaction.FinancialPaymentDetail.CreditCardTypeValueId.Value );
}
transaction.FinancialPaymentDetail.AccountNumberMasked = scheduledTransaction.FinancialPaymentDetail.AccountNumberMasked;
transaction.FinancialPaymentDetail.NameOnCardEncrypted = scheduledTransaction.FinancialPaymentDetail.NameOnCardEncrypted;
transaction.FinancialPaymentDetail.ExpirationMonthEncrypted = scheduledTransaction.FinancialPaymentDetail.ExpirationMonthEncrypted;
transaction.FinancialPaymentDetail.ExpirationYearEncrypted = scheduledTransaction.FinancialPaymentDetail.ExpirationYearEncrypted;
transaction.FinancialPaymentDetail.BillingLocationId = scheduledTransaction.FinancialPaymentDetail.BillingLocationId;
}
if ( currencyTypeValue != null )
{
transaction.FinancialPaymentDetail.CurrencyTypeValueId = currencyTypeValue.Id;
}
if ( creditCardTypevalue != null )
{
transaction.FinancialPaymentDetail.CreditCardTypeValueId = creditCardTypevalue.Id;
}
// Try to allocate the amount of the transaction based on the current scheduled transaction accounts
decimal remainingAmount = Math.Abs( txnAmount );
foreach ( var detail in scheduledTransaction.ScheduledTransactionDetails.Where( d => d.Amount != 0.0M ) )
{
var transactionDetail = new FinancialTransactionDetail();
transactionDetail.AccountId = detail.AccountId;
if ( detail.Amount <= remainingAmount )
{
// If the configured amount for this account is less than or equal to the remaining
// amount, allocate the configured amount
transactionDetail.Amount = detail.Amount;
remainingAmount -= detail.Amount;
}
else
{
// If the configured amount is greater than the remaining amount, only allocate
// the remaining amount
transaction.Summary += "Note: Downloaded transaction amount was less than the configured allocation amounts for the Scheduled Transaction.";
transactionDetail.Amount = remainingAmount;
transactionDetail.Summary = "Note: The downloaded amount was not enough to apply the configured amount to this account.";
remainingAmount = 0.0M;
}
transaction.TransactionDetails.Add( transactionDetail );
if ( remainingAmount <= 0.0M )
{
// If there's no amount left, break out of details
break;
}
}
// If there's still amount left after allocating based on current config, add the remainder
// to the account that was configured for the most amount
if ( remainingAmount > 0.0M )
{
transaction.Summary += "Note: Downloaded transaction amount was greater than the configured allocation amounts for the Scheduled Transaction.";
var transactionDetail = transaction.TransactionDetails
.OrderByDescending( d => d.Amount )
.FirstOrDefault();
if ( transactionDetail == null && defaultAccount != null )
{
transactionDetail = new FinancialTransactionDetail();
transactionDetail.AccountId = defaultAccount.Id;
transaction.TransactionDetails.Add( transactionDetail );
}
if ( transactionDetail != null )
{
transactionDetail.Amount += remainingAmount;
transactionDetail.Summary = "Note: Extra amount was applied to this account.";
}
}
// If the amount to apply was negative, update all details to be negative (absolute value was used when allocating to accounts)
if ( txnAmount < 0.0M )
{
foreach ( var txnDetail in transaction.TransactionDetails )
{
txnDetail.Amount = 0 - txnDetail.Amount;
}
}
// Get the batch
var batch = batchService.Get(
batchNamePrefix,
currencyTypeValue,
creditCardTypevalue,
transaction.TransactionDateTime.Value,
gateway.GetBatchTimeOffset(),
batches );
var batchChanges = new List<string>();
if ( batch.Id != 0 )
{
initialControlAmounts.AddOrIgnore( batch.Guid, batch.ControlAmount );
}
batch.ControlAmount += transaction.TotalAmount;
batch.Transactions.Add( transaction );
if ( txnAmount > 0.0M && receiptEmail.HasValue )
{
newTransactions.Add( transaction );
}
// Add summary
if ( !batchSummary.ContainsKey( batch.Guid ) )
{
batchSummary.Add( batch.Guid, new List<Decimal>() );
}
batchSummary[batch.Guid].Add( txnAmount );
if ( txnAmount > 0.0M )
{
totalAdded++;
}
else
{
totalReversals++;
}
}
else
{
totalAlreadyDownloaded++;
foreach ( var txn in txns.Where( t => t.Status != payment.Status || t.StatusMessage != payment.StatusMessage ) )
{
txn.Status = payment.Status;
txn.StatusMessage = payment.StatusMessage;
totalStatusChanges++;
}
}
}
else
{
totalNoScheduledTransaction++;
}
}
rockContext.SaveChanges();
// Queue a transaction to update the status of all affected scheduled transactions
var updatePaymentStatusTxn = new Rock.Transactions.UpdatePaymentStatusTransaction( gateway.Id, scheduledTransactionIds );
Rock.Transactions.RockQueue.TransactionQueue.Enqueue( updatePaymentStatusTxn );
if ( receiptEmail.HasValue )
{
// Queue a transaction to send receipts
var newTransactionIds = newTransactions.Select( t => t.Id ).ToList();
var sendPaymentReceiptsTxn = new Rock.Transactions.SendPaymentReceipts( receiptEmail.Value, newTransactionIds );
Rock.Transactions.RockQueue.TransactionQueue.Enqueue( sendPaymentReceiptsTxn );
}
}
StringBuilder sb = new StringBuilder();
sb.AppendFormat( "<li>{0} {1} downloaded.</li>", totalPayments.ToString( "N0" ),
( totalPayments == 1 ? "payment" : "payments" ) );
if ( totalAlreadyDownloaded > 0 )
{
sb.AppendFormat( "<li>{0} {1} previously downloaded and {2} already been added.</li>", totalAlreadyDownloaded.ToString( "N0" ),
( totalAlreadyDownloaded == 1 ? "payment was" : "payments were" ),
( totalAlreadyDownloaded == 1 ? "has" : "have" ) );
}
if ( totalStatusChanges > 0 )
{
sb.AppendFormat( "<li>{0} {1} previously downloaded but had a change of status.</li>", totalStatusChanges.ToString( "N0" ),
( totalStatusChanges == 1 ? "payment was" : "payments were" ) );
}
if ( totalNoScheduledTransaction > 0 )
{
sb.AppendFormat( "<li>{0} {1} could not be matched to an existing scheduled payment profile.</li>", totalNoScheduledTransaction.ToString( "N0" ),
( totalNoScheduledTransaction == 1 ? "payment" : "payments" ) );
}
sb.AppendFormat( "<li>{0} {1} successfully added.</li>", totalAdded.ToString( "N0" ),
( totalAdded == 1 ? "payment was" : "payments were" ) );
if ( totalReversals > 0 )
{
sb.AppendFormat( "<li>{0} {1} added as a reversal to a previous transaction.</li>", totalReversals.ToString( "N0" ),
( totalReversals == 1 ? "payment was" : "payments were" ) );
}
if ( totalStatusChanges > 0 )
{
sb.AppendFormat( "<li>{0} {1} previously downloaded but had a change of status.</li>", totalStatusChanges.ToString( "N0" ),
( totalStatusChanges == 1 ? "payment was" : "payments were" ) );
}
foreach ( var batchItem in batchSummary )
{
int items = batchItem.Value.Count;
if ( items > 0 )
{
var batch = batches
.Where( b => b.Guid.Equals( batchItem.Key ) )
.FirstOrDefault();
string batchName = string.Format( "'{0} ({1})'", batch.Name, batch.BatchStartDateTime.Value.ToString( "d" ) );
if ( !string.IsNullOrWhiteSpace( batchUrlFormat ) )
{
batchName = string.Format( "<a href='{0}'>{1}</a>", string.Format( batchUrlFormat, batch.Id ), batchName );
}
decimal sum = batchItem.Value.Sum();
string summaryformat = items == 1 ?
"<li>{0} transaction of {1} was added to the {2} batch.</li>" :
"<li>{0} transactions totaling {1} were added to the {2} batch</li>";
sb.AppendFormat( summaryformat, items.ToString( "N0" ), sum.FormatAsCurrency(), batchName );
}
}
return sb.ToString();
}
/// <summary>
/// Gets the templates.
/// </summary>
/// <param name="errors">The errors.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public override Dictionary<string, string> GetTemplates( out List<string> errors )
{
var templates = new Dictionary<string, string>();
errors = new List<string>();
// Get the access token
string errorMessage = string.Empty;
string accessToken = GetAccessToken( false, out errorMessage );
if ( string.IsNullOrWhiteSpace( accessToken ) )
{
errors.Add( errorMessage );
return null;
}
JObject folderListRes = CudaSign.Folder.List( accessToken );
errors = ParseErrors( folderListRes );
if ( errors.Any() )
{
errorMessage = errors.AsDelimited( "; " );
return null;
}
JArray folders = folderListRes.Value<JArray>( "folders" );
if ( folders != null )
{
foreach ( JObject folder in folders )
{
if ( folder.Value<string>( "name" ) == "Templates" )
{
string folderId = folder.Value<string>( "id" );
if ( !string.IsNullOrWhiteSpace( folderId ) )
{
JObject documentListRes = CudaSign.Folder.Get( accessToken, folderId );
errors = ParseErrors( documentListRes );
if ( errors.Any() )
{
errorMessage = errors.AsDelimited( "; " );
return null;
}
JArray documents = documentListRes.Value<JArray>( "documents" );
if ( documents != null )
{
foreach ( JObject document in documents )
{
templates.AddOrIgnore(
document.Value<string>( "id" ),
document.Value<string>( "document_name" ) );
}
}
}
}
}
}
return templates;
}
/// <summary>
/// Parses the fee.
/// </summary>
/// <param name="fee">The fee.</param>
/// <returns></returns>
private List<FeeInfo> ParseFee( RegistrationTemplateFee fee )
{
string fieldId = string.Format( "fee_{0}", fee.Id );
if ( fee.FeeType == RegistrationFeeType.Single )
{
if ( fee.AllowMultiple )
{
// Single Option, Multi Quantity
var numUpDown = phFees.FindControl( fieldId ) as NumberUpDown;
if ( numUpDown != null && numUpDown.Value > 0 )
{
return new List<FeeInfo> { new FeeInfo( string.Empty, numUpDown.Value, fee.CostValue.AsDecimal() ) };
}
}
else
{
// Single Option, Single Quantity
var cb = phFees.FindControl( fieldId ) as RockCheckBox;
if ( cb != null && cb.Checked )
{
return new List<FeeInfo> { new FeeInfo( string.Empty, 1, fee.CostValue.AsDecimal() ) };
}
}
}
else
{
// Parse the options to get name and cost for each
var options = new Dictionary<string, string>();
var optionCosts = new Dictionary<string, decimal>();
string[] nameValues = fee.CostValue.Split( new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries );
foreach ( string nameValue in nameValues )
{
string[] nameAndValue = nameValue.Split( new char[] { '^' }, StringSplitOptions.RemoveEmptyEntries );
if ( nameAndValue.Length == 1 )
{
options.AddOrIgnore( nameAndValue[0], nameAndValue[0] );
optionCosts.AddOrIgnore( nameAndValue[0], 0.0m );
}
if ( nameAndValue.Length == 2 )
{
options.AddOrIgnore( nameAndValue[0], string.Format( "{0} ({1:C2})", nameAndValue[0], nameAndValue[1].AsDecimal() ) );
optionCosts.AddOrIgnore( nameAndValue[0], nameAndValue[1].AsDecimal() );
}
}
if ( fee.AllowMultiple )
{
// Multi Option, Multi Quantity
var result = new List<FeeInfo>();
foreach ( var optionKeyVal in options )
{
string optionFieldId = string.Format( "{0}_{1}", fieldId, optionKeyVal.Key );
var numUpDown = phFees.FindControl( optionFieldId ) as NumberUpDown;
if ( numUpDown != null && numUpDown.Value > 0 )
{
result.Add( new FeeInfo( optionKeyVal.Key, numUpDown.Value, optionCosts[optionKeyVal.Key] ) );
}
}
if ( result.Any() )
{
return result;
}
}
else
{
// Multi Option, Single Quantity
var ddl = phFees.FindControl( fieldId ) as RockDropDownList;
if ( ddl != null && ddl.SelectedValue != "" )
{
return new List<FeeInfo> { new FeeInfo( ddl.SelectedValue, 1, optionCosts[ddl.SelectedValue] ) };
}
}
}
return null;
}
/// <summary>
/// Gets the suggestions.
/// </summary>
/// <param name="followingSuggestionType">Type of the following suggestion.</param>
/// <param name="followerPersonIds">The follower person ids.</param>
/// <returns></returns>
public override List <PersonEntitySuggestion> GetSuggestions(FollowingSuggestionType followingSuggestionType, List <int> followerPersonIds)
{
var suggestions = new List <PersonEntitySuggestion>();
var personAliasEntityType = EntityTypeCache.Read(typeof(Rock.Model.PersonAlias));
bool isAutoFollow = GetAttributeValue(followingSuggestionType, "AutoFollow").AsBoolean();
// Get the grouptype guid
Guid?groupTypeGuid = GetAttributeValue(followingSuggestionType, "GroupType").AsGuidOrNull();
if (groupTypeGuid.HasValue)
{
using (var rockContext = new RockContext())
{
var groupMemberService = new GroupMemberService(rockContext);
var personAliasService = new PersonAliasService(rockContext);
// Get all the groupmember records for any follower and the selected group type
var followers = groupMemberService.Queryable().AsNoTracking()
.Where(m =>
m.GroupMemberStatus == GroupMemberStatus.Active &&
m.Group != null &&
m.Group.IsActive &&
m.Group.GroupType.Guid.Equals(groupTypeGuid.Value) &&
followerPersonIds.Contains(m.PersonId));
// If a specific group or security role was specifed, limit groupmembers to only those of the selected group
Guid?groupGuid = GetAttributeValue(followingSuggestionType, "Group").AsGuidOrNull();
if (!groupGuid.HasValue)
{
groupGuid = GetAttributeValue(followingSuggestionType, "SecurityRole").AsGuidOrNull();
}
if (groupGuid.HasValue)
{
followers = followers.Where(m => m.Group.Guid.Equals(groupGuid.Value));
}
// If a specific role for the follower was specified, limit groupmembers to only those with the selected role
Guid?followerRoleGuid = GetAttributeValue(followingSuggestionType, "FollowerGroupType").AsGuidOrNull();
if (followerRoleGuid.HasValue)
{
followers = followers.Where(m => m.GroupRole.Guid.Equals(followerRoleGuid.Value));
}
// Run the query to get all the groups that follower is a member of with selected filters
var followerPersonGroup = followers
.Select(f => new
{
f.PersonId,
f.GroupId
})
.ToList();
// Get a unique list of any of the groups that followers belong to
var followedGroupIds = followerPersonGroup
.Select(f => f.GroupId)
.Distinct()
.ToList();
// Start building query to get the people to follow from any group that contains a follower
var followed = groupMemberService
.Queryable().AsNoTracking()
.Where(m => followedGroupIds.Contains(m.GroupId));
// If a specific role for the people being followed was specified, limit the query to only those with the selected role
Guid?followedRoleGuid = GetAttributeValue(followingSuggestionType, "FollowedGroupType").AsGuidOrNull();
if (followedRoleGuid.HasValue)
{
followed = followed.Where(m => m.GroupRole.Guid.Equals(followedRoleGuid.Value));
}
// Get all the people in any of the groups that contain a follower
var followedPersonGroup = followed
.Select(f => new
{
f.PersonId,
f.GroupId
})
.ToList();
// Get distinct list of people
var followedPersonIds = followedPersonGroup
.Select(f => f.PersonId)
.Distinct()
.ToList();
// Build a dictionary of the personid->personaliasid
var personAliasIds = new Dictionary <int, int>();
personAliasService.Queryable().AsNoTracking()
.Where(a =>
followedPersonIds.Contains(a.PersonId) &&
a.PersonId == a.AliasPersonId)
.ToList()
.ForEach(a => personAliasIds.AddOrIgnore(a.PersonId, a.Id));
// Loop through each follower/group combination
foreach (var followedGroup in followerPersonGroup)
{
// Loop through the other people in that group
foreach (int followedPersonId in followedPersonGroup
.Where(f =>
f.GroupId == followedGroup.GroupId &&
f.PersonId != followedGroup.PersonId)
.Select(f => f.PersonId))
{
// If the person has a valid personalias id
if (personAliasIds.ContainsKey(followedPersonId))
{
if (!isAutoFollow)
{
// add them to the list of suggestions
suggestions.Add(new PersonEntitySuggestion(followedGroup.PersonId, personAliasIds[followedPersonId]));
}
else
{
// auto-add the follow
var followingService = new FollowingService(rockContext);
int followerPersonAliasId = personAliasIds[followedGroup.PersonId];
int followeePersonAliasId = personAliasIds[followedPersonId];
// if person is not already following the person
bool isFollowing = followingService.Queryable().Where(f =>
f.EntityTypeId == personAliasEntityType.Id &&
f.EntityId == followeePersonAliasId &&
f.PersonAliasId == followerPersonAliasId).Any();
if (!isFollowing)
{
var following = new Following();
following.EntityTypeId = personAliasEntityType.Id;
following.EntityId = personAliasIds[followedPersonId];
following.PersonAliasId = personAliasIds[followedGroup.PersonId];
followingService.Add(following);
rockContext.SaveChanges();
}
}
}
}
}
}
}
return(suggestions);
}
/// <summary>
/// Shows the activity dialog.
/// </summary>
/// <param name="activityGuid">The activity unique identifier.</param>
private void ShowActivityDialog( Guid activityGuid )
{
ddlActivity.Items.Clear();
ddlActivity.Items.Add( new ListItem( string.Empty, string.Empty ) );
var connectors = new Dictionary<int, Person>();
ConnectionRequestActivity activity = null;
using ( var rockContext = new RockContext() )
{
var connectionRequestService = new ConnectionRequestService( rockContext );
var connectionRequest = connectionRequestService.Get( hfConnectionRequestId.ValueAsInt() );
if ( connectionRequest != null &&
connectionRequest.ConnectionOpportunity != null &&
connectionRequest.ConnectionOpportunity.ConnectionType != null )
{
foreach ( var activityType in connectionRequest.ConnectionOpportunity.ConnectionType.ConnectionActivityTypes.OrderBy( a => a.Name ) )
{
if ( activityType.IsAuthorized( Authorization.VIEW, CurrentPerson ) )
{
ddlActivity.Items.Add( new ListItem( activityType.Name, activityType.Id.ToString() ) );
}
}
connectionRequest.ConnectionOpportunity.ConnectionOpportunityConnectorGroups
.Where( g =>
!g.CampusId.HasValue ||
!connectionRequest.CampusId.HasValue ||
g.CampusId.Value == connectionRequest.CampusId.Value )
.SelectMany( g => g.ConnectorGroup.Members )
.Select( m => m.Person )
.ToList()
.ForEach( p => connectors.AddOrIgnore( p.Id, p ) );
}
if ( activityGuid != Guid.Empty )
{
activity = new ConnectionRequestActivityService( rockContext ).Get( activityGuid );
if ( activity != null && activity.ConnectorPersonAlias != null && activity.ConnectorPersonAlias.Person != null )
{
connectors.AddOrIgnore( activity.ConnectorPersonAlias.Person.Id, activity.ConnectorPersonAlias.Person );
}
}
}
if ( CurrentPerson != null )
{
connectors.AddOrIgnore( CurrentPerson.Id, CurrentPerson );
}
ddlActivity.SetValue( activity != null ? activity.ConnectionActivityTypeId : 0 );
ddlActivityConnector.Items.Clear();
connectors
.ToList()
.OrderBy( p => p.Value.LastName )
.ThenBy( p => p.Value.NickName )
.ToList()
.ForEach( c =>
ddlActivityConnector.Items.Add( new ListItem( c.Value.FullName, c.Key.ToString() ) ) );
ddlActivityConnector.SetValue(
activity != null && activity.ConnectorPersonAlias != null ?
activity.ConnectorPersonAlias.PersonId : CurrentPersonId ?? 0 );
tbNote.Text = activity != null ? activity.Note : string.Empty;
hfAddConnectionRequestActivityGuid.Value = activityGuid.ToString();
if ( activityGuid == Guid.Empty )
{
dlgConnectionRequestActivities.Title = "Add Activity";
dlgConnectionRequestActivities.SaveButtonText = "Add";
}
else
{
dlgConnectionRequestActivities.Title = "Edit Activity";
dlgConnectionRequestActivities.SaveButtonText = "Save";
}
ShowDialog( "ConnectionRequestActivities", true );
}
private void BindSchedules( int? locationId )
{
var schedules = new Dictionary<int, string> { { 0, "" } };
if ( _group != null && locationId.HasValue )
{
_group.GroupLocations
.Where( l => l.LocationId == locationId.Value )
.SelectMany( l => l.Schedules )
.OrderBy( s => s.Name )
.ToList()
.ForEach( s => schedules.AddOrIgnore( s.Id, s.Name ) );
}
if ( schedules.Any() )
{
ddlSchedule.DataSource = schedules;
ddlSchedule.DataBind();
}
ddlSchedule.Visible = ddlSchedule.Items.Count > 1;
}
/// <summary>
/// Rebinds the connectors.
/// </summary>
/// <param name="connectionRequest">The connection request.</param>
/// <param name="campusId">The campus identifier.</param>
/// <param name="rockContext">The rock context.</param>
public void RebindConnectors( ConnectionRequest connectionRequest, int? campusId, RockContext rockContext )
{
int? currentValue = ddlConnectorEdit.SelectedValueAsInt();
var connectors = new Dictionary<int, Person>();
if ( connectionRequest != null )
{
if ( !currentValue.HasValue && connectionRequest.ConnectorPersonAlias != null )
{
currentValue = connectionRequest.ConnectorPersonAlias.PersonId;
}
if ( connectionRequest.ConnectionOpportunity != null )
{
// Get the connectors from the connector groups
if ( connectionRequest.ConnectionOpportunity.ConnectionType != null )
{
connectionRequest.ConnectionOpportunity.ConnectionOpportunityConnectorGroups
.Where( g =>
!g.CampusId.HasValue ||
!campusId.HasValue ||
g.CampusId.Value == campusId.Value )
.SelectMany( g => g.ConnectorGroup.Members )
.Where( m => m.GroupMemberStatus == GroupMemberStatus.Active )
.Select( m => m.Person )
.ToList()
.ForEach( p => connectors.AddOrIgnore( p.Id, p ) );
}
if ( !currentValue.HasValue && campusId.HasValue )
{
currentValue = connectionRequest.ConnectionOpportunity.GetDefaultConnectorPersonId( campusId.Value );
}
}
}
// Add the current person as possible connector
if ( CurrentPerson != null )
{
connectors.AddOrIgnore( CurrentPerson.Id, CurrentPerson );
}
// Make sure the current value is an option
if ( currentValue.HasValue && !connectors.ContainsKey( currentValue.Value ) )
{
var person = new PersonService( rockContext ).Get( currentValue.Value );
if ( person != null )
{
connectors.AddOrIgnore( person.Id, person );
}
}
// Add connectors to dropdown list
ddlConnectorEdit.Items.Clear();
ddlConnectorEdit.Items.Add( new ListItem( "", "" ) );
connectors
.ToList()
.OrderBy( p => p.Value.LastName )
.ThenBy( p => p.Value.NickName )
.ToList()
.ForEach( c =>
ddlConnectorEdit.Items.Add( new ListItem( c.Value.FullName, c.Key.ToString() ) ) );
if ( currentValue.HasValue )
{
ddlConnectorEdit.SetValue( currentValue.Value );
}
}
private void RebindGroupRole( ConnectionRequest connectionRequest, RockContext rockContext )
{
int? currentRoleId = ddlPlacementGroupRole.SelectedValueAsInt();
ddlPlacementGroupRole.SelectedValue = null;
ddlPlacementGroupRole.Items.Clear();
if ( !currentRoleId.HasValue && connectionRequest.AssignedGroupMemberRoleId.HasValue )
{
currentRoleId = connectionRequest.AssignedGroupMemberRoleId.Value;
}
var roles = new Dictionary<int, string>();
int? groupId = ddlPlacementGroup.SelectedValueAsInt();
if ( groupId.HasValue )
{
var group = new GroupService( rockContext ).Get( groupId.Value );
if ( group != null )
{
foreach ( var groupConfig in new ConnectionOpportunityGroupConfigService( rockContext )
.Queryable().AsNoTracking()
.Where( c =>
c.ConnectionOpportunityId == connectionRequest.ConnectionOpportunityId &&
c.GroupTypeId == group.GroupTypeId ) )
{
if ( groupConfig.GroupMemberRole != null )
{
roles.AddOrIgnore( groupConfig.GroupMemberRole.Id, groupConfig.GroupMemberRole.Name );
}
}
}
}
foreach ( var roleItem in roles )
{
var listItem = new ListItem( roleItem.Value, roleItem.Key.ToString() );
listItem.Selected = currentRoleId.HasValue && currentRoleId.Value == roleItem.Key;
ddlPlacementGroupRole.Items.Add( listItem );
}
ddlPlacementGroupRole.Visible = ddlPlacementGroupRole.Items.Count > 1;
RebindGroupStatus( connectionRequest, rockContext );
}
/// <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>
/// Saves the person.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="person">The person.</param>
/// <param name="familyGuid">The family unique identifier.</param>
/// <param name="campusId">The campus identifier.</param>
/// <param name="location">The location.</param>
/// <param name="adultRoleId">The adult role identifier.</param>
/// <param name="childRoleId">The child role identifier.</param>
/// <param name="multipleFamilyGroupIds">The multiple family group ids.</param>
/// <param name="singleFamilyId">The single family identifier.</param>
/// <returns></returns>
private Person SavePerson( RockContext rockContext, Person person, Guid familyGuid, int? campusId, Location location, int adultRoleId, int childRoleId,
Dictionary<Guid, int> multipleFamilyGroupIds, ref int? singleFamilyId )
{
int? familyId = null;
if ( person.Id > 0 )
{
rockContext.SaveChanges();
// Set the family guid for any other registrants that were selected to be in the same family
var family = person.GetFamilies( rockContext ).FirstOrDefault();
if ( family != null )
{
familyId = family.Id;
multipleFamilyGroupIds.AddOrIgnore( familyGuid, family.Id );
if ( !singleFamilyId.HasValue )
{
singleFamilyId = family.Id;
}
}
}
else
{
// If we've created the family aready for this registrant, add them to it
if (
( RegistrationTemplate.RegistrantsSameFamily == RegistrantsSameFamily.Ask && multipleFamilyGroupIds.ContainsKey( familyGuid ) ) ||
( RegistrationTemplate.RegistrantsSameFamily == RegistrantsSameFamily.Yes && singleFamilyId.HasValue )
)
{
// Add person to existing family
var age = person.Age;
int familyRoleId = age.HasValue && age < 18 ? childRoleId : adultRoleId;
familyId = RegistrationTemplate.RegistrantsSameFamily == RegistrantsSameFamily.Ask ?
multipleFamilyGroupIds[familyGuid] :
singleFamilyId.Value;
PersonService.AddPersonToFamily( person, true, multipleFamilyGroupIds[familyGuid], familyRoleId, rockContext );
}
// otherwise create a new family
else
{
// Create Person/Family
var familyGroup = PersonService.SaveNewPerson( person, rockContext, campusId, false );
if ( familyGroup != null )
{
familyId = familyGroup.Id;
// Store the family id for next person
multipleFamilyGroupIds.AddOrIgnore( familyGuid, familyGroup.Id );
if ( !singleFamilyId.HasValue )
{
singleFamilyId = familyGroup.Id;
}
}
}
}
if ( familyId.HasValue && location != null )
{
var homeLocationType = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME.AsGuid() );
if ( homeLocationType != null )
{
var familyGroup = new GroupService( rockContext ).Get( familyId.Value );
if ( familyGroup != null )
{
GroupService.AddNewGroupAddress(
rockContext,
familyGroup,
Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME,
location.Street1, location.Street2, location.City, location.State, location.PostalCode, location.Country, true );
}
}
}
return new PersonService( rockContext ).Get( person.Id );
}
/// <summary>
/// Handles the Click event of the lbPlaceInGroup 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 lbPlaceInGroup_Click( object sender, EventArgs e )
{
var col = gGroupPlacements.Columns.OfType<GroupPickerField>().FirstOrDefault();
if ( col != null )
{
var placements = new Dictionary<int, List<int>>();
var colIndex = gGroupPlacements.Columns.IndexOf( col ).ToString();
foreach ( GridViewRow row in gGroupPlacements.Rows )
{
GroupPicker gp = row.FindControl( "groupPicker_" + colIndex.ToString() ) as GroupPicker;
if ( gp != null )
{
int? groupId = gp.SelectedValueAsInt();
if ( groupId.HasValue )
{
int registrantId = (int)gGroupPlacements.DataKeys[row.RowIndex].Value;
placements.AddOrIgnore( groupId.Value, new List<int>() );
placements[groupId.Value].Add( registrantId );
}
}
}
using ( var rockContext = new RockContext() )
{
var groupMemberService = new GroupMemberService( rockContext );
// Get all the registrants that were selected
var registrantIds = placements.SelectMany( p => p.Value ).ToList();
var registrants = new RegistrationRegistrantService( rockContext )
.Queryable( "PersonAlias" ).AsNoTracking()
.Where( r => registrantIds.Contains( r.Id ) )
.ToList();
// Get any groups that were selected
var groupIds = placements.Keys.ToList();
foreach ( var group in new GroupService( rockContext )
.Queryable( "GroupType" ).AsNoTracking()
.Where( g => groupIds.Contains( g.Id ) ) )
{
foreach ( int registrantId in placements[group.Id] )
{
int? roleId = group.GroupType.DefaultGroupRoleId;
if ( !roleId.HasValue )
{
roleId = group.GroupType.Roles
.OrderBy( r => r.Order )
.Select( r => r.Id )
.FirstOrDefault();
}
var registrant = registrants.FirstOrDefault( r => r.Id == registrantId );
if ( registrant != null && roleId.HasValue && roleId.Value > 0 )
{
var groupMember = new GroupMember();
groupMember.PersonId = registrant.PersonAlias.PersonId;
groupMember.GroupId = group.Id;
groupMember.GroupRoleId = roleId.Value;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
groupMemberService.Add( groupMember );
}
}
}
rockContext.SaveChanges();
}
}
BindGroupPlacementGrid();
}
/// <summary>
/// Binds the group placement grid.
/// </summary>
/// <param name="isExporting">if set to <c>true</c> [is exporting].</param>
private void BindGroupPlacementGrid( bool isExporting = false )
{
int? groupId = gpGroupPlacementParentGroup.SelectedValueAsInt();
int? instanceId = hfRegistrationInstanceId.Value.AsIntegerOrNull();
if ( instanceId.HasValue )
{
using ( var rockContext = new RockContext() )
{
// Start query for registrants
var qry = new RegistrationRegistrantService( rockContext )
.Queryable( "PersonAlias.Person.PhoneNumbers.NumberTypeValue,Fees.RegistrationTemplateFee,GroupMember.Group" ).AsNoTracking()
.Where( r =>
r.Registration.RegistrationInstanceId == instanceId.Value &&
r.PersonAlias != null &&
r.PersonAlias.Person != null );
if ( groupId.HasValue )
{
var validGroupIds = new GroupService( rockContext ).GetAllDescendents( groupId.Value )
.Select( g => g.Id )
.ToList();
var existingPeopleInGroups = new GroupMemberService( rockContext )
.Queryable().AsNoTracking()
.Where( m => validGroupIds.Contains( m.GroupId ) )
.Select( m => m.PersonId )
.ToList();
qry = qry.Where( r => !existingPeopleInGroups.Contains( r.PersonAlias.PersonId ) );
}
bool preloadCampusValues = false;
var registrantAttributeIds = new List<int>();
var personAttributesIds = new List<int>();
var groupMemberAttributesIds = new List<int>();
if ( RegistrantFields != null )
{
// Check if campus is used
preloadCampusValues = RegistrantFields
.Any( f =>
f.FieldSource == RegistrationFieldSource.PersonField &&
f.PersonFieldType.HasValue &&
f.PersonFieldType.Value == RegistrationPersonFieldType.Campus );
// Get all the registrant attributes selected
var registrantAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.RegistrationAttribute )
.Select( f => f.Attribute )
.ToList();
registrantAttributeIds = registrantAttributes.Select( a => a.Id ).Distinct().ToList();
// Get all the person attributes selected
var personAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.PersonAttribute )
.Select( f => f.Attribute )
.ToList();
personAttributesIds = personAttributes.Select( a => a.Id ).Distinct().ToList();
// Get all the group member attributes selected to be on grid
var groupMemberAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.GroupMemberAttribute )
.Select( f => f.Attribute )
.ToList();
groupMemberAttributesIds = groupMemberAttributes.Select( a => a.Id ).Distinct().ToList();
}
// Sort the query
IOrderedQueryable<RegistrationRegistrant> orderedQry = null;
SortProperty sortProperty = gGroupPlacements.SortProperty;
if ( sortProperty != null )
{
orderedQry = qry.Sort( sortProperty );
}
else
{
orderedQry = qry
.OrderBy( r => r.PersonAlias.Person.LastName )
.ThenBy( r => r.PersonAlias.Person.NickName );
}
// Set the grids LinqDataSource which will run query and set results for current page
gGroupPlacements.SetLinqDataSource<RegistrationRegistrant>( orderedQry );
if ( RegistrantFields != null )
{
// Get the query results for the current page
var currentPageRegistrants = gGroupPlacements.DataSource as List<RegistrationRegistrant>;
if ( currentPageRegistrants != null )
{
// Get all the registrant ids in current page of query results
var registrantIds = currentPageRegistrants
.Select( r => r.Id )
.Distinct()
.ToList();
// Get all the person ids in current page of query results
var personIds = currentPageRegistrants
.Select( r => r.PersonAlias.PersonId )
.Distinct()
.ToList();
// Get all the group member ids and the group id in current page of query results
var groupMemberIds = new List<int>();
GroupLinks = new Dictionary<int, string>();
foreach ( var groupMember in currentPageRegistrants
.Where( m =>
m.GroupMember != null &&
m.GroupMember.Group != null )
.Select( m => m.GroupMember ) )
{
groupMemberIds.Add( groupMember.Id );
GroupLinks.AddOrIgnore( groupMember.GroupId,
isExporting ? groupMember.Group.Name :
string.Format( "<a href='{0}'>{1}</a>",
LinkedPageUrl( "GroupDetailPage", new Dictionary<string, string> { { "GroupId", groupMember.GroupId.ToString() } } ),
groupMember.Group.Name ) );
}
// If the campus column was selected to be displayed on grid, preload all the people's
// campuses so that the databind does not need to query each row
if ( preloadCampusValues )
{
PersonCampusIds = new Dictionary<int, List<int>>();
Guid familyGroupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
foreach ( var personCampusList in new GroupMemberService( rockContext )
.Queryable().AsNoTracking()
.Where( m =>
m.Group.GroupType.Guid == familyGroupTypeGuid &&
personIds.Contains( m.PersonId ) )
.GroupBy( m => m.PersonId )
.Select( m => new
{
PersonId = m.Key,
CampusIds = m
.Where( g => g.Group.CampusId.HasValue )
.Select( g => g.Group.CampusId.Value )
.ToList()
} ) )
{
PersonCampusIds.Add( personCampusList.PersonId, personCampusList.CampusIds );
}
}
// If there are any attributes that were selected to be displayed, we're going
// to try and read all attribute values in one query and then put them into a
// custom grid ObjectList property so that the AttributeField columns don't need
// to do the LoadAttributes and querying of values for each row/column
if ( personAttributesIds.Any() || groupMemberAttributesIds.Any() || registrantAttributeIds.Any() )
{
// Query the attribute values for all rows and attributes
var attributeValues = new AttributeValueService( rockContext )
.Queryable( "Attribute" ).AsNoTracking()
.Where( v =>
v.EntityId.HasValue &&
(
(
personAttributesIds.Contains( v.AttributeId ) &&
personIds.Contains( v.EntityId.Value )
) ||
(
groupMemberAttributesIds.Contains( v.AttributeId ) &&
groupMemberIds.Contains( v.EntityId.Value )
) ||
(
registrantAttributeIds.Contains( v.AttributeId ) &&
registrantIds.Contains( v.EntityId.Value )
)
)
)
.ToList();
// Get the attributes to add to each row's object
var attributes = new Dictionary<string, AttributeCache>();
RegistrantFields
.Where( f => f.Attribute != null )
.Select( f => f.Attribute )
.ToList()
.ForEach( a => attributes
.Add( a.Id.ToString() + a.Key, a ) );
// Initialize the grid's object list
gGroupPlacements.ObjectList = new Dictionary<string, object>();
// Loop through each of the current page's registrants and build an attribute
// field object for storing attributes and the values for each of the registrants
foreach ( var registrant in currentPageRegistrants )
{
// Create a row attribute object
var attributeFieldObject = new AttributeFieldObject();
// Add the attributes to the attribute object
attributeFieldObject.Attributes = attributes;
// Add any person attribute values to object
attributeValues
.Where( v =>
personAttributesIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.PersonAlias.PersonId )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, new AttributeValueCache( v ) ) );
// Add any group member attribute values to object
if ( registrant.GroupMemberId.HasValue )
{
attributeValues
.Where( v =>
groupMemberAttributesIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.GroupMemberId.Value )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, new AttributeValueCache( v ) ) );
}
// Add any registrant attribute values to object
attributeValues
.Where( v =>
registrantAttributeIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.Id )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, new AttributeValueCache( v ) ) );
// Add row attribute object to grid's object list
gGroupPlacements.ObjectList.Add( registrant.Id.ToString(), attributeFieldObject );
}
}
}
}
gGroupPlacements.DataBind();
}
}
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Load" /> event.
/// </summary>
/// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnLoad( EventArgs e )
{
if ( !Page.IsPostBack )
{
var rockContext = new RockContext();
OccurrenceId = PageParameter( "EventItemOccurrenceId" ).AsIntegerOrNull();
ContentChannels = new List<ContentChannel>();
ExpandedPanels = new List<int>();
if ( OccurrenceId.HasValue && OccurrenceId.Value != 0 )
{
var channels = new Dictionary<int, ContentChannel>();
var eventItemOccurrence = new EventItemOccurrenceService( rockContext ).Get( OccurrenceId.Value );
if ( eventItemOccurrence != null && eventItemOccurrence.EventItem != null && eventItemOccurrence.EventItem.EventCalendarItems != null )
{
eventItemOccurrence.EventItem.EventCalendarItems
.SelectMany( i => i.EventCalendar.ContentChannels )
.Select( c => c.ContentChannel )
.ToList()
.ForEach( c => channels.AddOrIgnore( c.Id, c ) );
ExpandedPanels = eventItemOccurrence.ContentChannelItems
.Where( i => i.ContentChannelItem != null )
.Select( i => i.ContentChannelItem.ContentChannelId )
.Distinct()
.ToList();
}
ContentChannels = channels.Select( c => c.Value ).ToList();
}
CreateGrids( rockContext );
BindGrids();
}
base.OnLoad( e );
}
/// <summary>
/// Processes the payments.
/// </summary>
/// <param name="gateway">The gateway.</param>
/// <param name="batchNamePrefix">The batch name prefix.</param>
/// <param name="payments">The payments.</param>
/// <param name="batchUrlFormat">The batch URL format.</param>
/// <returns></returns>
public static string ProcessPayments( FinancialGateway gateway, string batchNamePrefix, List<Payment> payments, string batchUrlFormat = "" )
{
int totalPayments = 0;
int totalAlreadyDownloaded = 0;
int totalNoScheduledTransaction = 0;
int totalAdded = 0;
var batches = new List<FinancialBatch>();
var batchSummary = new Dictionary<Guid, List<Payment>>();
var initialControlAmounts = new Dictionary<Guid, decimal>();
var allBatchChanges = new Dictionary<Guid, List<string>>();
var allTxnChanges = new Dictionary<Guid, List<string>>();
var txnPersonNames = new Dictionary<Guid, string>();
using ( var rockContext = new RockContext() )
{
var accountService = new FinancialAccountService( rockContext );
var txnService = new FinancialTransactionService( rockContext );
var batchService = new FinancialBatchService( rockContext );
var scheduledTxnService = new FinancialScheduledTransactionService( rockContext );
var contributionTxnType = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid() );
var defaultAccount = accountService.Queryable()
.Where( a =>
a.IsActive &&
!a.ParentAccountId.HasValue &&
( !a.StartDate.HasValue || a.StartDate.Value <= RockDateTime.Now ) &&
( !a.EndDate.HasValue || a.EndDate.Value >= RockDateTime.Now )
)
.OrderBy( a => a.Order )
.FirstOrDefault();
var batchTxnChanges = new Dictionary<Guid, List<string>>();
var batchBatchChanges = new Dictionary<Guid, List<string>>();
foreach ( var payment in payments.Where( p => p.Amount > 0.0M ) )
{
totalPayments++;
// Only consider transactions that have not already been added
if ( txnService.GetByTransactionCode( payment.TransactionCode ) == null )
{
var scheduledTransaction = scheduledTxnService.GetByScheduleId( payment.GatewayScheduleId );
if ( scheduledTransaction != null )
{
scheduledTransaction.IsActive = payment.ScheduleActive;
var txnChanges = new List<string>();
var transaction = new FinancialTransaction();
transaction.FinancialPaymentDetail = new FinancialPaymentDetail();
transaction.Guid = Guid.NewGuid();
allTxnChanges.Add( transaction.Guid, txnChanges );
txnChanges.Add( "Created Transaction (Downloaded from Gateway)" );
transaction.TransactionCode = payment.TransactionCode;
History.EvaluateChange( txnChanges, "Transaction Code", string.Empty, transaction.TransactionCode );
transaction.TransactionDateTime = payment.TransactionDateTime;
History.EvaluateChange( txnChanges, "Date/Time", null, transaction.TransactionDateTime );
transaction.ScheduledTransactionId = scheduledTransaction.Id;
transaction.AuthorizedPersonAliasId = scheduledTransaction.AuthorizedPersonAliasId;
History.EvaluateChange( txnChanges, "Person", string.Empty, scheduledTransaction.AuthorizedPersonAlias.Person.FullName );
txnPersonNames.Add( transaction.Guid, scheduledTransaction.AuthorizedPersonAlias.Person.FullName );
transaction.FinancialGatewayId = gateway.Id;
History.EvaluateChange( txnChanges, "Gateway", string.Empty, gateway.Name );
transaction.TransactionTypeValueId = contributionTxnType.Id;
History.EvaluateChange( txnChanges, "Type", string.Empty, contributionTxnType.Value );
var currencyTypeValue = payment.CurrencyTypeValue;
var creditCardTypevalue = payment.CreditCardTypeValue;
if ( scheduledTransaction.FinancialPaymentDetail != null )
{
if ( currencyTypeValue == null && scheduledTransaction.FinancialPaymentDetail.CurrencyTypeValueId.HasValue )
{
currencyTypeValue = DefinedValueCache.Read( scheduledTransaction.FinancialPaymentDetail.CurrencyTypeValueId.Value );
}
if ( creditCardTypevalue == null && scheduledTransaction.FinancialPaymentDetail.CreditCardTypeValueId.HasValue )
{
creditCardTypevalue = DefinedValueCache.Read( scheduledTransaction.FinancialPaymentDetail.CreditCardTypeValueId.Value );
}
transaction.FinancialPaymentDetail.AccountNumberMasked = scheduledTransaction.FinancialPaymentDetail.AccountNumberMasked;
transaction.FinancialPaymentDetail.NameOnCardEncrypted = scheduledTransaction.FinancialPaymentDetail.NameOnCardEncrypted;
transaction.FinancialPaymentDetail.ExpirationMonthEncrypted = scheduledTransaction.FinancialPaymentDetail.ExpirationMonthEncrypted;
transaction.FinancialPaymentDetail.ExpirationYearEncrypted = scheduledTransaction.FinancialPaymentDetail.ExpirationYearEncrypted;
}
if ( currencyTypeValue != null )
{
transaction.FinancialPaymentDetail.CurrencyTypeValueId = currencyTypeValue.Id;
History.EvaluateChange( txnChanges, "Currency Type", string.Empty, currencyTypeValue.Value );
}
if ( creditCardTypevalue != null )
{
transaction.FinancialPaymentDetail.CreditCardTypeValueId = creditCardTypevalue.Id;
History.EvaluateChange( txnChanges, "Credit Card Type", string.Empty, creditCardTypevalue.Value );
}
//transaction.SourceTypeValueId = DefinedValueCache.Read( sourceGuid ).Id;
// Try to allocate the amount of the transaction based on the current scheduled transaction accounts
decimal remainingAmount = payment.Amount;
foreach ( var detail in scheduledTransaction.ScheduledTransactionDetails.Where( d => d.Amount != 0.0M ) )
{
var transactionDetail = new FinancialTransactionDetail();
transactionDetail.AccountId = detail.AccountId;
if ( detail.Amount <= remainingAmount )
{
// If the configured amount for this account is less than or equal to the remaining
// amount, allocate the configured amount
transactionDetail.Amount = detail.Amount;
remainingAmount -= detail.Amount;
}
else
{
// If the configured amount is greater than the remaining amount, only allocate
// the remaining amount
transaction.Summary = "Note: Downloaded transaction amount was less than the configured allocation amounts for the Scheduled Transaction.";
detail.Amount = remainingAmount;
detail.Summary = "Note: The downloaded amount was not enough to apply the configured amount to this account.";
remainingAmount = 0.0M;
}
transaction.TransactionDetails.Add( transactionDetail );
History.EvaluateChange( txnChanges, detail.Account.Name, 0.0M.ToString( "C2" ), transactionDetail.Amount.ToString( "C2" ) );
History.EvaluateChange( txnChanges, "Summary", string.Empty, transactionDetail.Summary );
if ( remainingAmount <= 0.0M )
{
// If there's no amount left, break out of details
break;
}
}
// If there's still amount left after allocating based on current config, add the remainder
// to the account that was configured for the most amount
if ( remainingAmount > 0.0M )
{
transaction.Summary = "Note: Downloaded transaction amount was greater than the configured allocation amounts for the Scheduled Transaction.";
var transactionDetail = transaction.TransactionDetails
.OrderByDescending( d => d.Amount )
.First();
if ( transactionDetail == null && defaultAccount != null )
{
transactionDetail = new FinancialTransactionDetail();
transactionDetail.AccountId = defaultAccount.Id;
}
if ( transactionDetail != null )
{
transactionDetail.Amount += remainingAmount;
transactionDetail.Summary = "Note: Extra amount was applied to this account.";
}
History.EvaluateChange( txnChanges, defaultAccount.Name, 0.0M.ToString( "C2" ), transactionDetail.Amount.ToString( "C2" ) );
History.EvaluateChange( txnChanges, "Summary", string.Empty, transactionDetail.Summary );
}
// Get the batch
var batch = batchService.Get(
batchNamePrefix,
currencyTypeValue,
creditCardTypevalue,
transaction.TransactionDateTime.Value,
gateway.GetBatchTimeOffset(),
batches );
var batchChanges = new List<string>();
if ( batch.Id != 0 )
{
initialControlAmounts.AddOrIgnore( batch.Guid, batch.ControlAmount );
}
batch.ControlAmount += transaction.TotalAmount;
batch.Transactions.Add( transaction );
// Add summary
if ( !batchSummary.ContainsKey( batch.Guid ) )
{
batchSummary.Add( batch.Guid, new List<Payment>() );
}
batchSummary[batch.Guid].Add( payment );
totalAdded++;
}
else
{
totalNoScheduledTransaction++;
}
}
else
{
totalAlreadyDownloaded++;
}
}
foreach ( var batch in batches )
{
var batchChanges = new List<string>();
allBatchChanges.Add( batch.Guid, batchChanges );
if ( batch.Id == 0 )
{
batchChanges.Add( "Generated the batch" );
History.EvaluateChange( batchChanges, "Batch Name", string.Empty, batch.Name );
History.EvaluateChange( batchChanges, "Status", null, batch.Status );
History.EvaluateChange( batchChanges, "Start Date/Time", null, batch.BatchStartDateTime );
History.EvaluateChange( batchChanges, "End Date/Time", null, batch.BatchEndDateTime );
}
if ( initialControlAmounts.ContainsKey( batch.Guid ) )
{
History.EvaluateChange( batchChanges, "Control Amount", initialControlAmounts[batch.Guid].ToString( "C2" ), batch.ControlAmount.ToString( "C2" ) );
}
}
rockContext.WrapTransaction( () =>
{
rockContext.SaveChanges();
foreach ( var batch in batches )
{
HistoryService.SaveChanges(
rockContext,
typeof( FinancialBatch ),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_BATCH.AsGuid(),
batch.Id,
allBatchChanges[batch.Guid]
);
foreach ( var transaction in batch.Transactions )
{
if ( allTxnChanges.ContainsKey( transaction.Guid ) )
{
HistoryService.SaveChanges(
rockContext,
typeof( FinancialBatch ),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(),
batch.Id,
allTxnChanges[transaction.Guid],
txnPersonNames[transaction.Guid],
typeof( FinancialTransaction ),
transaction.Id
);
}
}
}
rockContext.SaveChanges();
} );
}
StringBuilder sb = new StringBuilder();
sb.AppendFormat( "<li>{0} {1} downloaded.</li>", totalPayments.ToString( "N0" ),
( totalPayments == 1 ? "payment" : "payments" ) );
if ( totalAlreadyDownloaded > 0 )
{
sb.AppendFormat( "<li>{0} {1} previously downloaded and {2} already been added.</li>", totalAlreadyDownloaded.ToString( "N0" ),
( totalAlreadyDownloaded == 1 ? "payment was" : "payments were" ),
( totalAlreadyDownloaded == 1 ? "has" : "have" ) );
}
if ( totalNoScheduledTransaction > 0 )
{
sb.AppendFormat( "<li>{0} {1} could not be matched to an existing scheduled payment profile.</li>", totalNoScheduledTransaction.ToString( "N0" ),
( totalNoScheduledTransaction == 1 ? "payment" : "payments" ) );
}
sb.AppendFormat( "<li>{0} {1} successfully added.</li>", totalAdded.ToString( "N0" ),
( totalAdded == 1 ? "payment was" : "payments were" ) );
foreach ( var batchItem in batchSummary )
{
int items = batchItem.Value.Count;
if (items > 0)
{
var batch = batches
.Where( b => b.Guid.Equals( batchItem.Key ) )
.FirstOrDefault();
string batchName = string.Format("'{0} ({1})'", batch.Name, batch.BatchStartDateTime.Value.ToString("d"));
if ( !string.IsNullOrWhiteSpace( batchUrlFormat ) )
{
batchName = string.Format( "<a href='{0}'>{1}</a>", string.Format( batchUrlFormat, batch.Id ), batchName );
}
decimal sum = batchItem.Value.Select( p => p.Amount ).Sum();
string summaryformat = items == 1 ?
"<li>{0} transaction of {1} was added to the {2} batch.</li>" :
"<li>{0} transactions totaling {1} were added to the {2} batch</li>";
sb.AppendFormat( summaryformat, items.ToString( "N0" ), sum.ToString( "C2" ), batchName );
}
}
return sb.ToString();
}
/// <summary>
/// Handles the ApplyFilterClick event of the gfMetricValues 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 gfMetricValues_ApplyFilterClick( object sender, EventArgs e )
{
gfMetricValues.SaveUserPreference( "Date Range", drpDates.DelimitedValues );
gfMetricValues.SaveUserPreference( "Goal/Measure", ddlGoalMeasure.SelectedValue );
var metric = new MetricService( new RockContext() ).Get( hfMetricId.Value.AsInteger() );
var entityTypeEntityFilters = new Dictionary<int, int?>();
foreach ( var metricPartition in metric.MetricPartitions )
{
var metricPartitionEntityType = EntityTypeCache.Read( metricPartition.EntityTypeId ?? 0 );
var controlId = string.Format( "metricPartition{0}_entityTypeEditControl", metricPartition.Id );
Control entityTypeEditControl = phMetricValuePartitions.FindControl( controlId );
int? entityId;
if ( metricPartitionEntityType != null && metricPartitionEntityType.SingleValueFieldType != null && metricPartitionEntityType.SingleValueFieldType.Field is IEntityFieldType )
{
entityId = ( metricPartitionEntityType.SingleValueFieldType.Field as IEntityFieldType ).GetEditValueAsEntityId( entityTypeEditControl, new Dictionary<string, ConfigurationValue>() );
entityTypeEntityFilters.AddOrIgnore( metricPartitionEntityType.Id, entityId );
}
}
var entityTypeEntityUserPreferenceValue = entityTypeEntityFilters
.Select( a => new { EntityTypeId = a.Key, EntityId = a.Value } )
.Select( a => string.Format( "{0}|{1}", a.EntityTypeId, a.EntityId ) )
.ToList().AsDelimited( "," );
gfMetricValues.SaveUserPreference( this.EntityTypeEntityPreferenceKey, entityTypeEntityUserPreferenceValue );
BindGrid();
}
/// <summary>
/// Rebinds the connectors.
/// </summary>
/// <param name="connectionRequest">The connection request.</param>
/// <param name="campusId">The campus identifier.</param>
/// <param name="rockContext">The rock context.</param>
public void RebindGroupsAndConnectors( ConnectionRequest connectionRequest, RockContext rockContext )
{
int? currentGroupId = ddlPlacementGroup.SelectedValueAsInt();
int? currentConnectorId = ddlConnectorEdit.SelectedValueAsInt();
ddlPlacementGroup.Items.Clear();
ddlPlacementGroup.Items.Add( new ListItem( String.Empty, String.Empty ) );
ddlConnectorEdit.Items.Clear();
ddlConnectorEdit.Items.Add( new ListItem( String.Empty, String.Empty ) );
var connectors = new Dictionary<int, Person>();
if ( connectionRequest != null )
{
int? campusId = ddlCampus.SelectedValueAsInt();
// Set Group
if ( !currentGroupId.HasValue && connectionRequest.AssignedGroupId.HasValue )
{
currentGroupId = connectionRequest.AssignedGroupId.Value;
}
// Build list of groups
var groups = new List<Group>();
// First add any groups specifically configured for the opportunity
var opportunityGroupIds = connectionRequest.ConnectionOpportunity.ConnectionOpportunityGroups.Select( o => o.Id ).ToList();
if ( opportunityGroupIds.Any() )
{
groups = connectionRequest.ConnectionOpportunity.ConnectionOpportunityGroups
.Where( g =>
g.Group != null &&
g.Group.IsActive &&
( !campusId.HasValue || !g.Group.CampusId.HasValue || campusId.Value == g.Group.CampusId.Value ) )
.Select( g => g.Group )
.ToList();
}
// Then get any groups that are configured with 'all groups of type'
foreach ( var groupConfig in connectionRequest.ConnectionOpportunity.ConnectionOpportunityGroupConfigs )
{
if ( groupConfig.UseAllGroupsOfType )
{
var existingGroupIds = groups.Select( g => g.Id ).ToList();
groups.AddRange( new GroupService( new RockContext() )
.Queryable().AsNoTracking()
.Where( g =>
!existingGroupIds.Contains( g.Id ) &&
g.IsActive &&
g.GroupTypeId == groupConfig.GroupTypeId &&
( !campusId.HasValue || !g.CampusId.HasValue || campusId.Value == g.CampusId.Value ) )
.ToList() );
}
}
// Add the currently assigned group if it hasn't been added already
if ( connectionRequest.AssignedGroup != null &&
!groups.Any( g => g.Id == connectionRequest.AssignedGroup.Id ) )
{
groups.Add( connectionRequest.AssignedGroup );
}
foreach ( var g in groups.OrderBy( g => g.Name ) )
{
ddlPlacementGroup.Items.Add( new ListItem( String.Format( "{0} ({1})", g.Name, g.Campus != null ? g.Campus.Name : "No Campus" ), g.Id.ToString().ToUpper() ) );
}
ddlPlacementGroup.SetValue( currentGroupId );
// Set Connector
if ( !currentConnectorId.HasValue && connectionRequest.ConnectorPersonAlias != null )
{
currentConnectorId = connectionRequest.ConnectorPersonAlias.PersonId;
}
if ( connectionRequest.ConnectionOpportunity != null )
{
// Get the connectors from the connector groups
if ( connectionRequest.ConnectionOpportunity.ConnectionType != null )
{
connectionRequest.ConnectionOpportunity.ConnectionOpportunityConnectorGroups
.Where( g =>
( !campusId.HasValue || !g.CampusId.HasValue || g.CampusId.Value == campusId.Value ) )
.SelectMany( g => g.ConnectorGroup.Members )
.Where( m => m.GroupMemberStatus == GroupMemberStatus.Active )
.Select( m => m.Person )
.ToList()
.ForEach( p => connectors.AddOrIgnore( p.Id, p ) );
}
if ( !currentConnectorId.HasValue && campusId.HasValue )
{
currentConnectorId = connectionRequest.ConnectionOpportunity.GetDefaultConnectorPersonId( campusId.Value );
}
}
}
// Add the current person as possible connector
if ( CurrentPerson != null )
{
connectors.AddOrIgnore( CurrentPerson.Id, CurrentPerson );
}
// Make sure the current value is an option
if ( currentConnectorId.HasValue && !connectors.ContainsKey( currentConnectorId.Value ) )
{
var person = new PersonService( rockContext ).Get( currentConnectorId.Value );
if ( person != null )
{
connectors.AddOrIgnore( person.Id, person );
}
}
// Add connectors to dropdown list
connectors
.ToList()
.OrderBy( p => p.Value.LastName )
.ThenBy( p => p.Value.NickName )
.ToList()
.ForEach( c =>
ddlConnectorEdit.Items.Add( new ListItem( c.Value.FullName, c.Key.ToString() ) ) );
if ( currentConnectorId.HasValue )
{
ddlConnectorEdit.SetValue( currentConnectorId.Value );
}
RebindGroupRole( connectionRequest, rockContext );
}
/// <summary>
/// Creates the entity value lookups.
/// </summary>
/// <param name="metricID">The metric identifier.</param>
private void CreateEntityValueLookups( int? metricID )
{
Metric metric = new MetricService( new RockContext() ).Get( metricID ?? 0 );
if ( metric != null )
{
var rockContext = new RockContext();
_entityTypeEntityNameLookup = new Dictionary<int, Dictionary<int, string>>();
_entityTypeEntityLookupQry = new Dictionary<int, IQueryable<IEntity>>();
foreach ( var metricPartition in metric.MetricPartitions.Where( a => a.EntityTypeId.HasValue ) )
{
var entityTypeCache = EntityTypeCache.Read( metricPartition.EntityTypeId ?? 0 );
_entityTypeEntityNameLookup.AddOrIgnore( entityTypeCache.Id, new Dictionary<int, string>() );
_entityTypeEntityLookupQry.AddOrIgnore( entityTypeCache.Id, null );
if ( entityTypeCache != null )
{
if ( entityTypeCache.GetEntityType() == typeof( Rock.Model.Group ) )
{
_entityTypeEntityLookupQry[entityTypeCache.Id] = new GroupService( rockContext ).Queryable();
}
else
{
Type[] modelType = { entityTypeCache.GetEntityType() };
Type genericServiceType = typeof( Rock.Data.Service<> );
Type modelServiceType = genericServiceType.MakeGenericType( modelType );
var serviceInstance = Activator.CreateInstance( modelServiceType, new object[] { rockContext } ) as IService;
MethodInfo qryMethod = serviceInstance.GetType().GetMethod( "Queryable", new Type[] { } );
_entityTypeEntityLookupQry[entityTypeCache.Id] = qryMethod.Invoke( serviceInstance, new object[] { } ) as IQueryable<IEntity>;
}
}
}
}
}
private void RebindGroupStatus( ConnectionRequest connectionRequest, RockContext rockContext )
{
int? groupId = null;
int? roleId = null;
GroupMemberStatus? currentStatus = ddlPlacementGroupStatus.SelectedValueAsEnumOrNull<GroupMemberStatus>();
ddlPlacementGroupStatus.SelectedValue = null;
ddlPlacementGroupStatus.Items.Clear();
if ( connectionRequest != null )
{
if ( !currentStatus.HasValue && connectionRequest.AssignedGroupMemberStatus.HasValue )
{
currentStatus = connectionRequest.AssignedGroupMemberStatus.Value;
}
var statuses = new Dictionary<int, string>();
groupId = ddlPlacementGroup.SelectedValueAsInt();
roleId = ddlPlacementGroupRole.SelectedValueAsInt();
if ( groupId.HasValue && roleId.HasValue )
{
var group = new GroupService( rockContext ).Get( groupId.Value );
if ( group != null )
{
foreach ( var groupConfig in new ConnectionOpportunityGroupConfigService( rockContext )
.Queryable().AsNoTracking()
.Where( c =>
c.ConnectionOpportunityId == connectionRequest.ConnectionOpportunityId &&
c.GroupTypeId == group.GroupTypeId &&
c.GroupMemberRoleId == roleId.Value ) )
{
statuses.AddOrIgnore( groupConfig.GroupMemberStatus.ConvertToInt(), groupConfig.GroupMemberStatus.ConvertToString() );
}
}
}
foreach ( var statusItem in statuses )
{
var listItem = new ListItem( statusItem.Value, statusItem.Key.ToString() );
listItem.Selected = currentStatus.HasValue && currentStatus.Value.ConvertToInt() == statusItem.Key;
ddlPlacementGroupStatus.Items.Add( listItem );
}
ddlPlacementGroupStatus.Visible = ddlPlacementGroupStatus.Items.Count > 1;
}
CheckGroupRequirement();
BuildGroupMemberAttributes( groupId, roleId, ddlPlacementGroupStatus.SelectedValueAsEnumOrNull<GroupMemberStatus>(), true );
}
/// <summary>
/// Binds the filter.
/// </summary>
protected void BindFilter()
{
string dateRangePreference = rFilter.GetUserPreference( MakeKeyUniqueToGroup( "Date Range" ) );
if ( string.IsNullOrWhiteSpace( dateRangePreference ) )
{
// set the dateRangePreference to force rFilter_DisplayFilterValue to show our default three month limit
dateRangePreference = ",";
rFilter.SaveUserPreference( MakeKeyUniqueToGroup( "Date Range" ), "Date Range", dateRangePreference );
}
var dateRange = DateRangePicker.CalculateDateRangeFromDelimitedValues( dateRangePreference );
// if there is no start date, default to three months ago to minimize the chance of loading too much data
drpDates.LowerValue = dateRange.Start ?? RockDateTime.Today.AddMonths( -3 );
drpDates.UpperValue = dateRange.End;
if ( _group != null )
{
var grouplocations = _group.GroupLocations
.Where( l =>
l.Location.Name != null &&
l.Location.Name != string.Empty )
.ToList();
var locations = new Dictionary<string, string> { { string.Empty, string.Empty } };
var locationService = new LocationService( _rockContext );
foreach ( var location in grouplocations.Select( l => l.Location ) )
{
if ( !locations.ContainsKey( location.Id.ToString() ) )
{
locations.Add( location.Id.ToString(), locationService.GetPath( location.Id ) );
}
var parentLocation = location.ParentLocation;
while ( parentLocation != null )
{
string key = string.Format( "P{0}", parentLocation.Id );
if ( !locations.ContainsKey( key ) )
{
locations.Add( key, locationService.GetPath( parentLocation.Id ) );
}
parentLocation = parentLocation.ParentLocation;
}
}
if ( locations.Any() )
{
ddlLocation.Visible = true;
gOccurrences.Columns[2].Visible = true;
ddlLocation.DataSource = locations.OrderBy( l => l.Value );
ddlLocation.DataBind();
ddlLocation.SetValue( rFilter.GetUserPreference( MakeKeyUniqueToGroup( "Location" ) ) );
}
else
{
ddlLocation.Visible = false;
gOccurrences.Columns[2].Visible = false;
}
var schedules = new Dictionary<int, string> { { 0, string.Empty } };
grouplocations.SelectMany( l => l.Schedules ).OrderBy( s => s.Name ).ToList()
.ForEach( s => schedules.AddOrIgnore( s.Id, s.Name ) );
if ( schedules.Any() )
{
ddlSchedule.Visible = true;
gOccurrences.Columns[1].Visible = true;
ddlSchedule.DataSource = schedules;
ddlSchedule.DataBind();
ddlSchedule.SetValue( rFilter.GetUserPreference( MakeKeyUniqueToGroup( "Schedule" ) ) );
}
else
{
ddlSchedule.Visible = false;
gOccurrences.Columns[1].Visible = false;
}
}
}
/// <summary>
/// Handles the Click event of the lbPrintAttendanceRoster 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 lbPrintAttendanceRoster_Click( object sender, EventArgs e )
{
// NOTE: lbPrintAttendanceRoster is a full postback since we are returning a download of the roster
nbPrintRosterWarning.Visible = false;
var rockContext = new RockContext();
Dictionary<int, object> mergeObjectsDictionary = new Dictionary<int, object>();
if ( _attendees != null )
{
var personIdList = _attendees.Select( a => a.PersonId ).ToList();
var personList = new PersonService( rockContext ).GetByIds( personIdList );
foreach ( var person in personList.OrderBy( a => a.LastName ).ThenBy( a => a.NickName ) )
{
mergeObjectsDictionary.AddOrIgnore( person.Id, person );
}
}
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields( this.RockPage, this.CurrentPerson );
mergeFields.Add( "Group", this._group );
var mergeTemplate = new MergeTemplateService( rockContext ).Get( this.GetAttributeValue( "AttendanceRosterTemplate" ).AsGuid() );
if ( mergeTemplate == null )
{
this.LogException( new Exception( "No Merge Template specified in block settings" ) );
nbPrintRosterWarning.Visible = true;
nbPrintRosterWarning.Text = "Unable to print Attendance Roster";
return;
}
MergeTemplateType mergeTemplateType = mergeTemplate.GetMergeTemplateType();
if ( mergeTemplateType == null )
{
this.LogException( new Exception( "Unable to determine Merge Template Type" ) );
nbPrintRosterWarning.Visible = true;
nbPrintRosterWarning.Text = "Error printing Attendance Roster";
return;
}
BinaryFile outputBinaryFileDoc = null;
var mergeObjectList = mergeObjectsDictionary.Select( a => a.Value ).ToList();
outputBinaryFileDoc = mergeTemplateType.CreateDocument( mergeTemplate, mergeObjectList, mergeFields );
// set the name of the output doc
outputBinaryFileDoc = new BinaryFileService( rockContext ).Get( outputBinaryFileDoc.Id );
outputBinaryFileDoc.FileName = _group.Name + " Attendance Roster" + Path.GetExtension( outputBinaryFileDoc.FileName ?? "" ) ?? ".docx";
rockContext.SaveChanges();
if ( mergeTemplateType.Exceptions != null && mergeTemplateType.Exceptions.Any() )
{
if ( mergeTemplateType.Exceptions.Count == 1 )
{
this.LogException( mergeTemplateType.Exceptions[0] );
}
else if ( mergeTemplateType.Exceptions.Count > 50 )
{
this.LogException( new AggregateException( string.Format( "Exceptions merging template {0}. See InnerExceptions for top 50.", mergeTemplate.Name ), mergeTemplateType.Exceptions.Take( 50 ).ToList() ) );
}
else
{
this.LogException( new AggregateException( string.Format( "Exceptions merging template {0}. See InnerExceptions", mergeTemplate.Name ), mergeTemplateType.Exceptions.ToList() ) );
}
}
var uri = new UriBuilder( outputBinaryFileDoc.Url );
var qry = System.Web.HttpUtility.ParseQueryString( uri.Query );
qry["attachment"] = true.ToTrueFalse();
uri.Query = qry.ToString();
Response.Redirect( uri.ToString(), false );
Context.ApplicationInstance.CompleteRequest();
}
/// <summary>
/// Gets the merge object list for the current EntitySet
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="fetchCount">The fetch count.</param>
/// <returns></returns>
private List<object> GetMergeObjectList( RockContext rockContext, int? fetchCount = null )
{
int entitySetId = hfEntitySetId.Value.AsInteger();
var entitySetService = new EntitySetService( rockContext );
var entitySet = entitySetService.Get( entitySetId );
Dictionary<int, object> mergeObjectsDictionary = new Dictionary<int, object>();
// If this EntitySet contains IEntity Items, add those first
if ( entitySet.EntityTypeId.HasValue )
{
var qryEntity = entitySetService.GetEntityQuery( entitySetId );
if ( fetchCount.HasValue )
{
qryEntity = qryEntity.Take( fetchCount.Value );
}
var entityTypeCache = EntityTypeCache.Read( entitySet.EntityTypeId.Value );
bool isPersonEntityType = entityTypeCache != null && entityTypeCache.Guid == Rock.SystemGuid.EntityType.PERSON.AsGuid();
bool isGroupMemberEntityType = entityTypeCache != null && entityTypeCache.Guid == Rock.SystemGuid.EntityType.GROUP_MEMBER.AsGuid();
bool combineFamilyMembers = cbCombineFamilyMembers.Visible && cbCombineFamilyMembers.Checked;
if ( ( isGroupMemberEntityType || isPersonEntityType ) && combineFamilyMembers )
{
IQueryable<IEntity> qryPersons;
if ( isGroupMemberEntityType )
{
qryPersons = qryEntity.OfType<GroupMember>().Select( a => a.Person ).Distinct();
}
else
{
qryPersons = qryEntity;
}
Guid familyGroupType = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
var qryFamilyGroupMembers = new GroupMemberService( rockContext ).Queryable()
.Where( a => a.Group.GroupType.Guid == familyGroupType )
.Where( a => qryPersons.Any( aa => aa.Id == a.PersonId ) );
var qryCombined = qryFamilyGroupMembers.Join(
qryPersons,
m => m.PersonId,
p => p.Id,
( m, p ) => new { GroupMember = m, Person = p } )
.GroupBy( a => a.GroupMember.GroupId )
.Select( x => new
{
GroupId = x.Key,
Persons = x.Select( xx => xx.Person ).Distinct()
} );
foreach ( var combinedFamilyItem in qryCombined )
{
object mergeObject;
string commaPersonIds = combinedFamilyItem.Persons.Select( a => a.Id ).Distinct().ToList().AsDelimited( "," );
var primaryGroupPerson = combinedFamilyItem.Persons.FirstOrDefault() as Person;
if ( mergeObjectsDictionary.ContainsKey( primaryGroupPerson.Id ) )
{
foreach ( var person in combinedFamilyItem.Persons )
{
if ( !mergeObjectsDictionary.ContainsKey( person.Id ) )
{
primaryGroupPerson = person as Person;
break;
}
}
}
// if we are combining from a GroupMemberEntityType list add the GroupMember attributes of the primary person in the combined list
if ( isGroupMemberEntityType )
{
var groupMember = qryEntity.OfType<GroupMember>().Where( a => a.PersonId == primaryGroupPerson.Id ).FirstOrDefault();
primaryGroupPerson.AdditionalLavaFields = primaryGroupPerson.AdditionalLavaFields ?? new Dictionary<string, object>();
if ( groupMember != null )
{
primaryGroupPerson.AdditionalLavaFields.Add( "GroupMember", groupMember );
}
}
if ( combinedFamilyItem.Persons.Count() > 1 )
{
var combinedPerson = primaryGroupPerson.ToJson().FromJsonOrNull<MergeTemplateCombinedPerson>();
var familyTitle = RockUdfHelper.ufnCrm_GetFamilyTitle( rockContext, null, combinedFamilyItem.GroupId, commaPersonIds, true );
combinedPerson.FullName = familyTitle;
var firstNameList = combinedFamilyItem.Persons.Select( a => ( a as Person ).FirstName ).ToList();
var nickNameList = combinedFamilyItem.Persons.Select( a => ( a as Person ).NickName ).ToList();
combinedPerson.FirstName = firstNameList.AsDelimited( ", ", " & " );
combinedPerson.NickName = nickNameList.AsDelimited( ", ", " & " );
combinedPerson.LastName = primaryGroupPerson.LastName;
combinedPerson.SuffixValueId = null;
combinedPerson.SuffixValue = null;
mergeObject = combinedPerson;
}
else
{
mergeObject = primaryGroupPerson;
}
mergeObjectsDictionary.AddOrIgnore( primaryGroupPerson.Id, mergeObject );
}
}
else if ( isGroupMemberEntityType )
{
foreach ( var groupMember in qryEntity.AsNoTracking().OfType<GroupMember>() )
{
var person = groupMember.Person;
person.AdditionalLavaFields = new Dictionary<string, object>();
person.AdditionalLavaFields.Add( "GroupMember", groupMember );
mergeObjectsDictionary.AddOrIgnore( groupMember.PersonId, person );
}
}
else
{
foreach ( var item in qryEntity.AsNoTracking() )
{
mergeObjectsDictionary.AddOrIgnore( item.Id, item );
}
}
}
var entitySetItemService = new EntitySetItemService( rockContext );
string[] emptyJson = new string[] { string.Empty, "{}" };
var entitySetItemMergeValuesQry = entitySetItemService.GetByEntitySetId( entitySetId, true ).Where( a => !emptyJson.Contains( a.AdditionalMergeValuesJson ) );
if ( fetchCount.HasValue )
{
entitySetItemMergeValuesQry = entitySetItemMergeValuesQry.Take( fetchCount.Value );
}
// the entityId to use for NonEntity objects
int nonEntityId = 1;
// now, add the additional MergeValues regardless of if the EntitySet contains IEntity items or just Non-IEntity items
foreach ( var additionalMergeValuesItem in entitySetItemMergeValuesQry.AsNoTracking() )
{
object mergeObject;
int entityId;
if ( additionalMergeValuesItem.EntityId > 0 )
{
entityId = additionalMergeValuesItem.EntityId;
}
else
{
// not pointing to an actual EntityId, so use the nonEntityId for ti
entityId = nonEntityId++;
}
if ( mergeObjectsDictionary.ContainsKey( entityId ) )
{
mergeObject = mergeObjectsDictionary[entityId];
}
else
{
if ( entitySet.EntityTypeId.HasValue )
{
// if already have real entities in our list, don't add additional items to the mergeObjectsDictionary
continue;
}
// non-Entity merge object, so just use Dictionary
mergeObject = new Dictionary<string, object>();
mergeObjectsDictionary.AddOrIgnore( entityId, mergeObject );
}
foreach ( var additionalMergeValue in additionalMergeValuesItem.AdditionalMergeValues )
{
if ( mergeObject is IEntity )
{
// add the additional fields to AdditionalLavaFields
IEntity mergeEntity = ( mergeObject as IEntity );
mergeEntity.AdditionalLavaFields = mergeEntity.AdditionalLavaFields ?? new Dictionary<string, object>();
object mergeValueObject = additionalMergeValue.Value;
mergeEntity.AdditionalLavaFields.AddOrIgnore( additionalMergeValue.Key, mergeValueObject );
}
else if ( mergeObject is IDictionary<string, object> )
{
// anonymous object with no fields yet
IDictionary<string, object> nonEntityObject = mergeObject as IDictionary<string, object>;
nonEntityObject.AddOrIgnore( additionalMergeValue.Key, additionalMergeValue.Value );
}
else
{
throw new Exception( string.Format( "Unexpected MergeObject Type: {0}", mergeObject ) );
}
}
}
var result = mergeObjectsDictionary.Select( a => a.Value );
if ( fetchCount.HasValue )
{
// make sure the result is limited to fetchCount (even though the above queries are also limited to fetch count)
result = result.Take( fetchCount.Value );
}
return result.ToList();
}
/// <summary>
/// Gets the suggestions.
/// </summary>
/// <param name="followingSuggestionType">Type of the following suggestion.</param>
/// <param name="followerPersonIds">The follower person ids.</param>
/// <returns></returns>
public override List<PersonEntitySuggestion> GetSuggestions( FollowingSuggestionType followingSuggestionType, List<int> followerPersonIds )
{
var suggestions = new List<PersonEntitySuggestion>();
var personAliasEntityType = EntityTypeCache.Read( typeof( Rock.Model.PersonAlias ) );
bool isAutoFollow = GetAttributeValue( followingSuggestionType, "AutoFollow" ).AsBoolean();
// Get the grouptype guid
Guid? groupTypeGuid = GetAttributeValue( followingSuggestionType, "GroupType" ).AsGuidOrNull();
if ( groupTypeGuid.HasValue )
{
using ( var rockContext = new RockContext() )
{
var groupMemberService = new GroupMemberService( rockContext );
var personAliasService = new PersonAliasService( rockContext );
// Get all the groupmember records for any follower and the selected group type
var followers = groupMemberService.Queryable().AsNoTracking()
.Where( m =>
m.GroupMemberStatus == GroupMemberStatus.Active &&
m.Group != null &&
m.Group.IsActive &&
m.Group.GroupType.Guid.Equals( groupTypeGuid.Value ) &&
followerPersonIds.Contains( m.PersonId ) );
// If a specific group or security role was specifed, limit groupmembers to only those of the selected group
Guid? groupGuid = GetAttributeValue( followingSuggestionType, "Group" ).AsGuidOrNull();
if ( !groupGuid.HasValue )
{
groupGuid = GetAttributeValue( followingSuggestionType, "SecurityRole" ).AsGuidOrNull();
}
if ( groupGuid.HasValue )
{
followers = followers.Where( m => m.Group.Guid.Equals( groupGuid.Value ) );
}
// If a specific role for the follower was specified, limit groupmembers to only those with the selected role
Guid? followerRoleGuid = GetAttributeValue( followingSuggestionType, "FollowerGroupType" ).AsGuidOrNull();
if ( followerRoleGuid.HasValue )
{
followers = followers.Where( m => m.GroupRole.Guid.Equals( followerRoleGuid.Value ) );
}
// Run the query to get all the groups that follower is a member of with selected filters
var followerPersonGroup = followers
.Select( f => new
{
f.PersonId,
f.GroupId
} )
.ToList();
// Get a unique list of any of the groups that followers belong to
var followedGroupIds = followerPersonGroup
.Select( f => f.GroupId )
.Distinct()
.ToList();
// Start building query to get the people to follow from any group that contains a follower
var followed = groupMemberService
.Queryable().AsNoTracking()
.Where( m => followedGroupIds.Contains( m.GroupId ) );
// If a specific role for the people being followed was specified, limit the query to only those with the selected role
Guid? followedRoleGuid = GetAttributeValue( followingSuggestionType, "FollowedGroupType" ).AsGuidOrNull();
if ( followedRoleGuid.HasValue )
{
followed = followed.Where( m => m.GroupRole.Guid.Equals( followedRoleGuid.Value ) );
}
// Get all the people in any of the groups that contain a follower
var followedPersonGroup = followed
.Select( f => new
{
f.PersonId,
f.GroupId
} )
.ToList();
// Get distinct list of people
var followedPersonIds = followedPersonGroup
.Select( f => f.PersonId )
.Distinct()
.ToList();
// Build a dictionary of the personid->personaliasid
var personAliasIds = new Dictionary<int, int>();
personAliasService.Queryable().AsNoTracking()
.Where( a =>
followedPersonIds.Contains( a.PersonId ) &&
a.PersonId == a.AliasPersonId )
.ToList()
.ForEach( a => personAliasIds.AddOrIgnore( a.PersonId, a.Id ) );
// Loop through each follower/group combination
foreach ( var followedGroup in followerPersonGroup )
{
// Loop through the other people in that group
foreach ( int followedPersonId in followedPersonGroup
.Where( f =>
f.GroupId == followedGroup.GroupId &&
f.PersonId != followedGroup.PersonId )
.Select( f => f.PersonId ) )
{
// If the person has a valid personalias id
if ( personAliasIds.ContainsKey( followedPersonId ) )
{
if ( !isAutoFollow )
{
// add them to the list of suggestions
suggestions.Add( new PersonEntitySuggestion( followedGroup.PersonId, personAliasIds[followedPersonId] ) );
}
else
{
// auto-add the follow
var followingService = new FollowingService( rockContext );
int followerPersonAliasId = personAliasIds[followedGroup.PersonId];
int followeePersonAliasId = personAliasIds[followedPersonId];
// if person is not already following the person
bool isFollowing = followingService.Queryable().Where( f =>
f.EntityTypeId == personAliasEntityType.Id
&& f.EntityId == followeePersonAliasId
&& f.PersonAliasId == followerPersonAliasId ).Any();
if ( !isFollowing )
{
var following = new Following();
following.EntityTypeId = personAliasEntityType.Id;
following.EntityId = personAliasIds[followedPersonId];
following.PersonAliasId = personAliasIds[followedGroup.PersonId];
followingService.Add( following );
rockContext.SaveChanges();
}
}
}
}
}
}
}
return suggestions;
}
/// <summary>
/// Binds the grid.
/// </summary>
protected void BindGrid()
{
var rockContext = new RockContext();
var attendanceService = new AttendanceService( rockContext );
var qryAttendance = attendanceService.Queryable();
var personField = gHistory.Columns.OfType<PersonField>().FirstOrDefault();
if ( personField != null )
{
personField.Visible = _person == null;
}
var groupField = gHistory.Columns.OfType<RockBoundField>().FirstOrDefault( a => a.HeaderText == "Group" );
if ( groupField != null )
{
groupField.Visible = _group == null;
}
if ( _person != null )
{
qryAttendance = qryAttendance.Where( a => a.PersonAlias.PersonId == _person.Id );
if ( _group != null )
{
qryAttendance = qryAttendance.Where( a => a.GroupId == _group.Id );
}
else
{
int? groupId = ddlAttendanceGroup.SelectedValueAsInt();
if ( groupId.HasValue )
{
qryAttendance = qryAttendance.Where( a => a.GroupId == groupId.Value );
}
}
}
else
{
int? personId = ppPerson.SelectedValue;
if ( personId.HasValue )
{
qryAttendance = qryAttendance.Where( a => a.PersonAlias.PersonId == personId.Value );
}
}
// Filter by Date Range
if ( drpDates.LowerValue.HasValue )
{
qryAttendance = qryAttendance.Where( t => t.StartDateTime >= drpDates.LowerValue.Value );
}
if ( drpDates.UpperValue.HasValue )
{
DateTime upperDate = drpDates.UpperValue.Value.Date.AddDays( 1 );
qryAttendance = qryAttendance.Where( t => t.StartDateTime < upperDate );
}
// Filter by Schedule
int? scheduleId = spSchedule.SelectedValue.AsIntegerOrNull();
if ( scheduleId.HasValue && scheduleId.Value > 0 )
{
qryAttendance = qryAttendance.Where( h => h.ScheduleId == scheduleId.Value );
}
// Filter by DidAttend
int? didAttend = ddlDidAttend.SelectedValueAsInt( false );
if ( didAttend.HasValue )
{
if ( didAttend.Value == 1 )
{
qryAttendance = qryAttendance.Where( a => a.DidAttend == true );
}
else
{
qryAttendance = qryAttendance.Where( a => a.DidAttend == false );
}
}
var qry = qryAttendance
.Select( a => new
{
LocationId = a.LocationId,
LocationName = a.Location.Name,
CampusId = a.CampusId,
CampusName = a.Campus.Name,
ScheduleName = a.Schedule.Name,
Person = a.PersonAlias.Person,
GroupName = a.Group.Name,
GroupTypeId = a.Group.GroupTypeId,
StartDateTime = a.StartDateTime,
EndDateTime = a.EndDateTime,
DidAttend = a.DidAttend
} );
SortProperty sortProperty = gHistory.SortProperty;
if ( sortProperty != null )
{
qry = qry.Sort( sortProperty );
}
else
{
qry = qry.OrderByDescending( p => p.StartDateTime );
}
// build a lookup for _groupTypePaths for OnRowDatabound
_groupTypePaths = new GroupTypeService( rockContext ).GetAllCheckinGroupTypePaths().ToList();
// build a lookup for _locationpaths for OnRowDatabound
_locationPaths = new Dictionary<int, string>();
var qryLocations = new LocationService( rockContext ).Queryable().Where( a => qry.Any( b => b.LocationId == a.Id ) );
foreach (var location in qryLocations)
{
var parentLocation = location.ParentLocation;
var locationNames = new List<string>();
while (parentLocation != null)
{
locationNames.Add( parentLocation.Name );
parentLocation = parentLocation.ParentLocation;
}
string locationPath = string.Empty;
if ( locationNames.Any() )
{
locationNames.Reverse();
locationPath = locationNames.AsDelimited( " > " );
}
_locationPaths.AddOrIgnore( location.Id, locationPath );
}
gHistory.EntityTypeId = EntityTypeCache.Read<Attendance>().Id;
gHistory.DataSource = qry.ToList();
gHistory.DataBind();
}
/// <summary>
/// Creates the fee field.
/// </summary>
/// <param name="fee">The fee.</param>
/// <param name="setValues">if set to <c>true</c> [set values].</param>
/// <param name="feeValues">The fee values.</param>
private void CreateFeeField( RegistrationTemplateFee fee, bool setValues, List<FeeInfo> feeValues )
{
if ( fee.FeeType == RegistrationFeeType.Single )
{
string label = fee.Name;
var cost = fee.CostValue.AsDecimalOrNull();
if ( cost.HasValue && cost.Value != 0.0M )
{
label = string.Format( "{0} ({1})", fee.Name, cost.Value.ToString("C2"));
}
if ( fee.AllowMultiple )
{
// Single Option, Multi Quantity
var numUpDown = new NumberUpDown();
numUpDown.ID = "fee_" + fee.Id.ToString();
numUpDown.Label = label;
numUpDown.Minimum = 0;
phFees.Controls.Add( numUpDown );
if ( setValues && feeValues != null && feeValues.Any() )
{
numUpDown.Value = feeValues.First().Quantity;
}
}
else
{
// Single Option, Single Quantity
var cb = new RockCheckBox();
cb.ID = "fee_" + fee.Id.ToString();
cb.Label = label;
cb.SelectedIconCssClass = "fa fa-check-square-o fa-lg";
cb.UnSelectedIconCssClass = "fa fa-square-o fa-lg";
phFees.Controls.Add( cb );
if ( setValues && feeValues != null && feeValues.Any() )
{
cb.Checked = feeValues.First().Quantity > 0;
}
}
}
else
{
// Parse the options to get name and cost for each
var options = new Dictionary<string, string>();
string[] nameValues = fee.CostValue.Split( new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries );
foreach ( string nameValue in nameValues )
{
string[] nameAndValue = nameValue.Split( new char[] { '^' }, StringSplitOptions.RemoveEmptyEntries );
if ( nameAndValue.Length == 1)
{
options.AddOrIgnore( nameAndValue[0], nameAndValue[0] );
}
if ( nameAndValue.Length == 2 )
{
options.AddOrIgnore( nameAndValue[0], string.Format( "{0} ({1:C2})", nameAndValue[0], nameAndValue[1].AsDecimal() ) );
}
}
if ( fee.AllowMultiple )
{
HtmlGenericControl feeAllowMultiple = new HtmlGenericControl( "div" );
phFees.Controls.Add( feeAllowMultiple );
feeAllowMultiple.AddCssClass( "feetype-allowmultiples" );
Label titleLabel = new Label();
feeAllowMultiple.Controls.Add( titleLabel );
titleLabel.CssClass = "control-label";
titleLabel.Text = fee.Name;
foreach( var optionKeyVal in options )
{
var numUpDown = new NumberUpDown();
numUpDown.ID = string.Format( "fee_{0}_{1}", fee.Id, optionKeyVal.Key );
numUpDown.Label = string.Format( "{0}", optionKeyVal.Value );
numUpDown.Minimum = 0;
numUpDown.CssClass = "fee-allowmultiple";
feeAllowMultiple.Controls.Add( numUpDown );
if ( setValues && feeValues != null && feeValues.Any() )
{
numUpDown.Value = feeValues
.Where( f => f.Option == optionKeyVal.Key )
.Select( f => f.Quantity )
.FirstOrDefault();
}
}
}
else
{
// Multi Option, Single Quantity
var ddl = new RockDropDownList();
ddl.ID = "fee_" + fee.Id.ToString();
ddl.AddCssClass( "input-width-md" );
ddl.Label = fee.Name;
ddl.DataValueField = "Key";
ddl.DataTextField = "Value";
ddl.DataSource = options;
ddl.DataBind();
ddl.Items.Insert( 0, "");
phFees.Controls.Add( ddl );
if ( setValues && feeValues != null && feeValues.Any() )
{
ddl.SetValue( feeValues
.Where( f => f.Quantity > 0 )
.Select( f => f.Option )
.FirstOrDefault() );
}
}
}
}
public void AddOrIgnoreTest()
{
var dic=new Dictionary<string, string>();
dic.AddOrIgnore("test","test");
Assert.AreEqual("test",dic["test"]);
dic.AddOrIgnore("test","Jonas");
Assert.AreEqual("test", dic["test"]);
Assert.AreNotEqual("Jonas", dic["test"]);
}
/// <summary>
/// Shows the edit details.
/// </summary>
/// <param name="registration">The group.</param>
private void ShowEditDetails( Registration registration )
{
SetCostLabels( registration );
SetEditMode( true );
if ( registration.PersonAlias != null )
{
ppPerson.SetValue( registration.PersonAlias.Person );
}
else
{
ppPerson.SetValue( null );
}
tbFirstName.Text = registration.FirstName;
tbLastName.Text = registration.LastName;
ebConfirmationEmail.Text = registration.ConfirmationEmail;
var discountCodes = new Dictionary<string, string>();
if ( RegistrationTemplateState != null )
{
foreach( var discount in RegistrationTemplateState.Discounts.OrderBy( d => d.Code ) )
{
discountCodes.AddOrIgnore( discount.Code, discount.Code + ( string.IsNullOrWhiteSpace( discount.DiscountString ) ? "" :
string.Format( " ({0})", discount.DiscountString ) ) );
}
}
if ( !string.IsNullOrWhiteSpace( registration.DiscountCode ))
{
discountCodes.AddOrIgnore( registration.DiscountCode, registration.DiscountCode );
}
ddlDiscountCode.DataSource = discountCodes;
ddlDiscountCode.DataBind();
ddlDiscountCode.Items.Insert( 0, new ListItem( "", "" ) );
ddlDiscountCode.SetValue( registration.DiscountCode );
nbDiscountPercentage.Text = registration.DiscountPercentage != 0.0m ? ( registration.DiscountPercentage * 100.0m ).ToString( "N0" ) : "";
cbDiscountAmount.Text = registration.DiscountAmount != 0.0m ? registration.DiscountAmount.ToString( "N2" ) : "";
RegistrantsState = null;
BuildRegistrationControls( true );
lbAddRegistrant.Visible = false;
}
/// <summary>
/// Binds the registrants grid.
/// </summary>
private void BindRegistrantsGrid()
{
int? instanceId = hfRegistrationInstanceId.Value.AsIntegerOrNull();
if ( instanceId.HasValue )
{
using ( var rockContext = new RockContext() )
{
// Start query for registrants
var qry = new RegistrationRegistrantService( rockContext )
.Queryable( "PersonAlias.Person.PhoneNumbers.NumberTypeValue,Fees.RegistrationTemplateFee,GroupMember.Group" ).AsNoTracking()
.Where( r =>
r.Registration.RegistrationInstanceId == instanceId.Value &&
r.PersonAlias != null &&
r.PersonAlias.Person != null );
// Filter by daterange
if ( drpRegistrantDateRange.LowerValue.HasValue )
{
qry = qry.Where( r =>
r.CreatedDateTime.HasValue &&
r.CreatedDateTime.Value >= drpRegistrantDateRange.LowerValue.Value );
}
if ( drpRegistrantDateRange.UpperValue.HasValue )
{
qry = qry.Where( r =>
r.CreatedDateTime.HasValue &&
r.CreatedDateTime.Value <= drpRegistrantDateRange.UpperValue.Value );
}
// Filter by first name
if ( !string.IsNullOrWhiteSpace( tbRegistrantFirstName.Text ) )
{
string rfname = tbRegistrantFirstName.Text;
qry = qry.Where( r =>
r.PersonAlias.Person.NickName.StartsWith( rfname ) ||
r.PersonAlias.Person.FirstName.StartsWith( rfname ) );
}
// Filter by last name
if ( !string.IsNullOrWhiteSpace( tbRegistrantLastName.Text ) )
{
string rlname = tbRegistrantLastName.Text;
qry = qry.Where( r =>
r.PersonAlias.Person.LastName.StartsWith( rlname ) );
}
bool preloadCampusValues = false;
var registrantAttributes = new List<AttributeCache>();
var personAttributes = new List<AttributeCache>();
var groupMemberAttributes = new List<AttributeCache>();
var registrantAttributeIds = new List<int>();
var personAttributesIds = new List<int>();
var groupMemberAttributesIds = new List<int>();
if ( RegistrantFields != null )
{
// Filter by any selected
foreach ( var personFieldType in RegistrantFields
.Where( f =>
f.FieldSource == RegistrationFieldSource.PersonField &&
f.PersonFieldType.HasValue )
.Select( f => f.PersonFieldType.Value ) )
{
switch ( personFieldType )
{
case RegistrationPersonFieldType.Campus:
{
preloadCampusValues = true;
var ddlCampus = phRegistrantFormFieldFilters.FindControl( "ddlCampus" ) as RockDropDownList;
if ( ddlCampus != null )
{
var campusId = ddlCampus.SelectedValue.AsIntegerOrNull();
if ( campusId.HasValue )
{
var familyGroupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
qry = qry.Where( r =>
r.PersonAlias.Person.Members.Any( m =>
m.Group.GroupType.Guid == familyGroupTypeGuid &&
m.Group.CampusId.HasValue &&
m.Group.CampusId.Value == campusId ) );
}
}
break;
}
case RegistrationPersonFieldType.Email:
{
var tbEmailFilter = phRegistrantFormFieldFilters.FindControl( "tbEmailFilter" ) as RockTextBox;
if ( tbEmailFilter != null && !string.IsNullOrWhiteSpace( tbEmailFilter.Text ) )
{
qry = qry.Where( r =>
r.PersonAlias.Person.Email != null &&
r.PersonAlias.Person.Email.Contains( tbEmailFilter.Text ) );
}
break;
}
case RegistrationPersonFieldType.Birthdate:
{
var drpBirthdateFilter = phRegistrantFormFieldFilters.FindControl( "drpBirthdateFilter" ) as DateRangePicker;
if ( drpBirthdateFilter != null )
{
if ( drpBirthdateFilter.LowerValue.HasValue )
{
qry = qry.Where( r =>
r.PersonAlias.Person.BirthDate.HasValue &&
r.PersonAlias.Person.BirthDate.Value >= drpBirthdateFilter.LowerValue.Value );
}
if ( drpBirthdateFilter.UpperValue.HasValue )
{
qry = qry.Where( r =>
r.PersonAlias.Person.BirthDate.HasValue &&
r.PersonAlias.Person.BirthDate.Value <= drpBirthdateFilter.UpperValue.Value );
}
}
break;
}
case RegistrationPersonFieldType.Gender:
{
var ddlGenderFilter = phRegistrantFormFieldFilters.FindControl( "ddlGenderFilter" ) as RockDropDownList;
if ( ddlGenderFilter != null )
{
var gender = ddlGenderFilter.SelectedValue.ConvertToEnumOrNull<Gender>();
if ( gender.HasValue )
{
qry = qry.Where( r =>
r.PersonAlias.Person.Gender == gender );
}
}
break;
}
case RegistrationPersonFieldType.MaritalStatus:
{
var ddlMaritalStatusFilter = phRegistrantFormFieldFilters.FindControl( "ddlMaritalStatusFilter" ) as RockDropDownList;
if ( ddlMaritalStatusFilter != null )
{
var maritalStatusId = ddlMaritalStatusFilter.SelectedValue.AsIntegerOrNull();
if ( maritalStatusId.HasValue )
{
qry = qry.Where( r =>
r.PersonAlias.Person.MaritalStatusValueId.HasValue &&
r.PersonAlias.Person.MaritalStatusValueId.Value == maritalStatusId.Value );
}
}
break;
}
case RegistrationPersonFieldType.MobilePhone:
{
var tbPhoneFilter = phRegistrantFormFieldFilters.FindControl( "tbPhoneFilter" ) as RockTextBox;
if ( tbPhoneFilter != null && !string.IsNullOrWhiteSpace( tbPhoneFilter.Text ) )
{
string numericPhone = tbPhoneFilter.Text.AsNumeric();
qry = qry.Where( r =>
r.PersonAlias.Person.PhoneNumbers != null &&
r.PersonAlias.Person.PhoneNumbers.Any( n => n.Number.Contains( numericPhone ) ) );
}
break;
}
}
}
// Get all the registrant attributes selected to be on grid
registrantAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.RegistrationAttribute )
.Select( f => f.Attribute )
.ToList();
registrantAttributeIds = registrantAttributes.Select( a => a.Id ).Distinct().ToList();
// Filter query by any configured registrant attribute filters
if ( registrantAttributes != null && registrantAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in registrantAttributes )
{
var filterControl = phRegistrantFormFieldFilters.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
qry = qry
.Where( r => attributeValues.Select( v => v.EntityId ).Contains( r.Id ) );
}
}
}
}
// Get all the person attributes selected to be on grid
personAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.PersonAttribute )
.Select( f => f.Attribute )
.ToList();
personAttributesIds = personAttributes.Select( a => a.Id ).Distinct().ToList();
// Filter query by any configured person attribute filters
if ( personAttributes != null && personAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in personAttributes )
{
var filterControl = phRegistrantFormFieldFilters.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
qry = qry
.Where( r => attributeValues.Select( v => v.EntityId ).Contains( r.PersonAlias.PersonId ) );
}
}
}
}
// Get all the group member attributes selected to be on grid
groupMemberAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.GroupMemberAttribute )
.Select( f => f.Attribute )
.ToList();
groupMemberAttributesIds = groupMemberAttributes.Select( a => a.Id ).Distinct().ToList();
// Filter query by any configured person attribute filters
if ( groupMemberAttributes != null && groupMemberAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in groupMemberAttributes )
{
var filterControl = phRegistrantFormFieldFilters.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
qry = qry
.Where( r => r.GroupMemberId.HasValue &&
attributeValues.Select( v => v.EntityId ).Contains( r.GroupMemberId.Value ) );
}
}
}
}
}
// Sort the query
IOrderedQueryable<RegistrationRegistrant> orderedQry = null;
SortProperty sortProperty = gRegistrants.SortProperty;
if ( sortProperty != null )
{
orderedQry = qry.Sort( sortProperty );
}
else
{
orderedQry = qry
.OrderBy( r => r.PersonAlias.Person.LastName )
.ThenBy( r => r.PersonAlias.Person.NickName );
}
// Set the grids LinqDataSource which will run query and set results for current page
gRegistrants.SetLinqDataSource<RegistrationRegistrant>( orderedQry );
if ( RegistrantFields != null )
{
// Get the query results for the current page
var currentPageRegistrants = gRegistrants.DataSource as List<RegistrationRegistrant>;
if ( currentPageRegistrants != null )
{
// Get all the registrant ids in current page of query results
var registrantIds = currentPageRegistrants
.Select( r => r.Id )
.Distinct()
.ToList();
// Get all the person ids in current page of query results
var personIds = currentPageRegistrants
.Select( r => r.PersonAlias.PersonId )
.Distinct()
.ToList();
// Get all the group member ids and the group id in current page of query results
var groupMemberIds = new List<int>();
GroupLinks = new Dictionary<int,string>();
foreach( var groupMember in currentPageRegistrants
.Where( m =>
m.GroupMember != null &&
m.GroupMember.Group != null )
.Select( m => m.GroupMember ) )
{
groupMemberIds.Add( groupMember.Id );
GroupLinks.AddOrIgnore( groupMember.GroupId,
string.Format( "<a href='{0}'>{1}</a>",
LinkedPageUrl( "GroupDetailPage", new Dictionary<string, string> { { "GroupId", groupMember.GroupId.ToString() } } ),
groupMember.Group.Name ) );
}
// If the campus column was selected to be displayed on grid, preload all the people's
// campuses so that the databind does not need to query each row
if ( preloadCampusValues )
{
PersonCampusIds = new Dictionary<int, List<int>>();
Guid familyGroupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
foreach ( var personCampusList in new GroupMemberService( rockContext )
.Queryable().AsNoTracking()
.Where( m =>
m.Group.GroupType.Guid == familyGroupTypeGuid &&
personIds.Contains( m.PersonId ) )
.GroupBy( m => m.PersonId )
.Select( m => new
{
PersonId = m.Key,
CampusIds = m
.Where( g => g.Group.CampusId.HasValue )
.Select( g => g.Group.CampusId.Value )
.ToList()
} ) )
{
PersonCampusIds.Add( personCampusList.PersonId, personCampusList.CampusIds );
}
}
// If there are any attributes that were selected to be displayed, we're going
// to try and read all attribute values in one query and then put them into a
// custom grid ObjectList property so that the AttributeField columns don't need
// to do the LoadAttributes and querying of values for each row/column
if ( personAttributesIds.Any() || groupMemberAttributesIds.Any() || registrantAttributeIds.Any() )
{
// Query the attribute values for all rows and attributes
var attributeValues = new AttributeValueService( rockContext )
.Queryable( "Attribute" ).AsNoTracking()
.Where( v =>
v.EntityId.HasValue &&
(
(
personAttributesIds.Contains( v.AttributeId ) &&
personIds.Contains( v.EntityId.Value )
) ||
(
groupMemberAttributesIds.Contains( v.AttributeId ) &&
groupMemberIds.Contains( v.EntityId.Value )
) ||
(
registrantAttributeIds.Contains( v.AttributeId ) &&
registrantIds.Contains( v.EntityId.Value )
)
)
)
.ToList();
// Get the attributes to add to each row's object
var attributes = new Dictionary<string, AttributeCache>();
RegistrantFields
.Where( f => f.Attribute != null )
.Select( f => f.Attribute )
.ToList()
.ForEach( a => attributes
.Add( a.Id.ToString() + a.Key, a ) );
// Initialize the grid's object list
gRegistrants.ObjectList = new Dictionary<string, object>();
// Loop through each of the current page's registrants and build an attribute
// field object for storing attributes and the values for each of the registrants
foreach ( var registrant in currentPageRegistrants )
{
// Create a row attribute object
var attributeFieldObject = new AttributeFieldObject();
// Add the attributes to the attribute object
attributeFieldObject.Attributes = attributes;
// Add any person attribute values to object
attributeValues
.Where( v =>
personAttributesIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.PersonAlias.PersonId )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, v ) );
// Add any group member attribute values to object
if ( registrant.GroupMemberId.HasValue )
{
attributeValues
.Where( v =>
groupMemberAttributesIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.GroupMemberId.Value )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, v ) );
}
// Add any registrant attribute values to object
attributeValues
.Where( v =>
registrantAttributeIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.PersonAlias.PersonId )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, v ) );
// Add row attribute object to grid's object list
gRegistrants.ObjectList.Add( registrant.Id.ToString(), attributeFieldObject );
}
}
}
}
gRegistrants.DataBind();
}
}
}
/// <summary>
/// Executes this instance.
/// </summary>
public void Execute()
{
using ( var rockContext = new RockContext() )
{
var registration = new RegistrationService( rockContext )
.Queryable( "RegistrationInstance.RegistrationTemplate" ).AsNoTracking()
.FirstOrDefault( r => r.Id == RegistrationId );
if ( registration != null && !string.IsNullOrEmpty( registration.ConfirmationEmail ) &&
registration.RegistrationInstance != null && registration.RegistrationInstance.RegistrationTemplate != null )
{
var template = registration.RegistrationInstance.RegistrationTemplate;
var mergeFields = new Dictionary<string, object>();
mergeFields.Add( "RegistrationInstance", registration.RegistrationInstance );
mergeFields.Add( "Registration", registration );
var recipients = new Dictionary<string, Dictionary<string, object>>();
// Contact
if ( !string.IsNullOrWhiteSpace( registration.RegistrationInstance.ContactEmail ) &&
( template.Notify & RegistrationNotify.RegistrationContact ) == RegistrationNotify.RegistrationContact )
{
recipients.AddOrIgnore( registration.RegistrationInstance.ContactEmail, mergeFields );
}
// Group Followers
if ( registration.GroupId.HasValue &&
( template.Notify & RegistrationNotify.GroupFollowers ) == RegistrationNotify.GroupFollowers )
{
new GroupService( rockContext ).GetFollowers( registration.GroupId.Value )
.Where( f =>
f.Email != null &&
f.Email != "" )
.Select( f => f.Email )
.ToList()
.ForEach( f => recipients.AddOrIgnore( f, mergeFields ) );
}
// Group Leaders
if ( ( template.Notify & RegistrationNotify.GroupLeaders ) == RegistrationNotify.GroupLeaders )
{
new GroupMemberService( rockContext ).GetLeaders( registration.GroupId.Value )
.Where( m =>
m.Person != null &&
m.Person.Email != null &&
m.Person.Email != "" )
.Select( m => m.Person.Email )
.ToList()
.ForEach( m => recipients.AddOrIgnore( m, mergeFields ) );
}
if ( recipients.Any() )
{
var recipientList = new List<RecipientData>();
recipients.ToList().ForEach( r => recipientList.Add( new RecipientData( r.Key, r.Value ) ) );
Email.Send( Rock.SystemGuid.SystemEmail.REGISTRATION_NOTIFICATION.AsGuid(), recipientList, AppRoot, ThemeRoot );
}
}
}
}
/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
public void Execute( IJobExecutionContext context )
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
Guid? groupGuid = dataMap.GetString( "EligibleFollowers" ).AsGuidOrNull();
Guid? systemEmailGuid = dataMap.GetString( "EmailTemplate" ).AsGuidOrNull();
int followingEventsSent = 0;
if ( groupGuid.HasValue && systemEmailGuid.HasValue )
{
var exceptionMsgs = new List<string>();
using ( var rockContext = new RockContext() )
{
var followingService = new FollowingService( rockContext );
var followingEventTypeService = new FollowingEventTypeService( rockContext );
var followingEventNotificationService = new FollowingEventNotificationService( rockContext );
// Get all the active event types
var eventTypes = followingEventTypeService
.Queryable().AsNoTracking()
.Where( e =>
e.EntityTypeId.HasValue &&
e.IsActive )
.OrderBy( e => e.Order )
.ToList();
// Get the required event types
var requiredEventTypes = eventTypes
.Where( e => e.IsNoticeRequired )
.ToList();
// The people who are eligible to get following event notices based on the group type setting for this job
var eligiblePersonIds = new GroupMemberService( rockContext )
.Queryable().AsNoTracking()
.Where( m =>
m.Group != null &&
m.Group.Guid.Equals( groupGuid.Value ) &&
m.GroupMemberStatus == GroupMemberStatus.Active &&
m.Person != null &&
m.Person.Email != null &&
m.Person.Email != "" )
.Select( m => m.PersonId )
.Distinct()
.ToList();
// Get all the subscriptions for the eligible people
var eventSubscriptions = new FollowingEventSubscriptionService( rockContext )
.Queryable( "PersonAlias" ).AsNoTracking()
.Where( f => eligiblePersonIds.Contains( f.PersonAlias.PersonId ) )
.ToList();
// Dictionaries used to store information that will be used to create notification
var personSubscriptions = new Dictionary<int, List<int>>(); // Key: personId, Value: list of event type ids that person subscribes to
var personFollowings = new Dictionary<int, List<int>>(); // Key: personId, Value: list of following ids that person follows
var eventsThatHappened = new Dictionary<int, Dictionary<int, string>>(); // Key: event type id Value: Dictionary of entity id and formatted event notice for the entity
//Get the subscriptions for each person
foreach ( int personId in eligiblePersonIds )
{
var personEventTypes = eventSubscriptions
.Where( s => s.PersonAlias.PersonId == personId )
.Select( s => s.EventType )
.ToList();
personEventTypes.AddRange( requiredEventTypes );
if ( personEventTypes.Any() )
{
personSubscriptions.AddOrIgnore( personId, personEventTypes
.OrderBy( e => e.Order )
.ThenBy( e => e.Name )
.Select( e => e.Id )
.Distinct()
.ToList() );
}
}
// Get a distinct list of each entitytype/entity that is being followed by anyone that subscribes to events
var followings = followingService
.Queryable( "PersonAlias" ).AsNoTracking()
.Where( f => personSubscriptions.Keys.Contains( f.PersonAlias.PersonId ) )
.ToList();
// group the followings by their type
var followedEntityIds = new Dictionary<int, List<int>>();
foreach ( var followedEntity in followings
.Select( f => new
{
f.EntityTypeId,
f.EntityId
} )
.Distinct() )
{
followedEntityIds.AddOrIgnore( followedEntity.EntityTypeId, new List<int>() );
followedEntityIds[followedEntity.EntityTypeId].Add( followedEntity.EntityId );
}
// group the followings by the follower
foreach ( int personId in personSubscriptions.Select( s => s.Key ) )
{
var personFollowing = followings
.Where( f => f.PersonAlias.PersonId == personId )
.Select( f => f.Id )
.ToList();
personFollowings.Add( personId, personFollowing );
}
var timestamp = RockDateTime.Now;
// foreach followed entitytype
foreach ( var keyVal in followedEntityIds )
{
// Get the entitytype
EntityTypeCache itemEntityType = EntityTypeCache.Read( keyVal.Key );
if ( itemEntityType.AssemblyName != null )
{
// get the actual type of what is being followed
Type entityType = itemEntityType.GetEntityType();
if ( entityType != null )
{
var dbContext = Reflection.GetDbContextForEntityType( entityType );
if ( dbContext != null )
{
var serviceInstance = Reflection.GetServiceForEntityType( entityType, dbContext );
if ( serviceInstance != null )
{
MethodInfo qryMethod = serviceInstance.GetType().GetMethod( "Queryable", new Type[] { } );
var entityQry = qryMethod.Invoke( serviceInstance, new object[] { } ) as IQueryable<IEntity>;
// If looking at person alias following, make sure to exclude deceased people
if ( entityType == typeof( Rock.Model.PersonAlias ) )
{
var personAliasQry = entityQry as IQueryable<PersonAlias>;
if ( personAliasQry != null )
{
entityQry = personAliasQry.Where( p => !p.Person.IsDeceased );
}
}
var entityList = entityQry.Where( q => keyVal.Value.Contains( q.Id ) ).ToList();
// If there are any followed entities of this type
if ( entityList.Any() )
{
// Get the active event types for this entity type
foreach ( var eventType in eventTypes.Where( e => e.FollowedEntityTypeId == keyVal.Key ) )
{
try
{
// Get the component
var eventComponent = eventType.GetEventComponent();
if ( eventComponent != null )
{
// Get the previous notificatoins for this event type
var previousNotifications = followingEventNotificationService
.Queryable()
.Where( n => n.FollowingEventTypeId == eventType.Id )
.ToList();
// check each entity that is followed (by anyone)
foreach ( IEntity entity in entityList )
{
var previousNotification = previousNotifications
.Where( n => n.EntityId == entity.Id )
.FirstOrDefault();
DateTime? lastNotification = previousNotification != null ? previousNotification.LastNotified : (DateTime?)null;
// if the event happened
if ( eventComponent.HasEventHappened( eventType, entity, lastNotification ) )
{
// Store the event type id and the entity for later processing of notifications
eventsThatHappened.AddOrIgnore( eventType.Id, new Dictionary<int, string>() );
eventsThatHappened[eventType.Id].Add( entity.Id, eventComponent.FormatEntityNotification( eventType, entity ) );
if ( previousNotification == null )
{
previousNotification = new FollowingEventNotification();
previousNotification.FollowingEventTypeId = eventType.Id;
previousNotification.EntityId = entity.Id;
followingEventNotificationService.Add( previousNotification );
}
previousNotification.LastNotified = timestamp;
}
}
rockContext.SaveChanges();
}
eventType.LastCheckDateTime = RockDateTime.Now;
}
catch ( Exception ex )
{
exceptionMsgs.Add( string.Format( "An exception occurred calculating events for the '{0}' suggestion type:{1} {2}", eventType.Name, Environment.NewLine, ex.Messages().AsDelimited( Environment.NewLine + " " ) ) );
ExceptionLogService.LogException( ex, System.Web.HttpContext.Current );
}
}
}
}
}
}
}
}
// send notificatons
var appRoot = Rock.Web.Cache.GlobalAttributesCache.Read( rockContext ).GetValue( "ExternalApplicationRoot" );
var possibleRecipients = new PersonService( rockContext )
.Queryable().AsNoTracking()
.Where( p => personSubscriptions.Keys.Contains( p.Id ) )
.ToList();
// Loop through the possible recipients that actually subscribe to events
foreach ( var personSubscription in personSubscriptions )
{
// Get the recipient person
int personId = personSubscription.Key;
var person = possibleRecipients.Where( p => p.Id == personId ).FirstOrDefault();
if ( person != null )
{
try
{
// Make sure person is actually following anything
if ( personFollowings.ContainsKey( personId ) )
{
// Dictionary to store the entities that had an event for each event type
var personEventTypeNotices = new List<FollowingEventTypeNotices>();
// Get the event types that person subscribes to
foreach ( var eventType in eventsThatHappened.Where( e => personSubscription.Value.Contains( e.Key ) ) )
{
// Get the EntityTypeId for this event type
int entityTypeId = eventTypes
.Where( e => e.Id == eventType.Key )
.Select( e => e.FollowedEntityTypeId.Value )
.FirstOrDefault();
// Find all the entities with this event type that the person follows
var personFollowedEntityIds = followings
.Where( f =>
personFollowings[personId].Contains( f.Id ) &&
f.EntityTypeId == entityTypeId )
.Select( f => f.EntityId )
.ToList();
// Get any of those entities that had an event happen
var personFollowedEntities = eventType.Value
.Where( e => personFollowedEntityIds.Contains( e.Key ) )
.ToList();
// If any were found
if ( personFollowedEntities.Any() )
{
// Add the entry
var eventTypeObj = eventTypes.Where( e => e.Id == eventType.Key ).FirstOrDefault();
if ( eventTypeObj != null )
{
personEventTypeNotices.Add( new FollowingEventTypeNotices( eventTypeObj, personFollowedEntities.Select( e => e.Value ).ToList() ) );
}
}
}
// If there are any events for any of the entities that this person follows, send a notification
if ( personEventTypeNotices.Any() )
{
// Send the notice
var recipients = new List<RecipientData>();
var mergeFields = new Dictionary<string, object>();
mergeFields.Add( "Person", person );
mergeFields.Add( "EventTypes", personEventTypeNotices.OrderBy( e => e.EventType.Order ).ToList() );
recipients.Add( new RecipientData( person.Email, mergeFields ) );
Email.Send( systemEmailGuid.Value, recipients, appRoot );
followingEventsSent++;
}
}
}
catch ( Exception ex )
{
exceptionMsgs.Add( string.Format( "An exception occurred sending event notice to '{0}':{1} {2}", person.FullName, Environment.NewLine, ex.Messages().AsDelimited( Environment.NewLine + " " ) ) );
ExceptionLogService.LogException( ex, System.Web.HttpContext.Current );
}
}
}
}
context.Result = string.Format( "{0} following events emails sent", followingEventsSent );
if ( exceptionMsgs.Any() )
{
throw new Exception( "One or more exceptions occurred calculating following events..." + Environment.NewLine + exceptionMsgs.AsDelimited( Environment.NewLine ) );
}
}
}
