public async Task <Result> Handle(Query request, CancellationToken cancellationToken)
            {
                var spendingBudgetCategoryIds = _accessControlService.GetAccessibleBudgetCategoryIds(request.BudgetId, eBudgetCategoryType.Spending).ToList();
                var incomeBudgetCategoryIds   = _accessControlService.GetAccessibleBudgetCategoryIds(request.BudgetId, eBudgetCategoryType.Income).ToList();
                var savingBudgetCategoryIds   = _accessControlService.GetAccessibleBudgetCategoryIds(request.BudgetId, eBudgetCategoryType.Saving).ToList();

                var budgetCategoryIds = spendingBudgetCategoryIds.Union(incomeBudgetCategoryIds).Union(savingBudgetCategoryIds);

                var balances = budgetCategoryIds
                               .Select(x => _balanceService.GetTotalCategoryBalance(x))
                               .ToList();


                var spendingBalances = balances.Where(x => spendingBudgetCategoryIds.Contains(x.BudgetCategoryId)).ToList();
                var incomeBalances   = balances.Where(x => incomeBudgetCategoryIds.Contains(x.BudgetCategoryId)).ToList();
                var savingBalances   = balances.Where(x => savingBudgetCategoryIds.Contains(x.BudgetCategoryId)).ToList();


                var spendingSummary = new BudgetedAmountSummaryDto
                {
                    CurrentBudgetedAmount  = spendingBalances.Select(x => x.ThisMonthBudgetedAmount).Aggregate((a, b) => a + b),
                    TotalBudgetedAmount    = spendingBalances.Select(x => x.TotalBudgetedAmount).Aggregate((a, b) => a + b),
                    ThisYearBudgetedAmount = spendingBalances.Select(x => x.ThisYearBudgetedAmount).Aggregate((a, b) => a + b),
                };
                var incomeSummary = new BudgetedAmountSummaryDto
                {
                    CurrentBudgetedAmount  = incomeBalances.Select(x => x.ThisMonthBudgetedAmount).Aggregate((a, b) => a + b),
                    TotalBudgetedAmount    = incomeBalances.Select(x => x.TotalBudgetedAmount).Aggregate((a, b) => a + b),
                    ThisYearBudgetedAmount = incomeBalances.Select(x => x.ThisYearBudgetedAmount).Aggregate((a, b) => a + b),
                };
                var savingSummary = new BudgetedAmountSummaryDto
                {
                    CurrentBudgetedAmount  = savingBalances.Select(x => x.ThisMonthBudgetedAmount).Aggregate((a, b) => a + b),
                    TotalBudgetedAmount    = savingBalances.Select(x => x.TotalBudgetedAmount).Aggregate((a, b) => a + b),
                    ThisYearBudgetedAmount = savingBalances.Select(x => x.ThisYearBudgetedAmount).Aggregate((a, b) => a + b),
                };

                var totalSummary = new BudgetedAmountSummaryDto
                {
                    CurrentBudgetedAmount  = incomeSummary.CurrentBudgetedAmount - spendingSummary.CurrentBudgetedAmount - savingSummary.CurrentBudgetedAmount,
                    TotalBudgetedAmount    = incomeSummary.TotalBudgetedAmount - spendingSummary.TotalBudgetedAmount - savingSummary.TotalBudgetedAmount,
                    ThisYearBudgetedAmount = incomeSummary.ThisYearBudgetedAmount - spendingSummary.ThisYearBudgetedAmount - savingSummary.ThisYearBudgetedAmount,
                };

                return(new Result()
                {
                    Data = new SummaryDto()
                    {
                        SpendingSummary = spendingSummary,
                        IncomeSummary = incomeSummary,
                        SavingSummary = savingSummary,
                        TotalSummary = totalSummary
                    }
                });
            }
Esempio n. 2
0
            public async Task <Result> Handle(Query request, CancellationToken cancellationToken)
            {
                var budgetCategoryIds = _accessControlService.GetAccessibleBudgetCategoryIds(request.BudgetId);

                var query = _readDb.BudgetCategories
                            .Where(x => budgetCategoryIds.Contains(x.BudgetCategoryId) && x.BudgetId == request.BudgetId);

                if (request.BudgetCategoryTypes != null && request.BudgetCategoryTypes.Any())
                {
                    query = query.Where(x => request.BudgetCategoryTypes.Contains(x.BudgetCategoryType));
                }

                var budgetCategories = await query.ToListAsync(cancellationToken : cancellationToken);

                var dtos = _mapper.Map <List <BudgetCategoryDto> >(budgetCategories);

                return(new Result()
                {
                    Data = dtos.Select(x =>
                    {
                        x.BudgetedAmounts = x.BudgetedAmounts.OrderBy(s => s.ValidFrom).ToList();
                        return x;
                    })
                           .OrderBy(x => x.Order)
                           .ToList(),
                    Total = budgetCategories.Count()
                });
            }
            public async Task <Result> Handle(Query request, CancellationToken cancellationToken)
            {
                var budgetCategoryIdsQuery = _accessControlService.GetAccessibleBudgetCategoryIds(request.BudgetId, request.BudgetCategoryType);

                if (request.BudgetCategoryIds != null && request.BudgetCategoryIds.Any())
                {
                    budgetCategoryIdsQuery = budgetCategoryIdsQuery.Where(x => request.BudgetCategoryIds.Any(s => s == x));
                }

                var budgetCategoryIds = budgetCategoryIdsQuery.ToList();

                var query = _readDb.Transactions.Where(x => budgetCategoryIds.Contains(x.BudgetCategoryId));

                if (!string.IsNullOrEmpty(request.Search))
                {
                    query = query.Where(x => x.Description.ToLower().Contains(request.Search.ToLower()));
                }

                if (request.TransactionDateStart != null)
                {
                    query = query.Where(x => x.TransactionDate >= request.TransactionDateStart.Value.Date);
                }

                if (request.TransactionDateEnd != null)
                {
                    query = query.Where(x => x.TransactionDate <= request.TransactionDateEnd.Value.Date);
                }

                if (request.MinAmount != null)
                {
                    query = query.Where(x => x.Amount.Amount >= request.MinAmount);
                }

                if (request.MaxAmount != null)
                {
                    query = query.Where(x => x.Amount.Amount <= request.MaxAmount);
                }

                var data = await query.ProjectTo <TransactionDto>(_mapperConfiguration)
                           .ApplyGridQueryOptions(request)
                           .ToListAsync(cancellationToken);

                return(new Result()
                {
                    Data = data,
                    Total = query.Count(),
                    PageSize = request.PageSize
                });
            }
            public async Task <Result> Handle(Query request, CancellationToken cancellationToken)
            {
                var budgetCategoryIdsQuery = _accessControlService.GetAccessibleBudgetCategoryIds(request.BudgetId, request.BudgetCategoryType);

                var budgetCategoryIds = budgetCategoryIdsQuery.ToList();

                var query = _readDb.TransactionTemplates.Where(x => budgetCategoryIds.Contains(x.BudgetCategoryId));

                var data = await query.ProjectTo <TransactionTemplateDto>(_mapperConfiguration)
                           .OrderBy(x => x.Description)
                           .ToListAsync(cancellationToken);

                return(new Result()
                {
                    Data = data,
                    Total = query.Count()
                });
            }
Esempio n. 5
0
            public async Task <Result> Handle(Query request, CancellationToken cancellationToken)
            {
                var      budgetCategoryIds = _accessControlService.GetAccessibleBudgetCategoryIds(request.BudgetId).ToList();
                var      query             = _readDb.Allocations.Where(x => budgetCategoryIds.Any(s => s == x.TargetBudgetCategoryId));
                DateTime?min = null;
                DateTime?max = null;

                if (query.Any())
                {
                    min = (await query.MinAsync(x => x.AllocationDate, cancellationToken)).Date;
                    max = (await query.MaxAsync(x => x.AllocationDate, cancellationToken)).Date;
                }

                return(new Result()
                {
                    Data = new DatesRangeDto()
                    {
                        MaxDate = max,
                        MinDate = min
                    }
                });
            }
            public async Task <Result> Handle(Query request, CancellationToken cancellationToken)
            {
                var budgetCategoryIdsQuery = _accessControlService.GetAccessibleBudgetCategoryIds(request.BudgetId, request.BudgetCategoryType);

                if (request.BudgetCategoryIds != null && request.BudgetCategoryIds.Any())
                {
                    budgetCategoryIdsQuery = budgetCategoryIdsQuery.Where(x => request.BudgetCategoryIds.Any(s => s == x));
                }

                var budgetCurrency = _readDb.Budgets.First(x => x.BudgetId == request.BudgetId).Currency;

                var budgetCategoryIds = budgetCategoryIdsQuery.ToList();
                var budgetCategories  = _readDb.BudgetCategories.Where(x => budgetCategoryIds.Contains(x.BudgetCategoryId)).ToList();

                var query = _readDb.Transactions.Where(x => budgetCategoryIds.Contains(x.BudgetCategoryId));

                query = query.Where(x => x.TransactionDate >= request.TransactionDateStart.Date && x.TransactionDate <= request.TransactionDateEnd.Date);


                var transactions = await query.ToListAsync(cancellationToken);

                if (!transactions.Any())
                {
                    return(new Result());
                }

                var timelinePeriod = new DateRange(request.TransactionDateStart, request.TransactionDateEnd);

                var periods = request.GroupingStep switch
                {
                    eGroupingStep.Day => timelinePeriod.Start.EachDayTo(timelinePeriod.End),
                    eGroupingStep.Year => timelinePeriod.Start.EachYearTo(timelinePeriod.End),
                    eGroupingStep.Month => timelinePeriod.Start.EachMonthTo(timelinePeriod.End),
                    eGroupingStep.Quarter => timelinePeriod.Start.EachQuarterTo(timelinePeriod.End),
                    eGroupingStep.Week => timelinePeriod.Start.EachWeekTo(timelinePeriod.End, CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek),
                    _ => throw new ArgumentOutOfRangeException()
                };

                var dateRanges = transactions.GroupBy(x => periods.FirstOrDefault(s => s.Contains(x.TransactionDate)))
                                 .Select(periodGroup =>
                {
                    var period = periodGroup.Key;

                    var categoryDataPoints = budgetCategories.Select(category =>
                    {
                        var categoryId     = category.BudgetCategoryId;
                        var categoryAmount = periodGroup.Where(s => s.BudgetCategoryId == categoryId)
                                             .Select(s => s.Amount + s.SubTransactions.Select(t => t.Amount).Aggregate(new MoneyAmount(budgetCurrency.CurrencyCode, 0), (a, b) => a + b))
                                             .Aggregate(new MoneyAmount(budgetCurrency.CurrencyCode, 0), (a, b) => a + b);

                        return(new BudgetCategoryDataPointDto()
                        {
                            DateRange = period,
                            BudgetCategoryId = categoryId,
                            Key = period.ToString(),
                            AmountTotal = categoryAmount
                        });
                    })
                                             .ToList();

                    var totalAmount = categoryDataPoints.Select(x => x.AmountTotal)
                                      .Aggregate(new MoneyAmount(budgetCurrency.CurrencyCode, 0), (a, b) => a + b);

                    return(new DateRangeData()
                    {
                        DateRange = period,
                        Key = period.ToString(),
                        BudgetCategories = categoryDataPoints,
                        Total = new DataPointDto()
                        {
                            DateRange = period,
                            Key = period.ToString(),
                            AmountTotal = totalAmount
                        }
                    });
                })
                                 .OrderByDescending(x => x.DateRange.Start)
                                 .ToList();

                if (dateRanges.Count > 1)
                {
                    for (var i = 0; i < dateRanges.Count - 1; i++)
                    {
                        var current  = dateRanges[i];
                        var previous = dateRanges[i + 1];

                        foreach (var budgetCategoryDataPoint in current.BudgetCategories)
                        {
                            var previousBudgetCategoryDataPoint = previous.BudgetCategories.FirstOrDefault(x => x.BudgetCategoryId == budgetCategoryDataPoint.BudgetCategoryId);
                            if (previousBudgetCategoryDataPoint == null)
                            {
                                continue;
                                ;
                            }

                            budgetCategoryDataPoint.AmountTotalChange = previousBudgetCategoryDataPoint.AmountTotal.Amount > 0
                                                                            ? (budgetCategoryDataPoint.AmountTotal.Amount - previousBudgetCategoryDataPoint.AmountTotal.Amount) / previousBudgetCategoryDataPoint.AmountTotal.Amount
                                                                            : (decimal?)null;

                            budgetCategoryDataPoint.AmountPerDayChange = previousBudgetCategoryDataPoint.AmountPerDay.Amount > 0
                                                                             ? (budgetCategoryDataPoint.AmountPerDay.Amount - previousBudgetCategoryDataPoint.AmountPerDay.Amount) / previousBudgetCategoryDataPoint.AmountPerDay.Amount
                                                                             : (decimal?)null;

                            budgetCategoryDataPoint.AmountPerWeekChange = previousBudgetCategoryDataPoint.AmountPerWeek.Amount > 0
                                                                              ? (budgetCategoryDataPoint.AmountPerWeek.Amount - previousBudgetCategoryDataPoint.AmountPerWeek.Amount) / previousBudgetCategoryDataPoint.AmountPerWeek.Amount
                                                                              : (decimal?)null;

                            budgetCategoryDataPoint.AmountPerMonthChange = previousBudgetCategoryDataPoint.AmountPerMonth.Amount > 0
                                                                               ? (budgetCategoryDataPoint.AmountPerMonth.Amount - previousBudgetCategoryDataPoint.AmountPerMonth.Amount) / previousBudgetCategoryDataPoint.AmountPerMonth.Amount
                                                                               : (decimal?)null;
                        }

                        current.Total.AmountTotalChange = previous.Total.AmountTotal.Amount > 0
                                                              ? (current.Total.AmountTotal.Amount - previous.Total.AmountTotal.Amount) / previous.Total.AmountTotal.Amount
                                                              : (decimal?)null;
                        current.Total.AmountPerDayChange = previous.Total.AmountTotal.Amount > 0
                                                               ? (current.Total.AmountPerDay.Amount - previous.Total.AmountPerDay.Amount) / previous.Total.AmountPerDay.Amount
                                                               : (decimal?)null;
                        current.Total.AmountPerWeekChange = previous.Total.AmountTotal.Amount > 0
                                                                ? (current.Total.AmountPerWeek.Amount - previous.Total.AmountPerWeek.Amount) / previous.Total.AmountPerWeek.Amount
                                                                : (decimal?)null;
                        current.Total.AmountPerMonthChange = previous.Total.AmountTotal.Amount > 0
                                                                 ? (current.Total.AmountPerMonth.Amount - previous.Total.AmountPerMonth.Amount) / previous.Total.AmountPerMonth.Amount
                                                                 : (decimal?)null;
                    }
                }

                var budgetCategoryTotals = dateRanges.SelectMany(x => x.BudgetCategories)
                                           .GroupBy(x => x.BudgetCategoryId)
                                           .Select(x => new BudgetCategoryDataPointDto()
                {
                    Key              = timelinePeriod.ToString(),
                    DateRange        = timelinePeriod,
                    BudgetCategoryId = x.Key,
                    AmountTotal      = x.Select(s => s.AmountTotal)
                                       .Aggregate(new MoneyAmount(budgetCurrency.CurrencyCode, 0), (a, b) => a + b)
                })
                                           .ToList();
                var total = new DataPointDto()
                {
                    DateRange   = timelinePeriod,
                    Key         = timelinePeriod.ToString(),
                    AmountTotal = budgetCategoryTotals.Select(x => x.AmountTotal)
                                  .Aggregate(new MoneyAmount(budgetCurrency.CurrencyCode, 0), (a, b) => a + b)
                };

                return(new Result()
                {
                    Data = new ResponseDto()
                    {
                        DateRanges = dateRanges,
                        BudgetCategoryTotals = budgetCategoryTotals,
                        Total = total
                    }
                });
            }
        }