/// <summary> /// Gets the financial account. /// </summary> /// <param name="achievementTypeCache">The achievement type cache.</param> /// <param name="rockContext">The rock context.</param> /// <returns> /// <br /> /// </returns> private FinancialAccount GetFinancialAccount(AchievementTypeCache achievementTypeCache, RockContext rockContext = null) { if (null == rockContext) { rockContext = new RockContext(); } var guid = GetFinancialAccountGuid(achievementTypeCache); if (!guid.HasValue) { return(null); } var accountService = new FinancialAccountService(rockContext); return(accountService.GetByGuids(new List <Guid>() { guid.Value }).FirstOrDefault()); }
/// <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; var selectionConfig = SelectionConfig.Parse(selection) ?? new SelectionConfig(); ComparisonType comparisonType = selectionConfig.ComparisonType; decimal amount = selectionConfig.Amount ?? 0.00M; DateRange dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(selectionConfig.SlidingDateRangePickerDelimitedValues); var accountGuids = selectionConfig.AccountGuids; List <int> accountIdList; if (accountGuids != null && accountGuids.Any()) { var financialAccountService = new FinancialAccountService(( RockContext )serviceInstance.Context); accountIdList = financialAccountService.GetByGuids(accountGuids).Select(a => a.Id).ToList(); if (selectionConfig.IncludeChildAccounts) { var parentAccountIds = accountIdList.ToList(); foreach (var parentAccountId in parentAccountIds) { var descendantChildAccountIds = financialAccountService.GetAllDescendentIds(parentAccountId); accountIdList.AddRange(descendantChildAccountIds); } } } else { accountIdList = new List <int>(); } bool combineGiving = selectionConfig.CombineGiving; int transactionTypeContributionId = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid()).Id; bool useAnalyticsModels = selectionConfig.UseAnalyticsModels; IQueryable <TransactionDetailData> financialTransactionDetailBaseQry; if (useAnalyticsModels) { financialTransactionDetailBaseQry = new AnalyticsSourceFinancialTransactionService(rockContext).Queryable() .Where(xx => xx.AuthorizedPersonAliasId.HasValue) .Where(xx => xx.TransactionTypeValueId == transactionTypeContributionId) .Select(ss => new TransactionDetailData { AuthorizedPersonAliasId = ss.AuthorizedPersonAliasId.Value, TransactionDateTime = ss.TransactionDateTime, Amount = ss.Amount, AccountId = ss.AccountId ?? 0 }); } else { financialTransactionDetailBaseQry = new FinancialTransactionDetailService(rockContext).Queryable() .Where(xx => xx.Transaction.AuthorizedPersonAliasId.HasValue) .Where(xx => xx.Transaction.TransactionDateTime.HasValue) .Where(xx => xx.Transaction.TransactionTypeValueId == transactionTypeContributionId) .Select(ss => new TransactionDetailData { AuthorizedPersonAliasId = ss.Transaction.AuthorizedPersonAliasId.Value, TransactionDateTime = ss.Transaction.TransactionDateTime.Value, Amount = ss.Amount, AccountId = ss.AccountId }); } if (dateRange.Start.HasValue) { financialTransactionDetailBaseQry = financialTransactionDetailBaseQry.Where(xx => xx.TransactionDateTime >= dateRange.Start.Value); } if (dateRange.End.HasValue) { financialTransactionDetailBaseQry = financialTransactionDetailBaseQry.Where(xx => xx.TransactionDateTime < dateRange.End.Value); } if (accountIdList.Any()) { if (accountIdList.Count() == 1) { var accountId = accountIdList[0]; financialTransactionDetailBaseQry = financialTransactionDetailBaseQry.Where(x => accountId == x.AccountId); } else { financialTransactionDetailBaseQry = financialTransactionDetailBaseQry.Where(x => accountIdList.Contains(x.AccountId)); } } if (selectionConfig.IgnoreInactiveAccounts) { var inactiveAccountIdQuery = new FinancialAccountService(rockContext).Queryable().Where(a => !a.IsActive).Select(a => a.Id); financialTransactionDetailBaseQry = financialTransactionDetailBaseQry.Where(a => !inactiveAccountIdQuery.Contains(a.AccountId)); } bool excludePersonsWithTransactions = false; // Create explicit joins to person alias and person tables so that rendered SQL has an INNER Joins vs OUTER joins on Person and PersonAlias var personAliasQry = new PersonAliasService(rockContext).Queryable(); var personQryForJoin = new PersonService(rockContext).Queryable(true); var financialTransactionDetailAmountQry = financialTransactionDetailBaseQry .Join( personAliasQry, t => t.AuthorizedPersonAliasId, pa => pa.Id, (t, pa) => new { TransactionDetailData = t, PersonId = pa.PersonId }) .Join( personQryForJoin, j1 => j1.PersonId, p => p.Id, (j1, p) => new { Amount = j1.TransactionDetailData.Amount, Person = p }); IQueryable <GiverAmountInfo> financialTransactionGivingAmountQry; if (combineGiving) { var financialTransactionGroupByQuery = financialTransactionDetailAmountQry.GroupBy(xx => xx.Person.GivingId); financialTransactionGivingAmountQry = financialTransactionGroupByQuery .Select(xx => new GiverAmountInfo { GivingId = xx.Key, TotalAmount = xx.Sum(ss => ss.Amount) }); } else { var financialTransactionGroupByQuery = financialTransactionDetailAmountQry.GroupBy(xx => xx.Person.Id); financialTransactionGivingAmountQry = financialTransactionGroupByQuery .Select(xx => new GiverAmountInfo { PersonId = xx.Key, TotalAmount = xx.Sum(ss => ss.Amount) }); } if (comparisonType == ComparisonType.LessThan) { // NOTE: Since we want people that have less than the specified, but also want to include people to didn't give anything at all (no transactions) // make this query the same as the GreaterThan, but use it to EXCLUDE people that gave MORE than the specified amount. That // way the filter will include people that had no transactions for the specified date/range and account financialTransactionGivingAmountQry = financialTransactionGivingAmountQry.Where(xx => xx.TotalAmount >= amount); excludePersonsWithTransactions = true; } else if (comparisonType == ComparisonType.EqualTo) { if (amount == 0.00M) { // NOTE: If we want to list people that gave $0.00 (they didn't giving anything) // EXCLUDE people that gave any amount excludePersonsWithTransactions = true; } else { financialTransactionGivingAmountQry = financialTransactionGivingAmountQry.Where(xx => xx.TotalAmount == amount); } } else if (comparisonType == ComparisonType.GreaterThanOrEqualTo) { // NOTE: if the amount filter is 'they gave $0.00 or more', and doing a GreaterThanOrEqualTo, then we don't need to calculate and compare against TotalAmount if (amount == 0.00M) { // no need to filter by amount if greater than or equal to $0.00 } else { financialTransactionGivingAmountQry = financialTransactionGivingAmountQry.Where(xx => xx.TotalAmount >= amount); } } IQueryable <Model.Person> qry; if (combineGiving) { if (excludePersonsWithTransactions) { // the filter is for people that gave LESS than the specified amount, so return people that didn't give MORE than the specified amount qry = new PersonService(rockContext).Queryable().Where(p => !financialTransactionGivingAmountQry.Any(xx => xx.GivingId == p.GivingId)); } else { qry = new PersonService(rockContext).Queryable().Where(p => financialTransactionGivingAmountQry.Any(xx => xx.GivingId == p.GivingId)); } } else { if (excludePersonsWithTransactions) { // the filter is for people that gave LESS than the specified amount, so return people that didn't give MORE than the specified amount qry = new PersonService(rockContext).Queryable().Where(p => !financialTransactionGivingAmountQry.Any(xx => xx.PersonId == p.Id)); } else { qry = new PersonService(rockContext).Queryable().Where(p => financialTransactionGivingAmountQry.Any(xx => xx.PersonId == p.Id)); } } Expression extractedFilterExpression = FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p"); return(extractedFilterExpression); }