public Recipe(string title, string description, string slug, RecipeCategory category)
{
Title = title;
Description = description;
Slug = slug;
Category = category;
}
public void StoreRecipe(List <CommodityShadowConfirmed> list, RecipeCategory recipeCategory)
{
var description = "";
foreach (var block in _recipeDescription)
{
description += block + "\n";
}
var recipe = _recipeModel.CreateRecipe(_recipeName, description);
// Now we need to bind them together! We do need these objects :D
_rcModel.CreateRC(recipe, recipeCategory);
foreach (var commodityShadow in list)
{
Commodity commodity;
commodity = commodityShadow.ConfirmedCommodity
? commodityShadow.Commodity
: _commodityModel.CreateCommodity(commodityShadow.Name);
_recipeCommodityModel.CreateRecipeCommodity(recipe, commodity, commodityShadow.Value,
commodityShadow.ConfirmedUnit
? commodityShadow.Unit.ToString()
: commodityShadow.UnitString);
}
MessageBox.Show("Opskriften er blevet gemt", "Succes", MessageBoxButton.OK, MessageBoxImage.Information);
_scrape.Close();
}
public RecipeCategory GetRecipeCategory(int recipeId)
{
RecipeCategory category;
using (var connection = new SqlConnection(Properties.Settings.Default.RecipeDatabaseConnectionString))
{
using (var transaction = new TransactionScope())
{
connection.Open();
using (var command = new SqlCommand("[dbo].GetRecipeCategory", connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("recipeID", recipeId);
var result = command.ExecuteReader();
if (result.HasRows)
{
result.Read();
category = new RecipeCategory(result.GetFieldValue <int>(0), result.GetFieldValue <string>(1));
}
else
{
throw new ArgumentException($"The recipeID: {recipeId}, does not exist in the the database.");
}
}
connection.Close();
return(category);
}
}
return(category);
}
private void RecipeToDb(List <CommodityShadow> commodityList, string recipeName, string recipeDescription,
RecipeCategory recipeCategory, Recipe recipe = null)
{
var rcModel = new RCModel(_dbPath);
var recipeCommodityModel = new RecipeCommodityModel(_dbPath);
var recipeModel = new RecipeModel(_dbPath);
var commodityModel = new CommodityModel(_dbPath);
if (recipe == null)
{
recipe = recipeModel.CreateRecipe(recipeName, recipeDescription);
}
rcModel.CreateRC(recipe, recipeCategory);
foreach (var commodityShadow in commodityList)
{
if (commodityShadow.Commodity != null)
{
recipeCommodityModel.CreateRecipeCommodity(recipe, commodityShadow.Commodity, commodityShadow.Value,
commodityShadow.Unit.ToString());
}
else
{
var commodity = commodityModel.CreateCommodity(commodityShadow.Name);
recipeCommodityModel.CreateRecipeCommodity(recipe, commodity, commodityShadow.Value,
commodityShadow.Unit.ToString());
}
}
}
public async Task <IActionResult> Edit(RecipeCategory recipeCategory)
{
if (ModelState.IsValid)
{
try
{
if (!await _recipeCategoryService.RecipeCategoryExists(recipeCategory.Id))
{
return(NotFound());
}
await _recipeCategoryService.Update(recipeCategory);
}
catch (DbUpdateConcurrencyException)
{
if (!await _recipeCategoryService.RecipeCategoryExists(recipeCategory.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(recipeCategory));
}
private void CreateRecipe(RecipeCategory recipeCategory, string recipeName, string inputName1, string inputName2, string outputName, string baseRecipeName, int inputAmount1, int inputAmount2, int outputAmount, string itemId)
{
var input1 = GameResources.Instance.Items.FirstOrDefault(s => s.name == inputName1);
var input2 = GameResources.Instance.Items.FirstOrDefault(s => s.name == inputName2);
var output = GameResources.Instance.Items.FirstOrDefault(s => s.name == outputName);
var baseRecipe = GameResources.Instance.Recipes.FirstOrDefault(s => s.name == baseRecipeName);
var recipe = ScriptableObject.CreateInstance <Recipe>();
recipe.name = recipeName;
recipe.Inputs = new InventoryItemData[] { new InventoryItemData {
Item = input1, Amount = inputAmount1
}, new InventoryItemData {
Item = input2, Amount = inputAmount2
} };
recipe.Output = new InventoryItemData {
Item = output, Amount = outputAmount
};
recipe.RequiredUpgrades = baseRecipe.RequiredUpgrades;
recipe.Categories = new RecipeCategory[] { recipeCategory };
var guid = GUID.Parse(itemId);
typeof(Definition).GetField("m_assetId", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(recipe, guid);
AssetReference[] assets = new AssetReference[] { new AssetReference()
{
Object = recipe, Guid = guid, Labels = new string[0]
} };
RuntimeAssetStorage.Add(assets, default);
QuestingDict.questingRegistry[recipeName] = guid;
QuestLog.Log("[Questing Update | Recipes]: Recipe " + recipeName + " has been Loaded");
}
public void SelectCategory(RecipeCategory foodCategory)
{
searchPage.SetActive(true);
audioSource.PlayOneShot(audioClip);
searchFieldTMP.text = foodCategory.categoryTitle;
List <Recipe> _recipeList = new List <Recipe>();
foreach (RecipeCategory recipeCategory in recipeCategories)
{
if (recipeCategory.foodCategory == foodCategory.foodCategory)
{
foreach (var recipe in recipeCategory.recipes)
{
_recipeList.Add(recipe);
}
}
}
foreach (Transform item in searchHolder)
{
Destroy(item.gameObject);
}
foreach (Recipe recipe in _recipeList)
{
CreateRecipesObj(recipe, searchHolder, searchRecipeTemplate);
}
}
public ActionResult DeleteConfirmed(int id)
{
RecipeCategory RecipeCategory = _recipeCategoryService.GetById(id);
_recipeCategoryService.Delete(RecipeCategory);
return(RedirectToAction("Index"));
}
public Recipe[] RetrieveRecipe(RecipeCategory category)
{
return(this.recipes
.Take(numRecipes)
.Where(x => x.Category == category)
.ToArray());
}
public void Setup()
{
RecipeCategory recipeCategory = new RecipeCategory()
{
Name = "category",
Id = RecipeCategoryId
};
GroceryCategory groceryCategory = new GroceryCategory()
{
Id = GroceryCategoryId,
Name = "category",
};
GroceryItem groceryItem = new GroceryItem()
{
Id = GroceryItemId,
Name = "item",
Category = groceryCategory
};
_context.RecipeCategories.Add(recipeCategory);
_context.GroceryCategories.Add(groceryCategory);
_context.GroceryItems.Add(groceryItem);
_context.SaveChanges();
}
public RecipeCategory CreateRecipeCategory(string name)
{
var category = new RecipeCategory(0, name);
_recipeCategories.Add(category);
return(category);
}
public bool UpdateRecipe(List <int> authorsId, List <int> categoriesId, List <int> stepsId, List <int> ingredientsId, Recipe recipe)
{
var authors = _recipeDbContext.Authors.Where(a => authorsId.Contains(a.Id)).ToList();
var categories = _recipeDbContext.Categories.Where(c => categoriesId.Contains(c.Id)).ToList();
var steps = _recipeDbContext.Steps.Where(s => stepsId.Contains(s.Id)).ToList();
var ingredients = _recipeDbContext.Ingredients.Where(i => ingredientsId.Contains(i.Id)).ToList();
var recipeAuthorsToDelete = _recipeDbContext.RecipeAuthors.Where(r => r.RecipeId == recipe.Id);
var categoryAuthorsToDelete = _recipeDbContext.RecipeCategories.Where(c => c.RecipeId == recipe.Id);
var ingredientAuthorsToDelete = _recipeDbContext.RecipeIngredients.Where(i => i.RecipeId == recipe.Id);
var stepsToDelete = _recipeDbContext.Steps.Where(s => s.Recipe.Id == recipe.Id);
_recipeDbContext.RemoveRange(recipeAuthorsToDelete);
_recipeDbContext.RemoveRange(categoryAuthorsToDelete);
_recipeDbContext.RemoveRange(ingredientAuthorsToDelete);
_recipeDbContext.RemoveRange(stepsToDelete);
foreach (var author in authors)
{
var recipeAuthor = new RecipeAuthor()
{
Author = author,
Recipe = recipe
};
_recipeDbContext.Add(recipeAuthor);
}
foreach (var category in categories)
{
var recipeCategories = new RecipeCategory()
{
Category = category,
Recipe = recipe
};
_recipeDbContext.Add(recipeCategories);
}
foreach (var ingredient in ingredients)
{
var recipeIngredients = new RecipeIngredient()
{
Ingredient = ingredient,
Recipe = recipe
};
_recipeDbContext.Add(recipeIngredients);
}
foreach (var step in steps)
{
var s = new Step()
{
Description = step.Description,
Recipe = recipe
};
_recipeDbContext.Add(s);
}
return(Save());
}
public RecipeAdded(OperationId operationId, Amount amount, Label label, Pair pair, RecipeCategory category)
{
Pair = pair;
Label = label;
Amount = amount;
Category = category;
OperationId = operationId;
}
public ActionResult DeleteConfirmed(int id)
{
RecipeCategory recipeCategory = db.RecipeCategories.Find(id);
db.RecipeCategories.Remove(recipeCategory);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public bool InCategory(Recipe recipe, RecipeCategory category)
{
if (recipe == null || category == null)
{
return(false);
}
return(recipe.CategoryId == category.Id);
}
public AddRecipe(PeriodId periodId, Amount amount, Label label, Pair pair, RecipeCategory category)
{
PeriodId = periodId;
Amount = amount;
Label = label;
Pair = pair;
Category = category;
}
public OperationId AddRecipe(Amount amount, Label label, Pair pair, RecipeCategory category)
{
var operationId = OperationId.From(State.GetNextOperationId());
RaiseEvent(new RecipeAdded(operationId, amount, label, pair, category));
RaiseBalanceChanged();
return(operationId);
}
public async Task <IActionResult> CreateRecipe([FromBody] RecipeModel model)
{
string recipeError = ValidateRecipe(model);
if (!String.IsNullOrEmpty(recipeError))
{
return(BadRequest(recipeError));
}
// create Recipe
Recipe recipe = new Recipe();
recipe.Name = model.name;
recipe.PreparationTime = model.preparationTime;
recipe.Servings = model.servings;
context.Recipe.Add(recipe);
// create RecipeFrontImage
RecipeFrontImage recipeFrontImage = new RecipeFrontImage();
recipeFrontImage.FrontImage = FileHelper.EncodeString(model.frontImage);
context.RecipeFrontImage.Add(recipeFrontImage);
recipeFrontImage.RecipeNavigation = recipe;
// create multiple RecipeIngredientMeasure
foreach (IngredientModel ingredient in model.ingredients)
{
RecipeIngredientMeasure recipeIngredientMeasure = new RecipeIngredientMeasure();
recipeIngredientMeasure.Ingredient = Int32.Parse(ingredient.ingredientValue);
recipeIngredientMeasure.Amount = ingredient.amount;
recipeIngredientMeasure.Measure = Int32.Parse(ingredient.measureValue);
recipeIngredientMeasure.RecipeNavigation = recipe;
context.RecipeIngredientMeasure.Add(recipeIngredientMeasure);
}
// create multiple RecipeIngredientMeasure
foreach (DirectionModel direction in model.directions)
{
RecipeDirection recipeDirection = new RecipeDirection();
recipeDirection.Sort = direction.sortNumber;
recipeDirection.Direction = direction.description.Trim();
recipeDirection.RecipeNavigation = recipe;
context.RecipeDirection.Add(recipeDirection);
}
// create multiple RecipeCategory
foreach (FilterModel category in model.categories)
{
RecipeCategory recipeCategory = new RecipeCategory();
recipeCategory.Category = Int32.Parse(category.value);
recipeCategory.RecipeNavigation = recipe;
context.RecipeCategory.Add(recipeCategory);
}
await context.SaveChangesAsync();
return(Ok(recipe.Id));
}
public ActionResult Edit([Bind(Include = "RecipeCategoryId,Name,Id")] RecipeCategory RecipeCategory)
{
if (ModelState.IsValid)
{
_recipeCategoryService.Update(RecipeCategory);
return(RedirectToAction("Index"));
}
return(View(RecipeCategory));
}
public ChangeRecipe(PeriodId periodId, OperationId operationId, Amount amount = null, Label label = null, Pair pair = null, RecipeCategory category = null)
{
PeriodId = periodId;
OperationId = operationId;
Amount = amount;
Label = label;
Pair = pair;
Category = category;
}
public async Task <IActionResult> AddRecipe([FromBody] NewRecipe input)
{
return(await SendCommandAsync(new AddRecipe(
PeriodId.From(input.PeriodId),
Amount.From(input.Amount),
Label.From(input.Label),
Pair.From(input.Pair),
RecipeCategory.From(input.Category))));
}
public void Equals_ReturnsTrueIfAllAreTheSame_RecipeCategory()
{
// Arrange, Act
RecipeCategory firstRecipeCategory = new RecipeCategory(1, 1);
RecipeCategory secondRecipeCategory = new RecipeCategory(1, 1);
// Assert
Assert.AreEqual(firstRecipeCategory, secondRecipeCategory);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
RecipeCategory recipeCategory = await db.RecipeCategories.FindAsync(id);
db.RecipeCategories.Remove(recipeCategory);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "Id,CatName,CatDesc")] RecipeCategory recipeCategory)
{
if (ModelState.IsValid)
{
db.Entry(recipeCategory).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(recipeCategory));
}
public async Task <IActionResult> Create(RecipeCategory recipeCategory)
{
if (ModelState.IsValid)
{
await _recipeCategoryService.Create(recipeCategory);
return(RedirectToAction(nameof(Index)));
}
return(View(recipeCategory));
}
public ActionResult Create(string recipeName, string recipeRating, string categoryName)
{
Recipe newRecipe = new Recipe(recipeName, int.Parse(recipeRating));
newRecipe.Save();
RecipeCategory newPair = new RecipeCategory(newRecipe.GetId(), Category.FindCategoryByName(categoryName).GetId());
newPair.Save();
return(RedirectToAction("Index"));
}
public void RemoveRecipe(RecipeCategory category)
{
for (int i = 0; i < numRecipes; ++i)
{
if (this.recipes[i].Category == category)
{
RemoveElement(i);
}
}
}
public async Task <Unit> Handle(CreateRecipeCategoryCommand command, CancellationToken cancellationToken)
{
var category = new RecipeCategory(command.Name);
await _recipeRepository.CreateRecipeCategoryAsync(category);
await _unitOfWork.CommitAsync(cancellationToken);
return(Unit.Value);
}
public async Task <RecipeCategory> AddRecipeCategory(AddRecipeCategoryDto newRecipeCategory)
{
RecipeCategory category = _mapper.Map <RecipeCategory>(newRecipeCategory);
await _context.RecipeCategories.AddAsync(category);
await _context.SaveChangesAsync();
return(category);
}
public async Task <IActionResult> ChangeRecipe([FromBody] UpdateRecipe input)
{
return(await SendCommandAsync(new ChangeRecipe(
PeriodId.From(input.PeriodId),
OperationId.From(input.OperationId),
Amount.From(input.Amount),
Label.From(input.Label),
Pair.From(input.Pair),
RecipeCategory.From(input.Category))));
}
public static void InsertRecipe(string name, string source, RecipeCategory category, string description, string prep, string cook, List<IngredientEntry> ingredients, out int recid)
{
int id;
try
{
using (RecipeBook_DataModelDataContext db = new RecipeBook_DataModelDataContext())
{
Recipe rec = new Recipe();
rec.rec_Name = name;
rec.rec_Source = source;
rec.rec_Description = description;
rec.rec_PreparationInstructions = prep;
rec.rec_CookingInstructions = cook;
rec.rec_EntryDate = DateTime.Today;
rec.cat_ID = category.cat_ID;
db.Recipes.InsertOnSubmit(rec);
db.SubmitChanges();
id = rec.rec_ID;
}
using (RecipeBook_DataModelDataContext db = new RecipeBook_DataModelDataContext())
{
var recipe = (from rec in db.Recipes where rec.rec_ID == id select rec).First();
foreach (IngredientEntry i in ingredients)
{
RecipeIngredient recing = new RecipeIngredient();
recing.rec_ID = id;
recing.ing_ID = i.Ingredient.ing_ID;
recing.mes_ID = i.Measurement.mes_ID;
recing.ri_Amount = i.Amount;
recipe.RecipeIngredients.Add(recing);
}
db.SubmitChanges();
}
recid = id;
}
catch (Exception)
{
recid = -1;
throw;
}
}
public RecipeEntry(string name, string source, RecipeCategory category, string description, string prep, string cook, List<IngredientEntry> ingredients, int id)
{
_ingredients = ingredients;
_name = name;
_category = category;
_description = description;
_source = source;
_prepinstructions = prep;
_cookinstructions = cook;
recID = id;
}
public static void UpdateRecipe(string name, string source, RecipeCategory category, string description, string prep, string cook, List<IngredientEntry> ingredients, int rec_ID)
{
try
{
using (RecipeBook_DataModelDataContext db = new RecipeBook_DataModelDataContext())
{
var original = (from rec in db.Recipes where rec.rec_ID == rec_ID select rec).First();
original.rec_Name = name;
original.rec_Source = source;
original.rec_Description = description;
original.rec_PreparationInstructions = prep;
original.rec_CookingInstructions = cook;
original.cat_ID = category.cat_ID;
db.SubmitChanges();
}
using (RecipeBook_DataModelDataContext db = new RecipeBook_DataModelDataContext())
{
var original = (from rec in db.Recipes where rec.rec_ID == rec_ID select rec.RecipeIngredients).First();
original.Clear();
foreach (IngredientEntry i in ingredients)
{
RecipeIngredient recTemp = new RecipeIngredient();
recTemp.ing_ID = i.Ingredient.ing_ID;
recTemp.mes_ID = i.Measurement.mes_ID;
recTemp.ri_Amount = i.Amount;
recTemp.rec_ID = rec_ID;
original.Add(recTemp);
}
db.SubmitChanges();
}
}
catch (Exception)
{
throw;
}
}
