public async Task <ActionResult <IncomeDto> > CreateIncomeAsync([FromBody] CreateIncomeDto incomeForCreateDto)
{
if (incomeForCreateDto.BudgetId == null)
{
return(BadRequest("BudgetId is required."));
}
var budget = await budgetRepository.GetByIdAsync(incomeForCreateDto.BudgetId.Value);
if (budget == null)
{
return(NotFound($"No budget with id {incomeForCreateDto.BudgetId.Value} found"));
}
if (!IsUserAuthorizedForResource(budget))
{
return(Unauthorized($"You are not authorized to access budget with id {incomeForCreateDto.BudgetId.Value}"));
}
var newIncome = mapper.Map <Income>(incomeForCreateDto);
incomeRepository.Add(newIncome);
var saveResult = await incomeRepository.SaveAllAsync();
if (!saveResult)
{
return(BadRequest("Unable to create expense."));
}
var incomeForReturn = mapper.Map <IncomeDto>(newIncome);
return(CreatedAtRoute("GetIncomeAsync", new { id = incomeForReturn.Id }, incomeForReturn));
}
/// <inheritdoc />
public override async Task <Response> Handle(Query request, CancellationToken cancellationToken)
{
if (!await BudgetRepository.IsAccessibleToUser(request.BudgetId))
{
throw new NotFoundException("Budget was not found");
}
var budgetEntity = await BudgetRepository.GetByIdAsync(request.BudgetId);
var categoryReports = budgetEntity.BudgetCategories
.Select(x => new BudgetCategoryReport(x, request.DateStart, request.DateEnd))
.ToList();
var reportDto = new MonthlyBudgetReportDto();
reportDto.BudgetCategoryReports = categoryReports.Select(x => new BudgetCategoryMonthlyReportDto()
{
BudgetCategoryId = x.Category.Id,
BudgetCategoryType = x.Category.Type,
MonthlyReports = x.MonthByMonth
.Data
.Select(t => new MonthReportDto()
{
Month = new Month()
{
MonthNumber = t.Month,
Year = t.Year
},
ReportData = new ReportDataDto()
{
AllocationsSum = t.AllocationsSum,
AveragePerDay = t.AveragePerDay,
TransactionsSum = t.TransactionsSum
}
})
})
.ToList();
reportDto.TotalMonthlyReports = reportDto.BudgetCategoryReports
.SelectMany(x => x.MonthlyReports)
.GroupBy(x => x.Month)
.Select(t => new MonthReportDto()
{
Month = t.Key,
ReportData = new ReportDataDto()
{
AllocationsSum = t.Sum(g => g.ReportData.AllocationsSum),
TransactionsSum = t.Sum(g => g.ReportData.TransactionsSum),
AveragePerDay = t.Sum(g => g.ReportData.AveragePerDay)
}
});
return(new Response()
{
Data = reportDto
});
}
/// <inheritdoc />
public override async Task <Response> Handle(Query request, CancellationToken cancellationToken)
{
if (!await BudgetRepository.IsAccessibleToUser(request.BudgetId))
{
throw new NotFoundException("Budget was not found");
}
var repositoryResult = await BudgetRepository.GetByIdAsync(request.BudgetId);
var dto = Mapper.Map <BudgetDto>(repositoryResult);
return(new Response()
{
Data = dto
});
}
/// <inheritdoc />
public override async Task <Response> Handle(Query request, CancellationToken cancellationToken)
{
if (!await BudgetRepository.IsAccessibleToUser(request.BudgetId))
{
throw new NotFoundException("Budget was not found");
}
var budgetEntity = await BudgetRepository.GetByIdAsync(request.BudgetId);
var categoryReports = budgetEntity.BudgetCategories
.Select(x => new BudgetCategoryReport(x, request.DateStart, request.DateEnd))
.ToList();
var reportDto = new PeriodBudgetReportDto();
reportDto.BudgetCategoryReports = categoryReports.Select(x => new BudgetCategoryPeriodReportDto()
{
BudgetCategoryId = x.Category.Id,
BudgetCategoryType = x.Category.Type,
ReportData = new ReportDataDto()
{
BudgetedSum = x.PeriodReport.BudgetAmount,
AllocationsSum = x.PeriodReport.AllocationsSum,
AveragePerDay = x.PeriodReport.AveragePerDay,
TransactionsSum = x.PeriodReport.TransactionsSum
}
})
.ToList();
reportDto.TotalPeriodReport = new ReportDataDto()
{
BudgetedSum = reportDto.BudgetCategoryReports.Sum(g => g.ReportData.BudgetedSum),
AllocationsSum = reportDto.BudgetCategoryReports.Sum(g => g.ReportData.AllocationsSum),
TransactionsSum = reportDto.BudgetCategoryReports.Sum(g => g.ReportData.TransactionsSum),
AveragePerDay = reportDto.BudgetCategoryReports.Sum(g => g.ReportData.AveragePerDay)
};
return(new Response()
{
Data = reportDto
});
}
/// <inheritdoc />
public override async Task <Response> Handle(Request request, CancellationToken cancellationToken)
{
var budgetEntity = await BudgetRepository.GetByIdAsync(request.BudgetId);
if (AuthenticationProvider.User.UserId != budgetEntity.OwnedByUserId)
{
throw new NotFoundException("Requested budget was not found in user's owned budgets'");
}
await BudgetRepository.DeleteAsync(budgetEntity);
await BudgetRepository.SaveChangesAsync(cancellationToken);
_ = _mediator.Publish(new Notification()
{
BudgetId = budgetEntity.Id,
}, cancellationToken);
return(new Response()
{
Data = new Unit()
});
}
public async Task <ActionResult <BudgetDto> > GetBudgetAsync(int id)
{
var result = await budgetRepository.GetByIdAsync(id);
if (result == null)
{
return(NotFound($"No Budget with Id {id} found."));
}
if (!IsUserAuthorizedForResource(result))
{
return(Unauthorized("You can only access your own budget."));
}
var budgetForReturn = mapper.Map <BudgetDto>(result);
return(Ok(budgetForReturn));
}
