public Task UpdateCountry(string id, [FromBody] string name)
{
var command = new UpdateCountryCommand(id, name);
_commandBus.ExecuteAsync(command).Wait();
return(Task.CompletedTask);
}
public Task ExecuteAsync(UpdateCountryCommand command)
{
var locationDomain = new LocationDomain(_domainService.WriteService);
locationDomain.UpdateCountry(command.Id, command.Name, command.IsoCode, command.DisplayOrder, command.Published);
_domainService.ApplyChanges(locationDomain);
return(Task.CompletedTask);
}
public async Task <APIResult> Update([FromBody] UpdateCountryCommand command)
{
var rs = await mediator.Send(command);
return(new APIResult()
{
Result = rs
});
}
public async Task <IActionResult> UpdateCountry(UpdateCountryCommand command)
{
if (!ModelState.IsValid)
{
return(View(command));
}
await Mediator.Send(command);
return(RedirectToAction(nameof(GetCountryList)));
}
public async Task <IActionResult> Update(int id, UpdateCountryCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
await Mediator.Send(command);
return(Ok());
}
public async Task <ActionResult <Result> > UpdateCountry([FromBody] UpdateCountryCommand command)
{
var result = await Mediator.Send(command);
if (!result.Succeeded)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async void CountryShouldThrowNotFoundException()
{
var updatedCountry = new UpdateCountryCommand {
Id = GConst.InvalidId, Name = GConst.ValidName
};
var status = await Record.ExceptionAsync(async() => await sut.Handle(updatedCountry, CancellationToken.None));
Assert.NotNull(status);
Assert.Equal(string.Format(GConst.NotFoundExceptionMessage, GConst.Country, GConst.InvalidId), status.Message);
}
public async Task Update_Country_With_Wrong_Id_Should_Throw_Exception()
{
var command = new UpdateCountryCommand
{
Id = -1,
Name = "Poland"
};
var commandHandler = new UpdateCountryCommandHandler(_context, _mapper);
await commandHandler.Handle(command, CancellationToken.None).ShouldThrowAsync <NotFoundException>();
}
public async Task <ActionResult <Country> > UpdateCountry(UpdateCountryCommand updateCountryCommand)
{
try
{
Country country = await this.mediator.Send(updateCountryCommand);
return(Ok(country));
}
catch (Exception ex)
{
return(this.BadRequest(ex));
}
}
public async Task <IActionResult> Update(int id, [FromForm] UpdateCountryCommand command)
{
if (ModelState.IsValid)
{
command.ID = id;
Country taskReturn = await Mediator.Send(command);
return(Ok(new CountriesResponse(nameof(Country), taskReturn, taskReturn.statusCode, _baseLocalizer, _localizer)));
}
else
{
return(BadRequest(ModelState));
}
}
public async void CountryShouldUpdateCorrect()
{
var updatedCountry = new UpdateCountryCommand {
Id = countryId, Name = GConst.UpdatedName
};
var status = Task <Unit> .FromResult(await sut.Handle(updatedCountry, CancellationToken.None));
var resultId = context.Countries.SingleOrDefault(x => x.Name == GConst.UpdatedName).Id;
Assert.Equal(countryId, resultId);
Assert.Equal(GConst.SuccessStatus, status.Status.ToString());
Assert.Equal(GConst.ValidCount, context.Countries.Count());
}
public async Task Update_Country_Should_Edit_Country_In_Database()
{
var command = new UpdateCountryCommand
{
Id = 2,
Name = "Poland"
};
var commandHandler = new UpdateCountryCommandHandler(_context, _mapper);
await commandHandler.Handle(command, CancellationToken.None);
var result = _context.Countries
.Where(x => x.Id.Equals(command.Id))
.Where(x => x.Name.Equals(command.Name))
.FirstOrDefault();
result.ShouldNotBeNull();
}
public async Task <IActionResult> updateCountry([FromForm] UpdateCountryCommand command)
{
command = JsonConvert.DeserializeObject <UpdateCountryCommand>(Request.Form.ToList()[0].Value.ToString());
foreach (var file in Request.Form.Files)
{
using (var memoryStream = new MemoryStream())
{
file.OpenReadStream().CopyTo(memoryStream);
if (file.FileName.Contains("svg"))
{
command.ImagesData.SVGName = file.FileName; command.ImagesData.SVGData = Convert.ToBase64String(memoryStream.ToArray());
}
else
{
command.ImagesData.JPGName = file.FileName; command.ImagesData.JPGData = Convert.ToBase64String(memoryStream.ToArray());
}
}
}
var response = await _mediator.Send(command);
return(CreateResponse(response));
}
public async Task <IActionResult> Update([FromForm] UpdateCountryCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public async Task <IActionResult> Update(int countryId, [FromBody] UpdateCountryCommand command)
{
command.CountryId = countryId;
return(Ok(await Mediator.Send(command)));
}
public async Task <ActionResult <Unit> > Update(int id, UpdateCountryCommand command)
{
command.Id = id;
return(await Mediator.Send(command));
}
public async Task <ActionResult> UpdateCountry([FromBody] UpdateCountryCommand request, CancellationToken cancellationToken)
{
var response = await Mediator.Send(request, cancellationToken);
return(NoContent());
}
public async Task <IActionResult> Edit(
int id, UpdateCountryCommand command)
=> await this.Send(command);
public UpdateCountryCommandValidatorTests()
{
this.updateValidator = new UpdateCountryCommandValidator();
this.updateCommand = new UpdateCountryCommand();
}
