private async Task <ResponseMessagesDto> UpdateExpenseAsync(CreateExpenseDto expenseDto)
{
var result = await _expenseRepository.UpdateAsync(new Expense()
{
Id = expenseDto.Id,
Name = expenseDto.Name,
Description = expenseDto.Description,
Cost = expenseDto.Cost
});
if (result != null)
{
return(new ResponseMessagesDto()
{
Id = result.Id,
SuccessMessage = AppConsts.SuccessfullyUpdated,
Success = true,
Error = false,
});
}
return(new ResponseMessagesDto()
{
Id = 0,
ErrorMessage = AppConsts.UpdateFailure,
Success = false,
Error = true,
});
}
public async Task <ActionResult <ExpenseDto> > CreateExpenseAsync([FromBody] CreateExpenseDto expenseForCreateDto)
{
if (expenseForCreateDto.BudgetId == null)
{
return(BadRequest("BudgetId is required."));
}
var budget = await budgetRepository.GetByIdAsync(expenseForCreateDto.BudgetId.Value);
if (budget == null)
{
return(NotFound($"No budget with id {expenseForCreateDto.BudgetId.Value} found"));
}
if (!IsUserAuthorizedForResource(budget))
{
return(Unauthorized($"You are not authorized to access budget with id {expenseForCreateDto.BudgetId.Value}"));
}
var newExpense = mapper.Map <Expense>(expenseForCreateDto);
expenseRepository.Add(newExpense);
var saveResult = await expenseRepository.SaveAllAsync();
if (!saveResult)
{
return(BadRequest("Unable to create expense."));
}
var expenseForReturn = mapper.Map <ExpenseDto>(newExpense);
return(CreatedAtRoute("GetExpenseAsync", new { id = expenseForReturn.Id }, expenseForReturn));
}
private async Task <ResponseMessagesDto> CreateExpenseAsync(CreateExpenseDto expenseDto)
{
var result = await _expenseRepository.InsertAsync(new Expense()
{
Name = expenseDto.Name,
Description = expenseDto.Description,
Cost = expenseDto.Cost,
TenantId = expenseDto.TenantId
});
await UnitOfWorkManager.Current.SaveChangesAsync();
if (result.Id != 0)
{
return(new ResponseMessagesDto()
{
Id = result.Id,
SuccessMessage = AppConsts.SuccessfullyInserted,
Success = true,
Error = false,
});
}
return(new ResponseMessagesDto()
{
Id = 0,
ErrorMessage = AppConsts.InsertFailure,
Success = false,
Error = true,
});
}
public async Task <ExpenseDto> CreateAsync(CreateExpenseDto dto, CancellationToken cancellationToken)
{
var entity = fMapper.Map <ExpenseEntity>(dto);
DbSet.Add(entity);
await fContext.SaveChangesAsync(cancellationToken);
return(fMapper.Map <ExpenseDto>(entity));
}
public async Task <IActionResult> CreateExpense([FromBody] CreateExpenseDto createExpenseDto)
{
var user = await _userService.GetById(int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier)));
if (createExpenseDto.PlannerId != user.PlannerId)
{
return(BadRequest());
}
await _expenseService.Create(createExpenseDto);
return(Ok());
}
public async Task <ResponseMessagesDto> CreateOrEditAsync(CreateExpenseDto expenseDto)
{
ResponseMessagesDto result;
if (expenseDto.Id == 0)
{
result = await CreateExpenseAsync(expenseDto);
}
else
{
result = await UpdateExpenseAsync(expenseDto);
}
return(result);
}
public async Task <ActionResult <ExpenseDto> > CreateExpenseAsync(CreateExpenseDto createExpenseDto)
{
Expense expense = new()
{
Id = Guid.NewGuid(),
Category = createExpenseDto.Category,
Price = createExpenseDto.Price,
DateOfExpense = DateTimeOffset.UtcNow
};
await repository.CreateExpenseAsync(expense);
return(CreatedAtAction(nameof(CreateExpenseAsync), new { id = expense.Id }, expense.AsDto()));
}
public async Task <ActionResult <ExpenseDto> > CreateExpenseAsync(CreateExpenseDto expenseToCreate)
{
var newExpense = new Expense
{
Id = Guid.NewGuid(),
ApplicationUserId = expenseToCreate.ApplicationUserId,
Price = expenseToCreate.Price,
Description = expenseToCreate.Description,
DateOfExpense = DateTimeOffset.UtcNow,
CategoryId = expenseToCreate.CategoryId
};
await _expensesRepository.CreateExpenseAsync(newExpense);
return(CreatedAtAction(nameof(CreateExpenseAsync), new { id = newExpense.Id }, newExpense.AsDto()));
}
