public static void CreateRandomDetails(IStorageService service, Recipe r)
{
RecipeDetails details = new RecipeDetails()
{
recipe = r
};
Random random = new Random();
int size = random.Next(10);
for (int i = 0; i < size; i++)
{
Instruction instr = new Instruction()
{
type = (InstructionType)random.Next(2)
};
if (instr.type != InstructionType.Image)
{
instr.data = randomDetails[random.Next(8)].data;
}
else
{
var index = random.Next(5);
instr.data = index.ToString() + ".jpg";
FileStream file = File.OpenRead($"Resources/Images/Instructions/{instr.data}");
service.UploadPicture(file, r.ID, instr.data);
file.Close();
}
details.Instructions.Add(instr);
}
Save(service, details);
}
protected void Page_Load(object sender, EventArgs e)
{
//Instantiate object
Utility Util = new Utility();
//Instantiate database field
RecipeDetails Recipe = new RecipeDetails();
Recipe.WhatPageID = constant.intRecipeDetails; //1 = we are dealing with print.aspx use the same as recipedetails.
Recipe.ID = (int)Util.Val(Request.QueryString["id"]);
//Fill up database fields
Recipe.fillup();
lblingredientsdis.Text = "Ingredients:";
lblinstructionsdis.Text = "Instructions:";
lblname.Text = Recipe.RecipeName;
lblIngredients.Text = Util.FormatText(Recipe.Ingredients);
lblInstructions.Text = Util.FormatText(Recipe.Instructions);
strRName = "Printing" + Recipe.RecipeName + " Recipe";
//Release allocated memory
Util = null;
Recipe = null;
}
private EditRecipeViewModel ParseEditRecipeViewModel(Recipe recipe, RecipeDetails recipeDetails)
{
EditRecipeViewModel returnedModel = new EditRecipeViewModel();
IEnumerable <Category> categories = _categoryProvider.GetCategories();
if (recipe != null)
{
returnedModel.RecipeId = recipe.RecipeId;
returnedModel.Name = recipe.Name;
returnedModel.ImageUrl = recipe.ImageUrl;
returnedModel.CategoryId = recipe.CategoryId;
returnedModel.Categories = new SelectList(categories, "CategoryId", "Name", returnedModel.CategoryId);
}
else
{
returnedModel.Categories = new SelectList(categories, "CategoryId", "Name");
}
if (recipeDetails != null)
{
returnedModel.CookingTime = recipeDetails.CookingTime;
returnedModel.CookingTemperature = recipeDetails.CookingTemperature;
returnedModel.Description = recipeDetails.Description;
}
return(returnedModel);
}
public async Task InsertAsync(RecipeDetails recipe)
{
if (recipe.Image.Split(',')[0].Equals("data:image/png;base64") == false)
{
throw new BadRequestException();
}
var recipeToInsert = mapper.Map <Recipe>(recipe);
await recipeService.InsertAsync(recipeToInsert);
string imgPath = Path.Combine(environment.WebRootPath, $"images/{recipeToInsert.Id}.PNG");
bool isNewImage = File.Exists(imgPath);
if (isNewImage == true)
{
throw new BadRequestException();
}
byte[] data = Convert.FromBase64String(recipe.Image.Split(',')[1]);
var format = GetImageFormat(data);
if (format != ImageFormat.png)
{
throw new BadRequestException();
}
using (var imageFile = new FileStream(imgPath, FileMode.Create))
{
imageFile.Write(data, 0, data.Length);
imageFile.Flush();
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
//Validate admin session username and password by comparing them to the admin user database record.
UserNameVal.ValidateAdminUserNameandPass();
GetDropdownCategoryID();
lblusername.Text = "Welcome Admin: " + UserNameVal.AdminUsername;
//Instantiate database field
RecipeDetails Recipe = new RecipeDetails();
Recipe.ID = (int)Util.Val(Request.QueryString["id"]);
strRecipeImage = GetRecipeImage.GetImage(Recipe.ID);
Recipe.WhatPageID = constant.intRecipeAdminEditing; //Parameter 3 = we are pulling database field for Admin/editing.aspx
//Fill up database fields
Recipe.fillup();
Name.Text = Recipe.RecipeName;
Author.Text = Recipe.Author;
Hits.Text = Recipe.Hits.ToString();
Ingredients.Text = Recipe.Ingredients;
Instructions.Text = Recipe.Instructions;
//Release allocated memory
Recipe = null;
myBL = null;
}
}
public void UpdateRecipe(Recipe recipe, RecipeDetails recipeDetails)
{
if (recipe != null && recipeDetails != null)
{
_recipeRepository.UpdateRecipe(recipe, recipeDetails);
}
}
public static RecipeDetailsDto FromRecipeDetails(RecipeDetails recipesDetails) =>
new RecipeDetailsDto(recipesDetails.Id.Value,
recipesDetails.Name,
recipesDetails.Requirements,
recipesDetails.Allergens,
recipesDetails.MealTypes,
recipesDetails.Calories,
recipesDetails.MacroNutrientQuantity);
public async Task <RecipeDetails> Create(Guid recipeId)
{
var recipe = await _recipeDetailsRepository.GetRecipeById(recipeId);
var ingredients = await _recipeDetailsRepository.GetAggregatedIngredientsDetailsByIds(recipe.RecipeIngredients);
return(RecipeDetails.FromRecipeAndIngredientsDetails(recipe, ingredients));
}
protected void Page_Load(object sender, EventArgs e)
{
Recipe.WhatPageID = constant.intRecipeDetails;
Recipe.ID = (int)Util.Val(Request.QueryString["id"]);
//Fill up database fields
Recipe.fillup();
//Initialize variables to use for aspx page.
RecCatId = Recipe.CatID;
strRName = Recipe.RecipeName;
strCName = Recipe.Category;
RecipeSection = constant.intRecipe;
recipeimage.Visible = false;
//Display recipe image if exist.
if (!string.IsNullOrEmpty(Recipe.RecipeImage))
{
recipeimage.Visible = true;
recipeimage.ImageUrl = GetRecipeImage.ImagePathDetail + Recipe.RecipeImage;
}
lbcountcomment.Text = Recipe.CountComments.ToString();
lblname.Text = Recipe.RecipeName;
lblauthor.Text = Recipe.Author;
lblhits.Text = string.Format("{0:#,###}", Recipe.Hits);
lblrating.Text = Recipe.Rating;
lblvotescount.Text = Recipe.NoRates;
lblcategorytop.Text = Recipe.Category;
lbldate.Text = Recipe.Date.ToShortDateString();
lblIngredients.Text = Util.FormatText(Recipe.Ingredients);
lblInstructions.Text = Util.FormatText(Recipe.Instructions);
starimage.ImageUrl = Utility.GetStarImage(Recipe.Rating);
//Save to Favorite/Bookmark URL
strBookmarkURL = Bookmark.URL;
//Get dynamic page title and keywords
GetMetaKeywords(DynamicKeywords.Keywords(constant.intRecipeDynamicKeywordDetails, Recipe.RecipeName.ToString() + " recipe, " + Recipe.Category.ToString() + " recipe"));
//Display New and Popular image
ShowNewPopularImage();
//Get 15 related recipes datatable.
GetRelatedrecipes();
//Get user recipe cookie rating
GetUserRecipeCookieRating();
//Get Recipe Comment
GetComments();
//Release allocated memory
Util = null;
Recipe = null;
}
public RecipeDetails UpdateRecipe(RecipeDetails recipeDetails)
{
var existing = _recipes.Single(r => r.Id == recipeDetails.Id);
var index = _recipes.IndexOf(existing);
_recipes[index] = recipeDetails;
return(recipeDetails);
}
public RecipeDetails AddRecipe(RecipeDetails recipeDetails)
{
recipeDetails.Id = _recipes
.Select(r => r.Id)
.DefaultIfEmpty(0)
.Max() + 1;
_recipes.Add(recipeDetails);
return(recipeDetails);
}
public int InsertRecipe(Recipe recipe, RecipeDetails recipeDetails)
{
if (recipe != null && recipeDetails != null)
{
return(_recipeRepository.InsertRecipe(recipe, recipeDetails));
}
else
{
return(0);
}
}
public async Task CreateNewOrReplaceExisting(RecipeDetails recipeDetails)
{
var key = recipeDetails.Id.Value
.ToDictionaryKey(nameof(RecipeDetails));
if (_cachingProvider.Exists(key))
{
_cachingProvider.Remove(key);
}
_cachingProvider.Set(key, recipeDetails, TimeSpan.FromDays(30));
}
public DetailPageViewModel()
{
localPath = Path.Combine(FileSystem.CacheDirectory, Constants.LocalFileName);
recipe = JsonConvert.DeserializeObject <RecipeDetails>(File.ReadAllText(LocalPath));
image = recipe.ImageURL;
title = recipe.Title;
description = recipe.Description;
recipeInformation = recipe.RecipeInformation;
recipe.Ingredients.ForEach(i => ingredients.Add(i));
recipe.InstructionSteps.ForEach(i => instructions.Add(i));
}
public static RecipeDetails ExtractRecipe(Recipe r)
{
var recipe = new RecipeDetails();
recipe.Title = r.Title;
recipe.Description = r.Summary;
recipe.ImageURL = r.Image;
recipe.Ingredients = r.ExtendedIngredients.Any() ? SimplyfyIngredients(r.ExtendedIngredients) : new List <Ingredient>();
recipe.InstructionSteps = r.AnalyzedInstructions.Any() ? SimplyfyInstructions(r.AnalyzedInstructions) : new List <Instruction>();
recipe.RecipeInformation = SimplyfyInformation(r);
return(recipe);
}
private RecipeDetails ExecuteRecipeDetailsSqlCmd(SqlConnection sqlConnection, SqlCommand cmd)
{
RecipeDetails recipeDetails = new RecipeDetails();
try
{
sqlConnection.Open();
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
recipeDetails.RecipeId = reader.GetFieldValue <int>(0);
if (!reader.IsDBNull(1))
{
recipeDetails.CookingTime = reader.GetFieldValue <string>(1);
}
else
{
recipeDetails.CookingTime = "";
}
if (!reader.IsDBNull(2))
{
recipeDetails.CookingTemperature = reader.GetFieldValue <string>(2);
}
else
{
recipeDetails.CookingTemperature = "";
}
if (!reader.IsDBNull(3))
{
recipeDetails.Description = reader.GetFieldValue <string>(3);
}
else
{
recipeDetails.Description = "";
}
recipeDetails.Sequencing = reader.GetFieldValue <string>(4);
}
};
}
catch (Exception ex)
{
_logger.ErrorMessage(ex);
}
finally
{
sqlConnection.Close();
}
return(recipeDetails);
}
public void ToRecipe(RecipeDetails details)
{
Name = details.Name;
Id = details.ID;
Description = details.Description;
Image = details.Image;
var list = ChamberOfSecrets.Proxy.dbGetContains(Id, true).ToList();
foreach (var item in list)
{
var grocery = new Grocery(item.Grocery.Name, Grocery.ParseEnum <Unit>(item.Grocery.Unit), Grocery.ParseEnum <Category>(item.Grocery.Category), item.Amount);
Groceries.Add(grocery);
}
}
//View the recipe of selected soap
private void ViewRecipeEvent(object sender, MouseButtonEventArgs e)
{
se.RecipeTable.Load();
RecipeDetails rd = new RecipeDetails();
String searchedRecipeName = (String)(sender as ListView).SelectedItem;
MessageBox.Show(searchedRecipeName);
DateTime searchedRecipeDate = se.RecipeTable.Local.Where(x => x.Name == searchedRecipeName).Select(x => x.Date).First();
String searchedRecipeOthers = se.RecipeTable.Local.Where(x => x.Name == searchedRecipeName).Select(x => x.Others).First();
rd.RecipeDetailsDataGrid.ItemsSource = se.RecipeTable.Local.Where(x => x.Name == searchedRecipeName).ToList();
rd.Title = searchedRecipeName + searchedRecipeDate.ToString("-yyyy-MM-DD") + searchedRecipeOthers;
rd.ShowDialog();
}
private RecipeDetails ParseRecipeDetails(EditRecipeViewModel editRecipeViewModel)
{
RecipeDetails recipeDetails = new RecipeDetails();
if (editRecipeViewModel != null)
{
recipeDetails.RecipeId = editRecipeViewModel.RecipeId;
recipeDetails.CookingTemperature = editRecipeViewModel.CookingTemperature;
recipeDetails.CookingTime = editRecipeViewModel.CookingTime;
recipeDetails.Description = editRecipeViewModel.Description;
recipeDetails.Sequencing = null;
}
return(recipeDetails);
}
public ActionResult AddOrEditRecipe(int recipeId)
{
Recipe recipe = _recipeProvider.GetRecipeById(recipeId);
RecipeDetails recipeDetails = _recipeProvider.GetRecipeDetailsByRecipeId(recipeId);
EditRecipeViewModel model = ParseEditRecipeViewModel(recipe, recipeDetails);
if (Request.IsAjaxRequest())
{
return(PartialView("_AddOrEditRecipe", model));
}
else
{
return(View(model));
}
}
public ActionResult ShowSequencingByRecipeId(int recipeId)
{
IEnumerable <RecipeIngridientView> recipeIngridients = _recipeProvider.GetRecipeIngridientsByRecipeId(recipeId);
Recipe recipe = _recipeProvider.GetRecipeById(recipeId);
RecipeDetails recipeDetails = _recipeProvider.GetRecipeDetailsByRecipeId(recipeId);
EditSequencingViewModel model = ParseEditSequencingViewModel(recipeIngridients, recipeId, recipe.Name, recipeDetails.Sequencing);
if (Request.IsAjaxRequest())
{
return(PartialView("_ShowSequencingByRecipeId", model));
}
else
{
return(View("ShowSequencingByRecipeId", model));
}
}
public ShoppingListViewModel()
{
localPath = Path.Combine(FileSystem.CacheDirectory, Constants.LocalFileName);
recipe = JsonConvert.DeserializeObject <RecipeDetails>(File.ReadAllText(localPath));
recipe.Ingredients.ForEach(i => { ingredients.Add(i); });
// UpdateIngredient this works as intended
UpdateIngredientsCommand = new Command(() =>
{
List <Ingredient> updatedList = new List <Ingredient>();
updatedList.AddRange(Ingredients);
recipe.Ingredients = updatedList;
File.WriteAllText(LocalPath, JsonConvert.SerializeObject(recipe));
});
}
public async Task <ActionResult> Details(int id)
{
using (var webclient = new WebClient())
{
string myurl = "https://spoonacular-recipe-food-nutrition-v1.p.rapidapi.com/recipes/informationBulk?ids=";
webclient.Headers[HttpRequestHeader.Accept] = "application/json";
webclient.Headers["X-RapidAPI-Key"] = "037ed14f35msh15f3f745fd822dbp10e5b8jsn21f31374305f";
string json = await webclient.DownloadStringTaskAsync(myurl + id);
var recipeDetails = RecipeDetails.FromJson(json);
return(View(recipeDetails));
}
}
public async Task <IActionResult> RecImgDetails(int?id)
{
if (id == null)
{
return(new BadRequestResult());
}
var client = new HttpClient();
var response = await client.GetAsync($"{_baseUrl}/{id.Value}");
if (response.IsSuccessStatusCode)
{
var recipe = JsonConvert.DeserializeObject <Recipe>(await response.Content.ReadAsStringAsync());
var images = JsonConvert.DeserializeObject <List <Image> >(await(await client.GetAsync("http://localhost:50541/api/Images")).Content.ReadAsStringAsync());
var ingredients = JsonConvert.DeserializeObject <List <Ingredient> >(await(await client.GetAsync("http://localhost:50541/api/Ingredients")).Content.ReadAsStringAsync());
var brands = JsonConvert.DeserializeObject <List <Brand> >(await(await client.GetAsync("http://localhost:50541/api/Brands")).Content.ReadAsStringAsync());
var recipeIngredients = JsonConvert.DeserializeObject <List <RecipeIngredient> >(await(await client.GetAsync("http://localhost:50541/api/RecipeIngredients")).Content.ReadAsStringAsync());
var image = images.Where(x => x.RecipeId == id).ToList().First();
var user = _context.AppUsers.Where(x => x.Id == recipe.AppUserId).ToList().First();
var recipeIngredient = recipeIngredients.Where(x => x.RecipeId == id).ToList();
var listIngredient = new List <Ingredient>();
var listBrand = new List <Brand>();
foreach (var item in recipeIngredient)
{
item.Ingredient = ingredients.Where(x => x.Id == item.IngredientId).ToList().First();
item.Brand = brands.Where(x => x.Id == item.BrandId).ToList().First();
}
RecipeDetails recImgDet = new RecipeDetails
{
Recipe = recipe,
Image = image,
AppUser = user,
RecipeIngredients = recipeIngredient,
CreationDate = recipe.CreationDate.ToString("d")
};
return(View(recImgDet));
}
return(NotFound());
}
public RecipeDetails GetRecipeDetailsByRecipeId(int recipeId)
{
RecipeDetails recipeDetails = new RecipeDetails();
if (recipeId > 0)
{
_executerRecipeDetailsCmd executer = new _executerRecipeDetailsCmd(ExecuteRecipeDetailsSqlCmd);
using (SqlConnection sqlConnection = new SqlConnection(_connectionString))
{
using (SqlCommand cmd = new SqlCommand("GetRecipeDetailsById", sqlConnection))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@RecipeId", recipeId);
recipeDetails = executer(sqlConnection, cmd);
}
}
}
return(recipeDetails);
}
public async Task <IActionResult> GetDetails(string id = "")
{
string url = apiURL + "/" + id + "/information?" + apiID;
using (HttpResponseMessage response = await APIHelper.ApiClient.GetAsync(url))
{
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
RecipeDetails resObject = JsonConvert.DeserializeObject <RecipeDetails>(json);
return(View(resObject));
}
else
{
throw new Exception(response.ReasonPhrase);
}
}
}
public static RecipeDetails CallRecipeDetailsApi(string id)
{
RecipeDetails objRecipeDetails = new RecipeDetails();
try
{
string query = "recipe/" + id + "?_app_id=" + ConfigurationManager.AppSettings["App_Id"] + "&_app_key=" + ConfigurationManager.AppSettings["App_Key"];
string json = CallApiAL.CallWebApi(query);
if (!String.IsNullOrEmpty(json))
{
objRecipeDetails = JsonConvert.DeserializeObject <RecipeDetails>(json.ToString());
}
}
catch (Exception ex)
{
ex.SendMail();
objRecipeDetails = new RecipeDetails();
}
return(objRecipeDetails);
}
public async Task <IActionResult> Show(string id)
{
var recipes = from m in _context.MyRecipe
join n in _context.MyRecipe_Ingredient
on m.Id equals n.R_id
join o in _context.Ingredient
on n.I_id equals o.Id
join p in _context.MyRecipe_Seasoning
on m.Id equals p.R_id
join q in _context.Seasoning
on p.S_id equals q.Id
orderby m.Name, o.Name, q.Name
select new
{
MyRecipe = m,
Ingred = o,
InWeight = n.Weight,
Season = q,
SeWeight = p.Weight
};
if (!String.IsNullOrEmpty(id))
{
recipes = recipes.Where(m => m.MyRecipe.Name.Contains(id));
}
recipes = recipes.OrderBy(m => m.Ingred.Name).OrderBy(m => m.MyRecipe.Name);
var tmp = await recipes.ToListAsync();
List <RecipeDetails> lrd = new List <RecipeDetails>();
foreach (var item in tmp)
{
int rid = item.MyRecipe.Id;
RecipeDetails rd = (lrd.Count > 0) ? lrd.ElementAt(lrd.Count - 1) : null;
if (rd != null && rd.MyRecipe.Id == rid)
{
Ingredient_W cew = new Ingredient_W {
Ingredient = item.Ingred, Weight = item.InWeight
};
rd.I_common.Add(cew);
rd.Total_calories += item.Ingred.Calories * item.InWeight;
Seasoning_W sew = new Seasoning_W {
Seasoning = item.Season, Weight = item.SeWeight
};
rd.S_common.Add(sew);
rd.Total_calories += item.Season.Calories * item.SeWeight;
}
else
{
List <Ingredient_W> my_lce = new List <Ingredient_W>();
Ingredient_W cew = new Ingredient_W {
Ingredient = item.Ingred, Weight = item.InWeight
};
my_lce.Add(cew);
List <Seasoning_W> my_lse = new List <Seasoning_W>();
Seasoning_W sew = new Seasoning_W {
Seasoning = item.Season, Weight = item.SeWeight
};
my_lse.Add(sew);
rd = new RecipeDetails
{
MyRecipe = item.MyRecipe,
I_common = my_lce,
S_common = my_lse
};
rd.Total_calories += item.Ingred.Calories * item.InWeight;
rd.Total_calories += item.Season.Calories * item.SeWeight;
lrd.Add(rd);
}
}
ViewData["TypesArray"] = new string[] { "Ingredient", "Seasoning" };
return(View(lrd));
}
public async Task OnGetAsync(long id)
{
Recipe = await recipeService.GetRecipeAsync(id);
}
public void UpdateRecipe(Recipe recipe, RecipeDetails recipeDetails)
{
if (recipe != null && recipeDetails != null)
{
using (SqlConnection sqlConnection = new SqlConnection(_connectionString))
{
SqlCommand cmdUpdateRecipe = new SqlCommand("UpdateRecipe", sqlConnection);
cmdUpdateRecipe.CommandType = CommandType.StoredProcedure;
cmdUpdateRecipe.Parameters.AddWithValue("@RecipeId", recipe.RecipeId);
cmdUpdateRecipe.Parameters.AddWithValue("@Name", recipe.Name);
if (recipe.ImageUrl == null)
{
cmdUpdateRecipe.Parameters.AddWithValue("@ImageUrl", DBNull.Value);
}
else
{
cmdUpdateRecipe.Parameters.AddWithValue("@ImageUrl", recipe.ImageUrl);
}
cmdUpdateRecipe.Parameters.AddWithValue("@CategoryId", recipe.CategoryId);
SqlCommand cmdUpdateRecipeDetails = new SqlCommand("UpdateRecipeDetails", sqlConnection);
cmdUpdateRecipeDetails.CommandType = CommandType.StoredProcedure;
cmdUpdateRecipeDetails.Parameters.AddWithValue("@RecipeId", recipe.RecipeId);
if (recipeDetails.CookingTime == null)
{
cmdUpdateRecipeDetails.Parameters.AddWithValue("@CookingTime", DBNull.Value);
}
else
{
cmdUpdateRecipeDetails.Parameters.AddWithValue("@CookingTime", recipeDetails.CookingTime);
}
if (recipeDetails.CookingTemperature == null)
{
cmdUpdateRecipeDetails.Parameters.AddWithValue("@CookingTemperature", DBNull.Value);
}
else
{
cmdUpdateRecipeDetails.Parameters.AddWithValue("@CookingTemperature", recipeDetails.CookingTemperature);
}
if (recipeDetails.Description == null)
{
cmdUpdateRecipeDetails.Parameters.AddWithValue("@Description", DBNull.Value);
}
else
{
cmdUpdateRecipeDetails.Parameters.AddWithValue("@Description", recipeDetails.Description);
}
if (recipeDetails.Sequencing == null)
{
cmdUpdateRecipeDetails.Parameters.AddWithValue("@Sequencing", DBNull.Value);
}
else
{
cmdUpdateRecipeDetails.Parameters.AddWithValue("@Sequencing", recipeDetails.Sequencing);
}
SqlTransaction transaction = null;
try
{
sqlConnection.Open();
transaction = sqlConnection.BeginTransaction();
cmdUpdateRecipe.Transaction = transaction;
cmdUpdateRecipeDetails.Transaction = transaction;
cmdUpdateRecipe.ExecuteNonQuery();
cmdUpdateRecipeDetails.ExecuteNonQuery();
transaction.Commit();
}
catch (Exception ex)
{
_logger.ErrorMessage(ex);
transaction.Rollback();
}
finally
{
sqlConnection.Close();
}
}
}
}
