public async Task <IActionResult> Edit(int?id)
{
var dish = await _context.Dishes.Include(x => x.DishIngredients).ThenInclude(y => y.Ingredient).SingleOrDefaultAsync(m => m.DishId == id);
if (dish == null)
{
return(NotFound());
}
var model = new EditDishViewModel
{
Dish = dish,
Ingredients = new List <CheckBox>()
};
foreach (var ingredient in _ingredientService.All())
{
model.Ingredients.Add(new CheckBox
{
Id = ingredient.IngredientId,
Name = ingredient.Name,
Selected = _dishService.HasIngredient(dish.DishId, ingredient.IngredientId)
});
}
return(View(model));
}
public async Task <IActionResult> AddIngredient(EditDishViewModel mdl)
{
// Check if the state is valid, see EditDishViewModel for valid attributes
if (string.IsNullOrWhiteSpace(mdl.NewIngredient))
{
mdl.Dish = await _dishService.GetDishAsync(mdl.Dish.MatrattId);
mdl.Categories = await _dishService.GetDishCategoriesAsync();
mdl.Ingredients = await _dishService.GetDishIngredientsAsync();
ModelState.AddModelError("NewIngredient", "Namnet får endast innehålla a-ö.");
return(PartialView("_AddIngredientPartialView", mdl));
}
// Save new ingredient and attach it to the dish
await _dishService.AddIngredientToDish(mdl.NewIngredient, mdl.Dish.MatrattId);
// Refill the ViewModel and return
mdl.Dish = await _dishService.GetDishAsync(mdl.Dish.MatrattId);
mdl.NewIngredient = string.Empty;
mdl.Categories = await _dishService.GetDishCategoriesAsync();
mdl.Ingredients = await _dishService.GetDishIngredientsAsync();
return(PartialView("_AddIngredientPartialView", mdl));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var menuCategoryNames = _menuCatRep.GetCategoryNames();
var dish = _repository.GetById(id);
if (dish == null)
{
return(HttpNotFound());
}
var positions = GetPositionList();
positions.Add(dish.Position);
positions.Sort();
EditDishViewModel model = new EditDishViewModel()
{
DishID = dish.Id,
Description = dish.Description,
Name = dish.Name,
Price = dish.Price,
Position = dish.Position,
MenuCategoryName = dish.MenuCategory.Name,
MenuCategories = new SelectList(menuCategoryNames),
Positions = new SelectList(positions),
Photo = dish.Photo,
PhotoMimeType = dish.PhotoMimeType
};
return(View(model));
}
public ActionResult Edit([Bind(Exclude = "Positions,MenuCategories")] EditDishViewModel model,
HttpPostedFileBase photo)
{
if (ModelState.IsValid)
{
var menuCategory = _menuCatRep.GetByName(model.MenuCategoryName);
Dish dish = new Dish
{
Id = model.DishID,
Description = model.Description,
Name = model.Name,
Price = model.Price,
Position = model.Position,
MenuCatId = menuCategory.Id
};
if (photo != null)
{
dish.Photo = PhotoManager.GetBytes(photo);
dish.PhotoMimeType = photo.ContentType;
}
else
{
dish.PhotoMimeType = model.PhotoMimeType;
dish.Photo = model.Photo;
}
_repository.Update(dish);
_repository.Save();
TempData["Message"] = "The dish: " + model.Name + " has been changed.";
return(RedirectToAction("Manage", "Dish"));
}
ModelState.AddModelError("", "Model is not valid.");
return(View());
}
public async Task <IActionResult> Edit(EditDishViewModel model)
{
if (ModelState.IsValid)
{
var dish = _db.Dishes.FirstOrDefault(d => d.Id == model.Id);
dish.Category = model.Category;
dish.SubCategory = model.SubCategory;
dish.Name = model.Name;
dish.Cost = model.Cost;
dish.Description = model.Description;
dish.Calorie = model.Calorie;
dish.ProperNutrition = model.ProperNutrition;
dish.Vegetarian = model.Vegetarian;
dish.Ingredients = model.Ingredients;
dish.EditTime = DateTime.Now;
dish.EditorId = _userManager.GetUserId(User);
if (model.File != null)
{
await DeleteDishAvatar(dish);
dish.Avatar = await Load(model.Id, model.File);
}
_db.Entry(dish).State = EntityState.Modified;
await _db.SaveChangesAsync();
return(RedirectToAction("Index", "Dishes"));
}
return(View(model));
}
public IActionResult EditDish(int id)
{
EditDishViewModel model = new EditDishViewModel();
model.DishTypes = GetDishTypes();
model.IngredientCheckBoxes = GetCheckBoxDataForDish(id);
model.CurrentMatratt = _context.Matratts.SingleOrDefault(m => m.MatrattId == id);
return(View("EditFoodMenu", model));
}
private void UpdateBtn_Click(object sender, RoutedEventArgs e)
{
EditDishViewModel.Update();
Window parentWindow = Application.Current.MainWindow;
if (parentWindow.GetType() == typeof(MainWindow))
{
(parentWindow as MainWindow).DataContext = new DishesListViewModel();
(parentWindow as MainWindow).Go.Visibility = Visibility.Visible;
}
}
public IActionResult EditDish(int id)
{
var model = new EditDishViewModel
{
Dish = _dishService.FetchDish(id),
Ingredients = _dishService.FetchDishIngredients(),
Categories = _dishService.FetchDishCategories()
};
return(View(model));
}
public async Task <IActionResult> EditDish(int id)
{
var model = new EditDishViewModel
{
Dish = await _dishService.GetDishAsync(id),
Categories = await _dishService.GetDishCategoriesAsync(),
Ingredients = await _dishService.GetDishIngredientsAsync()
};
return(View(model));
}
public async Task EditDishAsyncWorksCorrectly()
{
await this.PopulateDB();
await this.AddDishesToDb();
var newIngredient = new Ingredient()
{
Name = "test3",
Id = 3,
};
this.DbContext.Ingredients.Add(newIngredient);
await this.DbContext.SaveChangesAsync();
var ingredient = this.DbContext.Ingredients.FirstOrDefault(x => x.Id == 1);
var dishTypeId = 2;
var ingredientId = 1;
var image = this.GetFile("test123");
var expectedName = "edit";
var expectedIntValue = 33;
var editDish = new EditDishViewModel()
{
Id = "test1",
Name = expectedName,
Price = expectedIntValue,
Weight = expectedIntValue,
PrepareTime = expectedIntValue,
AdditionalInfo = expectedName,
DishTypeId = dishTypeId,
IngredientsId = new List <int>()
{
ingredientId, newIngredient.Id
},
NewImage = image,
};
await this.DishService.EditDishAsync(editDish, AppDomain.CurrentDomain.BaseDirectory);
var actualIngredient = this.DbContext.Ingredients.FirstOrDefault(x => x.Id == ingredientId);
var actual = this.DbContext.Dishes.FirstOrDefault(x => x.Id == "test1");
Assert.Equal(editDish.Name, actual.Name);
Assert.Equal(expectedIntValue, actual.Price);
Assert.Equal(expectedIntValue, actual.Weight);
Assert.Equal(expectedName, actual.AdditionalInfo);
Assert.Equal(expectedIntValue, actual.PrepareTime);
Assert.Equal(dishTypeId, actual.DishTypeId);
Assert.Equal(new List <Ingredient>()
{
actualIngredient, newIngredient
}, actual.Ingredients);
Assert.Equal(ImageExtension.jpeg, actual.Image.Extension);
}
public async Task <IActionResult> EditDish(int dishId)
{
EditDishViewModel model = new EditDishViewModel(await _repository.GetDishById(dishId), _repository.GetAllDishTypes(), _repository.GetAllProducts());
foreach (var product in model.Dish.MatrattProdukts)
{
Produkt p = model.Products.SingleOrDefault(p => p.ProduktId == product.ProduktId);
p.Checked = true;
}
return(View(model));
}
public async Task <IActionResult> DeleteIngredient(int dishID, int ingredientID)
{
await _dishService.DeleteIngredientFromDish(dishID, ingredientID);
var model = new EditDishViewModel
{
Dish = _dishService.FetchDish(dishID),
Ingredients = _dishService.FetchDishIngredients(),
Categories = _dishService.FetchDishCategories()
};
return(ViewComponent("EditDishIngredients", model));
}
public ActionResult EditDish(string id)
{
var db = new IFood();
EditDishViewModel model = new EditDishViewModel();
model.dish = db.Dishes.Where(d => d.Id.ToString().Equals(id)).FirstOrDefault <Dish>();
model.listCategory = db.Categories.ToList <Category>();
model.listIngredient = db.Ingredients.ToList <Ingredient>();
model.listUnit = db.Units.ToList <Unit>();
model.listCourse = db.Courses.ToList <Course>();
return(View(model));
}
public IActionResult EditDish(EditDishViewModel data)
{
if (ModelState.IsValid)
{
_dishService.UpdateDish(data.Dish);
return(RedirectToAction("ViewDishes", "Admin"));
}
var model = new EditDishViewModel
{
Dish = _dishService.FetchDish(data.Dish.MatrattId),
Categories = _dishService.FetchDishCategories(),
Ingredients = _dishService.FetchDishIngredients(),
};
return(View(model));
}
public async Task <IActionResult> Edit(int id, EditDishViewModel model)
{
if (id != model.Dish.DishId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _context.DishIngredients
.Where(i => i.DishId == model.Dish.DishId)
.ForEachAsync(di => _context.Remove(di));
await _context.SaveChangesAsync();
foreach (var ingredient in model.Ingredients.Where(i => i.Selected))
{
_context.DishIngredients.Add(new DishIngredient
{
DishId = id,
IngredientId = ingredient.Id
});
_context.Update(model.Dish);
await _context.SaveChangesAsync();
}
}
catch (DbUpdateConcurrencyException exc)
{
if (!DishExists(model.Dish.DishId))
{
_logger.LogError(exc.ToString());
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public async Task <IActionResult> AddIngredient(int dishID, int ingredientID)
{
var result = await _dishService.AddIngredientToDish(dishID, ingredientID);
if (result == false)
{
ViewBag.IngredientError = "Ingrediensen finns redan i maträtten";
}
var model = new EditDishViewModel
{
Dish = _dishService.FetchDish(dishID),
Ingredients = _dishService.FetchDishIngredients(),
Categories = _dishService.FetchDishCategories()
};
return(ViewComponent("EditDishIngredients", model));
}
public async Task <IActionResult> ChangeDishValues(EditDishViewModel mdl)
{
if (ModelState.IsValid)
{
await _dishService.UpdateDishAsync(mdl.Dish);
return(RedirectToAction("AdminPage"));
}
// Else return new ViewModel
mdl.Dish = await _dishService.GetDishAsync(mdl.Dish.MatrattId);
mdl.Categories = await _dishService.GetDishCategoriesAsync();
mdl.Ingredients = await _dishService.GetDishIngredientsAsync();
return(View("EditDish", mdl));
}
public IActionResult Edit(string id)
{
var dish = _db.Dishes.FirstOrDefault(d => d.Id == id);
var model = new EditDishViewModel
{
Id = id,
Category = dish.Category,
SubCategory = dish.SubCategory,
Name = dish.Name,
Cost = dish.Cost,
Description = dish.Description,
Calorie = dish.Calorie,
ProperNutrition = dish.ProperNutrition,
Vegetarian = dish.Vegetarian,
Ingredients = dish.Ingredients
};
return(View(model));
}
public async Task <IActionResult> RemoveIngredient(string id)
{
var arr = id.Split("-");
var produktId = int.Parse(arr[0]);
var matrattId = int.Parse(arr[1]);
await _dishService.RemoveIngredientFromDish(produktId, matrattId);
// Refill the ViewModel and return
var mdl = new EditDishViewModel
{
Dish = await _dishService.GetDishAsync(matrattId),
NewIngredient = string.Empty,
Categories = await _dishService.GetDishCategoriesAsync(),
Ingredients = await _dishService.GetDishIngredientsAsync()
};
return(PartialView("_AddIngredientPartialView", mdl));
}
public async Task <IActionResult> UpdateDish(EditDishViewModel model, List <int> selectedProducts)
{
Matratt dish = await _repository.SelectById <Matratt>(model.Dish.MatrattId);
dish.MatrattNamn = model.Dish.MatrattNamn;
dish.Beskrivning = model.Dish.Beskrivning;
dish.Pris = model.Dish.Pris;
dish.MatrattTyp = model.Dish.MatrattTyp;
await _repository.UpdateAsync <Matratt>(dish);
_repository.DeleteMattrattJ(dish.MatrattId);
foreach (var product in selectedProducts)
{
MatrattProdukt smrp = new MatrattProdukt(dish.MatrattId, product);
await _repository.CreateAsync <MatrattProdukt>(smrp);
}
return(RedirectToAction("Dishes"));
}
public IActionResult EditDish(EditDishViewModel model)
{
var editedDish = _context.Matratts.SingleOrDefault(x => x.MatrattId == model.CurrentMatratt.MatrattId);
editedDish.MatrattNamn = model.CurrentMatratt.MatrattNamn;
editedDish.Beskrivning = model.CurrentMatratt.Beskrivning;
editedDish.Pris = model.CurrentMatratt.Pris;
if (model.CurrentMatrattDishTypeID != null)
{
editedDish.MatrattTypId = int.Parse(model.CurrentMatrattDishTypeID);
}
_context.SaveChanges();
UpdateIngredients(editedDish, model.IngredientCheckBoxes);
ViewBag.Message = "Changes saved";
return(RedirectToAction("EditFoodMenu", "Admin"));
}
public IActionResult EditFoodMenu()
{
EditDishViewModel model = new EditDishViewModel();
var dishes = _context.Matratts.Include(r => r.MatrattProdukts).Include(t => t.MatrattTyp).ToList();
foreach (var item in dishes)
{
DishViewModel dish = new DishViewModel();
dish.Id = item.MatrattId;
dish.Name = item.MatrattNamn;
dish.IngredientsString = GetIngredients(item);
dish.DishType = item.MatrattTyp.Beskrivning;
dish.Description = item.Beskrivning;
dish.Ingredients = GetCheckBoxDataForDish(item.MatrattId);
model.AllDishes.Add(dish);
}
return(View(model));
}
public async Task <IActionResult> EditDish(EditDishViewModel editDish)
{
await this.dishService.EditDishAsync(editDish, this.webHostEnvironment.WebRootPath);
return(this.RedirectToAction("Index", "Menu"));
}
public IViewComponentResult Invoke(EditDishViewModel model)
{
return(View("EditDishIngredients", model));
}
