public async Task <ActionResult <ShallowExpenseDto> > AddExpense(ExpenseCreateUpdateDto dto)
{
var command = new CreateExpenseCommand(dto, GetCurrentUserId());
var result = await _mediator.Send(command);
return(result == null?BadRequest() : (ActionResult)Ok(result));
}
public async Task Create(string accountName, [FromBody] CreateExpenseCommand cmd)
{
accountName = Uri.UnescapeDataString(accountName);
cmd.AccountName = accountName;
cmd.UserName = this.currentUser.Name;
await this.mediator.Send(cmd);
}
public void Can_Validate_Commands(CreateExpenseCommand cmd, bool shouldBeValid)
{
//When
var result = _validator.Validate(cmd);
//Then
Assert.True(result.IsValid == shouldBeValid);
}
public async Task <IActionResult> CreateExpense([FromBody] CreateExpenseCommand command)
{
var response = await _mediator.Send <ResultResponse <ExpenseDTO> >(command);
if (response.IsSuccess)
{
return(CreatedAtAction(nameof(GetExpenseDetail), new { id = response.Result.Id }, response.Result));
}
return(BadRequest(response.ErrorMessage));
}
public async Task <IActionResult> CreateExpense(int userId, ExpenseForCreationDto expenseForCreationDto)
{
var command = new CreateExpenseCommand(expenseForCreationDto);
var result = await Mediator.Send(command);
if (result != null)
{
return(CreatedAtAction(nameof(GetExpenseById),
new { expenseId = result.Id, userId }, result));
}
throw new Exception("Creating expense failed on save.");
}
public async Task <TResp> Handle(CreateExpenseCommand request, CancellationToken cancellationToken, RequestHandlerDelegate <TResp> next)
{
if (request.Details == null)
{
request.Details = string.Empty;
}
if (!string.IsNullOrEmpty(request.Details))
{
request.Details = Regex.Replace(request.Details, "pizza", "pidser", RegexOptions.IgnoreCase);
request.Details = Regex.Replace(request.Details, "cola", "coler", RegexOptions.IgnoreCase);
}
return(await next());
}
public ExpenseController()
{
ExpenseFactory expenseFactory = new ExpenseFactory();
BalanceSheetServices balanceSheetServices = new BalanceSheetServices();
GetChargeablesListQuery chargeablesListQuery = new GetChargeablesListQuery(new DatabaseService());
GetBalanceListQuery balanceListQuery = new GetBalanceListQuery(new DatabaseService());
GetBalanceDetailQuery balanceDetailQuery = new GetBalanceDetailQuery(new DatabaseService());
CreateExpenseViewModelFactory factory = new CreateExpenseViewModelFactory(chargeablesListQuery);
CreateExpenseCommand createExpenseCommand = new CreateExpenseCommand(new DatabaseService(), expenseFactory, balanceSheetServices);
_balanceListQuery = balanceListQuery;
_balanceDetailQuery = balanceDetailQuery;
_factory = factory;
_createExpenseCommand = createExpenseCommand;
}
public async Task <ActionResult <Guid> > CreateExpense(
[FromBody] CreateExpenseCommand createExpenseCommand, CancellationToken cancellationToken)
{
var userId = User.GetClaim("id");
if (userId == null)
{
return(Forbid());
}
createExpenseCommand.OwnerId = new Guid(userId.Value);
var result = await _mediator.Send(createExpenseCommand, cancellationToken);
return(Ok(result));
}
public static CreateExpenseCommand AsCommand(this Expense expense, string accountName)
{
var cmd = new CreateExpenseCommand
{
AccountName = accountName,
Amount = expense.Amount,
CategoryName = expense.Category,
SubcategoryName = expense.Subcategory,
Created = expense.Created.LocalDateTime,
Date = expense.Date,
Details = expense.Details,
Type = expense.Type,
};
return(cmd);
}
public async Task ShouldCreateNew()
{
// Arrange
Guid expectedId = Guid.NewGuid();
var repository = new Mock <IExpenseRepository>();
CreateExpenseCommand cmd =
new CreateExpenseCommand(expectedId, Guid.NewGuid(), Guid.NewGuid(), "Name", "Description",
0.12m, DateTime.Now, DateTime.Now, DateTime.Now);
ExpenseCommandHandler actual = new ExpenseCommandHandler(repository.Object);
// Act
await actual.HandleAsync(cmd);
// Assert
repository.Verify(e =>
e.Add(It.Is <Expense>(a => a.Id == expectedId)
),
Times.Once
);
}
public async Task CreateASimpleExpenseWithPayDayNullNoMustToDebitFromBankAccount()
{
//Arrange
var bankAccount = new BankAccount("Nuconta", 100);
_unitOfWork.BankAccountRepository.GetById(bankAccount.Id).Returns(bankAccount);
var command = new CreateExpenseCommand
{
BankAccountId = bankAccount.Id,
Name = "Lunch",
Value = 50,
DueDate = DateTime.Today,
AccountKind = Simple,
PayDay = null,
Detail = "Test"
};
//Action
await _sut.Handle(command, new CancellationToken());
//Assert
bankAccount.Balance.Should().Be(100);
}
public async Task <IActionResult> Post(CreateExpenseCommand command, CancellationToken cancellationToken)
{
var result = await _mediator.Send(command, cancellationToken);
return(Ok(result));
}
public async Task <IActionResult> Create([FromBody] CreateExpenseCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public async Task <IActionResult> Create(CreateExpenseCommand command)
{
var result = await _mediator.Send(command);
return(Ok(result));
}
public async Task <IActionResult> Create(CreateExpenseCommand expense)
{
var id = await _mediator.Send(expense);
return(Ok(new { id }));
}
