public Guid IngredientId; // KPC Shopping Ingredient ID
#endregion Fields
#region Constructors
public PantryItem(Ingredients.IngredientUsage usage)
{
this.IngredientId = usage.Ingredient.Id;
// Need to convert IngredientUsage into proper Pantry form
if (usage.Amount != null)
{
var toUnit = Unit.GetDefaultUnitType(usage.Ingredient.ConversionType);
if (UnitConverter.CanConvert(usage.Form.FormUnitType, toUnit))
{
// Always take high amount for pantry items
this.Amount = UnitConverter.Convert(usage.Amount, toUnit).SizeHigh;
}
else
{
// Find conversion path
var amount = FormConversion.GetNativeAmountForUsage(usage.Ingredient, usage);
// Always take high amount for pantry items
this.Amount = UnitConverter.Convert(amount, toUnit).SizeHigh;
}
}
else
{
this.Amount = null;
}
}
public DemonBase makeDemon(Ingredients body, Ingredients limbs, Ingredients horns)
{
DemonBase newDemon = makeDemon (body.GetTier (), body.GetStat ().ToString (), limbs.GetTier (), limbs.GetStat ().ToString (), horns.GetTier (), horns.GetStat ().ToString ());
float baseStat = (body.GetTier () + limbs.GetTier () + horns.GetTier () + 3) / 6f;
float[] newStats = new float[5] { baseStat, baseStat, baseStat, baseStat, baseStat };
newStats [(int)body.GetStat ()] += body.GetTier () + 1;
newStats [(int)limbs.GetStat ()] += limbs.GetTier () + 1;
newStats [(int)horns.GetStat ()] += horns.GetTier () + 1;
newDemon.setStats (newStats, Mathf.FloorToInt ((body.GetTier () + limbs.GetTier () + horns.GetTier () + 3) / 3f));
if (ParticlePrefab)
newDemon.ParticleInstance = Instantiate (ParticlePrefab);
switch((int)body.GetStat()) {
case(0):
SoundManager.instance.playSound ("power");
break;
case(1):
SoundManager.instance.playSound ("clever");
break;
case(2):
SoundManager.instance.playSound ("deception");
break;
case(3):
SoundManager.instance.playSound ("seduction");
break;
case(4):
SoundManager.instance.playSound ("occult");
break;
}
return newDemon;
}
public static Ingredients Instance()
{
if (ingredients == null)
{
ingredients = new Ingredients();
}
return ingredients;
}
public ObservableCollection <IngredientPurchase> GetIngredientPurchase(DateTimeOffset startDate, DateTimeOffset endDate)
{
DateTimeOffset start = startDate.Date;
DateTimeOffset end = endDate.Date.AddDays(1);
string clause =
$" WHERE DateTicks >= {start.UtcTicks} AND DateTicks < {end.UtcTicks}";
var list = DBHelper.Populate <IngredientPurchase>(null, clause);
foreach (var item in list)
{
item.Ingredient = Ingredients.First(x => x.ID == item.IngredientID);
}
return(list);
}
/// Gets the remaining ingredients needed to complete this recipe given [items] ingredients.
/// Returns `null` if [items] contains invalid ingredients.
public List <ItemType> GetMissingIngredients(List <Item> items)
{
var missing = Ingredients.Clone().ToList();
if (items == null)
{
return(missing.ToList());
}
foreach (var itemType in items.Select(i => i.type))
{
missing.Remove(itemType);
}
return(missing.ToList());
}
private void DeleteIngredient(Ingredient ingredient)
{
try
{
if (_ingredientRepo.DeleteIngredientReturnSuccess(ingredient))
{
Ingredients.Remove(ingredient);
MessageHandler.InvokeSuccessMessage(Resources.Delete, Resources.InformationIngredientRemoved.Replace("{name}", ingredient.Name).Replace("{action}", Resources.Deleted));
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private async void RemoveIngredientAction(object args)
{
if (SelectedRemoveIngredient == null)
{
return;
}
Ingredients.Remove(Ingredients.Find(X => X.Name == SelectedRemoveIngredient.Name));
await Global.ArticleRepo.UpdateAsync(new Article()
{
ID = this.ID, BasePrice = this.BasePrice, Name = this.Name, IsActive = this.IsActive, Type = this.Type, Ingredients = this.Ingredients
});
Trace.WriteLine(SelectedRemoveIngredient.Name);
}
public void Add(Ingredient ingredient)
{
if (this.Capacity > this.Ingredients.Count)
{
if (this.CurrentAlcoholLevel + ingredient.Alcohol <= MaxAlcoholLevel)
{
if (this.Ingredients.Any(x => x.Name == ingredient.Name))
{
}
else
{
Ingredients.Add(ingredient);
}
}
}
}
//TODO: Should this be in Ingredients class
public void AddIngredient(int itemId, int quantity)
{
var existing = Ingredients.FirstOrDefault(i => i.ItemId == itemId);
if (existing == null)
{
existing = new ItemQuantity()
{
ItemId = itemId
};
Ingredients.Add(existing);
}
;
existing.Quantity += quantity;
}
public async void GetIngredientById_Should_Be_OK()
{
//Arrange
var expected = new Ingredients()
{
Id = 1,
Name = "Green Apple",
Price = 2.5m
};
//Act
var response = await _client.GetFromJsonAsync <Ingredients>("api/v1/ingredients/1");
//Assert
Assert.Equal(response, expected);
}
public async Task <bool> AddIngredientsAsync(Guid parentId, Ingredients ingredients)
{
var parent = _context.Recipes.Single(x => x.Id == parentId);
ingredients.RecipeParent = parent;
ingredients.IsUsed = false;
//if (ingredients.Quantity == 0)
// return false;
_context.Ingredients.Add(ingredients);
var saveResult = await _context.SaveChangesAsync();
return(saveResult == 1);
}
// GET: Ingredients/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ingredients ingredients = db.Ingredients.Find(id);
if (ingredients == null)
{
return(HttpNotFound());
}
ViewBag.FK_Production = new SelectList(db.Finished_Production, "ID_FinPr", "Name_FinPr", ingredients.FK_Production);
ViewBag.FK_Stock = new SelectList(db.Stock, "ID_Stock", "Name_of_Stock", ingredients.FK_Stock);
return(View(ingredients));
}
public IActionResult Put(int Ingredientid, [FromBody] Ingredients Ingredient)
{
try
{
Validation.IngredientShouldExist(Ingredientid);
Ingredient.Ingredientid = Ingredientid;
var Response = _context.Ingredients.Update(Ingredient).Entity;
_context.SaveChanges();
return(Handler.HandlePutResponse(Response));
}
catch (Exception ex)
{
return(Handler.HandleException(ex, Ingredientid, Ingredient));
}
}
public void Drop(Ingredients ingredientDropping)
{
if (!ingredientDropping.animController)
{
DropObjImg.sprite = ingredientDropping.sprite;
}
else
{
DropObjAnim.runtimeAnimatorController = ingredientDropping.animController;
DropObjAnim.SetBool("isHovering", true);
}
PotionSceneManager.instance.isDropping = true;
StartCoroutine(SmoothDrop(ingredientDropping));
}
public void DecreaseStock(Pizzas pizza)
{
List <PizzasIngredients> pizzaIngredients = _db.PizzasIngredients
.Include(p => p.Ingredient)
.Where(p => p.PizzaId == pizza.Id)
.ToList();
foreach (PizzasIngredients pizzaIngredient in pizzaIngredients)
{
IngredientRepository ingredientRepository = new IngredientRepository(_db);
Ingredients ingredient = (Ingredients)ingredientRepository.GetById(pizzaIngredient.IngredientId);
ingredient.Stock = ingredient.Stock - 1;
ingredientRepository.Update(ingredient, ingredient.Id);
ingredientRepository.SaveChanges();
}
}
public IResult Add(Ingredients entity)
{
//Aspect yazılmadan önce validationlar bu şekilde yazılır.
//var validator = new IngredientValidator();
//var validationResult = validator.Validate(entity);
//if (!validationResult.IsValid)
// return BadRequest(new ErrorResult(Messages.ModelNotValid));
var checkForAdd = CheckIfSameMaterialAddedSameFood(entity.MaterialId, entity.FoodId);
if (!checkForAdd.IsSuccess)
{
return(checkForAdd);
}
return(new SuccessResult(Messages.IngredientAdded));
}
public async Task <IActionResult> CreateIngredient([FromBody] Ingredients ingredient)
{
//Ajout de l'ingrédient avec la BLL server
Ingredients newIngredient = await _restaurantService.CreateIngredient(ingredient);
if (newIngredient != null)
{
//Créer une redirection vers GetIngredientById(NewIngredient.IngredientId)
return(CreatedAtAction(nameof(GetIngredientById), new { id = newIngredient.Id }, newIngredient));
}
else
{
//Retourner code 400 Bad Request
return(BadRequest());
}
}
public override void CreateIngredients()
{
Ingredients.Add(new Bread());
Ingredients.Add(new Turkey());
Ingredients.Add(new Turkey());
Ingredients.Add(new Turkey());
Ingredients.Add(new Lettuce());
Ingredients.Add(new Mustard());
Ingredients.Add(new Bread());
Ingredients.Add(new Turkey());
Ingredients.Add(new Turkey());
Ingredients.Add(new Turkey());
Ingredients.Add(new Lettuce());
Ingredients.Add(new Mustard());
Ingredients.Add(new Bread());
}
/// <summary>
/// Créer un ingrédient
/// </summary>
/// <param name="entity">Un Ingrédient</param>
/// <returns></returns>
public async Task <Ingredients> InsertAsync(Ingredients entity)
{
var stmt = @"insert into ingredients(Name, Price) output INSERTED.Id
values (@Name, @Price)";
try
{
int i = await _session.Connection.QuerySingleAsync <int>(stmt, entity, _session.Transaction);
return(await GetAsync(i));
}
catch (Exception)
{
throw new Exception("Error on create Ingredient request" + System.Reflection.MethodInfo.GetCurrentMethod().ToString());
}
}
public void TestAddingSameIngredientsToUniqueList()
{
Recipe recipe = new Recipe();
Ingredients ing1 = new Ingredients(new MVC_CookBook_PSSC.Models.CommonComponents.Text("txt"), new Quantity(new MVC_CookBook_PSSC.Models.CommonComponents.Number(10), new MeasuringUnit(new MVC_CookBook_PSSC.Models.CommonComponents.ShortText("txt"))));
Ingredients ing2 = new Ingredients(new MVC_CookBook_PSSC.Models.CommonComponents.Text("txt"), new Quantity(new MVC_CookBook_PSSC.Models.CommonComponents.Number(10), new MeasuringUnit(new MVC_CookBook_PSSC.Models.CommonComponents.ShortText("txt"))));
Ingredients ing3 = new Ingredients(new MVC_CookBook_PSSC.Models.CommonComponents.Text("txt2"), new Quantity(new MVC_CookBook_PSSC.Models.CommonComponents.Number(10), new MeasuringUnit(new MVC_CookBook_PSSC.Models.CommonComponents.ShortText("txt"))));
recipe.AddInexistentIngredient(ing1);
recipe.AddInexistentIngredient(ing2);
Assert.AreNotSame(ing1, ing2);
Assert.AreEqual(1, recipe.GetIngredients.Count);
recipe.AddInexistentIngredient(ing3);
Assert.AreNotSame(ing1, ing3);
Assert.AreEqual(2, recipe.GetIngredients.Count);
}
public async Task <IngredientResponse> SaveAsync(Ingredients ingredient)
{
try
{
await _ingredientRepository.AddAsync(ingredient);
await _unitOfWork.CompleteAsync();
return(new IngredientResponse(ingredient));
}
catch (Exception ex)
{
// Do some logging stuff
return(new IngredientResponse($"An error occurred when saving the category: {ex.Message}"));
}
}
private void SeedIngredients()
{
Ingredients.Add(new IngredientEntity
{
Id = ingredientGuids[0],
Name = "Vejce",
Description = "Popis vajec",
ImageUrl = "https://upload.wikimedia.org/wikipedia/en/thumb/5/58/Instagram_egg.jpg/220px-Instagram_egg.jpg"
});
Ingredients.Add(new IngredientEntity
{
Id = ingredientGuids[1],
Name = "Cibule",
Description = "Popis cibule",
ImageUrl = "https://upload.wikimedia.org/wikipedia/commons/2/25/Onion_on_White.JPG"
});
}
public void Update()
{
Ingredients.Clear();
using (IIngredientController controller = factory.CreateIngredientController())
{
DataControllerMessage <IEnumerable <IngredientDisplayDTO> > controllerMessage = controller.GetAll();
if (controllerMessage.IsSuccess)
{
foreach (IngredientDisplayDTO ingredient in controllerMessage.Data)
{
Ingredients.Add(ingredient);
}
}
}
}
public async Task ActivateAsync()
{
using (Ingredients.SuppressChangeNotifications())
{
Ingredients.Clear();
var ingredients = await _ingredientsRepository.GetAllAsync();
var ingredientViewModels = FilterIngredientsTemplateMethod(ingredients);
var orderedIngredients = ingredientViewModels
.OrderBy(i => !i.IsAvailable)
.ThenBy(i => i.BottleIndex)
.ToList();
Ingredients.AddRange(orderedIngredients);
}
}
public IngredientEdit(TcpClient client, Ingredients selected)
{
InitializeComponent();
_client = client;
selectedIngredient = selected;
ComboBoxAvailable.Items.Add("Tak");
ComboBoxAvailable.Items.Add("Nie");
TextBoxName.Text = selectedIngredient.Name;
if (selectedIngredient.Available)
{
ComboBoxAvailable.SelectedIndex = 0;
}
else
{
ComboBoxAvailable.SelectedIndex = 1;
}
}
private List <Ingredients> FindPossibleIngredients(Ingredients ingredient)
{
List <Ingredients> list = new List <Ingredients>();
for (int i = 0; i < recipes.Count; i++)
{
if (recipes[i].ingredients.Contains(ingredient))
{
for (int j = 0; j < recipes[i].ingredients.Length; j++)
{
list.Add(recipes[i].ingredients[j]);
}
}
}
return(list);
}
public void AddIngridiant(SRL_Ingredient ingredient)
{
List <SRL_Ingredient> list = Ingredients;
string foodName = ingredient.FoodName;
SRL_Ingredient tIngredient = list.Find(f => f.FoodName == foodName);
if (tIngredient == null)
{
list.Add(ingredient);
}
Ingredients = list;
dlistIngredients.DataSource = Ingredients.ToArray();
dlistIngredients.DataBind();
}
public void AskForExtrasTest()
{
using var stringWriter = new StringWriter();
Console.SetOut(stringWriter);
MessageHandlers.AskForExtras();
var expected = "\n\nWould you like to add extra ingredients to your pizza?";
var extras = Ingredients.GetExtra();
for (int i = 0; i < extras.Length; i++)
{
expected += $"\n{extras[i]} ({i})";
}
expected += "\n";
var actual = stringWriter.ToString();
Assert.AreEqual(expected, actual);
}
async Task ExecuteSaveCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Meal.Ingredients.Clear();
Meal.Ingredients.AddRange(Ingredients);
bool isNew = Meal.Id == Guid.Empty;
var mealDoc = new Meal
{
Description = Meal.Description,
ImgFilename = Meal.ImgFilename,
Ingredients = Ingredients.ToList(),
LastUpdated = Meal.LastUpdated,
MealDate = Meal.MealDate,
Reaction = Meal.Reaction
};
if (isNew)
{
await _dataStore.AddItemAsync(mealDoc);
}
else
{
mealDoc.Id = Meal.Id;
await _dataStore.SaveItemAsync(mealDoc);
}
MessagingCenter.Send(this, MealSavedMessage, mealDoc);
}
catch (Exception ex)
{
Debug.WriteLine($"[{nameof(MealEntryPageViewModel)}] Save error: {ex.Message}");
MessagingCenter.Send(this, MealSaveErrorMessage);
}
finally
{
IsBusy = false;
}
}
public ActionResult CreateIngredient(Ingredients model)
{
if (!ModelState.IsValid)
{
return(View("IngredientForm", model));
}
Ingredients ingredient = new Ingredients();
ingredient = model;
_context.Ingredientss.Add(ingredient);
_context.SaveChanges();
return(RedirectToAction("ListIngredients", "Recipes"));
}
public void UpdateWorks()
{
int id = 0;
// arrange (use the context directly - we assume that works)
var options = new DbContextOptionsBuilder <Project1Context>()
.UseInMemoryDatabase("db__ingredient_test_update").Options;
using (var db = new Project1Context(options));
// act (for act, only use the repo, to test it)
using (var db = new Project1Context(options))
{
var repo = new IngredientRepository(db);
Ingredients ingredient = new Ingredients {
Name = "Test Update", Stock = 10
};
repo.Save(ingredient, id);
repo.SaveChanges();
id = ingredient.Id;
}
// assert (for assert, once again use the context directly for verify.)
using (var db = new Project1Context(options))
{
var repo = new IngredientRepository(db);
Ingredients ingredient = (Ingredients)repo.GetById(id);
Assert.NotEqual(0, ingredient.Id);
Assert.Equal("Test Update", ingredient.Name);
Assert.Equal(10, ingredient.Stock);
ingredient.Name = "Test Update 2";
ingredient.Stock = 20;
repo.Save(ingredient, id);
repo.SaveChanges();
ingredient = (Ingredients)repo.GetById(id);
Assert.NotEqual(0, ingredient.Id);
Assert.Equal(id, ingredient.Id);
Assert.Equal("Test Update 2", ingredient.Name);
Assert.Equal(20, ingredient.Stock);
}
}
public IActionResult OnPost(List <Ingredient> ingredients)
{
if (ModelState.IsValid)
{
int.TryParse((string)RouteData.Values["Id"], out int id);
List <string> ids = Request.Form["IngredientId"].ToList();
// Remove all non checked ingredients
Ingredients.RemoveAll(x => !ids.Contains(x.Id.ToString()));
ingredientsInRecipeRepository.AddNewIngredientsInRecipe(id, Ingredients);
return(RedirectToPage("/Recipes/Edit", new { Id = id }));
}
OnGet();
return(Page());
}
public bool CreateIngredient(IngredientCreate model)
{
var entity =
new Ingredients()
{
Name = model.Name,
Quantity = model.Quantity,
Price = model.Price,
UPC = model.UPC
};
using (var ctx = new ApplicationDbContext())
{
ctx.Ingredients.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
int partToIndex(Ingredients.bodyParts bp)
{
switch(bp)
{
case Ingredients.bodyParts.Horns:
return 0;
case Ingredients.bodyParts.Body:
return 1;
case Ingredients.bodyParts.Limbs:
return 2;
}
return -1;
}
void GenRecipes()
{
tier_ingredient = new List<HashSet<Ingredients>>();
System.Random rnd = new System.Random((int)System.DateTime.Now.Ticks);
if (tier_GmO == null)
{
tier_GmO = new List<HashSet<GameObject>>(new HashSet<GameObject>[] { });
foreach (Transform tiers in base_ingredients.transform)
{
HashSet<GameObject> h = new HashSet<GameObject>();
tier_GmO.Add(h);
foreach (Transform ingredient in tiers)
{
h.Add(ingredient.gameObject);
}
}
}
stat_ingredient = new Dictionary<Ingredients.stats, HashSet<Ingredients>>();
part_ingredient = new Dictionary<Ingredients.bodyParts, HashSet<Ingredients>>();
var values = System.Enum.GetValues(typeof(Ingredients.bodyParts));
foreach(Ingredients.bodyParts value in values)
{
part_ingredient.Add(value, new HashSet<Ingredients>());
}
values = System.Enum.GetValues(typeof(Ingredients.stats));
foreach (Ingredients.stats value in values)
{
stat_ingredient.Add(value, new HashSet<Ingredients>());
}
for (int x = 0; x < tier_GmO.Count; x++)
{
List<GameObject> ingredient_l = GetIngredientsTier(x);
GameObject[] stats = new GameObject[ingredient_l.Count];
int[] parts_n = new int[5];
int[] parts_v = { 2, 3, 5 };
for (int y = 0; y < 5; y++)
{
parts_n[y] = 1;
for (int z = 0; z < 2; z++)
{
int chk = rnd.Next(0, ingredient_l.Count);
stats[y*2+z] = ingredient_l[chk];
ingredient_l.RemoveAt(chk);
}
}
for (int y = 0; y < 3; y++)
{
for (int a = 0; a < 3 || (y >= 2 && a < 4); a++)
{
int min = parts_n.Min();
int count = 0;
if (min > 1)
{
count = parts_n.Where(elem => elem < 6 && elem % parts_v[y] > 0).Count();
min = 5;
}
else
{
count = parts_n.Where(elem => elem < 2).Count();
min = 1;
}
int chk = rnd.Next(0, count);
int ct = 0;
for (int z = 0; z < parts_n.Count(); z++)
{
if (ct == chk && parts_n[z] <= min && parts_n[z] % parts_v[y] > 0)
{
parts_n[z] *= parts_v[y];
break;
}
if (parts_n[z] <= min && parts_n[z] % parts_v[y] > 0)
{
ct++;
}
}
}
}
HashSet<Ingredients> tier_set = new HashSet<Ingredients>();
for (int y = 0; y < stats.Count(); y++)
{
foreach(int prime in parts_v)
{
if(parts_n[y/2] % prime == 0)
{
Ingredients temp = new Ingredients(stats[y].name, y / 2, prime, x, stats[y]);
tier_set.Add(temp);
name_ingredient.Add(stats[y].name, temp);
stat_ingredient[((Ingredients.stats)(y / 2))].Add(temp);
part_ingredient[((Ingredients.bodyParts)prime)].Add(temp);
parts_n[y / 2] /= prime;
break;
}
}
}
tier_ingredient.Add(tier_set);
}
}
