public async Task CreateCityAsync_Should_Return_CreatedAtRouteResult_With_CityResponse()
{
var createCityRequest = new CreateCityRequest {
Name = "Name", PolishName = "PolishName"
};
var createCityCommand = new CreateCityCommand(Guid.NewGuid(), createCityRequest.Name,
createCityRequest.PolishName, Guid.NewGuid());
var cityOutputQuery = new CityOutputQuery(createCityCommand.CityId, Array.Empty <byte>(), createCityCommand.Name,
createCityCommand.PolishName, createCityCommand.StateId);
var cityResponse = new CityResponse(cityOutputQuery.Id, cityOutputQuery.RowVersion, cityOutputQuery.Name,
cityOutputQuery.PolishName, cityOutputQuery.StateId);
_mapperMock.Setup(x => x.Map <CreateCityRequest, CreateCityCommand>(It.IsAny <CreateCityRequest>())).Returns(createCityCommand);
_communicationBusMock.Setup(x => x.SendCommandAsync(It.IsAny <CreateCityCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
_getCityQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetCityInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cityOutputQuery);
_mapperMock.Setup(x => x.Map <CityOutputQuery, CityResponse>(It.IsAny <CityOutputQuery>())).Returns(cityResponse);
var result = await _controller.CreateCityAsync(createCityRequest);
var createdAtRouteResult = result.As <CreatedAtRouteResult>();
createdAtRouteResult.Value.Should().BeEquivalentTo(cityResponse);
createdAtRouteResult.RouteName.Should().BeEquivalentTo("GetCity");
createdAtRouteResult.RouteValues.Should().BeEquivalentTo(new RouteValueDictionary(new { id = cityResponse.Id }));
}
public async Task <IActionResult> AddOrEditCity([FromRoute] int cityId, [FromBody] CreateCityRequest request,
CancellationToken cancellationToken = default)
{
try
{
var apiResponse = await _citiesService.AddOrEditCityAsync(cityId, request, cancellationToken);
if (apiResponse.Success)
{
return(Ok(apiResponse));
}
else if (apiResponse.Errors[0].Code == StatusCodes.Status404NotFound)
{
return(NotFound(apiResponse));
}
return(BadRequest(apiResponse));
}
catch (Exception exception)
{
return(_actionResultMapper.Map(exception));
}
}
private City CreateCity(CreateCityRequest request)
{
return(new City()
{
CountryId = request.CountryId,
Name = request.Name,
CreatedBy = _httpContextAccessor.HttpContext.User.Identity.Name
});
}
public async Task <IActionResult> CreateCityAsync([FromBody] CreateCityRequest request)
{
var createCityCommand = _mapper.Map <CreateCityRequest, CreateCityCommand>(request);
await _communicationBus.SendCommandAsync(createCityCommand);
var getCityOutputQuery = await _getCityQueryHandler.HandleAsync(new GetCityInputQuery(createCityCommand.CityId));
var cityResponse = _mapper.Map <CityOutputQuery, CityResponse>(getCityOutputQuery);
return(CreatedAtRoute("GetCity", new { id = cityResponse.Id }, cityResponse));
}
/// <summary>
/// Add or Edit an existing city
/// </summary>
/// <param name="cityId"></param>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <Response> AddOrEditCityAsync(int cityId, CreateCityRequest request, CancellationToken cancellationToken = default)
{
var responseModel = new Response();
if (await _citiesRepo.CityNameExists(request.CountryId, request.Name))
{
responseModel.AddError(ExceptionCreator.CreateBadRequestError("city", "city name does already exist"));
return(responseModel);
}
if (cityId != 0)
{
var city = await _dbContext.Cities.FirstOrDefaultAsync(c => c.Id == cityId);
try
{
if (city != null)
{
city.CountryId = request.CountryId;
city.Name = request.Name;
city.LastModifiedBy = _httpContextAccessor.HttpContext.User.Identity.Name;
city.LastModifiedOn = DateTime.UtcNow;
await _citiesRepo.UpdateAsync(city);
}
else
{
responseModel.AddError(ExceptionCreator.CreateNotFoundError(nameof(city), $"city of Id: { cityId} not found"));
return(responseModel);
}
}
catch (Exception ex)
{
responseModel.AddError(ExceptionCreator.CreateInternalServerError(ex.ToString()));
}
}
else
{
try
{
await _citiesRepo.AddAsync(CreateCity(request));
}
catch (Exception ex)
{
responseModel.AddError(ExceptionCreator.CreateInternalServerError(ex.ToString()));
}
}
return(responseModel);
}
public async Task Should_Return_Unauthorized_Status_Code_When_Requesting_By_Anonymous_Client()
{
var createCityRequest = new CreateCityRequest
{
Name = "CreateCityIntegrationTest",
PolishName = "CreateCityIntegrationTest",
StateId = Guid.NewGuid()
};
var createCityRequestString = JsonConvert.SerializeObject(createCityRequest);
var requestContent = new StringContent(createCityRequestString, Encoding.UTF8, "application/json");
_fixture.AnonymousHttpClient.DefaultRequestHeaders.Add("api-version", "1");
var response = await _fixture.AnonymousHttpClient.PostAsync("api/cities", requestContent);
response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.Unauthorized);
}
public async Task Should_Create_City_When_Requesting_By_Administrator_Client()
{
var state = await InsertStateEntityAsync(_fixture.AdministratorDbContext);
var createCityRequest = new CreateCityRequest
{
Name = "CreateCityIntegrationTest",
PolishName = "CreateCityIntegrationTest",
StateId = state.Id
};
var createCityRequestString = JsonConvert.SerializeObject(createCityRequest);
var requestContent = new StringContent(createCityRequestString, Encoding.UTF8, "application/json");
_fixture.AdministratorHttpClient.DefaultRequestHeaders.Add("api-version", "1");
var response = await _fixture.AdministratorHttpClient.PostAsync("api/cities", requestContent);
var responseContentString = await response.Content.ReadAsStringAsync();
var expectedResponse = await PrepareExpectedResponseAsync(_fixture.AdministratorDbContext, createCityRequest.Name);
response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.Created);
responseContentString.Should().BeEquivalentTo(expectedResponse);
}
public async Task <IActionResult> Create([FromBody] CreateCityRequest request, CancellationToken cancellationToken)
{
await _mediator.Send(new CreateCityCommand(request.Name, request.City, request.Country, request.Latitude, request.Longitude), cancellationToken);
return(Ok());
}
public async Task <IActionResult> Create([FromBody] CreateCityRequest request)
{
var result = await _citiesApi.Create(request);
return(Ok(result));
}
