/// <summary>
/// Determines whether the filter's comparison type and filter compare value(s) evaluates to true for the specified value
/// </summary>
/// <param name="filterValues">The filter values.</param>
/// <param name="value">The value.</param>
/// <returns>
/// <c>true</c> if [is compared to value] [the specified filter values]; otherwise, <c>false</c>.
/// </returns>
public override bool IsComparedToValue(List <string> filterValues, string value)
{
if (filterValues == null || filterValues.Count < 2)
{
return(false);
}
ComparisonType?filterComparisonType = filterValues[0].ConvertToEnumOrNull <ComparisonType>();
ComparisonType?equalToCompareValue = GetEqualToCompareValue().ConvertToEnumOrNull <ComparisonType>();
DateTime? valueAsDateTime = value.AsDateTime();
// uses Tab Delimited since slidingDateRangePicker is | delimited
var filterValueValues = filterValues[1].Split(new string[] { "\t" }, StringSplitOptions.None);
// Parse for RelativeValue of DateTime (if specified)
filterValueValues[0] = ParseRelativeValue(filterValueValues[0]);
DateTime?filterValueAsDateTime1;
DateTime?filterValueAsDateTime2 = null;
if (filterComparisonType == ComparisonType.Between)
{
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(filterValueValues[1]);
filterValueAsDateTime1 = dateRange.Start;
filterValueAsDateTime2 = dateRange.End;
}
else
{
filterValueAsDateTime1 = filterValueValues[0].AsDateTime();
filterValueAsDateTime2 = null;
}
return(ComparisonHelper.CompareNumericValues(filterComparisonType.Value, valueAsDateTime?.Ticks, filterValueAsDateTime1?.Ticks, filterValueAsDateTime2?.Ticks));
}
/// <summary>
/// Loads the schedules
/// </summary>
private void LoadDropdowns()
{
var currentRange = RockPage.GetUserPreference(ContextPreferenceName);
var dateRangeString = Request.QueryString["SlidingDateRange"];
if (!string.IsNullOrEmpty(dateRangeString) && currentRange != dateRangeString)
{
// set context to query string
SetDateRangeContext(dateRangeString, false);
currentRange = dateRangeString;
}
// if current range is selected, show a tooltip, otherwise show the default
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(currentRange);
if (dateRange != null && dateRange.Start != null && dateRange.End != null)
{
lCurrentSelection.Text = dateRange.ToStringAutomatic();
drpSlidingDateRange.DelimitedValues = currentRange;
}
else
{
lCurrentSelection.Text = GetAttributeValue("NoDateRangeText");
drpSlidingDateRange.DelimitedValues = GetAttributeValue("DefaultDateRange");
}
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
SelectionConfig selectionConfig = SelectionConfig.Parse(selection);
if (!selectionConfig.ConnectionActivityTypeGuid.HasValue)
{
return(null);
}
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(selectionConfig.SlidingDateRangeDelimitedValues);
var rockContext = serviceInstance.Context as RockContext;
var connectionRequestActivityQry = new ConnectionRequestActivityService(rockContext).Queryable();
if (dateRange.Start.HasValue)
{
var startDate = dateRange.Start.Value;
connectionRequestActivityQry = connectionRequestActivityQry.Where(a => a.CreatedDateTime >= startDate);
}
if (dateRange.End.HasValue)
{
var endDate = dateRange.End.Value;
connectionRequestActivityQry = connectionRequestActivityQry.Where(a => a.CreatedDateTime < endDate);
}
connectionRequestActivityQry = connectionRequestActivityQry.Where(a => a.ConnectionActivityType.Guid == selectionConfig.ConnectionActivityTypeGuid.Value);
var qry = new ConnectionRequestService(rockContext).Queryable()
.Where(p => connectionRequestActivityQry.Where(xx => xx.ConnectionRequestId == p.Id).Count() == selectionConfig.MinimumCount);
BinaryExpression compareEqualExpression = FilterExpressionExtractor.Extract <Rock.Model.ConnectionRequest>(qry, parameterExpression, "p") as BinaryExpression;
BinaryExpression result = FilterExpressionExtractor.AlterComparisonType(selectionConfig.IntegerCompare, compareEqualExpression, null);
return(result);
}
/// <summary>
/// Gets a filter expression for an entity property value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="propertyType">Type of the property.</param>
/// <returns></returns>
public override Expression PropertyFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, Expression parameterExpression, string propertyName, Type propertyType)
{
if (filterValues.Count >= 2)
{
// uses Tab Delimited since slidingDateRangePicker is | delimited
var filterValueValues = filterValues[1].Split(new string[] { "\t" }, StringSplitOptions.None);
// Parse for RelativeValue of DateTime (if specified)
filterValueValues[0] = ParseRelativeValue(filterValueValues[0]);
string comparisonValue = filterValues[0];
if (comparisonValue != "0" && comparisonValue.IsNotNullOrWhiteSpace())
{
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
MemberExpression propertyExpression = Expression.Property(parameterExpression, propertyName);
if (comparisonType == ComparisonType.Between && filterValueValues.Length > 1)
{
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(filterValueValues[1]);
ConstantExpression constantExpressionLower = dateRange.Start.HasValue
? Expression.Constant(dateRange.Start, typeof(DateTime))
: null;
ConstantExpression constantExpressionUpper = dateRange.End.HasValue
? Expression.Constant(dateRange.End, typeof(DateTime))
: null;
if (constantExpressionLower == null && constantExpressionUpper == null)
{
return(new NoAttributeFilterExpression());
}
else
{
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpressionLower, constantExpressionUpper));
}
}
else
{
var dateTime = filterValueValues[0].AsDateTime();
if (dateTime.HasValue)
{
ConstantExpression constantExpression = Expression.Constant(dateTime, typeof(DateTime));
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
}
else
{
if (comparisonType == ComparisonType.IsBlank || comparisonType == ComparisonType.IsNotBlank)
{
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, null));
}
else
{
return(new NoAttributeFilterExpression());
}
}
}
}
}
return(null);
}
/// <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)
{
base.OnLoad(e);
// tell the browser to not cache this page so that it'll reload this page and apply the last search settings
// when the user navigates back to it. If we don't do this, the browser will show the the initial full load of the page (without the results)
this.Response.Cache.SetCacheability(System.Web.HttpCacheability.NoCache);
this.Response.Cache.SetNoStore();
if (!Page.IsPostBack)
{
BindFilter();
// load and apply the SearchSettings if this user navigates back to this page during the session
var searchSettings = this.Session[string.Format("SearchSettings_Block_{0}_EventCalendarId_", this.BlockId, this.PageParameter("EventCalendarId"))] as SearchSettings;
if (searchSettings != null)
{
cpCampusPicker.SelectedCampusId = searchSettings.CampusId;
pDateRange.LowerValue = searchSettings.DateRange.Start;
pDateRange.UpperValue = searchSettings.DateRange.End;
}
else
{
var defaultDateRangeDelimitedValues = this.GetAttributeValue("DefaultDateRange");
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(defaultDateRangeDelimitedValues);
pDateRange.LowerValue = dateRange.Start;
pDateRange.UpperValue = dateRange.End;
}
ShowResults();
}
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(drpSlidingDateRange.DelimitedValues);
string groupIds = GetSelectedGroupIds().AsDelimited(",");
string campusIds = cpCampuses.SelectedCampusIds.AsDelimited(",");
SortProperty sortProperty = gAttendance.SortProperty;
var chartData = new AttendanceService(new RockContext()).GetChartData(
hfGroupBy.Value.ConvertToEnumOrNull <AttendanceGroupBy>() ?? AttendanceGroupBy.Week,
hfGraphBy.Value.ConvertToEnumOrNull <AttendanceGraphBy>() ?? AttendanceGraphBy.Total,
dateRange.Start,
dateRange.End,
groupIds,
campusIds);
if (sortProperty != null)
{
gAttendance.DataSource = chartData.AsQueryable().Sort(sortProperty).ToList();
}
else
{
gAttendance.DataSource = chartData.OrderBy(a => a.DateTimeStamp).ToList();
}
gAttendance.DataBind();
}
private IEnumerable <Rock.Chart.IChartData> GetChartData()
{
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(drpSlidingDateRange.DelimitedValues);
var currenceTypeIds = new List <int>();
cblCurrencyTypes.SelectedValues.ForEach(i => currenceTypeIds.Add(i.AsInteger()));
var sourceIds = new List <int>();
cblTransactionSource.SelectedValues.ForEach(i => sourceIds.Add(i.AsInteger()));
var accountIds = new List <int>();
foreach (var cblAccounts in phAccounts.Controls.OfType <RockCheckBoxList>())
{
accountIds.AddRange(cblAccounts.SelectedValuesAsInt);
}
var chartData = new FinancialTransactionDetailService(_rockContext).GetChartData(
hfGroupBy.Value.ConvertToEnumOrNull <ChartGroupBy>() ?? ChartGroupBy.Week,
hfGraphBy.Value.ConvertToEnumOrNull <TransactionGraphBy>() ?? TransactionGraphBy.Total,
dateRange.Start,
dateRange.End,
nreAmount.LowerValue,
nreAmount.UpperValue,
currenceTypeIds,
sourceIds,
accountIds,
dvpDataView.SelectedValueAsInt());
return(chartData);
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
pnlUpdateMessage.Visible = false;
pnlResults.Visible = true;
int?accountId = apAccount.SelectedValue.AsIntegerOrNull();
if (!accountId.HasValue)
{
return;
}
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(drpSlidingDateRange.DelimitedValues);
DateTime?start = dateRange.Start ?? (DateTime?)System.Data.SqlTypes.SqlDateTime.MinValue;
DateTime?end = dateRange.End ?? ( DateTime? )System.Data.SqlTypes.SqlDateTime.MaxValue;
var minPledgeAmount = nrePledgeAmount.LowerValue;
var maxPledgeAmount = nrePledgeAmount.UpperValue;
var minComplete = nrePercentComplete.LowerValue;
var maxComplete = nrePercentComplete.UpperValue;
var minGiftAmount = nreAmountGiven.LowerValue;
var maxGiftAmount = nreAmountGiven.UpperValue;
int includeOption = rblInclude.SelectedValueAsInt() ?? 0;
bool includePledges = includeOption != 1;
bool includeGifts = includeOption != 0;
DataSet ds = FinancialPledgeService.GetPledgeAnalytics(accountId.Value, start, end,
minPledgeAmount, maxPledgeAmount, minComplete, maxComplete, minGiftAmount, maxGiftAmount,
includePledges, includeGifts);
System.Data.DataView dv = ds.Tables[0].DefaultView;
if (gList.SortProperty != null)
{
try
{
var sortProperties = new List <string>();
foreach (string prop in gList.SortProperty.Property.SplitDelimitedValues(false))
{
sortProperties.Add(string.Format("[{0}] {1}", prop, gList.SortProperty.DirectionString));
}
dv.Sort = sortProperties.AsDelimited(", ");
}
catch
{
dv.Sort = "[LastName] ASC, [NickName] ASC";
}
}
else
{
dv.Sort = "[LastName] ASC, [NickName] ASC";
}
gList.DataSource = dv;
gList.DataBind();
}
private void LoadRegistration()
{
var rockContext = new RockContext();
var groupService = new GroupService(rockContext);
var attendanceService = new AttendanceService(rockContext);
var attendanceOccurrenceService = new AttendanceOccurrenceService(rockContext);
// get list of groups of this type
var groups = groupService.Queryable()
.Where(g =>
g.GroupTypeId == _groupType.Id &&
g.IsActive == true)
.ToList();
var groupIds = groups.Select(g => g.Id).ToList();
// get listing of possible attendance for groups of this type
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(GetAttributeValue("DateRange") ?? "-1||");
var attendanceOccurrences = attendanceOccurrenceService.Queryable()
.Where(a =>
a.GroupId.HasValue &&
groupIds.Contains(a.GroupId.Value) &&
a.OccurrenceDate >= dateRange.Start.Value &&
a.OccurrenceDate <= dateRange.End.Value &&
a.LocationId == _location.Id)
.Distinct()
.ToList();
_schedules = attendanceOccurrences.Select(a => new ScheduleResult
{
Group = a.Group,
Schedule = a.Schedule,
Date = a.OccurrenceDate
})
.Distinct()
.ToList();
var occurrenceIds = attendanceOccurrences.Select(o => o.Id).ToList();
// get personal schedules (things you already signed up for)
_personalSchedules = attendanceService.Queryable()
.Where(a =>
occurrenceIds.Contains(a.OccurrenceId) &&
a.PersonAlias.PersonId == CurrentPersonId &&
a.RSVP == RSVP.Yes)
.Select(a => new ScheduleResult
{
Group = a.Occurrence.Group,
Schedule = a.Occurrence.Schedule,
Date = a.StartDateTime
})
.Distinct()
.ToList();
rptScheduleDates.DataSource = _schedules.Select(s => s.Date.Date).Distinct();
rptScheduleDates.DataBind();
}
/// <summary>
/// Renders the specified writer.
/// </summary>
/// <param name="badge">The badge.</param>
/// <param name="writer">The writer.</param>
public override void Render(PersonBadgeCache badge, System.Web.UI.HtmlTextWriter writer)
{
Guid?groupTypeGuid = GetAttributeValue(badge, "GroupType").AsGuidOrNull();
if (groupTypeGuid.HasValue)
{
var lavaTemplate = this.GetAttributeValue(badge, "LavaTemplate");
var slidingDateRangeDelimitedValues = this.GetAttributeValue(badge, "DateRange");
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(slidingDateRangeDelimitedValues);
var dateRangeSummary = SlidingDateRangePicker.FormatDelimitedValues(slidingDateRangeDelimitedValues);
var mergeFields = Lava.LavaHelper.GetCommonMergeFields(null, null, new Lava.CommonMergeFieldsOptions {
GetLegacyGlobalMergeFields = false
});
mergeFields.Add("Person", this.Person);
using (var rockContext = new RockContext())
{
var groupType = GroupTypeCache.Read(groupTypeGuid.Value);
int groupTypeId = groupType?.Id ?? 0;
mergeFields.Add("GroupType", groupType);
mergeFields.Add("Badge", badge);
mergeFields.Add("DateRange", new { Dates = dateRange, Summary = dateRangeSummary });
var personAliasIds = Person.Aliases.Select(a => a.Id).ToList();
var attendanceQuery = new AttendanceService(rockContext).Queryable().Where(a =>
a.Group.GroupTypeId == groupTypeId && a.DidAttend == true &&
personAliasIds.Contains(a.PersonAliasId.Value));
if (dateRange.Start.HasValue)
{
attendanceQuery = attendanceQuery.Where(a => a.StartDateTime >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
attendanceQuery = attendanceQuery.Where(a => a.StartDateTime < dateRange.End.Value);
}
var attendanceDateTimes = attendanceQuery.Select(a => a.StartDateTime).ToList();
if (attendanceDateTimes.Any())
{
var attendanceResult = new
{
Count = attendanceDateTimes.Count(),
LastDateTime = attendanceDateTimes.Max()
};
mergeFields.Add("Attendance", attendanceResult);
}
string output = lavaTemplate.ResolveMergeFields(mergeFields);
writer.Write(output);
}
}
}
/// <summary>
/// Shows the readonly details.
/// </summary>
/// <param name="metric">The metric.</param>
private void ShowReadonlyDetails(Metric metric)
{
SetEditMode(false);
hfMetricId.SetValue(metric.Id);
lcMetricsChart.Visible = GetAttributeValue("ShowChart").AsBooleanOrNull() ?? true;
var chartDateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(GetAttributeValue("SlidingDateRange") ?? "-1||");
lcMetricsChart.StartDate = chartDateRange.Start;
lcMetricsChart.EndDate = chartDateRange.End;
lcMetricsChart.MetricId = metric.Id;
lcMetricsChart.CombineValues = GetAttributeValue("CombineChartSeries").AsBooleanOrNull() ?? false;
lReadOnlyTitle.Text = metric.Title.FormatAsHtmlTitle();
DescriptionList descriptionListMain = new DescriptionList();
descriptionListMain.Add("Subtitle", metric.Subtitle);
descriptionListMain.Add("Description", metric.Description);
if (metric.MetricCategories != null && metric.MetricCategories.Any())
{
descriptionListMain.Add("Categories", metric.MetricCategories.Select(s => s.Category.ToString()).OrderBy(o => o).ToList().AsDelimited(","));
}
// only show LastRun and Schedule label if SourceValueType is not Manual
int manualSourceType = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.METRIC_SOURCE_VALUE_TYPE_MANUAL.AsGuid()).Id;
ltLastRunDateTime.Visible = metric.SourceValueTypeId != manualSourceType;
hlScheduleFriendlyText.Visible = metric.SourceValueTypeId != manualSourceType;
if (metric.LastRunDateTime != null)
{
ltLastRunDateTime.LabelType = LabelType.Success;
ltLastRunDateTime.Text = "Last Run: " + metric.LastRunDateTime.ToString();
}
else
{
ltLastRunDateTime.LabelType = LabelType.Warning;
ltLastRunDateTime.Text = "Never Run";
}
if (metric.Schedule != null)
{
hlScheduleFriendlyText.LabelType = metric.Schedule.HasSchedule() ? LabelType.Info : LabelType.Danger;
hlScheduleFriendlyText.Text = "<i class='fa fa-clock-o'></i> " + metric.Schedule.FriendlyScheduleText;
}
else
{
hlScheduleFriendlyText.LabelType = LabelType.Danger;
hlScheduleFriendlyText.Text = "<i class='fa fa-clock-o'></i> " + "Not Scheduled";
}
lblMainDetails.Text = descriptionListMain.Html;
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var rockContext = (RockContext)serviceInstance.Context;
SelectionConfig selectionConfig = SelectionConfig.Parse(selection);
if (selectionConfig == null)
{
return(null);
}
DateRange dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(selectionConfig.DelimitedValues);
int transactionTypeContributionId = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid()).Id;
var financialTransactionsQry = new FinancialTransactionService(rockContext)
.Queryable()
.Where(xx => xx.TransactionTypeValueId == transactionTypeContributionId);
var accountIdList = new FinancialAccountService(( RockContext )serviceInstance.Context).GetByGuids(selectionConfig.AccountGuids).Select(a => a.Id).ToList();
if (accountIdList.Any())
{
if (accountIdList.Count == 1)
{
int accountId = accountIdList.First();
financialTransactionsQry = financialTransactionsQry.Where(xx => xx.TransactionDetails.Any(a => a.AccountId == accountId));
}
else
{
financialTransactionsQry = financialTransactionsQry.Where(xx => xx.TransactionDetails.Any(a => accountIdList.Contains(a.AccountId)));
}
}
var firstContributionDateQry = financialTransactionsQry
.GroupBy(xx => xx.AuthorizedPersonAlias.PersonId)
.Select(ss => new
{
PersonId = ss.Key,
FirstTransactionDate = ss.Min(a => selectionConfig.UseSundayDate == true ? a.SundayDate : a.TransactionDateTime)
});
if (dateRange.Start.HasValue)
{
firstContributionDateQry = firstContributionDateQry.Where(xx => xx.FirstTransactionDate >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
firstContributionDateQry = firstContributionDateQry.Where(xx => xx.FirstTransactionDate < dateRange.End.Value);
}
var innerQry = firstContributionDateQry.Select(xx => xx.PersonId).AsQueryable();
var qry = new PersonService(rockContext).Queryable().Where(p => innerQry.Any(xx => xx == p.Id));
return(FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p"));
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
string[] selectionValues = selection.Split('|');
if (selectionValues.Length >= 1)
{
List <Guid> registrationTemplateGuids = selectionValues[0].Split(',').AsGuidList();
var registrationInstanceService = new RegistrationInstanceService((RockContext)serviceInstance.Context);
var registrationInstanceIds = registrationInstanceService.Queryable().Where(ri => registrationTemplateGuids.Contains(ri.RegistrationTemplate.Guid)).Select(ri => ri.Id).Distinct().ToList();
RegistrationRegistrantService registrationRegistrantService = new RegistrationRegistrantService((RockContext)serviceInstance.Context);
bool includeInactiveRegistrationInstances = false;
if (selectionValues.Length >= 2)
{
includeInactiveRegistrationInstances = selectionValues[1].AsBooleanOrNull() ?? true;;
}
else
{
// if options where saved before this option was added, set to false, even though it would have included inactive before
includeInactiveRegistrationInstances = false;
}
var registrationRegistrantServiceQry = registrationRegistrantService.Queryable();
if (registrationTemplateGuids.Count > 0)
{
registrationRegistrantServiceQry = registrationRegistrantServiceQry.Where(xx => registrationInstanceIds.Contains(xx.Registration.RegistrationInstanceId));
}
if (selectionValues.Length >= 3)
{
string slidingDelimitedValues = selectionValues[2].Replace(',', '|');
DateRange dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(slidingDelimitedValues);
if (dateRange.Start.HasValue)
{
registrationRegistrantServiceQry = registrationRegistrantServiceQry.Where(xx => xx.CreatedDateTime >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
registrationRegistrantServiceQry = registrationRegistrantServiceQry.Where(xx => xx.CreatedDateTime < dateRange.End.Value);
}
}
var qry = new PersonService((RockContext)serviceInstance.Context).Queryable()
.Where(p => registrationRegistrantServiceQry.Any(xx => xx.PersonAlias.PersonId == p.Id));
Expression extractedFilterExpression = FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p");
return(extractedFilterExpression);
}
return(null);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var groupAttendanceFilterSelection = GetGroupAttendanceFilterSelection(selection);
if (groupAttendanceFilterSelection.GroupGuids == null || groupAttendanceFilterSelection.GroupGuids.Count == 0)
{
// no groups selected, so return nothing
return(Expression.Constant(false));
}
var rockContext = serviceInstance.Context as RockContext;
var attendanceQry = new AttendanceService(rockContext).Queryable().Where(a => a.DidAttend.HasValue && a.DidAttend.Value);
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(groupAttendanceFilterSelection.SlidingDateRange);
if (dateRange.Start.HasValue)
{
var startDate = dateRange.Start.Value;
attendanceQry = attendanceQry.Where(a => a.Occurrence.OccurrenceDate >= startDate);
}
if (dateRange.End.HasValue)
{
var endDate = dateRange.End.Value;
attendanceQry = attendanceQry.Where(a => a.Occurrence.OccurrenceDate < endDate);
}
var groupIds = GetGroupIds(groupAttendanceFilterSelection.GroupGuids, groupAttendanceFilterSelection.IncludeChildGroups);
if (groupIds.Count == 1)
{
// if there is exactly one groupId we can avoid a 'Contains' (Contains has a small performance impact)
int groupId = groupIds[0];
attendanceQry = attendanceQry.Where(a => a.Occurrence.GroupId.HasValue && a.Occurrence.GroupId.Value == groupId);
}
else if (groupIds.Count > 1)
{
attendanceQry = attendanceQry.Where(a => a.Occurrence.GroupId.HasValue && groupIds.Contains(a.Occurrence.GroupId.Value));
}
if (groupAttendanceFilterSelection.Schedules.Any())
{
attendanceQry = attendanceQry.Where(a => a.Occurrence.ScheduleId.HasValue && groupAttendanceFilterSelection.Schedules.Contains(a.Occurrence.ScheduleId.Value));
}
var qry = new PersonService(rockContext)
.Queryable()
.Where(p => attendanceQry.Where(xx => xx.PersonAlias.PersonId == p.Id).Count() == groupAttendanceFilterSelection.AttendedCount);
var compareEqualExpression = FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p") as BinaryExpression;
var comparisonType = groupAttendanceFilterSelection.IntegerCompare.ConvertToEnum <ComparisonType>(ComparisonType.GreaterThanOrEqualTo);
var result = FilterExpressionExtractor.AlterComparisonType(comparisonType, compareEqualExpression, null);
return(result);
}
/// <summary>
/// Bind data to the grid control.
/// </summary>
private void BindDiscountsGrid()
{
var instanceId = this.RegistrationInstanceId;
if (instanceId == null || instanceId == 0)
{
return;
}
var registrationTemplateDiscountService = new RegistrationTemplateDiscountService(new RockContext());
var data = registrationTemplateDiscountService.GetRegistrationInstanceDiscountCodeReport(( int )instanceId);
// Add Date Range
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(sdrpDiscountDateRange.DelimitedValues);
if (dateRange.Start.HasValue)
{
data = data.Where(r => r.RegistrationDate >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
data = data.Where(r => r.RegistrationDate < dateRange.End.Value);
}
// Discount code, use ddl if one is selected, otherwise try the search box.
if (ddlDiscountCode.SelectedIndex > 0)
{
data = data.Where(r => r.DiscountCode == ddlDiscountCode.SelectedItem.Text);
}
else if (tbDiscountCodeSearch.Text.IsNotNullOrWhiteSpace())
{
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(tbDiscountCodeSearch.Text.ToLower());
data = data.Where(r => regex.IsMatch(r.DiscountCode.ToLower()));
}
var results = data.ToList();
SortProperty sortProperty = gDiscounts.SortProperty;
if (sortProperty != null)
{
results = results.AsQueryable().Sort(sortProperty).ToList();
}
else
{
results = results.OrderByDescending(d => d.RegistrationDate).ToList();
}
gDiscounts.DataSource = results;
gDiscounts.DataBind();
PopulateTotals(results);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
string[] selectionValues = selection.Split('|');
if (selectionValues.Length >= 4)
{
var rockContext = ( RockContext )serviceInstance.Context;
var interactionQry = new InteractionService(rockContext).Queryable();
Guid interactionChannelGuid = selectionValues[0].AsGuid();
var interactionComponentGuid = selectionValues[1].AsGuidOrNull();
if (interactionComponentGuid.HasValue)
{
interactionQry = interactionQry.Where(xx => xx.InteractionComponent.Guid == interactionComponentGuid.Value);
}
else
{
interactionQry = interactionQry.Where(xx => xx.InteractionComponent.Channel.Guid == interactionChannelGuid);
}
string operation = string.Empty;
operation = selectionValues[2];
if (!string.IsNullOrEmpty(operation))
{
interactionQry = interactionQry.Where(xx => xx.Operation == operation);
}
string slidingDelimitedValues = selectionValues[3].Replace(',', '|');
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(slidingDelimitedValues);
if (dateRange.Start.HasValue)
{
interactionQry = interactionQry.Where(i => i.InteractionDateTime >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
interactionQry = interactionQry.Where(i => i.InteractionDateTime <= dateRange.End.Value);
}
var innerQry = interactionQry.Select(xx => xx.PersonAlias.PersonId).AsQueryable();
var qry = new PersonService(( RockContext )serviceInstance.Context).Queryable()
.Where(p => innerQry.Any(xx => xx == p.Id));
Expression extractedFilterExpression = FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p");
return(extractedFilterExpression);
}
return(null);
}
/// <summary>
/// Binds the fees grid.
/// </summary>
private void BindFeesGrid()
{
var instanceId = this.RegistrationInstanceId;
if (instanceId.GetValueOrDefault(0) == 0)
{
return;
}
var registrationTemplateFeeService = new RegistrationTemplateFeeService(new RockContext());
var data = registrationTemplateFeeService.GetRegistrationTemplateFeeReport(instanceId.Value);
// Add Date Range
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(sdrpFeeDateRange.DelimitedValues);
if (dateRange.Start.HasValue)
{
data = data.Where(r => r.RegistrationDate >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
data = data.Where(r => r.RegistrationDate < dateRange.End.Value);
}
// Fee Name
if (ddlFeeName.SelectedIndex > 0)
{
data = data.Where(r => r.FeeName == ddlFeeName.SelectedItem.Text);
}
// Fee Options
if (cblFeeOptions.SelectedValues.Count > 0)
{
data = data.Where(r => cblFeeOptions.SelectedValues.Any(v => v.Equals(r.FeeItem.Guid.ToString(), StringComparison.OrdinalIgnoreCase)));
}
SortProperty sortProperty = gFees.SortProperty;
if (sortProperty != null)
{
data = data.AsQueryable().Sort(sortProperty).ToList();
}
else
{
data = data.OrderByDescending(f => f.RegistrationDate).ToList();
}
gFees.DataSource = data;
gFees.DataBind();
}
/// <summary>
/// Builds the base query for the Exception List grid data
/// </summary>
/// <returns>IQueryable containing filtered ExceptionLog records</returns>
private IQueryable <ExceptionLog> BuildBaseExceptionListQuery(RockContext rockContext)
{
ExceptionLogService exceptionLogService = new ExceptionLogService(rockContext);
IQueryable <ExceptionLog> query = exceptionLogService.Queryable();
int siteId;
if (int.TryParse(fExceptionList.GetUserPreference("Site"), out siteId) && siteId > 0)
{
query = query.Where(e => e.SiteId == siteId);
}
int pageId;
if (int.TryParse(fExceptionList.GetUserPreference("Page"), out pageId) && pageId > 0)
{
query = query.Where(e => e.PageId == pageId);
}
int userPersonID;
if (int.TryParse(fExceptionList.GetUserPreference("User"), out userPersonID) && userPersonID > 0)
{
query = query.Where(e => e.CreatedByPersonAlias != null && e.CreatedByPersonAlias.PersonId == userPersonID);
}
string statusCode = fExceptionList.GetUserPreference("Status Code");
if (!String.IsNullOrEmpty(statusCode))
{
query = query.Where(e => e.StatusCode == statusCode);
}
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(fExceptionList.GetUserPreference("Date Range"));
if (dateRange.Start.HasValue)
{
query = query.Where(e => e.CreatedDateTime.HasValue && e.CreatedDateTime.Value >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
query = query.Where(e => e.CreatedDateTime.HasValue && e.CreatedDateTime.Value < dateRange.End.Value);
}
//Only look for inner exceptions
query = query.Where(e => e.HasInnerException == null || e.HasInnerException == false);
return(query);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="entityIdProperty">The entity identifier property.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(RockContext context, MemberExpression entityIdProperty, string selection)
{
string[] selectionValues = selection.Split('|');
if (selectionValues.Length >= 4)
{
var interactionQry = new InteractionService(context).Queryable();
Guid interactionChannelGuid = selectionValues[0].AsGuid();
var interactionComponentGuid = selectionValues[1].AsGuidOrNull();
if (interactionComponentGuid.HasValue)
{
interactionQry = interactionQry.Where(xx => xx.InteractionComponent.Guid == interactionComponentGuid.Value);
}
else
{
interactionQry = interactionQry.Where(xx => xx.InteractionComponent.Channel.Guid == interactionChannelGuid);
}
string operation = string.Empty;
operation = selectionValues[2];
if (!string.IsNullOrEmpty(operation))
{
interactionQry = interactionQry.Where(xx => xx.Operation == operation);
}
string slidingDelimitedValues = selectionValues[3].Replace(',', '|');
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(slidingDelimitedValues);
if (dateRange.Start.HasValue)
{
interactionQry = interactionQry.Where(i => i.InteractionDateTime >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
interactionQry = interactionQry.Where(i => i.InteractionDateTime <= dateRange.End.Value);
}
var qry = new PersonService(context).Queryable()
.Select(p => interactionQry.Where(l => l.PersonAlias.PersonId == p.Id)
.Count());
Expression selectExpression = SelectExpressionExtractor.Extract(qry, entityIdProperty, "p");
return(selectExpression);
}
return(null);
}
/// <summary>
/// Shows the bar graph.
/// </summary>
/// <param name="attendances">The attendances.</param>
protected void ShowBarGraph(List <Attendance> attendances)
{
if (!attendances.Any())
{
nbNoData.Visible = true;
return;
}
DateRange dateRange;
if (sdrpDateRange.DelimitedValues.IsNotNullOrWhiteSpace())
{
dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(sdrpDateRange.DelimitedValues);
}
else
{
dateRange = new DateRange();
}
if (!dateRange.Start.HasValue)
{
dateRange.Start = attendances.Min(a => a.StartDateTime.Date);
}
if (!dateRange.End.HasValue)
{
dateRange.End = attendances.Max(a => a.StartDateTime.Date);
}
var firstDateTime = dateRange.Start.Value.Date;
var lastDateTime = dateRange.End.Value.Date;
int daysCount = ( int )Math.Ceiling((lastDateTime - firstDateTime).TotalDays);
if (daysCount / 7 > 26)
{
// if more than 6 months summarize by month
CreateBarChartGroupedByMonth(firstDateTime, lastDateTime, attendances);
}
else if (daysCount > 31)
{
// if more than 1 month summarize by week
CreateBarChartGroupedByWeek(daysCount, firstDateTime, attendances);
}
else
{
// Otherwise summarize by day
CreateBarChartGroupedByDay(daysCount, firstDateTime, attendances);
}
}
/// <summary>
/// Loads the attendance reporting settings from user preferences.
/// </summary>
private void LoadSettingsFromUserPreferences()
{
string keyPrefix = string.Format("pledge-analytics-{0}-", this.BlockId);
string accountSetting = this.GetUserPreference(keyPrefix + "apAccount");
if (!string.IsNullOrWhiteSpace(accountSetting))
{
apAccount.SetValue(Int32.Parse(accountSetting));
}
string slidingDateRangeSettings = this.GetUserPreference(keyPrefix + "drpDateRange");
if (string.IsNullOrWhiteSpace(slidingDateRangeSettings))
{
// default to current year
drpSlidingDateRange.SlidingDateRangeMode = SlidingDateRangePicker.SlidingDateRangeType.Current;
drpSlidingDateRange.TimeUnit = SlidingDateRangePicker.TimeUnitType.Year;
}
else
{
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(slidingDateRangeSettings);
if (!dateRange.Start.HasValue && !dateRange.End.HasValue)
{
// default to current year
drpSlidingDateRange.SlidingDateRangeMode = SlidingDateRangePicker.SlidingDateRangeType.Current;
drpSlidingDateRange.TimeUnit = SlidingDateRangePicker.TimeUnitType.Year;
}
else
{
drpSlidingDateRange.DelimitedValues = slidingDateRangeSettings;
}
}
nrePledgeAmount.DelimitedValues = this.GetUserPreference(keyPrefix + "nrePledgeAmount");
nrePercentComplete.DelimitedValues = this.GetUserPreference(keyPrefix + "nrePercentComplete");
nreAmountGiven.DelimitedValues = this.GetUserPreference(keyPrefix + "nreAmountGiven");
string includeSetting = this.GetUserPreference(keyPrefix + "Include");
if (!string.IsNullOrWhiteSpace(includeSetting))
{
rblInclude.SetValue(Int32.Parse(includeSetting));
}
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
var viewModelQuery = GetViewModelQuery();
// Filter the results by the date range
var startDateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(sdrpDateRange.DelimitedValues);
if (startDateRange.Start.HasValue)
{
viewModelQuery = viewModelQuery.Where(vm => vm.InteractionDateTime >= startDateRange.Start.Value);
}
if (startDateRange.End.HasValue)
{
viewModelQuery = viewModelQuery.Where(vm => vm.InteractionDateTime <= startDateRange.End.Value);
}
// Filter by the authenticated state
var isAuthenticated = rblIsAuthenticated.SelectedValue.AsBooleanOrNull();
if (isAuthenticated.HasValue)
{
viewModelQuery = viewModelQuery.Where(vm => vm.PersonAliasId.HasValue == isAuthenticated.Value);
}
// Filter by URL
var url = tbUrlContains.Text;
if (!url.IsNullOrWhiteSpace())
{
viewModelQuery = viewModelQuery.Where(vm => vm.Url.Contains(url));
}
// Sort the results
var sortProperty = gInteractions.SortProperty ?? new SortProperty
{
Direction = SortDirection.Descending,
Property = "InteractionDateTime"
};
viewModelQuery = viewModelQuery.Sort(sortProperty);
gInteractions.SetLinqDataSource(viewModelQuery);
gInteractions.DataBind();
}
public void Execute(IJobExecutionContext context)
{
var dataMap = context.JobDetail.JobDataMap;
RockContext rockContext = null;
IQueryable <GroupMember> familyMembers = null;
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(dataMap.GetString("DateRange") ?? "-1||");
int peopleUpdated = 0;
var familyGroupType = GroupTypeCache.Get(Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY);
do
{
if (familyMembers != null)
{
foreach (var familyMember in familyMembers.OrderBy(f => f.Id).Take(100).ToList())
{
familyMember.Person.GivingGroupId = familyMember.GroupId;
peopleUpdated += 1;
}
rockContext.SaveChanges();
}
rockContext = new RockContext();
familyMembers = new GroupMemberService(rockContext)
.Queryable("Group,Person")
.Where(g => g.Group.GroupType.Id == familyGroupType.Id &&
(g.Person.GivingGroupId == 0 || g.Person.GivingGroupId == null));
if (dateRange.Start.HasValue)
{
familyMembers = familyMembers.Where(g => g.Person.CreatedDateTime >= dateRange.Start);
}
if (dateRange.End.HasValue)
{
familyMembers = familyMembers.Where(g => g.Person.CreatedDateTime < dateRange.End);
}
} while (familyMembers.Any());
context.Result = string.Format("Combined giving on {0} {1}", peopleUpdated, peopleUpdated == 1 ? "person" : "people");
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
SelectionConfig selectionConfig = SelectionConfig.Parse(selection);
if (selectionConfig != null)
{
var entityTypeIdPerson = EntityTypeCache.GetId <Rock.Model.Person>();
var noteQry = new NoteService(( RockContext )serviceInstance.Context).Queryable()
.Where(x => x.NoteType.EntityTypeId == entityTypeIdPerson);
if (selectionConfig.NoteTypeId.HasValue)
{
noteQry = noteQry.Where(x => x.NoteTypeId == selectionConfig.NoteTypeId.Value);
}
if (selectionConfig.NoteContains.IsNotNullOrWhiteSpace())
{
noteQry = noteQry.Where(a => a.Text.Contains(selectionConfig.NoteContains));
}
if (selectionConfig.DateRangeMode != null)
{
DateRange dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(selectionConfig.DelimitedValues);
if (dateRange.Start.HasValue)
{
noteQry = noteQry.Where(n => n.CreatedDateTime >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
noteQry = noteQry.Where(n => n.CreatedDateTime <= dateRange.End.Value);
}
}
var qry = new PersonService(( RockContext )serviceInstance.Context).Queryable()
.Where(p => noteQry.Any(x => x.EntityId == p.Id));
return(FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p"));
}
return(null);
}
public int InteractionsInRange(int personId, int interactionChannelId, string delimitedDateRange)
{
var interactionQry = new InteractionService((Rock.Data.RockContext)Service.Context).Queryable()
.Where(a => a.PersonAlias.PersonId == personId && a.InteractionComponent.InteractionChannelId == interactionChannelId);
if (!string.IsNullOrEmpty(delimitedDateRange))
{
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(delimitedDateRange);
if (dateRange.Start.HasValue)
{
interactionQry = interactionQry.Where(a => a.InteractionDateTime >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
interactionQry = interactionQry.Where(a => a.InteractionDateTime <= dateRange.End.Value);
}
}
return(interactionQry.Count());
}
/// <summary>
/// Get the selected date range or the default range
/// </summary>
/// <returns></returns>
private DateRange GetDateRange()
{
var isDaily = IsStreakTypeDaily();
var range = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(sdrpDateRange.DelimitedValues);
if (!range.Start.HasValue && !range.End.HasValue)
{
range.Start = GetDefaultStartDate();
range.End = GetDefaultEndDate();
}
else if (!range.Start.HasValue)
{
range.Start = range.End.Value.AddDays((0 - DefaultCheckboxCount) * (isDaily ? 1 : DaysPerWeek));
}
else if (!range.End.HasValue)
{
range.End = range.Start.Value.AddDays((DefaultCheckboxCount) * (isDaily ? 1 : DaysPerWeek));
}
return(range);
}
/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
public virtual void Execute(IJobExecutionContext context)
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
var groupTypeService = new GroupTypeService(new RockContext());
groupTypes = new List <GroupType>(groupTypeService.GetByGuids(dataMap.Get("GroupTypes").ToString().Split(',').Select(Guid.Parse).ToList()));
var requestDateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(dataMap.Get("OccurrenceDateRange").ToString() ?? "-1||");
startDate = ( DateTime )requestDateRange.Start;
endDate = ( DateTime )requestDateRange.End;
if (groupTypes.IsNull() || groupTypes.Count == 0)
{
context.Result = "Job failed. Unable to find group role/type";
throw new Exception("No group role/type found");
}
systemEmailGuid = dataMap.GetString("SystemEmail").AsGuid();
SendEmailToCampusPastors();
context.Result = string.Format("{0} emails sent", engagementEmailsSent);
if (errorMessages.Any())
{
StringBuilder sb = new StringBuilder();
sb.AppendLine();
sb.Append(string.Format("{0} Errors: ", errorCount));
errorMessages.ForEach(e => { sb.AppendLine(); sb.Append(e); });
string errors = sb.ToString();
context.Result += errors;
var exception = new Exception(errors);
HttpContext context2 = HttpContext.Current;
ExceptionLogService.LogException(exception, context2);
throw exception;
}
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="entityIdProperty">The entity identifier property.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(RockContext context, MemberExpression entityIdProperty, string selection)
{
var settings = new CreatedNotesCountSelectSettings(selection);
if (settings != null)
{
var noteQry = new NoteService(context).Queryable().Where(x => x.CreatedByPersonAliasId.HasValue);
if (settings.NoteTypeIds != null && settings.NoteTypeIds.Any())
{
noteQry = noteQry.Where(xx => settings.NoteTypeIds.Contains(xx.NoteTypeId));
}
if (settings.DelimitedValues.IsNotNullOrWhiteSpace())
{
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(settings.DelimitedValues);
if (dateRange.Start.HasValue)
{
noteQry = noteQry.Where(i => i.CreatedDateTime >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
noteQry = noteQry.Where(i => i.CreatedDateTime <= dateRange.End.Value);
}
}
var qry = new PersonService(context).Queryable()
.Select(p => noteQry.Where(l => l.CreatedByPersonAlias.PersonId == p.Id).Count());
var selectExpression = SelectExpressionExtractor.Extract(qry, entityIdProperty, "p");
return(selectExpression);
}
return(null);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
string[] options = selection.Split('|');
if (options.Length < 4)
{
return(null);
}
var groupGuidList = options[0].Split(',').AsGuidList();
ComparisonType comparisonType = options[1].ConvertToEnum <ComparisonType>(ComparisonType.GreaterThanOrEqualTo);
int? attended = options[2].AsIntegerOrNull();
string slidingDelimitedValues = options[3].Replace(',', '|');
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(slidingDelimitedValues);
bool includeChildGroups = options.Length >= 5 ? options[4].AsBooleanOrNull() ?? false : false;
var groupService = new GroupService(new RockContext());
var groups = groupService.GetByGuids(groupGuidList);
List <int> groupIds = new List <int>();
foreach (var group in groups)
{
groupIds.Add(group.Id);
if (includeChildGroups)
{
var childGroups = groupService.GetAllDescendents(group.Id);
if (childGroups.Any())
{
groupIds.AddRange(childGroups.Select(a => a.Id));
// get rid of any duplicates
groupIds = groupIds.Distinct().ToList();
}
}
}
var rockContext = serviceInstance.Context as RockContext;
var attendanceQry = new AttendanceService(rockContext).Queryable().Where(a => a.DidAttend.HasValue && a.DidAttend.Value);
if (dateRange.Start.HasValue)
{
var startDate = dateRange.Start.Value;
attendanceQry = attendanceQry.Where(a => a.StartDateTime >= startDate);
}
if (dateRange.End.HasValue)
{
var endDate = dateRange.End.Value;
attendanceQry = attendanceQry.Where(a => a.StartDateTime < endDate);
}
if (groupIds.Count == 1)
{
int groupId = groupIds[0];
attendanceQry = attendanceQry.Where(a => a.GroupId.HasValue && a.GroupId.Value == groupId);
}
else if (groupIds.Count > 1)
{
attendanceQry = attendanceQry.Where(a => a.GroupId.HasValue && groupIds.Contains(a.GroupId.Value));
}
else
{
// no groups selected, so return nothing
return(Expression.Constant(false));
}
var qry = new PersonService(rockContext).Queryable()
.Where(p => attendanceQry.Where(xx => xx.PersonAlias.PersonId == p.Id).Count() == attended);
BinaryExpression compareEqualExpression = FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p") as BinaryExpression;
BinaryExpression result = FilterExpressionExtractor.AlterComparisonType(comparisonType, compareEqualExpression, null);
return(result);
}
public string CalculateSlidingDateRange(SlidingDateRangePicker.SlidingDateRangeType slidingDateRangeType, SlidingDateRangePicker.TimeUnitType timeUnitType, string startDate, string endDate, int number = 1)
{
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(string.Format("{0}|{1}|{2}|{3}|{4}", slidingDateRangeType, number, timeUnitType, startDate, endDate));
return(dateRange.ToStringAutomatic());
}