public IActionResult CreatePointOfInterest(int cityId, [FromBody] PointOfInterestForCreationDTO pointOfInterest) { if (pointOfInterest.Name == pointOfInterest.Description) { ModelState.AddModelError( "Description", "The provided description should be different than the name" ); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var city = CitiesDataStore.Current.Cities.FirstOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } var maxPoiId = CitiesDataStore.Current.Cities.SelectMany(c => c.PointsOfInterest).Max(p => p.Id); var finalPoi = new PointOfInterestDto() { Id = ++maxPoiId, Name = pointOfInterest.Name, Description = pointOfInterest.Description }; city.PointsOfInterest.Add(finalPoi); return(CreatedAtRoute("GetPointOfInterest", new { cityId, id = finalPoi.Id }, finalPoi)); }
// an important note, the parameter placeholder in the HttpGet route defined above needs to match exactly with the parameter name defined in // actual method signature. public IActionResult GetPointOfInterest(int cityId, int id) { if (!_cityInfoRepository.CityExists(cityId)) { _logger.LogInformation($"City with id {cityId} wasnt found when accessing points of interest."); return(NotFound()); } PointOfInterestDto poi = _cityInfoRepository.GetPointOfInterestForCity(cityId, id); if (poi == null) { return(NotFound()); } //PointOfInterestDto result = new PointOfInterestDto() //{ // Id = poi.Id, // Name = poi.Name, // Description = poi.Description //}; var result = Mapper.Map <PointOfInterestDto>(poi); return(Ok(result)); }
public IActionResult UpdatePointOfInterest(int cityId, int id, [FromBody] PointOfInterestDto pointOfInterest) { if (pointOfInterest == null) { return(BadRequest()); } var city = CitiesDataStore.Current.Cities.FirstOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } var updatePointOfInterest = city.PointsOfInterest.FirstOrDefault(p => p.Id == id); if (updatePointOfInterest == null) { return(NotFound()); } updatePointOfInterest.Name = pointOfInterest.Name; updatePointOfInterest.Description = pointOfInterest.Description; return(NoContent()); }
public IActionResult DeletePointOfInterest([FromBody] PointOfInterestDto pointOfInterestDto) { PointOfInterest pointOfInterest = _mapper.Map <PointOfInterest>(pointOfInterestDto); _pointOfInterest.Delete(pointOfInterest.Id); return(Ok()); }
public void TestMultiplePoints() { PointOfInterestDto poi1 = new PointOfInterestDto { Id = 1, Name = "Downtown", Description = "Lots of food" }; PointOfInterestDto poi2 = new PointOfInterestDto { Id = 2, Name = "Stanley Park", Description = "Lots to do" }; PointOfInterestDto poi3 = new PointOfInterestDto { Id = 3, Name = "Science World", Description = "Lots of science" }; CityDto city2 = new CityDto { Id = 2, Name = "Van", Description = "City of Vancouver", PointsOfInterest = { poi1, poi2, poi3 } }; Assert.Equal(3, city2.PointsOfInterest.Count); }
public IActionResult CreatePointOfInterest(int cityId, [FromBody] PointOfInterestModel pointOfInterest) { if (pointOfInterest == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var city = CityDataStore.Current.Cities.FirstOrDefault(x => x.Id == cityId); if (city == null) { return(NotFound()); } int id = GetCurrentPointOfInterestId(); var result = new PointOfInterestDto { Id = ++id, Name = pointOfInterest.Name, Description = pointOfInterest.Description }; city.PointofInterest.Add(result); return(CreatedAtAction("GetPointOfInterest", new { cityId = cityId, id = result.Id }, result)); }
public IActionResult createPointOfInteres(int cityId, [FromBody] PointOfInterestForCreationDto pointOfInterest) { if (pointOfInterest == null) { return(BadRequest()); } var city = CitiesDataStore.Current.Cities.FirstOrDefault(c => c.Id == cityId); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (city == null) { return(NotFound()); } var maxPointOfInterestId = CitiesDataStore.Current.Cities.SelectMany( c => c.PointOfInterest).Max(p => p.Id); var finalPointOfInterest = new PointOfInterestDto() { Id = ++maxPointOfInterestId, Name = pointOfInterest.Name, Description = pointOfInterest.Description }; city.PointOfInterest.Add(finalPointOfInterest); return(CreatedAtRoute("GetPointOfInterest", new { cityId = cityId, id = finalPointOfInterest.Id }, finalPointOfInterest)); }
public IActionResult CreatePointOfInterest1(int cityId, [FromBody] CreatePointOfInterestDto pointOfInterest) { if (pointOfInterest == null) { return(BadRequest()); } var city = CitiesDataStore.Current.Cities.SingleOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } int newPointIfInterestId = CitiesDataStore.Current.Cities.SelectMany(c => c.PointsOfInterest).Max(i => i.Id); var newPointOfInterest = new PointOfInterestDto() { Id = ++newPointIfInterestId, Name = pointOfInterest.Name, Description = pointOfInterest.Description }; city.PointsOfInterest.Add(newPointOfInterest); //return the 201 with the location header set to any string, it can be jibberish as well return(Created("blabla", newPointOfInterest)); }
public async Task <IActionResult> PostAsync(int cityId, [FromBody] PointOfInterestDto pointOfInterest) { if (!_cityService.CityExists(cityId).Result) { return(NotFound()); } if (pointOfInterest == null) { return(BadRequest()); } if (pointOfInterest.Description == pointOfInterest.Name) { ModelState.AddModelError(nameof(pointOfInterest.Description), "The provided description should be different from the name."); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { pointOfInterest.CityId = cityId; await _pointOfInterestService.Create(pointOfInterest); return(CreatedAtRoute("Get", new { id = pointOfInterest.Id }, pointOfInterest)); } catch (Exception exception) { return(StatusCode((int)HttpStatusCode.InternalServerError, exception.Message)); } }
public IActionResult poster(int cityId, [FromBody] PointOfInterestCreationDto newPointOfInterest) { var city = CitiesStore.Current.Cities.FirstOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } if (newPointOfInterest.Comment == newPointOfInterest.Name) { ModelState.AddModelError("comment", "comment should not be same as name"); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } //for data anotation. //can be automatically handle by apiConroller, but its required if custom Modelerror are added. var maxId = CitiesStore.Current.Cities.SelectMany(c => c.PointOfInterest).Max(p => p.Id); var finalPointOfInterest = new PointOfInterestDto() { Id = ++maxId, Name = newPointOfInterest.Name, Comment = newPointOfInterest.Comment }; city.PointOfInterest.Add(finalPointOfInterest); return(CreatedAtRoute("GetPointOfInterest", new { cityId = cityId, id = finalPointOfInterest.Id }, finalPointOfInterest)); }
public IActionResult CreatePointOfInterest([FromRoute] int cityId, [FromBody] PointOfInterestDto pointOfInterest) { bool hasRedFlags = HasRedFlags(); if (hasRedFlags) { return(BadRequest(ModelState)); } var cityExists = _cityInfoRepository.CityExists(cityId); if (!cityExists) { return(NotFound()); } var finalPointsOfInterest = _mapper.Map <PointOfInterest>(pointOfInterest); _cityInfoRepository.AddPointOfInterestForCity(cityId, finalPointsOfInterest); _cityInfoRepository.Save(); var createdPointOfInterest = _mapper.Map <PointOfInterestDto>(finalPointsOfInterest); return(CreatedAtRoute("GetPointOfInterest", new { cityId, Id = createdPointOfInterest.Id, createdPointOfInterest }, createdPointOfInterest)); }
public IActionResult UpdatePointOfInterest([FromRoute] int cityId, PointOfInterestDto pointOfInterest) { bool hasRedFlags = HasRedFlags(); if (hasRedFlags) { return(BadRequest(ModelState)); } var cityExists = _cityInfoRepository.CityExists(cityId); if (!cityExists) { return(NotFound()); } var pointOfInterestEntity = _cityInfoRepository.GetOnePointOfInterestForCity(cityId, pointOfInterest.Id); if (pointOfInterestEntity == null) { return(NotFound()); } _mapper.Map(pointOfInterest, pointOfInterestEntity); _cityInfoRepository.Save(); return(NoContent()); }
public IActionResult CreatePointOfInterest(int cityId, [FromBody] PointOfInterestForCreationDto pointOfInterest) { if (pointOfInterest.Name == pointOfInterest.Description) { ModelState.AddModelError("Description", "Name and Description can't be same."); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var city = CitiesDataStore.Current.Cities.FirstOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } var maxPointOfINterest = city.PointOfInterest.Max(p => p.Id); var finalPointOfInterest = new PointOfInterestDto() { Id = ++maxPointOfINterest, Name = pointOfInterest.Name, Description = pointOfInterest.Description }; city.PointOfInterest.Add(finalPointOfInterest); return(CreatedAtRoute("GetPointOfInterest", new { cityId, id = finalPointOfInterest.Id }, finalPointOfInterest)); }
public IActionResult CreatePointOfInterest2(int cityId, [FromBody] CreatePointOfInterestDto pointOfInterest) { if (pointOfInterest == null) { return(BadRequest()); } var city = CitiesDataStore.Current.Cities.SingleOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } int newPointIfInterestId = CitiesDataStore.Current.Cities.SelectMany(c => c.PointsOfInterest).Max(i => i.Id); var newPointOfInterest = new PointOfInterestDto() { Id = ++newPointIfInterestId, Name = pointOfInterest.Name, Description = pointOfInterest.Description }; city.PointsOfInterest.Add(newPointOfInterest); //return the 201 with the location header to the route associated with the controller action //NOTE: this is not the best choice since the acton name may change in a refactoring and the reference here will be still pointing to the old controller action // for that reason, the best usage would be CreatedAtRoute that will reference the Name associated with the route which will not change with the refactoring return(CreatedAtAction("GetPointOfInterest", new { cityId = cityId, id = newPointOfInterest.Id }, newPointOfInterest)); }
public IActionResult Add(int cityId, PointOfInterestForCreationDto pointOfInterest) { if (pointOfInterest == null) { return(BadRequest()); } var city = _cityDataStore.Cities.Where(a => a.Id == cityId).FirstOrDefault(); if (city == null) { return(BadRequest()); } var maxPointOfInterestId = city.PointsOfInterest.Max(a => a.Id); var newPointOfInterest = new PointOfInterestDto() { Name = pointOfInterest.Name, Description = pointOfInterest.Description, Id = ++maxPointOfInterestId }; city.PointsOfInterest.Add(newPointOfInterest); return(CreatedAtRoute("GetPointOfInterest", new { cityId, id = newPointOfInterest.Id }, newPointOfInterest)); }
public IActionResult CreatePointOfInterestForCity(int cityId, [FromBody] CreatePointOfInterestRequestModel requestModel) { if (requestModel == null || !ModelState.IsValid) { return(BadRequest()); } var city = CitiesDataStore.Current.Cities.SingleOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } var maxPointOfInterestId = CitiesDataStore.Current.Cities.SelectMany(c => c.PointsOfInterest).Max(p => p.Id); var finalPointOfInterest = new PointOfInterestDto() { Id = ++maxPointOfInterestId, Name = requestModel.Name, Description = requestModel.Description }; city.PointsOfInterest.Add(finalPointOfInterest); return(CreatedAtRoute("GetPointOfInterestForCity", new { cityId, pId = finalPointOfInterest.Id }, finalPointOfInterest)); }
public IActionResult PartiallyUpdatePointOfInterest(int cityId, int id, [FromBody] JsonPatchDocument <PointOfInterestForUpdateDto> patchDocument) { // first lets check to make sure the patch document is ok if (patchDocument == null) { return(BadRequest()); } // now we run our normal validation checks CityDto city = CitiesDataStore.Current.Cities.FirstOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } PointOfInterestDto pointOfInterestFromStore = city.PointsOfInterest.FirstOrDefault(p => p.Id == id); if (pointOfInterestFromStore == null) { return(NotFound()); } PointOfInterestForUpdateDto pointOfInterestToPatch = new PointOfInterestForUpdateDto() { Name = pointOfInterestFromStore.Name, Description = pointOfInterestFromStore.Description }; // here we are applying the incoming patch document to our update dto object to see if it passes the requirements patchDocument.ApplyTo(pointOfInterestToPatch, ModelState); // check the model state after the patch document has been applied to see if it passes. if (!ModelState.IsValid) { return(BadRequest(ModelState)); } // check our custom validation rule if (pointOfInterestToPatch.Description == pointOfInterestToPatch.Name) { ModelState.AddModelError("Description", "The provided description should be different than the name."); } // now we are going to use a built in validation helper to check the model itself for its validation. TryValidateModel(pointOfInterestToPatch); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } pointOfInterestFromStore.Name = pointOfInterestToPatch.Name; pointOfInterestFromStore.Description = pointOfInterestToPatch.Description; return(NoContent()); }
public IActionResult CreatePointOfInterest(int cityId, [FromBody] PointOfInterestForCreationDto pointOfInterest) { // [FromBody] - allows us to get the content of the request. The request body will contain the information needed // to create a new point of interest. We want to serialize this point of interest dto. // because we are expecting a well formed PointOfInterestForCreationDto json object to be passed in we need to do some validation first if (pointOfInterest == null) { return(BadRequest()); } //validate the incoming PointOfInterestForCreationDto has valid properties // we can of course create our own validation on the object like so: if (pointOfInterest.Description == pointOfInterest.Name) { ModelState.AddModelError("Description", "The provided description should be different than the name."); } if (!ModelState.IsValid) { //return BadRequest(); // if we just want to return a bad request then we can just use this return(BadRequest(ModelState)); // if we want to include the property error messages (in the response body) that are defined on the // PointOfInterestForCreationDto model then we need to include the model state. } // make sure the city exists CityDto city = CitiesDataStore.Current.Cities.FirstOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } // get the last POI ID so we can create the new one int lastPointOfInterestID = CitiesDataStore.Current.Cities.SelectMany(c => city.PointsOfInterest).Max(p => p.Id); // map the POI for creation object to a DTO that we will use PointOfInterestDto newPointOfInterestDto = new PointOfInterestDto() { Id = ++lastPointOfInterestID, Name = pointOfInterest.Name, Description = pointOfInterest.Description }; city.PointsOfInterest.Add(newPointOfInterestDto); // for posts, its recommended to return a 201 Created response, we can return this using a the built in helper methods. // This helper response method will allow us to add a location header to the response, this will contain the new location URI where // the newly created information can be found. return(CreatedAtRoute("GetPointOfInterestReferenceName", new { cityId = cityId, id = newPointOfInterestDto.Id }, newPointOfInterestDto)); }
public IActionResult Delete(int cityId, int id) { using (HttpClient client = ApiClient.GetClient()) { HttpResponseMessage response = client.GetAsync("/api/cities/" + cityId + "/pointsofinterest/" + id).Result; string stringData = response.Content.ReadAsStringAsync().Result; PointOfInterestDto data = JsonConvert.DeserializeObject <PointOfInterestDto>(stringData); return(View(data)); }; }
public IActionResult createPointOfInterest( int cityid, [FromBody] PointOfInterestForCreate pointofinterest ) { //string result = $@"[name = { data.name }, description = { data.description } ]"; //null exception if (pointofinterest == null) { return(BadRequest()); } List <CityDto> cities = CitiesStore.Instance.cities; CityDto city = null; foreach (var c in cities) { if (c.id == cityid) { city = c; } } //no city exception if (city == null) { return(NotFound()); } //search maxid var points = city.PointsOfInterest; int maxid = 0; foreach (var p in points) { if (p.id > maxid) { maxid = p.id; } } //new point of interest var createdPointOfInterest = new PointOfInterestDto() { id = maxid + 1, name = pointofinterest.name, description = pointofinterest.description }; //add point of interest points.Add(createdPointOfInterest); return(Ok()); }
public IActionResult Create(int cityId, PointOfInterestDto pointOfInterest) { using (HttpClient client = ApiClient.GetClient()) { string stringData = JsonConvert.SerializeObject(pointOfInterest); var contentData = new StringContent(stringData, System.Text.Encoding.UTF8, "application/json"); HttpResponseMessage response = client.PostAsync("/api/cities/" + cityId + "/pointsofinterest", contentData).Result; ViewBag.Message = response.Content.ReadAsStringAsync().Result; return(RedirectToAction("Details", "Cities", new { Id = cityId })); }; }
private List <CityDto> MapHere(List <City> Cities) { List <CityDto> CityDtos = new List <CityDto>(); //ICollection<CityDto> CityDtosI = new List<CityDto>(); for (int Counter = 0; Counter < Cities.Count(); Counter++) { CityDto CityDto_Object = new CityDto(); CityDto_Object.Id = Cities[Counter].Id; CityDto_Object.Name = Cities[Counter].Name; CityDto_Object.Description = Cities[Counter].Description; CityDto_Object.PointsOfInterest = new List <PointOfInterestDto>(); for (int PointOfInterestsCounter = 0; PointOfInterestsCounter < Cities[Counter].PointsOfInterest.Count(); PointOfInterestsCounter++) { PointOfInterestDto PointOfInterestDto_Object = new PointOfInterestDto(); PointOfInterestDto_Object.Id = Cities[Counter].PointsOfInterest.ElementAt(PointOfInterestsCounter).Id; PointOfInterestDto_Object.CityID = Cities[Counter].PointsOfInterest.ElementAt(PointOfInterestsCounter).CityId; PointOfInterestDto_Object.Name = Cities[Counter].PointsOfInterest.ElementAt(PointOfInterestsCounter).Name; PointOfInterestDto_Object.Description = Cities[Counter].PointsOfInterest.ElementAt(PointOfInterestsCounter).Description; CityDto_Object.PointsOfInterest.Add(PointOfInterestDto_Object); } CityDto_Object.CityLanguages = new List <LanguageDtoMinusRelations>(); for (int CityLanguageCounter = 0; CityLanguageCounter < Cities[Counter].CityLanguages.Count(); CityLanguageCounter++) { LanguageDtoMinusRelations LanguageDto_Object = new LanguageDtoMinusRelations(); LanguageDto_Object.Id = Cities[Counter].CityLanguages.ElementAt(CityLanguageCounter).LanguageId; LanguageDto_Object.LanguageName = Cities[Counter].CityLanguages.ElementAt(CityLanguageCounter).Language.LanguageName; CityDto_Object.CityLanguages.Add(LanguageDto_Object); } CityDtos.Add(CityDto_Object); } CityDto CityDto_Object_Final = new CityDto(); CityDto_Object_Final.Id = 0; CityDto_Object_Final.Name = "Egen Konvertering !!!"; CityDto_Object_Final.Description = "Det sidste objekt her er lavet for at illustrere det arbejde, som AutoMapper gør for os !!!"; CityDtos.Add(CityDto_Object_Final); return(CityDtos); }
//Action:Generation of resources public IActionResult CreatePointOfInterest(int cityId, [FromBody] PointsOfInterestDtoResourceGeneration pointOfInterestPosted) { //input data validation. Input validation can be done via Data anotations in the entity used for generate resources; PointsOfInterestDtoResourceGeneration. This is the basic but not the best because doesn't respect separation of concerns by defining validation in controller and model. Check FluentVAlidation on Github to see a robust input validation. if (pointOfInterestPosted == null) { return(new BadRequestResult()); } //Using ModelsState is a dictionary that checks DataAnnotations on DTOs adherence and contains error mesages if failed. if (!ModelState.IsValid) { return(new BadRequestObjectResult(ModelState));//returns the ModelState that will display errors when user inpunt doesn't comply data anottations } //Custom input validation using ModelState if (pointOfInterestPosted.Description == pointOfInterestPosted.Name) { ModelState.AddModelError("CustomErrorKey", "CustomError message: The provided description should be different from the name"); return(new BadRequestObjectResult(ModelState));//returns the ModelState thar will display errors when user inpunt doesn't comply data anottations } var cityOfPoints = CitiesDataStore.Current.Cities.FirstOrDefault(city => city.Id == cityId); if (cityOfPoints == null) { return(new NotFoundResult()); } //create the point of interest //Generating id for new point --temporary solution using maping. to be refactored //I need to iterate trhough all the point od interest of all cities to find the highest id and increment it var maxPointOfInterestId = CitiesDataStore.Current.Cities.SelectMany(city => city.PointsOfInterest).Max(pointOfInterest => pointOfInterest.Id); //generating the new poit of interest var newPointOfInterest = new PointOfInterestDto() { Id = ++maxPointOfInterestId, Name = pointOfInterestPosted.Name, Description = pointOfInterestPosted.Description }; //Adding the newlly created point of interest to the city cityOfPoints.PointsOfInterest.Add(newPointOfInterest); //Generating response for the request //I need to sendback the ubication for the newlly created point. I use the name given to the get route to get a Interest point and pass the city and new point ids as a parameter in a annonimus type(new {}) and finally I pass the newlly created point to be sended in the body of the response. return(CreatedAtRoute("GetPointOfInterest", new { cityId = cityId, pointId = newPointOfInterest.Id }, newPointOfInterest)); }
public IActionResult DeletePointOfInterest(int cityid, int pointid) { CityDto city = CitiesStore.Instance.Cities.FirstOrDefault(c => c.Id == cityid); PointOfInterestDto point = city.PointsOfInterest.FirstOrDefault(p => p.Id == pointid); if (point == null) { return(NotFound()); } city.PointsOfInterest.Remove(point); return(NoContent()); }
public bool UpdatePointOfInterest(CityDto city, PointOfInterestDto pointOfInterest) { var entity = city.PointsOfInterest.SingleOrDefault(p => p.Id == pointOfInterest.Id); if (entity == null) { return(false); } entity.Id = pointOfInterest.Id; entity.Name = pointOfInterest.Name; entity.Description = pointOfInterest.Description; return(true); }
public IActionResult CreatPointOfInterest(int cityId, [FromBody] PointOfInterestForCreationDto pointOfInterest) { // Error: Bad request if (pointOfInterest == null) { return(BadRequest()); } // if description and name are the same, return an error if (pointOfInterest.Description == pointOfInterest.Name) { ModelState.AddModelError("Description", "The provided description should be different from the name."); } // make sure the request is valid according to our 'PointOfInterestForCreationDto' [required] blocks // it will also check to see if ModelState is set to invalid inside of this function, e.g., ModelState.AddModelError if (!ModelState.IsValid) { return(BadRequest(ModelState)); // ModelState tells you the specifically what is wrong, in the response for the request. For customized error handling + default } // --- // Error: Trying to add a point of interest to a city that does not exist var city = CitiesDataStore.Current.Cities.FirstOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } // --- // Bad Practice, will be improved: Calculate the number of cities we have by looping through all of them and finding the one with the highest Id var maxPointOfInterestId = CitiesDataStore.Current.Cities.SelectMany( c => c.PointsOfInterest).Max(p => p.Id); // Create the new point of interest object var finalPointOfInterest = new PointOfInterestDto() { Id = ++maxPointOfInterestId, // add one more to the current value, which we will use for the new point of interest Name = pointOfInterest.Name, Description = pointOfInterest.Description }; // add the new point of interest city.PointsOfInterest.Add(finalPointOfInterest); // return our status code CreatedAtRoute which requires route(city) value, and the created object value (finalPointOfInterest) // note: getpoint ofinterest refers to the id that was sent in the GET route return(CreatedAtRoute("GetPointOfInterest", new { cityId = cityId, id = finalPointOfInterest.Id }, finalPointOfInterest)); }
public IActionResult CreatePointOfInterest(int cityId, PointOfInterestForCreationDto pointOfInterest) { //----------------------------------------------------> // This section of code is custom validation to check if the name matches the description if (pointOfInterest.Description == pointOfInterest.Name) { ModelState.AddModelError( "Description", "The provided description should be different from the name" ); } // ModelState must be manually thrown if you add a Model Error if (!ModelState.IsValid) { return(BadRequest(ModelState)); } //----------------------------------------------------> var city = CitiesDataStore.Current.Cities.FirstOrDefault(item => item.Id == cityId); if (city == null) { return(NotFound()); } // Amp through all POI and get the highest value var maxPointOfInterestId = CitiesDataStore.Current.Cities.SelectMany(item => item.PointOfInterest).Max(poi => poi.Id); var finalPointOfInterest = new PointOfInterestDto() { Id = ++maxPointOfInterestId, // increment the existing id by +1 Name = pointOfInterest.Name, // pointOfInterest.Name = user input Description = pointOfInterest.Description // pointOfInterest.Description = user input }; city.PointOfInterest.Add(finalPointOfInterest); // Add the result into List<PointOfInterest> defined in CitiesDto // CreatedAtRoute(routeName, routeValues, objectValues) return(CreatedAtRoute("GetPointOfInterest", new { cityId, id = finalPointOfInterest.Id }, finalPointOfInterest)); /* To execute an POST request, it requires 201 response code. * * CreatedAtRoute() returns a location header */ }
public IActionResult CreatePointOfInterest(int cityId, [FromBody] PointOfInterestForCreationDto pointOfInterest) { // if body is null, send bad request if (pointOfInterest == null) { return(BadRequest(ModelState)); } // add a validation check to the model state to check that the description is not the same as the name. if (pointOfInterest.Description.Equals(pointOfInterest.Name, System.StringComparison.InvariantCultureIgnoreCase)) { ModelState.AddModelError("Description", "The description cannot be the same as the name."); } // if the model is not valid (decorated by attributes), send bad request if (!ModelState.IsValid) { return(BadRequest(ModelState)); } // get the specified city var foundCity = CitiesDataStore.Current.Cities.Find(city => city.Id == cityId); // if the city is not found, send not found if (foundCity == null) { return(NotFound()); } // get the new POI ID - not optimal, will improve (todo) var currentMaxId = CitiesDataStore.Current.Cities.SelectMany(city => city.PointsOfInterest).Max(poiDto => poiDto.Id); var newPoi = new PointOfInterestDto { Id = ++currentMaxId, Name = pointOfInterest.Name, Description = pointOfInterest.Description }; // add the new point of interest to the specified city foundCity.PointsOfInterest.Add(newPoi); // create a result pointing to the new city (with the route specified) return(CreatedAtRoute("GetPointOfInterest", new { cityId = cityId, poiId = newPoi.Id }, newPoi)); }
public IActionResult CreatePointOfInterest(int cityId, [FromBody] PointOfInterestForCreationDto pointOfInterest) { // this block will contain the request body will contain the data for the point of interest. // we want to deseraialize into a point of interest, for creation dto. // Thats what a from body attribute is for. if (pointOfInterest == null) { return(BadRequest()); } if (pointOfInterest.Description == pointOfInterest.Name) { ModelState.AddModelError("Description", "The provided description should be different from the name."); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var city = CitiesDataStore.Current.Cities.FirstOrDefault(c => c.Id == cityId); if (city == null) { return(NotFound()); } var maxPointOfInterestId = CitiesDataStore.Current.Cities.SelectMany( c => c.PointsOfInterest).Max(p => p.Id); var finalPointOfInterest = new PointOfInterestDto() { Id = ++maxPointOfInterestId, Name = pointOfInterest.Name, Description = pointOfInterest.Description }; city.PointsOfInterest.Add((finalPointOfInterest)); return(CreatedAtRoute("GetPointOfInterest", new { cityId = cityId, id = finalPointOfInterest.Id }, finalPointOfInterest)); }
public IActionResult CreatePointOfInterest(int cityId, [FromBody] PointOfInterestForCreation pointOfInterest) { var city = CitiesDataStore.Current.Cities.FirstOrDefault(c => c.Id == cityId); var maxIdPointOfInterest = CitiesDataStore.Current.Cities.SelectMany(c => c.PointsOfInterest).Max(p => p.Id); if (city == null) { return(NotFound()); } var newPoint = new PointOfInterestDto { Id = ++maxIdPointOfInterest, Description = pointOfInterest.Description, Name = pointOfInterest.Name, }; city.PointsOfInterest.Add(newPoint); return(CreatedAtRoute("GetPointOfAction", new { cityId = city.Id, id = newPoint.Id }, newPoint)); }