public ControllerMessage Update(DishEditDTO dishEditDTO)
{
string message = String.Empty;
bool success = Validate(dishEditDTO, ref message);
if (success)
{
try
{
DishEntity dishEntity = unitOfWork.Dishes.Get(dishEditDTO.OldName);
dishEntity.Name = dishEditDTO.NewName;
dishEntity.Price = dishEditDTO.Price;
unitOfWork.Commit();
message = "Dish changed";
}
catch (Exception ex)
{
success = false;
message = ExceptionMessageBuilder.BuildMessage(ex);
}
}
return(new ControllerMessage(success, message));
}
public async Task <bool> EditDishAsync(DishEditDTO dishEditDTO, string webRootPath)
{
Dish dishToUpdate = await _dishRepository.GetAsync(dishEditDTO.Id);
if (dishToUpdate != null)
{
dishToUpdate.Name = dishEditDTO.Name;
dishToUpdate.Description = dishEditDTO.Description;
dishToUpdate.Weight = dishEditDTO.Weight;
dishToUpdate.Price = dishEditDTO.Price;
dishToUpdate.DishGroupId = dishEditDTO.DishGroupId;
string oldImageUrl = dishToUpdate.ImageURL;
if (!String.IsNullOrEmpty(dishEditDTO.ImageURL))
{
dishToUpdate.ImageURL = dishEditDTO.ImageURL;
}
_dishRepository.Update(dishToUpdate);
if (await _unitOfWork.SaveChangesAsync() > 0)
{
if (!String.IsNullOrEmpty(dishEditDTO.ImageURL) && File.Exists($"{webRootPath}/{oldImageUrl}"))
{
File.Delete($"{webRootPath}/{oldImageUrl}");
}
return(true);
}
}
return(false);
}
public async Task <IActionResult> Edit(DishEditViewModel dishEditViewModel, IFormFile uploadedImage)
{
try
{
DishEditDTO dishEditDTO = new DishEditDTO()
{
Id = dishEditViewModel.Id,
Name = dishEditViewModel.Name,
Description = dishEditViewModel.Description,
Weight = dishEditViewModel.Weight,
Price = dishEditViewModel.Price,
DishGroupId = dishEditViewModel.DishGroupId,
ImageURL = await SaveDishImageAsync(uploadedImage, dishEditViewModel.Id)
};
bool response = await _dishService.EditDishAsync(dishEditDTO, _hostingEnvironment.WebRootPath);
if (response)
{
return(RedirectToAction("Info", new { id = dishEditDTO.Id }));
}
}
catch (Exception ex)
{
//logging
}
return(ErrorView());
}
public async Task <IActionResult> Create()
{
try
{
DishEditDTO dishEditDTO = await _dishService.GetCreateDishEditDTOAsync();
DishEditViewModel dishEditViewModel = new DishEditViewModel()
{
DishGroups = dishEditDTO.DishGroups
.Select(x => new SelectListItem()
{
Text = x.Text,
Value = x.Value
}).ToList()
};
return(View(dishEditViewModel));
}
catch (Exception)
{
//logging
}
return(ErrorView());
}
public async Task <IActionResult> Edit(int id)
{
try
{
DishEditDTO dishEditDTO = await _dishService.GetDishByIdForEditAsync(id);
if (dishEditDTO != null)
{
DishEditViewModel dishEditViewModel = new DishEditViewModel()
{
Name = dishEditDTO.Name,
Description = dishEditDTO.Description,
Weight = dishEditDTO.Weight,
Price = dishEditDTO.Price,
DishGroupId = dishEditDTO.DishGroupId,
ImageURL = dishEditDTO.ImageURL,
DishGroups = dishEditDTO.DishGroups
.Select(x => new SelectListItem()
{
Text = x.Text,
Value = x.Value
}).ToList()
};
return(View(dishEditViewModel));
}
}
catch (Exception)
{
//logging
}
return(ErrorView());
}
public async Task <IActionResult> Create(DishEditViewModel dishEditViewModel, IFormFile uploadedImage)
{
try
{
DishEditDTO dishEditDTO = new DishEditDTO()
{
Name = dishEditViewModel.Name,
Description = dishEditViewModel.Description,
Weight = dishEditViewModel.Weight,
Price = dishEditViewModel.Price,
DishGroupId = dishEditViewModel.DishGroupId,
ImageURL = "/images/No_Image_Available.jpg"
};
bool response = await _dishService.CreateNewDishAsync(dishEditDTO);
if (response)
{
dishEditDTO.ImageURL = await SaveDishImageAsync(uploadedImage, dishEditDTO.Id);
bool responseImg = await _dishService.EditDishImageAsync(dishEditDTO);
if (responseImg)
{
return(RedirectToAction("Info", new { id = dishEditDTO.Id }));
}
}
}
catch (Exception ex)
{
//logging
}
return(ErrorView());
}
public UIElement GetEditView(IIngredientSubject subject, DishEditDTO dishEditDTO)
{
IngredientListViewModel ingredientListViewModel = new IngredientListViewModel(factory, subject);
RecipeAddViewModel recipeAddViewModel = new RecipeAddViewModel(factory, this, ingredientListViewModel);
recipeAddViewModel.MustSelectDish = false;
DishEditViewModel viewModel = new DishEditViewModel(dishEditDTO, recipeAddViewModel);
DishEditView view = new DishEditView(viewModel);
viewModel.DishSaveRequest += (s, e) =>
{
using (IDishController controller = factory.CreateDishController())
{
ControllerMessage controllerMessage = controller.Update(e.Data);
if (controllerMessage.IsSuccess)
{
Notify();
}
else
{
MessageBox.Show(controllerMessage.Message);
}
}
};
viewModel.DishSaveRecipesRequest += (s, e) =>
{
using (IDishController controller = factory.CreateDishController())
{
ControllerMessage controllerMessage = controller.UpdateRecipes(e.Data);
if (controllerMessage.IsSuccess)
{
Notify();
}
else
{
MessageBox.Show(controllerMessage.Message);
}
}
};
viewModel.DishDeleteRequest += (s, e) =>
{
using (IDishController controller = factory.CreateDishController())
{
ControllerMessage controllerMessage = controller.Delete(e.Data.OldName);
if (controllerMessage.IsSuccess)
{
Notify();
RaiseDishDeletedEvent(e.Data.OldName);
}
else
{
MessageBox.Show(controllerMessage.Message);
}
}
};
return(view);
}
public ControllerMessage UpdateRecipes(DishEditDTO dishEditDTO)
{
string message = String.Empty;
bool success = Validate(dishEditDTO, ref message);
if (success)
{
try
{
DishEntity dishEntity = unitOfWork.Dishes.Get(dishEditDTO.OldName);
IEnumerable <string> added = dishEditDTO.Recipes
.Select(recipe => recipe.Name)
.Where(recipeName => !dishEntity.Recipes.Select(recipe => recipe.Name).Contains(recipeName));
IEnumerable <string> deleted = dishEntity.Recipes
.Select(recipe => recipe.Name)
.Where(recipeName => !dishEditDTO.Recipes.Select(recipe => recipe.Name).Contains(recipeName))
.ToList();
foreach (DishRecipeEditDTO recipe in dishEditDTO.Recipes.Where(recipe => added.Contains(recipe.Name)))
{
if (!unitOfWork.Recipes.Exists(recipe.Name))
{
RecipeEntity recipeEntity = new RecipeEntity
{
Name = recipe.Name,
Description = recipe.Description,
Dish = dishEntity,
RecipeIngredients = recipe.Ingredients.Select(ingredient => new RecipeIngredientEntity
{
Portion = ingredient.Portion,
Ingredient = unitOfWork.Ingredients.Get(ingredient.Ingredient)
})
.ToList()
};
unitOfWork.Recipes.Add(recipeEntity);
}
}
foreach (string recipeName in deleted)
{
RecipeEntity recipeEntity = dishEntity.Recipes.Single(recipe => recipe.Name == recipeName);
unitOfWork.Recipes.Remove(recipeEntity);
}
unitOfWork.Commit();
message = "Dish's recipes changed";
}
catch (Exception ex)
{
success = false;
message = ExceptionMessageBuilder.BuildMessage(ex);
}
}
return(new ControllerMessage(success, message));
}
private void RaiseDishDeleteRequestEvent(DishEditDTO dish)
{
var handler = DishDeleteRequest;
if (handler != null)
{
GenericEventArgs <DishEditDTO> e = new GenericEventArgs <DishEditDTO>(dish);
handler(this, e);
}
}
public DataControllerMessage <DishEditDTO> Get(string dishName)
{
string message = String.Empty;
bool success = true;
DishEditDTO data = null;
try
{
DishEntity dishEntity = unitOfWork.Dishes.Get(dishName);
if (dishEntity != null)
{
data = new DishEditDTO
{
NewName = dishEntity.Name,
OldName = dishEntity.Name,
Price = dishEntity.Price,
CategoryName = dishEntity.Category.Name
};
foreach (RecipeEntity recipeEntity in dishEntity.Recipes)
{
DishRecipeEditDTO dishRecipe = new DishRecipeEditDTO
{
Name = recipeEntity.Name,
Description = recipeEntity.Description
};
var ingredients = recipeEntity.RecipeIngredients.Select(ri => new IngredientPortion
{
Ingredient = ri.Ingredient.Name,
Portion = ri.Portion
})
.OrderBy(ingredient => ingredient.Ingredient);
dishRecipe.Ingredients.AddRange(ingredients);
data.Recipes.Add(dishRecipe);
}
}
else
{
success = false;
message = "Dish not found";
}
}
catch (Exception ex)
{
success = false;
message = ExceptionMessageBuilder.BuildMessage(ex);
}
return(new DataControllerMessage <DishEditDTO>(success, message, data));
}
/// <summary>
/// Get DishEditDTO to create new dish
/// </summary>
/// <returns></returns>
public async Task <DishEditDTO> GetCreateDishEditDTOAsync()
{
DishEditDTO dishEditDTO = new DishEditDTO()
{
DishGroups = (await _dishGroupRepository.GetAllAsync())
.Select(x => new ListItemDTO()
{
Text = x.Name,
Value = x.Id.ToString()
}).ToList()
};
return(dishEditDTO);
}
public async Task <bool> EditDishImageAsync(DishEditDTO dishEditDTO)
{
Dish dishToUpdateImage = await _dishRepository.GetAsync(dishEditDTO.Id);
if (dishToUpdateImage != null)
{
dishToUpdateImage.ImageURL = dishEditDTO.ImageURL;
_dishRepository.Update(dishToUpdateImage);
return(await _unitOfWork.SaveChangesAsync() > 0);
}
return(false);
}
private void Edit(DishEditDTO dishEditDTO, IIngredientSubject subject)
{
IngredientListViewModel ingredientListViewModel = new IngredientListViewModel(factory, subject);
RecipeAddViewModel recipeAddViewModel = new RecipeAddViewModel(factory, this, ingredientListViewModel);
recipeAddViewModel.MustSelectDish = false;
DishEditViewModel viewModel = new DishEditViewModel(dishEditDTO, recipeAddViewModel);
DishEditView view = new DishEditView(viewModel);
Window window = WindowFactory.CreateByContentsSize(view);
window.MinWidth = view.MinWidth;
viewModel.DishSaveRequest += (s, e) =>
{
using (IDishController controller = factory.CreateDishController())
{
ControllerMessage controllerMessage = controller.Update(e.Data);
if (controllerMessage.IsSuccess)
{
Notify();
}
else
{
MessageBox.Show(controllerMessage.Message);
}
}
};
viewModel.DishSaveRecipesRequest += (s, e) =>
{
using (IDishController controller = factory.CreateDishController())
{
ControllerMessage controllerMessage = controller.UpdateRecipes(e.Data);
if (controllerMessage.IsSuccess)
{
Notify();
}
else
{
MessageBox.Show(controllerMessage.Message);
}
}
};
window.Show();
}
public async Task <bool> CreateNewDishAsync(DishEditDTO dishEditDTO)
{
Dish dishToCreate = new Dish()
{
Name = dishEditDTO.Name,
Description = dishEditDTO.Description,
Weight = dishEditDTO.Weight,
Price = dishEditDTO.Price,
DishGroupId = dishEditDTO.DishGroupId,
ImageURL = dishEditDTO.ImageURL
};
_dishRepository.Add(dishToCreate);
if (await _unitOfWork.SaveChangesAsync() > 0)
{
dishEditDTO.Id = dishToCreate.Id;
return(true);
}
return(false);
}
public DishEditViewModel(DishEditDTO dish, RecipeAddViewModel viewModel)
{
this.dish = dish;
this.RecipeAddViewModel = viewModel;
this.RemoveRecipeCommand = new DelegateCommand(
() => Recipes.Remove(Recipe),
obj => Recipe != null
);
this.SaveRecipesCommand = new DelegateCommand(
() => Save(dish),
obj => CanSave()
);
this.SaveCommand = new DelegateCommand(
() => RaiseDishSaveRequestEvent(dish),
obj => CanSave()
);
this.DeleteCommand = new DelegateCommand(() => RaiseDishDeleteRequestEvent(dish));
this.Recipes = new ObservableCollection <DishRecipeEditDTO>(dish.Recipes);
viewModel.RecipeAdded += (s, e) =>
{
var addedRecipe = e.Data;
if (!Recipes.Select(recipe => recipe.Name).Contains(addedRecipe.Name))
{
DishRecipeEditDTO recipe = new DishRecipeEditDTO
{
Name = addedRecipe.Name,
Description = addedRecipe.Description
};
recipe.Ingredients.AddRange(addedRecipe.Ingredients);
Recipes.Add(recipe);
}
};
}
private bool Validate(DishEditDTO dishEditDTO, ref string message)
{
bool isValid = true;
string oldName = dishEditDTO.OldName;
string newName = dishEditDTO.NewName;
string categoryName = dishEditDTO.CategoryName;
decimal price = dishEditDTO.Price;
if (String.IsNullOrEmpty(newName))
{
isValid = false;
message = "Dish's name cannot be empty";
}
if (newName.Length > 40)
{
isValid = false;
message = "Dish's name cannot be more then 40 symbols";
}
else if (String.IsNullOrEmpty(categoryName))
{
isValid = false;
message = "Dish's category's name cannot be empty";
}
else if (price < 0)
{
isValid = false;
message = "Dish's price cannot be less then 0";
}
else if (oldName != newName && unitOfWork.Dishes.GetAll().Any(dish => dish.Name == newName))
{
isValid = false;
message = "Dish with such name already exists";
}
return(isValid);
}
private void Save(DishEditDTO dish)
{
dish.Recipes.Clear();
dish.Recipes.AddRange(Recipes);
RaiseDishSaveRecipesRequestEvent(dish);
}
