Francesco Lorenzo D'Amico
520 lines
20 KiB
C#
520 lines
20 KiB
C#
namespace Francesco.Recipes.World.Controller.Recipe
|
|
{
|
|
using Francesco.Recipes.World.Data;
|
|
using Francesco.Recipes.World.Models;
|
|
using Francesco.Recipes.World.Models.BackendModels.Ingredient;
|
|
using Francesco.Recipes.World.Models.BackendModels.Instruction;
|
|
using Francesco.Recipes.World.Models.BackendModels.Recipe;
|
|
using Francesco.Recipes.World.Repositories.Category;
|
|
using Francesco.Recipes.World.Repositories.Favorit;
|
|
using Francesco.Recipes.World.Repositories.Ingredient;
|
|
using Francesco.Recipes.World.Repositories.Instruction;
|
|
using Francesco.Recipes.World.Repositories.MediaFile;
|
|
using Francesco.Recipes.World.Repositories.Recipe;
|
|
using Francesco.Recipes.World.Repositories.Unit;
|
|
using Francesco.Recipes.World.Views.Category;
|
|
using Francesco.Recipes.World.Views.Recipe;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.Mvc.Rendering;
|
|
|
|
public class RecipeController : Controller
|
|
{
|
|
private readonly IRecipeRepository _recipeRepository;
|
|
private readonly IUnitRepository _unitRepository;
|
|
private readonly ICategoryRepository _categoryRepository;
|
|
private readonly IIngredientRepository _ingredientRepository;
|
|
private readonly IMediaFileRepository _mediaFileRepository;
|
|
private readonly IInstructionRepository _instructionRepository;
|
|
private readonly IFavoriteRepository _favoriteRepository;
|
|
private readonly FrancescosRecipesWorldDbContext _context;
|
|
|
|
public IReadOnlyCollection<Recipe> Recipes { get; set; }
|
|
|
|
public RecipeController(
|
|
IRecipeRepository recipeRepository,
|
|
IUnitRepository unitRepository,
|
|
ICategoryRepository categoryRepository,
|
|
IIngredientRepository ingredientRepository,
|
|
IMediaFileRepository mediaFileRepository,
|
|
IInstructionRepository instructionRepository,
|
|
IFavoriteRepository favoriteRepository,
|
|
FrancescosRecipesWorldDbContext context)
|
|
{
|
|
_recipeRepository = recipeRepository;
|
|
_unitRepository = unitRepository;
|
|
_categoryRepository = categoryRepository;
|
|
_ingredientRepository = ingredientRepository;
|
|
Recipes = new List<Recipe>();
|
|
_mediaFileRepository = mediaFileRepository;
|
|
_instructionRepository = instructionRepository;
|
|
_favoriteRepository = favoriteRepository;
|
|
_context = context;
|
|
}
|
|
|
|
// GET: /Recipe/{recipeId}/AddOrCreateIngredient
|
|
[HttpGet("{recipeId}/AddOrCreateIngredient")]
|
|
public async Task<IActionResult> AddOrCreateIngredient(Guid recipeId)
|
|
{
|
|
if (recipeId == Guid.Empty)
|
|
{
|
|
return BadRequest("Recipe ID cannot be empty.");
|
|
}
|
|
|
|
var units = await _unitRepository.GetAllUnitsAsync();
|
|
var recipeIngredients = await _ingredientRepository.GetIngredientsByRecipeIdAsync(recipeId);
|
|
var ingredients = recipeIngredients.Select(ri => ri.Ingredient).ToList();
|
|
|
|
var viewModel = new IngredientViewModel
|
|
{
|
|
RecipeId = recipeId,
|
|
Ingredients = ingredients,
|
|
Units = units.ToList(),
|
|
};
|
|
|
|
return View(viewModel);
|
|
}
|
|
|
|
// GET: /Recipe/Details/{recipeId}
|
|
[HttpGet("Details/{recipeId}")]
|
|
public async Task<IActionResult> Details(Guid recipeId)
|
|
{
|
|
var recipe = await _recipeRepository.GetRecipeByIdAsync(recipeId);
|
|
if (recipe == null)
|
|
{
|
|
return NotFound("Recipe not found.");
|
|
}
|
|
|
|
return View(recipe);
|
|
}
|
|
|
|
// GET: /Recipe/CategoryRecipes
|
|
[HttpGet("CategoryRecipes")]
|
|
public async Task<IActionResult> CategoryRecipes()
|
|
{
|
|
var categories = await _categoryRepository.GetAllCategoriesWithRecipesAsync();
|
|
|
|
var viewModel = categories.Select(c => new CategoryRecipesViewModel
|
|
{
|
|
Category = c,
|
|
Recipes = c.Recipes,
|
|
}).ToList();
|
|
|
|
return View(viewModel);
|
|
}
|
|
|
|
// POST: /Recipe/{recipeId}/AddOrCreateIngredient
|
|
[HttpPost("{recipeId}/AddOrCreateIngredient")]
|
|
[ValidateAntiForgeryToken]
|
|
public async Task<IActionResult> AddOrCreateIngredient(Guid recipeId, string ingredientName, int quantity, Guid unitId)
|
|
{
|
|
if (recipeId == Guid.Empty)
|
|
{
|
|
return BadRequest("Recipe ID cannot be empty.");
|
|
}
|
|
|
|
if (quantity <= 0)
|
|
{
|
|
ModelState.AddModelError(nameof(quantity), "Die Menge muss größer als 0 sein.");
|
|
}
|
|
|
|
if (!ModelState.IsValid)
|
|
{
|
|
var units = await _unitRepository.GetAllUnitsAsync();
|
|
ViewBag.Units = new SelectList(units, "Id", "Name");
|
|
return View();
|
|
}
|
|
|
|
await _recipeRepository.CreateRecipeIngredientAsync(recipeId, ingredientName, quantity, unitId);
|
|
return RedirectToAction("Details", new { id = recipeId });
|
|
}
|
|
|
|
// GET: /Recipe/Create/{categoryId}
|
|
[HttpGet("Create/{categoryId}")]
|
|
public async Task<IActionResult> Create(Guid categoryId)
|
|
{
|
|
var category = await _categoryRepository.GetCategoryByIdAsync(categoryId);
|
|
if (category == null)
|
|
{
|
|
return NotFound($"Kategorie mit ID {categoryId} wurde nicht gefunden.");
|
|
}
|
|
|
|
var units = await _unitRepository.GetAllUnitsAsync();
|
|
|
|
var viewModel = new CreateRecipeViewModel
|
|
{
|
|
CategoryId = categoryId,
|
|
CategoryName = category.Name,
|
|
IngredientViewModel = new IngredientViewModel
|
|
{
|
|
RecipeId = Guid.Empty,
|
|
Ingredients = new List<Ingredient>(),
|
|
Units = units.ToList(),
|
|
},
|
|
InstructionViewModel = new InstructionViewModel
|
|
{
|
|
RecipeId = Guid.Empty,
|
|
Instructions = new List<Instruction>(),
|
|
},
|
|
};
|
|
return View(viewModel);
|
|
}
|
|
|
|
// POST: /Recipe/Create/{categoryId}
|
|
[HttpPost("Create/{categoryId}")]
|
|
[ValidateAntiForgeryToken]
|
|
public async Task<IActionResult> Create(Guid categoryId, CreateRecipeViewModel model)
|
|
{
|
|
if (model == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(model), "CreateRecipeViewModel cannot be null.");
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(model.Name))
|
|
{
|
|
ModelState.AddModelError(nameof(model.Name), "Name darf nicht leer sein.");
|
|
}
|
|
|
|
if (model.Servings <= 0)
|
|
{
|
|
ModelState.AddModelError(nameof(model.Servings), "Anzahl der Portionen muss größer als 0 sein.");
|
|
}
|
|
|
|
if (!ModelState.IsValid)
|
|
{
|
|
var category = await _categoryRepository.GetCategoryByIdAsync(categoryId);
|
|
if (category == null)
|
|
{
|
|
return NotFound($"Kategorie mit ID {categoryId} wurde nicht gefunden.");
|
|
}
|
|
|
|
var units = await _unitRepository.GetAllUnitsAsync();
|
|
|
|
if (model.IngredientViewModel == null)
|
|
{
|
|
model.IngredientViewModel = new IngredientViewModel
|
|
{
|
|
RecipeId = Guid.Empty,
|
|
Ingredients = new List<Ingredient>(),
|
|
Units = units.ToList(),
|
|
};
|
|
}
|
|
else
|
|
{
|
|
model.IngredientViewModel.Units = units.ToList();
|
|
}
|
|
|
|
model.CategoryName = category.Name;
|
|
return View(model);
|
|
}
|
|
|
|
using var transaction = await _context.Database.BeginTransactionAsync();
|
|
try
|
|
{
|
|
var categoryEntity = await _categoryRepository.GetCategoryByIdAsync(categoryId);
|
|
if (categoryEntity == null)
|
|
{
|
|
return NotFound($"Kategorie mit ID {categoryId} wurde nicht gefunden.");
|
|
}
|
|
|
|
model.PreparationTime = new TimeSpan(model.PrepHours, model.PrepMinutes, 0);
|
|
model.CookingTime = new TimeSpan(model.CookHours, model.CookMinutes, 0);
|
|
|
|
var recipe = await _recipeRepository.CreateRecipeForCategoryAsync(
|
|
categoryEntity,
|
|
model.Name,
|
|
model.Description ?? string.Empty,
|
|
model.Difficulty,
|
|
model.Servings,
|
|
model.PreparationTime,
|
|
model.CookingTime);
|
|
|
|
if (model.Photo != null)
|
|
{
|
|
await _mediaFileRepository.UploadRecipeMediaAsync(recipe.Id, model.Photo);
|
|
}
|
|
|
|
if (model.Video != null)
|
|
{
|
|
await _mediaFileRepository.UploadRecipeMediaAsync(recipe.Id, model.Video);
|
|
}
|
|
|
|
if (model.IngredientViewModel?.Ingredients != null)
|
|
{
|
|
foreach (var ingredient in model.IngredientViewModel.Ingredients)
|
|
{
|
|
var ri = ingredient.RecipeIngredients?.FirstOrDefault();
|
|
if (!string.IsNullOrWhiteSpace(ingredient.Name) && ri?.Quantity > 0 && ri?.Unit?.Id != null)
|
|
{
|
|
await _recipeRepository.CreateRecipeIngredientAsync(
|
|
recipe.Id,
|
|
ingredient.Name,
|
|
ri.Quantity,
|
|
ri.Unit.Id);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (model.InstructionViewModel?.Instructions != null)
|
|
{
|
|
for (var i = 0; i < model.InstructionViewModel.Instructions.Count; i++)
|
|
{
|
|
var instruction = model.InstructionViewModel.Instructions[i];
|
|
if (!string.IsNullOrWhiteSpace(instruction.Description))
|
|
{
|
|
var fileKey = $"InstructionViewModel.Instructions[{i}].MediaFile";
|
|
IFormFile? imageFile = null;
|
|
|
|
if (Request.Form.Files.Any(f => f.Name == fileKey))
|
|
{
|
|
imageFile = Request.Form.Files[fileKey];
|
|
}
|
|
|
|
await _instructionRepository.CreateInstructionAsync(
|
|
recipe.Id,
|
|
instruction.Description,
|
|
imageFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
await transaction.CommitAsync();
|
|
return RedirectToAction("Details", new { recipeId = recipe.Id });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await transaction.RollbackAsync();
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
|
|
// GET: /Recipe/{recipeId}/RemoveIngredient/{ingredientId}
|
|
[HttpGet("{recipeId}/RemoveIngredient/{ingredientId}")]
|
|
public async Task<IActionResult> RemoveIngredient(Guid recipeId, Guid ingredientId)
|
|
{
|
|
var recipe = await _recipeRepository.GetRecipeAsync(recipeId);
|
|
var ingredient = await _ingredientRepository.GetIngredientByIdAsync(ingredientId);
|
|
|
|
if (recipe == null || ingredient == null)
|
|
{
|
|
return NotFound("Recipe or Ingredient not found.");
|
|
}
|
|
|
|
ViewBag.RecipeId = recipeId;
|
|
ViewBag.IngredientId = ingredientId;
|
|
|
|
return View();
|
|
}
|
|
|
|
// DELETE: /Recipe/{recipeId}/RemoveIngredient/{ingredientId}
|
|
[HttpDelete("{recipeId}/RemoveIngredient/{ingredientId}")]
|
|
[ValidateAntiForgeryToken]
|
|
public async Task<IActionResult> RemoveIngredientConfirmed(Guid recipeId, Guid ingredientId)
|
|
{
|
|
await _recipeRepository.RemoveIngredientFromRecipeAsync(recipeId, ingredientId);
|
|
TempData["SuccessMessage"] = "Ingredient removed successfully.";
|
|
return RedirectToAction("Details", new { id = recipeId });
|
|
}
|
|
|
|
// GET: /Recipe/{recipeId}/RemoveInstruction/{instructionId}
|
|
[HttpGet("{recipeId}/RemoveInstruction/{instructionId}")]
|
|
public async Task<IActionResult> RemoveInstruction(Guid recipeId, Guid instructionId)
|
|
{
|
|
var recipe = await _recipeRepository.GetRecipeAsync(recipeId);
|
|
|
|
if (recipe == null)
|
|
{
|
|
return NotFound("Recipe not found.");
|
|
}
|
|
|
|
var instruction = recipe.Instructions?.FirstOrDefault(i => i.Id == instructionId);
|
|
if (instruction == null)
|
|
{
|
|
return NotFound("Instruction not found in the specified recipe.");
|
|
}
|
|
|
|
ViewBag.RecipeId = recipeId;
|
|
ViewBag.InstructionId = instructionId;
|
|
|
|
return View();
|
|
}
|
|
|
|
// DELETE: /Recipe/{recipeId}/RemoveInstruction/{instructionId}
|
|
[HttpDelete("{recipeId}/RemoveInstruction/{instructionId}")]
|
|
[ValidateAntiForgeryToken]
|
|
public async Task<IActionResult> RemoveInstructionConfirmed(Guid recipeId, Guid instructionId)
|
|
{
|
|
try
|
|
{
|
|
await _instructionRepository.RemoveInstructionFromRecipeAsync(recipeId, instructionId);
|
|
TempData["SuccessMessage"] = "Instruction removed successfully.";
|
|
return RedirectToAction("Details", new { recipeId });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TempData["ErrorMessage"] = $"An error occurred while removing the instruction: {ex.Message}";
|
|
return RedirectToAction("Details", new { recipeId });
|
|
}
|
|
}
|
|
|
|
// GET: /Recipe/FilterByDifficulty
|
|
[HttpGet("FilterByDifficulty")]
|
|
public async Task<IActionResult> FilterByDifficulty(Difficulty? selectedDifficulty)
|
|
{
|
|
var recipes = await _recipeRepository.GetRecipesByDifficultyAsync(selectedDifficulty);
|
|
var viewModel = new FilterByDifficultyViewModel
|
|
{
|
|
SelectedDifficulty = selectedDifficulty,
|
|
Recipes = recipes,
|
|
};
|
|
return View(viewModel);
|
|
}
|
|
|
|
// GET: /Recipe/{recipeId}/AddInstruction
|
|
[HttpGet("{recipeId}/AddInstruction")]
|
|
public async Task<IActionResult> AddInstruction(Guid recipeId)
|
|
{
|
|
var recipe = await _recipeRepository.GetRecipeByIdAsync(recipeId);
|
|
if (recipe == null)
|
|
{
|
|
return NotFound("Recipe not found.");
|
|
}
|
|
|
|
var instructions = await _instructionRepository.GetInstructionsOfRecipeAsync(recipeId);
|
|
|
|
var viewModel = new InstructionViewModel
|
|
{
|
|
RecipeId = recipeId,
|
|
Instructions = instructions,
|
|
};
|
|
|
|
return View(viewModel);
|
|
}
|
|
|
|
// POST: /Recipe/{recipeId}/AddInstruction
|
|
[HttpPost("{recipeId}/AddInstruction")]
|
|
[ValidateAntiForgeryToken]
|
|
public async Task<IActionResult> AddInstruction(Guid recipeId, string description, IFormFile? image)
|
|
{
|
|
try
|
|
{
|
|
await _instructionRepository.CreateInstructionAsync(recipeId, description, image);
|
|
|
|
var recipe = await _recipeRepository.GetRecipeByIdAsync(recipeId);
|
|
var instructions = recipe?.Instructions?.ToList() ?? new List<Instruction>();
|
|
|
|
var viewModel = new InstructionViewModel
|
|
{
|
|
RecipeId = recipeId,
|
|
Instructions = instructions,
|
|
};
|
|
|
|
return RedirectToAction("AddInstruction", new { recipeId });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
|
|
// GET: /Recipe/Favorites
|
|
[HttpGet("Favorites")]
|
|
public async Task<IActionResult> Favorites()
|
|
{
|
|
var favoriteRecipes = await _favoriteRepository.GetFavoriteRecipesAsync();
|
|
return View(favoriteRecipes);
|
|
}
|
|
|
|
// POST: /Recipe/AddFavorite
|
|
[HttpPost("AddFavorite")]
|
|
[ValidateAntiForgeryToken]
|
|
public async Task<IActionResult> AddFavorite(Guid recipeId)
|
|
{
|
|
await _favoriteRepository.AddFavoriteAsync(recipeId);
|
|
var recipe = await _recipeRepository.GetRecipeByIdAsync(recipeId);
|
|
if (recipe == null)
|
|
{
|
|
return NotFound("Recipe not found.");
|
|
}
|
|
|
|
return PartialView("_FavoriteButton", recipe);
|
|
}
|
|
|
|
// POST: /Recipe/RemoveFavorite
|
|
[HttpPost("RemoveFavorite")]
|
|
[ValidateAntiForgeryToken]
|
|
public async Task<IActionResult> RemoveFavorite(Guid recipeId)
|
|
{
|
|
await _favoriteRepository.RemoveFavoriteAsync(recipeId);
|
|
var recipe = await _recipeRepository.GetRecipeByIdAsync(recipeId);
|
|
if (recipe == null)
|
|
{
|
|
return NotFound("Recipe not found.");
|
|
}
|
|
|
|
return PartialView("_FavoriteButton", recipe);
|
|
}
|
|
|
|
// GET: /Recipe/{recipeId}/GetIngredients
|
|
[HttpGet("{recipeId}/GetIngredients")]
|
|
public async Task<IActionResult> GetIngredients(Guid recipeId)
|
|
{
|
|
var recipeIngredients = (await _ingredientRepository.GetIngredientsByRecipeIdAsync(recipeId)).Select(ri => ri.Ingredient).ToList();
|
|
var units = await _unitRepository.GetAllUnitsAsync();
|
|
|
|
var viewModel = new IngredientViewModel
|
|
{
|
|
RecipeId = recipeId,
|
|
Ingredients = recipeIngredients,
|
|
Units = units,
|
|
};
|
|
|
|
return PartialView("_IngredientsPartial", viewModel);
|
|
}
|
|
|
|
// GET: /Recipe/{recipeId}/AdjustableIngredients
|
|
[HttpGet("{recipeId}/AdjustableIngredients")]
|
|
public async Task<IActionResult> GetAdjustableIngredients(Guid recipeId)
|
|
{
|
|
var recipe = await _recipeRepository.GetRecipeByIdAsync(recipeId);
|
|
if (recipe == null)
|
|
{
|
|
return NotFound("Recipe not found.");
|
|
}
|
|
|
|
return PartialView("_AdjustableIngredientsPartial", recipe);
|
|
}
|
|
|
|
// GET: /Recipe/{recipeId}/Delete
|
|
[HttpGet("{recipeId}/Delete")]
|
|
public async Task<IActionResult> Delete(Guid recipeId)
|
|
{
|
|
var recipe = await _recipeRepository.GetRecipeByIdAsync(recipeId);
|
|
if (recipe == null)
|
|
{
|
|
return NotFound("Recipe not found.");
|
|
}
|
|
|
|
return View(recipe);
|
|
}
|
|
|
|
// DELETE: /Recipe/{recipeId}/Delete
|
|
[HttpDelete("{recipeId}/Delete")]
|
|
[ValidateAntiForgeryToken]
|
|
public async Task<IActionResult> DeleteConfirmed(Guid recipeId)
|
|
{
|
|
var deleted = await _recipeRepository.DeleteRecipeAsync(recipeId);
|
|
|
|
if (deleted)
|
|
{
|
|
TempData["SuccessMessage"] = "Rezept wurde erfolgreich gelöscht.";
|
|
return RedirectToAction("Index", "Home");
|
|
}
|
|
else
|
|
{
|
|
TempData["ErrorMessage"] = "Rezept nicht gefunden oder konnte nicht gelöscht werden.";
|
|
return RedirectToAction("Details", new { recipeId });
|
|
}
|
|
}
|
|
}
|
|
}
|