/// <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()); }