public ActionResult <BrewDto> CreateBrew([FromBody] BrewForCreationDto brew,
[FromHeader(Name = ExtendedControllerBase.ACCEPT)] string mediaTypes)
{
var splitMediaTypes = mediaTypes.Split(',');
if (!MediaTypeHeaderValue.TryParseList(splitMediaTypes,
out IList <MediaTypeHeaderValue> parsedMediaTypes))
{
return(BadRequest());
}
if (!_homebrewRepository.RecipeExists(brew.RecipeId))
{
ModelState.AddModelError(
"Recipe ID",
$"The associated recipe id [{brew.RecipeId}] for the {brew.Name} brew must be valid.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var includeSteps = true;
var includeAdditionalInfo = true;
var finalBrew = _mapper.Map <Entities.Brew>(brew);
_homebrewRepository.AddBrew(finalBrew);
finalBrew.Recipe = _homebrewRepository.GetRecipe(brew.RecipeId, includeSteps);
_homebrewRepository.Save();
var brewToReturn = _mapper.Map <Models.BrewDto>(finalBrew);
if (parsedMediaTypes.Any(pmt => pmt.SubTypeWithoutSuffix.EndsWith(this.HATEOAS, StringComparison.InvariantCultureIgnoreCase)))
{
var links = CreateLinksForBrew(brewToReturn.Id, includeAdditionalInfo);
var linkedResourceToReturn = brewToReturn.ShapeData(null)
as IDictionary <string, object>;
linkedResourceToReturn.Add(this.LINKS, links);
return(CreatedAtRoute(
"GetBrew",
new { id = linkedResourceToReturn["Id"], includeAdditionalInfo },
linkedResourceToReturn));
}
return(CreatedAtRoute(
"GetBrew",
new { id = brewToReturn.Id, includeAdditionalInfo },
brewToReturn));
}
public ActionResult <RecipeDto> CreateRecipe([FromBody] RecipeForCreationDto recipe,
[FromHeader(Name = ExtendedControllerBase.ACCEPT)] string mediaTypes)
{
var splitMediaTypes = mediaTypes.Split(',');
if (!MediaTypeHeaderValue.TryParseList(splitMediaTypes,
out IList <MediaTypeHeaderValue> parsedMediaTypes))
{
return(BadRequest());
}
if (!_homeBrewRepository.WaterProfileExists(recipe.WaterProfileId))
{
ModelState.AddModelError(
"Description",
"The water profile ID for the recipe must exist.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var includeSteps = true;
var finalRecipe = _mapper.Map <Entities.Recipe>(recipe);
_homeBrewRepository.AddRecipe(finalRecipe);
finalRecipe.WaterProfile = _homeBrewRepository.GetWaterProfile(recipe.WaterProfileId, true);
_homeBrewRepository.Save();
var recipeToReturn = _mapper.Map <Models.RecipeDto>(finalRecipe);
if (parsedMediaTypes.Any(pmt => pmt.SubTypeWithoutSuffix.EndsWith(this.HATEOAS, StringComparison.InvariantCultureIgnoreCase)))
{
var links = CreateLinksForRecipe(recipeToReturn.Id, includeSteps);
var linkedResourceToReturn = recipeToReturn.ShapeData(null)
as IDictionary <string, object>;
linkedResourceToReturn.Add(this.LINKS, links);
return(CreatedAtRoute(
"GetRecipe",
new { id = linkedResourceToReturn["Id"], includeSteps },
linkedResourceToReturn));
}
return(CreatedAtRoute(
"GetRecipe",
new { id = recipeToReturn.Id, includeSteps },
recipeToReturn));
}
public ActionResult <TastingNoteDto> CreateTastingNote(int brewId,
[FromBody] TastingNoteForCreationDto tastingNote,
[FromHeader(Name = ExtendedControllerBase.ACCEPT)] string mediaTypes)
{
var splitMediaTypes = mediaTypes.Split(',');
if (!MediaTypeHeaderValue.TryParseList(splitMediaTypes,
out IList <MediaTypeHeaderValue> parsedMediaTypes))
{
return(BadRequest());
}
if (!_homebrewRepository.BrewExists(brewId))
{
return(NotFound());
}
var includeAdditionalInfo = true;
var finalTastingNote = _mapper.Map <Entities.TastingNote>(tastingNote);
_homebrewRepository.AddTastingNote(finalTastingNote);
finalTastingNote.Brew = _homebrewRepository.GetBrew(brewId, includeAdditionalInfo);
_homebrewRepository.Save();
var tastingNoteToReturn = _mapper.Map <Models.TastingNoteDto>(finalTastingNote);
if (parsedMediaTypes.Any(pmt => pmt.SubTypeWithoutSuffix.EndsWith(this.HATEOAS, StringComparison.InvariantCultureIgnoreCase)))
{
var links = CreateLinksForTastingNote(brewId, tastingNoteToReturn.Id);
var linkedResourcesToReturn = tastingNote.ShapeData(null) as IDictionary <string, object>;
linkedResourcesToReturn.Add(this.LINKS, links);
return(CreatedAtRoute(
"GetTastingNote",
new { brewId, id = linkedResourcesToReturn["Id"] },
linkedResourcesToReturn));
}
return(CreatedAtRoute(
"GetTastingNote",
new { brewId, id = tastingNoteToReturn.Id },
tastingNoteToReturn));
}
public ActionResult <IngredientDto> CreateIngredient(int recipeStepId,
[FromBody] IngredientForCreationDto ingredient)
{
if (!_homeBrewRepository.RecipeStepExists(recipeStepId))
{
return(NotFound());
}
var finalIngredient = _mapper.Map <Entities.Ingredient>(ingredient);
_homeBrewRepository.AddIngredientForRecipeStep(recipeStepId, finalIngredient);
_homeBrewRepository.Save();
var createdIngredientToReturn = _mapper.Map <Models.IngredientDto>(finalIngredient);
return(CreatedAtRoute(
"GetIngredient",
new { recipeStepId, id = finalIngredient.Id },
createdIngredientToReturn));
}
public ActionResult <WaterProfileDto> CreateWaterProfile([FromBody] WaterProfileForCreationDto waterProfile,
[FromHeader(Name = ExtendedControllerBase.ACCEPT)] string mediaTypes)
{
var splitMediaTypes = mediaTypes.Split(',');
if (!MediaTypeHeaderValue.TryParseList(splitMediaTypes,
out IList <MediaTypeHeaderValue> parsedMediaTypes))
{
return(BadRequest());
}
var includeAdditions = true;
var finalWaterProfile = _mapper.Map <Entities.WaterProfile>(waterProfile);
_homeBrewRepository.AddWaterProfile(finalWaterProfile);
_homeBrewRepository.Save();
var waterProfileToReturn = _mapper.Map <Models.WaterProfileDto>(finalWaterProfile);
if (parsedMediaTypes.Any(pmt => pmt.SubTypeWithoutSuffix.EndsWith(this.HATEOAS, StringComparison.InvariantCultureIgnoreCase)))
{
var links = CreateLinksForWaterProfile(waterProfileToReturn.Id, includeAdditions);
var linkedResourceToReturn = waterProfileToReturn.ShapeData(null)
as IDictionary <string, object>;
linkedResourceToReturn.Add(this.LINKS, links);
return(CreatedAtRoute(
"GetWaterProfile",
new { id = linkedResourceToReturn["Id"], includeAdditions },
linkedResourceToReturn));
}
return(CreatedAtRoute(
"GetWaterProfile",
new { id = finalWaterProfile.Id, includeAdditions },
waterProfileToReturn));
}
public ActionResult <RecipeStepDto> CreateRecipeStep(int recipeId,
[FromBody] RecipeStepForCreationDto recipeStep)
{
if (!_homeBrewRepository.RecipeExists(recipeId))
{
return(NotFound());
}
var finalRecipeStep = _mapper.Map <Entities.RecipeStep>(recipeStep);
_homeBrewRepository.AddStepForRecipe(recipeId, finalRecipeStep);
_homeBrewRepository.Save();
var createdRecipeStepToReturn = _mapper.Map <Models.RecipeStepDto>(finalRecipeStep);
return(CreatedAtRoute(
"GetRecipeStep",
new { recipeId, id = finalRecipeStep.Id },
createdRecipeStepToReturn));
}
