public async Task <Result <CityModel, Error> > CreateCity(CreateCityModel cityModel)
{
var city = await _cityRepository.GetByName(cityModel.Name);
if (city != null)
{
return(Result.Failure <CityModel, Error>(ErrorsList.ExistingCity));
}
var userId = Guid.Parse(_accessor.HttpContext.User.Claims.First(c => c.Type == "userId").Value);
var user = await _userRepository.GetById(userId);
var userType = await _userTypeRepository.GetByName("Admin");
if (user.UserTypeId != userType.Id)
{
return(Result.Failure <CityModel, Error>(ErrorsList.UnauthorizedUser));
}
var newCity = new City(cityModel.Name);
await _cityRepository.Add(newCity);
await _cityRepository.SaveChanges();
return(Result.Success <CityModel, Error>(_mapper.Map <CityModel>(newCity)));
}
public async Task <CityModel> Post([FromBody] CreateCityModel requestModel)
{
var item = await _query.Create(requestModel);
var model = _mapper.Map <CityModel>(item);
return(model);
}
public async Task <IActionResult> CreateCity([FromBody] CreateCityModel cityModel)
{
var(_, isFailure, value, error) = await _cityService.CreateCity(cityModel);
if (isFailure)
{
return(BadRequest(error));
}
return(Ok(value));
}
public async Task <City> Create(CreateCityModel model)
{
var item = new City
{
Name = model.Name,
Sort = model.Sort,
};
_uow.Add(item);
await _uow.CommitAsync();
return(item);
}
public async Task <City> Add(CreateCityModel model)
{
try
{
City city = await this.cities.AddAsync(model.CityName, null, null);
return(city);
}
catch (Exception e)
{
this.LogError(e);
return(null);
}
}
public IActionResult Create([FromBody] CreateCityModel city)
{
if (city == null)
{
return(BadRequest());
}
var model = new City(
city.Name,
city.Description,
city.Population);
_storage.Create(model);
return(CreatedAtAction("Get", model));
}
public async Task <IActionResult> AddCity([FromBody] CreateCityModel city)
{
var cityEntity = _mapper.Map <CityEntity>(city);
var res = await _cityService.GetByNameAsync(city.Name).ConfigureAwait(false);
if (res != null)
{
return(BadRequest());
}
await _cityService.AddAsync(cityEntity).ConfigureAwait(false);
var test = await _cityService.GetByIdAsync(cityEntity.Id).ConfigureAwait(false);
return(CreatedAtRoute("GetCityById", new { id = test.Id }, _mapper.Map <CityEntity>(test)));
}
public ActionResult <City> Post([FromBody] CreateCityModel createTodoModel)
{
if (createTodoModel == null)
{
return(BadRequest());
}
var city = new City
{
Id = createTodoModel.Id,
Description = createTodoModel.Description
};
_repository.Create(city);
return(CreatedAtRoute("GetById", new { id = city.Id }, city));
}
public async Task CreateInvalidCityTest()
{
//Arrange
var cityModel = new CreateCityModel()
{
Name = "Buzau"
};
// Act
var firstResponse = await HttpClient.PostAsJsonAsync("/api/v1/cities", cityModel);
var secondResponse = await HttpClient.PostAsJsonAsync("/api/v1/cities", cityModel);
// Assert
firstResponse.IsSuccessStatusCode.Should().BeTrue();
secondResponse.IsSuccessStatusCode.Should().BeFalse();
}
public async Task CreateCityTest()
{
//Arrange
var cityModel = new CreateCityModel()
{
Name = "Buzau"
};
// Act
var response = await HttpClient.PostAsJsonAsync("/api/v1/cities", cityModel);
// Assert
response.IsSuccessStatusCode.Should().BeTrue();
City city = null;
await ExecuteDatabaseAction(async (doFestContext) => {
city = await doFestContext.Cities.FirstAsync(entity => entity.Name == cityModel.Name);
});
city.Name.Should().NotBeNull();
}
public async Task <int> CreateCity([FromBody] CreateCityModel request) => await _mediator.Send(_mapper.Map <CreateCityCommand>(request));
public static CreateCityModel WithName(this CreateCityModel model, string name)
{
model.Name = name;
return(model);
}
