public async Task <IActionResult> Edit(Guid id, IngredientDTO ingredientDTO)
{
if (id != ingredientDTO.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var ingredient = await _service.UpdateAsync(id, ingredientDTO);
}
catch (Exception)
{
return(Error());
}
return(RedirectToAction(nameof(Index)));
}
return(View(ingredientDTO));
}
private async Task NewIngredient()
{
ConsoleHelper.ColorWrite("What ingredient would you like to add: ");
var name = Console.ReadLine();
IngredientDTO newIngreditent = new IngredientDTO {
Name = name
};
try
{
await _ingredientService.AddIngredient(newIngreditent);
}
catch (KeyNotFoundException)
{
ConsoleHelper.ColorWriteLine(ConsoleColor.DarkYellow, $"{name} already exists.");
}
Console.WriteLine();
await this.Show();
}
public async Task <IActionResult> Create(IngredientViewModel ingredientToCreate)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, "Invalid bar parameters!");
return(View(ingredientToCreate));
}
try
{
var ingredient = new IngredientDTO
{
Name = ingredientToCreate.Name
};
await _ingredientManager.AddIngredientAsync(ingredient);
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
return(RedirectToAction("ErrorAction", "Error", new { errorCode = "500", errorMessage = ex.Message }));
}
}
public async Task CreateIngredient_WhenParamsAreValid()
{
//Arrange
var mockDatetimeProvider = new Mock <IDateTimeProvider>();
var mockMapper = new Mock <IIngredientMapper>();
mockMapper.Setup(i => i.MapToIngredient(It.IsAny <IngredientDTO>()))
.Returns <IngredientDTO>(i => new Ingredient
{
Name = i.Name,
ImageData = i.ImageData,
ImageSource = i.ImageSource
});
var mockCocktailMapper = new Mock <ICocktailMapper>();
var options = Utils.GetOptions(nameof(CreateIngredient_WhenParamsAreValid));
var ingredientDTO = new IngredientDTO
{
Name = "Black Pepper",
ImageData = new byte[] { },
ImageSource = "~/Testimage/pqt-ozer-premium.jpg"
};
string imageBase64Data = Convert.ToBase64String(ingredientDTO.ImageData);
ingredientDTO.ImageSource = string.Format("data:image/jpg;base64,{0}", imageBase64Data);
Utils.GetInMemoryDataBase(options);
//Act & Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new IngredientService(mockDatetimeProvider.Object, mockMapper.Object,
mockCocktailMapper.Object, assertContext);
var result = await sut.CreateIngredientAsync(ingredientDTO);
Assert.IsInstanceOfType(result, typeof(IngredientDTO));
}
}
/// <summary>
/// </summary>
/// <param name="ingredientAddDTO"></param>
/// <param name="recipeName"></param>
/// <returns>Name of the recipe</returns>
/// <exception cref="KeyNotFoundException"></exception>
public async Task <string> AddIngredientToRecipe(IngredientDTO ingredientAddDTO, string recipeName)
{
var recipe = await GetRecipeByNameIfExists(recipeName);
var ingredient = await _context.Ingredients
.SingleOrDefaultAsync(x => x.Name.ToLower() == ingredientAddDTO.Name.ToLower().Trim());
if (ingredient == null)
{
recipe.Ingredients.Add(_mapper.Map <Ingredient>(ingredientAddDTO));
}
else
{
recipe.Ingredients.Add(ingredient);
}
await Save();
_logger.LogInformation($"Added ingredient {ingredientAddDTO.Name} to recipe {recipeName}");
return(recipeName);
}
public async Task ReturnNull_WhenIdNotFound()
{
//Arrange
var mockDateTiemProvider = new Mock <IDateTimeProvider>();
var mockMapper = new Mock <IngredientMapper>();
var mockCocktailMapper = new Mock <CocktailMapper>();
var options = Utils.GetOptions(nameof(ReturnNull_WhenIdNotFound));
var newDTO = new IngredientDTO();
Utils.GetInMemoryDataBase(options);
//Act & Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new IngredientService(mockDateTiemProvider.Object, mockMapper.Object,
mockCocktailMapper.Object, assertContext);
var result = await sut.UpdateIngredientAsync(6, newDTO);
Assert.IsNull(result);
}
}
public IngredientViewModel MapToVMFromDTO(IngredientDTO ingredientDTO)
{
if (ingredientDTO == null)
{
return(null);
}
var ingredientVM = new IngredientViewModel
{
Id = ingredientDTO.Id,
Name = ingredientDTO.Name,
Cocktails = ingredientDTO.CocktailDTOs.Select(c => new CocktailViewModel
{
Id = c.Id,
Name = c.Name,
AverageRating = c.AverageRating
}).ToList(),
ImageData = ingredientDTO.ImageData,
ImageSource = ingredientDTO.ImageSource,
};
return(ingredientVM);
}
public async Task GetIngredientReturnsCorrectValue()
{
var options = TestUtilities.GetOptions(nameof(GetIngredientReturnsCorrectValue));
var mapToDTOMock = new Mock <IDTOServiceMapper <Ingredient, IngredientDTO> >();
var mapToEntityMock = new Mock <IDTOServiceMapper <IngredientDTO, Ingredient> >();
var ingredientDTOMock = new Mock <IngredientDTO>();
var ingredient = new Ingredient()
{
Name = "Chubaka",
Id = "1",
};
var ingredientDTO = new IngredientDTO()
{
Name = "Chubaka",
Id = "1",
};
mapToDTOMock.Setup(m => m.MapFrom(It.IsAny <Ingredient>())).Returns(ingredientDTO);
using (var actContext = new IriOnCocktailServiceDbContext(options))
{
await actContext.Ingredients.AddAsync(ingredient);
await actContext.SaveChangesAsync();
}
using (var assertContext = new IriOnCocktailServiceDbContext(options))
{
var sut = new IngredientService(assertContext, mapToDTOMock.Object, mapToEntityMock.Object);
var dto = await sut.GetIngredientDTO("1");
Assert.AreEqual("1", dto.Id);
Assert.AreEqual("Chubaka", dto.Name);
}
}
public IActionResult UpdateIngredient(int id, [FromBody] PostIngredientDTO ingredientDTO)
{
_requestLogService.SaveRequest(User.Identity.GetUserId(), "PUT", "api/v1/ingredients", "UpdateIngredient");
if (!ModelState.IsValid)
{
return(BadRequest("Invalid fields provided, please double check the parameters"));
}
var ingredient = _ingredientService.GetIngredientById(id);
if (ingredient == null)
{
return(NotFound());
}
if (ingredient.UserId != User.Identity.GetUserId())
{
return(StatusCode(403, "Ingredients can be amended only by admins or users that created them. Please provide id of ingredient that is created by user."));
}
IngredientDTO updatedIngredient = _ingredientService.UpdateIngredient(id, ingredientDTO);
return(Ok(updatedIngredient));
}
public bool Remove(IngredientDTO ingredient)
{
DBConnection conn = new();
if (conn.Open())
{
string cmd =
"DELETE " +
"ingredientdishrelation.* " +
"FROM " +
"ingredientdishrelation " +
"JOIN " +
"ingredient " +
"ON " +
"ingredient.id = ingredientdishrelation.ingredientID " +
"WHERE " +
$"ingredient.name = '{ingredient.Name}'";
conn.RunCommand(cmd);
conn.Close();
return(true);
}
return(false);
}
public async Task UpdateAsyncIngredient_MineralWater()
{
//Arrange
var ingredient = new IngredientDTO()
{
Id = SeedingData.IngredientMineralWaterEntity.Id,
Name = SeedingData.IngredientMineralWaterEntity.Name + Guid.NewGuid(),
Description = SeedingData.IngredientMineralWaterEntity.Description + Guid.NewGuid(),
};
//Act
await _ingredientRepositorySUT.InsertOrUpdateAsync(ingredient);
//Assert
using (var dbx = _dbContextFactory.CreateDbContext())
{
var retrievedIngredient = dbx.Ingredients.Single(i => i.Id == ingredient.Id);
Assert.Equal(ingredient.Id, retrievedIngredient.Id);
Assert.Equal(ingredient.Name, retrievedIngredient.Name);
Assert.Equal(ingredient.Description, retrievedIngredient.Description);
}
}
public IngredientDTO MapToIngredientDTO(Ingredient ingredient)
{
if (ingredient == null)
{
return(null);
}
var ingredientDTO = new IngredientDTO
{
Id = ingredient.Id,
Name = ingredient.Name,
CocktailDTOs = ingredient.IngredientsCocktails.Select(c => new CocktailDTO
{
Name = c.Cocktail.Name,
Id = c.Cocktail.Id
}).ToList(),
ImageData = ingredient.ImageData,
ImageSource = ingredient.ImageSource
//IsDeleted = ingredient.IsDeleted
};
return(ingredientDTO);
}
public async Task <IActionResult> EditIngredient(CreateEditIngredientModel model)
{
if (ModelState.IsValid)
{
IngredientDTO ingredient = new IngredientDTO
{
Id = model.Id,
Name = model.Name,
Price = model.Price
};
var result = await _adminManager.UpdateIngredient(ingredient);
if (result.Succedeed)
{
return(RedirectToAction("Ingredients"));
}
else
{
ModelState.AddModelError(result.Property, result.Message);
}
}
return(View(model));
}
public void Return_CocktailIngredientVM()
{
var cocktailDTO = new CocktailDTO()
{
Id = Guid.Parse("9ef97551-87f6-40ce-a88b-6c0e876ccb51"),
Name = "Margarita",
Description = "The Margarita is one of the most " +
"popular cocktails in North America—for good reason. " +
"Combining the tang of lime and the sweetness of o" +
"range liqueur with the distinctive strength of " +
"tequila, our classic Margarita strikes all of the right keys."
};
var ingredientDTO = new IngredientDTO
{
Id = Guid.Parse("1b98e50e-8314-4b1e-82df-491c3c8d086f"),
Name = "Gin",
Abv = 40,
Description = "Gin is a distilled alcoholic drink that derives its " +
"predominant flavour from juniper berries (Juniperus communis). " +
"Gin is one of the broadest categories of spirits, all of various origins, styles," +
" and flavour profiles, that revolve around juniper as a common ingredient.",
TypeId = Guid.Parse("27309394-4ac3-4dc6-a81a-c8e147e378f0"),
};
var ciDTO = new CocktailIngredientsDTO
{
CocktailId = cocktailDTO.Id,
IngredientId = ingredientDTO.Id,
CocktailName = cocktailDTO.Name,
IngredientName = ingredientDTO.Name,
};
var result = ciDTO.CocktailIngredientDTOMapToVM();
Assert.IsInstanceOfType(result, typeof(CocktailIngredientsViewModel));
}
public async Task <IActionResult> Create([Bind("Id,Name,Abv,Description,UnlistedOn,TypeId")] IngredientViewModel ingredient)
{
if (ModelState.IsValid)
{
ingredient.Id = Guid.NewGuid();
var ingredientDTO = new IngredientDTO
{
Id = ingredient.Id,
Name = ingredient.Name,
Description = ingredient.Description,
Abv = ingredient.Abv,
TypeId = ingredient.TypeId
};
var newIngredient = await ingredientService.CreateIngredient(ingredientDTO);
return(RedirectToAction(nameof(Index)));
}
ViewData["TypeId"] = new SelectList(_context.IngredientTypes, "Id", "Name", ingredient.TypeId);
return(View(ingredient));
}
/// <summary>
/// If id exist and the ingredient is not deleted, update the ingredient with current info from ingredientDTO
/// </summary>
/// <param name="id">The id of the ingredient to be updated</param>
/// <param name="ingredientDTO"></param>
/// <returns></returns>
public async Task <IngredientDTO> UpdateIngredientAsync(int id, IngredientDTO ingredientDTO)
{
var ingredient = await this.context.Ingredients
.FirstOrDefaultAsync(ingredient => ingredient.Id == id& ingredient.IsDeleted == false);
if (ingredient == null)
{
return(null);
}
ingredient.Name = ingredientDTO.Name;
if (ingredientDTO.ImageData != null)
{
ingredient.ImageData = ingredientDTO.ImageData;
string imageBase64Data = Convert.ToBase64String(ingredient.ImageData);
ingredient.ImageSource = string.Format("data:image/jpg;base64,{0}", imageBase64Data);
}
this.context.Ingredients.Update(ingredient);
await this.context.SaveChangesAsync();
return(ingredientDTO);
}
/// <summary>
/// Method to add an ingredient to the database
/// </summary>
/// <param name="ingredient">The name of the ingredient</param>
/// <returns></returns>
public async Task AddIngredient(TextBox ingredient)
{
var isValid = ValidationObject.ValidateIngredientName(ingredient);
if (isValid)
{
var ingredientToAdd = new IngredientDTO()
{
Name = ingredient.Text
};
var added = await BusinessObject.AddIngredientAsync(ingredientToAdd);
if (added)
{
ShowMessage($"Ingredient {ingredientToAdd.Name} Added");
}
else
{
ShowMessage($"Ingredient {ingredientToAdd.Name} Not Added");
}
}
}
public IngredientDTO Create(Ingredient ingredient)
{
return(IngredientDTO.CreateFromDomain(ingredient));
}
public void ReturnCorrectIngredients_when_AllValid()
{
//Arrange
var options = Utils.GetOptions("ReturnCorrectIngredients_when_AllValid");;
var entity1 = new Ingredient
{
Name = "Lime",
IsAlcoholic = false
};
var entity2 = new Ingredient
{
Name = "Coca Cola",
IsAlcoholic = false
};
var entity3 = new Ingredient
{
Name = "Bacardi Oro",
IsAlcoholic = true
};
var entity1DTO = new IngredientDTO
{
Name = "Lime",
IsAlcoholic = false
};
var entity2DTO = new IngredientDTO
{
Name = "Coca Cola",
IsAlcoholic = false
};
var entity3DTO = new IngredientDTO
{
Name = "Bacardi Oro",
IsAlcoholic = true
};
var mockMapper = new Mock <IIngredientMapper>();
mockMapper
.Setup((x) => x.MapEntityToDTO(It.Is <Ingredient>(a => a.Name == entity1.Name)))
.Returns(entity1DTO);
mockMapper
.Setup((x) => x.MapEntityToDTO(It.Is <Ingredient>(a => a.Name == entity2.Name)))
.Returns(entity2DTO);
mockMapper
.Setup((x) => x.MapEntityToDTO(It.Is <Ingredient>(a => a.Name == entity3.Name)))
.Returns(entity3DTO);
using (var arrangeContext = new BCcontext(options))
{
arrangeContext.Ingredients.Add(entity1);
arrangeContext.Ingredients.Add(entity2);
arrangeContext.Ingredients.Add(entity3);
arrangeContext.SaveChanges();
}
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new IngredientsService(context, mockMapper.Object);
var result = sut.GetAllAsync().Result.ToList();
Assert.AreEqual(3, result.Count());
Assert.AreEqual(entity3.Name, result[2].Name);
Assert.AreEqual(entity3.IsAlcoholic, result[2].IsAlcoholic);
}
}
public RedirectResult Edit(IngredientDTO ingredient)
{
_ingredientService.EditIngredient(ingredient.Id, ingredient);
return(Redirect("/Ingredient/GetAll"));
}
public RedirectResult Add(IngredientDTO ingredient)
{
_ingredientService.Create(ingredient);
return(Redirect("/Ingredient/GetAll"));
}
public Ingredient FindByName(string name)
{
IngredientDTO dto = ingredientContainerDAL.FindByName(name);
return(ConvertFromDTO(dto));
}
public OperationDetails CreateIngredient(IngredientDTO ingredient)
{
return(_ingredientService.Create(ingredient));
}
private async Task NewRecipe()
{
ConsoleHelper.ColorWrite("What recipe would you like to add: ");
var name = Console.ReadLine();
RecipeDTO recipe = new RecipeDTO {
Name = name
};
bool another = true;
List <IngredientDTO> ingredients = new List <IngredientDTO>();
while (another)
{
ConsoleHelper.ColorWrite("What ingredient would you like to add: ");
var input = Console.ReadLine();
try
{
var ingredient = await _ingredientService.GetIngredientDTOByNameAsync(input);
var ingredientToAdd = new IngredientDTO {
Name = ingredient.Name
};
ingredients.Add(ingredientToAdd);
}
catch (KeyNotFoundException)
{
ConsoleHelper.ColorWriteLine(ConsoleColor.DarkYellow, "The ingredient does not exist!");
ConsoleHelper.ColorWrite("Would you like to add it? (Y/n): ");
var add = Console.ReadLine();
if (Char.ToUpperInvariant(add[0]) == 'N')
{
ConsoleHelper.ColorWriteLine(ConsoleColor.Red, "Recipe not added.");
Console.WriteLine();
return;
}
ingredients.Add(new IngredientDTO {
Name = input
});
}
ConsoleHelper.ColorWrite("Would you like to add another ingredient? (y/N): ");
var addAnother = Console.ReadLine();
if (Char.ToUpperInvariant(addAnother[0]) != 'Y')
{
another = false;
}
}
try
{
await _recipeService.AddRecipe(recipe);
ConsoleHelper.ColorWriteLine(ConsoleColor.Green, $"'{recipe.Name}' has been added.");
}
catch (KeyNotFoundException)
{
ConsoleHelper.ColorWriteLine(ConsoleColor.DarkYellow, $"{name} already exists.");
}
foreach (var ingredient in ingredients)
{
try
{
await _recipeService.AddIngredientToRecipe(ingredient, recipe.Name);
}
catch (KeyNotFoundException)
{
ConsoleHelper.ColorWriteLine($"'{recipe.Name}' does not exist.");
}
}
Console.WriteLine();
await this.Show();
}
public void Create(IngredientDTO item)
{
_data.Ingredients.Create(Mapper.Map <Ingredient>(item));
_data.Save();
}
public async Task <OperationDetails> UpdateIngredient(IngredientDTO ingredient)
{
return(await _ingredientService.Update(ingredient));
}
public void AddIngredientToDish(int dishId, IngredientDTO newIngredient)
{
throw new NotImplementedException();
}
public async Task <RecipeDTO> GetByIdAsync(int id)
{
var getRecipe = await dbAccess.Recipes.GetByIdAsync(id);
//Check if recipe exists
if (getRecipe == null)
{
throw new ArgumentNullException("The recipe could not be found!");
}
//Convert user info to DTO
var user = await dbAccess.Users.GetByIdAsync(getRecipe.UserId);
UserDTO uResult = new UserDTO();
uResult.Id = user.Id;
uResult.Username = user.Username;
//Create list for ingredientlines
List <IngredientLineDTO> ilResults = new List <IngredientLineDTO>();
//Fetch ingredientlines in DB based on recipeId
var ingredientLines = (await dbAccess.IngredientLines.FindByCondition(nameof(IngredientLine.RecipeId), getRecipe.Id)).ToList();
//Loop over ingredientlines in DB, convert to DTO and add to new list of ingredientlines
foreach (var il in ingredientLines)
{
IngredientLineDTO ingredientLineDTO = new IngredientLineDTO();
var ingredient = await dbAccess.Ingredients.GetByIdAsync(il.IngredientId);
IngredientDTO ingredientDTO = new IngredientDTO();
ingredientDTO.Id = ingredient.Id;
ingredientDTO.Name = ingredient.Name;
ingredientLineDTO.Ingredient = ingredientDTO;
ingredientLineDTO.Amount = il.Amount;
ingredientLineDTO.MeasureUnit = il.MeasureUnit;
ingredientLineDTO.MeasureUnitInt = (int)il.MeasureUnit;
ilResults.Add(ingredientLineDTO);
}
//Create list for images
List <ImageDTO> imResults = new List <ImageDTO>();
//Fetch images in DB based on recipeId
var images = (await dbAccess.Images.FindByCondition(nameof(Image.RecipeId), getRecipe.Id)).ToList();
//Loop over images in DB, convert to DTO and add to new list of images
foreach (var im in images)
{
ImageDTO imageDTO = new ImageDTO();
imageDTO.Id = im.Id;
imageDTO.FileName = im.FileName;
imResults.Add(imageDTO);
}
//Convert recipe to DTO and return result
RecipeDTO result = new RecipeDTO();
result.User = uResult;
result.Id = getRecipe.Id;
result.Title = getRecipe.Title;
result.Slug = getRecipe.Slug;
result.Instruction = getRecipe.Instruction;
result.CreatedAt = getRecipe.CreatedAt;
result.IngredientLines = ilResults;
result.RowVer = getRecipe.RowVer;
result.Images = imResults;
return(result);
}
public void InitComponent(IngredientDTO model)
{
Name = model.Name;
UnitCount = model.UnitCount;
Unit = model.Unit;
}
public IngredientViewModel(IngredientDTO model = null)
{
Model = model ?? new IngredientDTO();
}
