public IActionResult UpdateCurrency([FromRoute] CurrencyId id, UpdateCurrencyCommand command)
{
command.Id = id;
try
{
_commandDispatcher.Dispatch(command);
var query = new GetCurrencyQuery
{
Id = id,
};
_queryRunner.Run(query);
var queryResult = query.GetResult();
var url = this.Url.Action("GetCurrency", "GetCurrency", new { id });
return(this.Ok(queryResult));
}
catch (CurrencyNotFoundException ex)
{
return(this.NotFoundError(ex));
}
catch (CodeAlreadyExistsException ex)
{
return(this.ConflictError(ex));
}
}
public void UpdateCurrency_CodeAlreadyExistsButSameCurrency_UpdatesCurrencyAndReturnsOkResultWithUpdatedCurrency()
{
// Arrange
var id = IntegrationTestHelper.PlnId;
var command = new UpdateCurrencyCommand
{
Code = "PLN", // keep PLN
Name = "Duzhe zlotiy",
};
// Act
var response = this.HttpClient.PutAsJsonAsync($"api/currencies/{id}", command).Result;
var queryResult = response.ReadAs <GetCurrencyQueryResult>();
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(queryResult.Id, Is.EqualTo(id));
Assert.That(queryResult.Code, Is.EqualTo("PLN"));
Assert.That(queryResult.Name, Is.EqualTo("Duzhe zlotiy"));
var updatedCurrency = this.AssertSession.Query <Currency>().Single(x => x.Id == id);
Assert.That(updatedCurrency.Code, Is.EqualTo("PLN"));
Assert.That(updatedCurrency.Name, Is.EqualTo("Duzhe zlotiy"));
}
public async Task <IActionResult> Put(int id, [FromBody] UpdateCurrencyCommand command)
{
if (command == null)
{
return(BadRequest());
}
if (command.Id != id)
{
ModelState.AddModelError("Name/FirstName", "The name or first name shouldn't be empty");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currencyToUpdate = (_mediator.Send(new GetCurrencyByIdQuery()
{
Id = id
})).Result.Data;
if (currencyToUpdate == null)
{
return(NotFound());
}
await _mediator.Send(command);
return(NoContent());
}
public Task Handle(UpdateCurrencyCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.CompletedTask);
}
var Currency = new Currency(message.Id, message.Code, message.Name, message.Address, message.Quantity, message.IsActive);
var existingCurrency = _CurrencyRepository.GetByCode(Currency.Code);
if (existingCurrency != null && existingCurrency.Id != Currency.Id)
{
if (!existingCurrency.Equals(Currency))
{
Bus.RaiseEvent(new DomainNotification(message.MessageType, "The Currency Code has already been taken."));
return(Task.CompletedTask);
}
}
_CurrencyRepository.Update(Currency);
if (Commit())
{
Bus.RaiseEvent(new CurrencyUpdatedEvent(Currency.Id, Currency.Code, Currency.Name, Currency.Address, Currency.Quantity, Currency.IsActive));
}
return(Task.CompletedTask);
}
public async Task <ActionResult <Result <int> > > Put(int id, UpdateCurrencyCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
return(Ok(await _mediator.Send(command)));
}
public async Task <IActionResult> Update(int id, [FromForm] UpdateCurrencyCommand command)
{
if (ModelState.IsValid)
{
command.ID = id;
Currency taskReturn = await Mediator.Send(command);
return(Ok(new CurrenciesResponse(nameof(Currency), taskReturn, taskReturn.statusCode, _baseLocalizer, _localizer)));
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <CommandResult <Currency> > Handle(UpdateCurrencyCommand request, CancellationToken cancellationToken)
{
var currency = await currencyRepository.FindOneAsync(p => p.IsoCode.Equals(request.CurrencyIso.ToLower()));
if (currency == null)
{
return(CommandResult <Currency> .Fail(currency, "IsoCode not exist"));
}
currency.Update(request.Name);
currencyRepository.Update(currency);
PublishEvents(currency);
return(CommandResult <Currency> .Success(currency));
}
public void UpdateCurrency_InvalidRequest_ReturnsValidationErrorResponse()
{
// Arrange
var id = new CurrencyId("59f103f7-c20e-4c97-ac39-17be6adfd3e1");
var command = new UpdateCurrencyCommand(); // all nulls
// Act
var response = this.HttpClient.PutAsJsonAsync($"api/currencies/{id}", command).Result;
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
var validationError = response.ReadAsValidationError();
validationError
.ShouldHaveFailureNumber(2)
.ShouldContainFailure("code", "NotEmptyValidator", "'Code' must not be empty.")
.ShouldContainFailure("name", "NotEmptyValidator", "'Name' must not be empty.");
}
public async Task <ActionResult> Updatecurrency([FromBody] UpdateCurrencyCommand request, CancellationToken cancellationToken)
{
var response = await Mediator.Send(request, cancellationToken);
return(Ok(response));
}
