private void Cb_Update_Ingridients_Selected(object sender, RoutedEventArgs e)
{
HideAllGridsButSelected(Grid_Update_Selected_Ingridient, Grid_Update_Existing_Ingridient);
string selectedComboboxValue = ((sender as ComboBox).SelectedItem as ComboBoxItem).Content as string;
Ingridient selectedIngridient = Ingridients.Where(i => i.Name == selectedComboboxValue).FirstOrDefault();
string imagePath = System.IO.Path.GetFullPath(selectedIngridient.ImagePath);
Image_Selected_Ingridient.Source = new BitmapImage(new Uri(imagePath));
switch (selectedIngridient.MeasurmentUnit)
{
case MeasurmentUnit.HundredGrams:
Lbl_Update_Selected_Ingridient_Price.Content = MeasurmentUnitHeb.HundredGrams;
break;
case MeasurmentUnit.Kilo:
Lbl_Update_Selected_Ingridient_Price.Content = MeasurmentUnitHeb.Kilo;
break;
case MeasurmentUnit.Liter:
Lbl_Update_Selected_Ingridient_Price.Content = MeasurmentUnitHeb.Liter;
break;
case MeasurmentUnit.Milliliter:
Lbl_Update_Selected_Ingridient_Price.Content = MeasurmentUnitHeb.Milliliter;
break;
case MeasurmentUnit.Unit:
Lbl_Update_Selected_Ingridient_Price.Content = MeasurmentUnitHeb.Unit;
break;
}
Tb_Update_Selected_Ingridient_Price.Text = selectedIngridient.Price.ToString();
}
public ActionResult AddOrEditIngridient(IngridientViewModel ingridientViewModel)
{
ingridientViewModel.Uniqueness = _ingridientProvider.IsUnique(ingridientViewModel.Name);
if (ingridientViewModel.Uniqueness == UniqueValidation.Dublicate)
{
ModelState.AddModelError("Name", "This ingridient is already exists");
}
if (ingridientViewModel.Uniqueness == UniqueValidation.Error)
{
ModelState.AddModelError("Name", "Name is required");
}
if (ModelState.IsValid)
{
if (ingridientViewModel.IngridientId == 0)
{
Ingridient ingridient = ParseIngridient(ingridientViewModel);
_ingridientProvider.InsertInrgridient(ingridient);
}
else
{
Ingridient ingridient = ParseIngridient(ingridientViewModel);
_ingridientProvider.UpdateIngridient(ingridient);
}
return(RedirectToAction("ShowIngridients"));
}
else
{
return(View("AddOrEditIngridient", ingridientViewModel));
}
}
private void SetDynamicallyCreatedTextboxValue(object sender, SelectionChangedEventArgs e)
{
ComboBox senderCb = (ComboBox)sender;
int cbNum = int.Parse(senderCb.Name.Split('_')[4]);
ComboBoxItem selectedFirstItem = (ComboBoxItem)senderCb.SelectedItem;
string ingridientValue = (string)selectedFirstItem.Content;
Ingridient ingridient = Ingridients.FirstOrDefault(i => i.Name == ingridientValue);
Label lbl = new Label();
foreach (var grid in Grid_New_Recipe_Ingridients.Children)
{
if ((grid as Grid).Name.Contains(cbNum.ToString()))
{
foreach (var child in (grid as Grid).Children)
{
if (child.GetType() == typeof(Label))
{
if ((child as Label).Name.Contains(cbNum.ToString()))
{
lbl = child as Label;
break;
}
}
}
}
}
lbl.Content = "מתוך " + MeasurmentUnitHeb.GetUnitHebrewValue(ingridient.MeasurmentUnit);
}
private void Btn_Add_New_Ingridient_Click(object sender, RoutedEventArgs e)
{
HideAllGridsButSelected(Grid_New_Ingridient);
Ingridient newIngridient = new Ingridient()
{
Name = this.Tb_New_Ingridient_Name.Text,
ImagePath = SelectedIngridientImagePath,
MeasurmentUnit = (MeasurmentUnit)Select_New_Ingridient_M_Unit.SelectedIndex,
Price = decimal.Parse(Tb_New_Ingridient_Price.Text),
UpsertDate = DateTime.Now
};
Ingridients = Functions.GetIngridientsList();
if (Ingridients.Where(i => i.Name == newIngridient.Name).Any())
{
MessageBox.Show("כבר קיים מוצר בשם " + newIngridient.Name + ". יש לבחור שם אחר או לערוך את חומר הגלם הקיים",
"תקלה - מוצר קיים",
MessageBoxButton.OK,
MessageBoxImage.Error,
MessageBoxResult.OK,
MessageBoxOptions.RightAlign);
return;
}
Functions.CreateUpdateIngridientsXml <Ingridient>(typeof(Ingridient), newIngridient);
Img_New_Product.Source = null;
Tb_New_Ingridient_Name.Text = string.Empty;
Tb_New_Ingridient_Price.Text = string.Empty;
Select_New_Ingridient_M_Unit.SelectedIndex = 0;
}
public async Task <Ingridient> CreateIngridient(Ingridient ingridient)
{
_applicationContext.Ingridients.Add(ingridient);
await _applicationContext.SaveChangesAsync();
return(ingridient);
}
public void UpdateIngridient(Ingridient ingridient)
{
if (ingridient != null)
{
_ingridientrepository.UpdateIngridient(ingridient);
}
}
public async Task <IActionResult> PutIngridient(int id, Ingridient ingridient)
{
if (id != ingridient.Id)
{
return(BadRequest());
}
_context.Entry(ingridient).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IngridientExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Ingridient> > PostIngridient(Ingridient ingridient)
{
_context.Ingridients.Add(ingridient);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetIngridient", new { id = ingridient.Id }, ingridient));
}
public void InsertInrgridient(Ingridient ingridient)
{
if (ingridient != null)
{
_ingridientrepository.InsertInrgridient(ingridient);
}
}
public Ingridient SearchIngridient(int id)
{
Ingridient ingridient =
_ingridientsDb.Ingridients.FirstOrDefault(i => i.IngridientId == id);
return(ingridient);
}
private List <Ingridient> ExecuteIngridientSqlCmd(SqlConnection sqlConnection, SqlCommand cmd)
{
List <Ingridient> returnedList = new List <Ingridient>();
try
{
sqlConnection.Open();
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Ingridient ingridient = new Ingridient();
ingridient.IngridientId = reader.GetFieldValue <int>(0);
ingridient.Name = reader.GetFieldValue <string>(1);
returnedList.Add(ingridient);
}
};
}
catch (Exception ex)
{
_logger.ErrorMessage(ex);
}
finally
{
sqlConnection.Close();
}
return(returnedList);
}
private EditRecipeIngridientViewModel ParseRecipeIngridient(RecipeIngridient recipeIngridient, int recipeId)
{
EditRecipeIngridientViewModel editRecipeIngridientViewModel = new EditRecipeIngridientViewModel();
List <Ingridient> ingridients = _ingridientProvider.GetIngridients();
List <RecipeIngridientView> recipeIngridients = _recipeProvider.GetRecipeIngridientsByRecipeId(recipeId);
editRecipeIngridientViewModel.RecipeId = recipeId;
if (recipeIngridients != null)
{
foreach (RecipeIngridientView item in recipeIngridients)
{
Ingridient ingridient = ingridients.FirstOrDefault(i => i.IngridientId == item.IngridientId);
if (ingridient != null)
{
ingridients.Remove(ingridient);
}
}
}
if (recipeIngridient != null)
{
editRecipeIngridientViewModel.IngridientId = recipeIngridient.IngridientId;
editRecipeIngridientViewModel.Weight = recipeIngridient.Weight;
editRecipeIngridientViewModel.Ingridients = new SelectList(ingridients, "IngridientId", "Name", recipeIngridient.IngridientId);
}
else
{
editRecipeIngridientViewModel.Ingridients = new SelectList(ingridients, "IngridientId", "Name");
}
return(editRecipeIngridientViewModel);
}
public Soup(string name, float spicyValue, float chunkyValue, Ingridient restrictedIngredient)
{
soupName = name;
this.spicyValue = spicyValue;
this.chunkyValue = chunkyValue;
this.restrictedIngredient = restrictedIngredient;
}
public IngridientModel(Ingridient entity)
{
ID = entity.ID;
Quantity = entity.Quantity;
Price = entity.Price;
ProductID = entity.ProductID;
Product = new ProductModel(entity.Product);
}
public ActionResult DeleteConfirmed(int id)
{
Ingridient ingridient = db.Ingridients.Find(id);
db.Ingridients.Remove(ingridient);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private void Cb_New_Recipe_Ing_1_Selected(object sender, RoutedEventArgs e)
{
ComboBox senderCb = (ComboBox)sender;
ComboBoxItem selectedFirstItem = (ComboBoxItem)senderCb.SelectedItem;
string ingridientValue = (string)selectedFirstItem.Content;
Ingridient ingridient = Ingridients.FirstOrDefault(i => i.Name == ingridientValue);
Lbl_New_Recipe_Ingridient_1_Amount_Name.Content = "מתוך " + MeasurmentUnitHeb.GetUnitHebrewValue(ingridient.MeasurmentUnit);
}
public IActionResult Post([FromBody] Ingridient newIngridient)
{
using (BurgerContext context = new BurgerContext())
{
context.Ingridients.Add(newIngridient);
context.SaveChanges();
}
return(Created("/ingridient", newIngridient));
}
public ActionResult Edit([Bind(Include = "Id,Name")] Ingridient ingridient)
{
if (ModelState.IsValid)
{
db.Entry(ingridient).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(ingridient));
}
public ActionResult Create([Bind(Include = "Id,Name")] Ingridient ingridient)
{
if (ModelState.IsValid)
{
db.Ingridients.Add(ingridient);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(ingridient));
}
private Ingridient ParseIngridient(IngridientViewModel ingridientViewModel)
{
Ingridient ingridient = new Ingridient();
if (ingridientViewModel != null)
{
ingridient.IngridientId = ingridientViewModel.IngridientId;
ingridient.Name = ingridientViewModel.Name;
}
return(ingridient);
}
public void GetIngridientById_ValidId_NotNull()
{
Mock <IIngridientRepository> mock = new Mock <IIngridientRepository>();
mock.Setup(i => i.GetIngridientById(It.IsAny <int>())).Returns(new Ingridient());
IngridientProvider ingridientProvider = new IngridientProvider(mock.Object);
Ingridient ingridient = ingridientProvider.GetIngridientById(1);
Assert.IsNotNull(ingridient);
}
/// <summary>
/// CreateSoup() grabs a child gameObject from the AllSoups gameObject in the scene. It then uses data stored in the gameObjects SoupCreator script to make a Soup instance.
/// </summary>
/// <param name="soupFromScene"></param>
Soup CreateSoup(Transform soupFromScene)
{
SoupCreator soupsData = soupFromScene.GetComponent <SoupCreator>();
Ingridient restrictedIngredient = ConvertTextToIngredient(soupsData.restrictedIngredient);
float spicyValue = soupsData.spicyValue;
float chunkyValue = soupsData.chunkyValue;
Soup newSoup = new Soup(soupsData.soupName, spicyValue, chunkyValue, restrictedIngredient);
return(newSoup);
}
public ActionResult DeleteIngridient(int id)
{
Ingridient cat = _db.Ingridients.Find(id);
_db.Ingridients.Remove(cat);
_db.SaveChanges();
ViewBag.Ingridients = _db.Ingridients.Include(x => x.Category);
ViewBag.Categories = new SelectList(_db.Categories, "Id", "Name");
return(RedirectToAction("Ingridients"));
}
public void CreateIngridient_ShouldThrow_EntityException(Ingridient ingridient, string expectedMessage)
{
//Arrange
var(ingridientRepository, dataBase) = GetMocks();
var ingridientService = new IngridientService(ingridientRepository.Object);
//Act
var exception = Assert.ThrowsAsync <EntityException>(() => ingridientService.CreateIngridient(ingridient));
//Assert
Assert.AreEqual(expectedMessage, exception.Message);
}
private Ingridient AddIngridient(string name, long count)
{
//if (AllIngridients.Any(x => x.Name == name))
//{
// return AllIngridients.Where(x => x.Name == name).FirstOrDefault();
//}
var res = new Ingridient(name, count);
//AllIngridients.Add(res);
return(res);
}
private IngridientViewModel ParseIngridient(Ingridient ingridient)
{
IngridientViewModel ingridientViewModel = new IngridientViewModel();
if (ingridient != null)
{
ingridientViewModel.IngridientId = ingridient.IngridientId;
ingridientViewModel.Name = ingridient.Name;
ingridientViewModel.Uniqueness = UniqueValidation.Unique;
}
return(ingridientViewModel);
}
public async Task <Ingridient> CreateIngridient(Ingridient ingridient)
{
if (ingridient.Kcal < 0)
{
throw new EntityException("Field 'kcal' of ingridient can't be less than 0");
}
if (string.IsNullOrEmpty(ingridient.Name))
{
throw new EntityException("Field 'name' of ingridient can't be null or empty");
}
return(await _ingridientRepository.CreateIngridient(ingridient));
}
public Ingridient ToEntity()
{
var entity = new Ingridient
{
ID = ID,
Quantity = Quantity,
Price = Price,
ProductID = ProductID,
Product = Product?.ToEntity()
};
return(entity);
}
/// <summary>
/// Remove an existing Ingridient from the collection
/// </summary>
/// <pdGenerated>Default Remove</pdGenerated>
public void RemoveAlergens(Ingridient oldIngridient)
{
if (oldIngridient == null)
{
return;
}
if (this.alergens != null)
{
if (this.alergens.Contains(oldIngridient))
{
this.alergens.Remove(oldIngridient);
}
}
}
public ActionResult AddOrEditIngridient(int ingridientId)
{
Ingridient ingridient = _ingridientProvider.GetIngridientById(ingridientId);
IngridientViewModel model = ParseIngridient(ingridient);
if (Request.IsAjaxRequest())
{
return(PartialView("_AddOrEditIngridient", model));
}
else
{
return(View(model));
}
}
