public RecipeCreator(IKpcContext context)
{
this.context = context;
this.recipe = new Recipe();
this.recipe.DateEntered = DateTime.Now;
}
private static void CategorizeMeal(Recipe recipe, CategorizationResult result, Analyzer analyzer)
{
IRecipeClassification trainedRecipe;
if (analyzer.CheckIfTrained(recipe.Id, out trainedRecipe))
{
result.MealBreakfast = trainedRecipe.IsBreakfast;
result.MealLunch = trainedRecipe.IsLunch;
result.MealDinner = trainedRecipe.IsDinner;
result.MealDessert = trainedRecipe.IsDessert;
}
else
{
var analysis = analyzer.GetPrediction(recipe);
result.MealBreakfast =
analysis.FirstPlace.Equals(Category.Breakfast) ||
analysis.SecondPlace.Equals(Category.Breakfast);
result.MealLunch =
analysis.FirstPlace.Equals(Category.Lunch) ||
analysis.SecondPlace.Equals(Category.Lunch);
result.MealDinner =
analysis.FirstPlace.Equals(Category.Dinner) ||
analysis.SecondPlace.Equals(Category.Dinner);
result.MealDessert =
analysis.FirstPlace.Equals(Category.Dessert) ||
analysis.SecondPlace.Equals(Category.Dessert);
}
}
public RecipeRater(IKPCContext context, Recipe recipe, Rating rating)
{
this.context = context;
this.newRatings = new Dictionary<Recipe, Rating>();
this.newRatings.Add(recipe, rating);
}
public RecipeClassification(Recipe recipe, RecipeTag tag)
{
this.Recipe = recipe;
this.IsBreakfast = tag == RecipeTag.Breakfast;
this.IsLunch = tag == RecipeTag.Lunch;
this.IsDinner = tag == RecipeTag.Dinner;
this.IsDessert = tag == RecipeTag.Dessert;
}
public MenuUpdater Add(Recipe recipe)
{
if (!this.addQueue.Contains(recipe))
{
this.addQueue.Add(recipe);
}
return this;
}
static readonly Regex valid = new Regex(@"[a-z]", RegexOptions.IgnoreCase); //All tokens have to have at least one letter in them
#endregion Fields
#region Methods
public static IEnumerable<IToken> Tokenize(Recipe recipe)
{
var tokens = new List<IToken>();
tokens.AddRange(ParseText(recipe.Title ?? ""));
tokens.AddRange(ParseText(recipe.Description ?? ""));
//tokens.AddRange(ParseText(recipe.Method ?? ""));
//tokens.Add(new TimeToken(recipe.CookTime.GetValueOrDefault() + recipe.PrepTime.GetValueOrDefault()));
tokens.AddRange(from i in recipe.Ingredients.NeverNull() select new IngredientToken(i.Ingredient) as IToken);
return tokens;
}
public RecipeBrief(Recipe recipe)
{
this.Id = recipe.Id;
this.OwnerId = recipe.OwnerId;
this.Title = recipe.Title;
this.Description = recipe.Description;
this.ImageUrl = recipe.ImageUrl;
this.Author = recipe.OwnerAlias;
this.PreparationTime = recipe.PreparationTime;
this.CookingTime = recipe.CookingTime;
this.AverageRating = recipe.AverageRating;
}
public RecipeBrief(Recipe r)
{
this.Id = r.Id;
this.OwnerId = r.OwnerId;
this.Title = r.Title;
this.Description = r.Description;
this.ImageUrl = r.ImageUrl;
this.Author = r.OwnerAlias;
this.PrepTime = r.PrepTime;
this.CookTime = r.CookTime;
this.AvgRating = r.AvgRating;
}
public CategorizationResult Categorize(Recipe recipe)
{
var result = new CategorizationResult();
CategorizeMeal(recipe, result, analyzer);
CategorizeDiet(recipe, result);
CategorizeNutrition(recipe, result);
CategorizeSkill(recipe, result);
CategorizeTaste(recipe, result);
return result;
}
public static Recipe MockRecipe(string title, string desc, RecipeTags tags = null)
{
var ret = new Recipe(Guid.NewGuid(), title, desc, null);
ret.Method = "This is a mock recipe.";
ret.OwnerAlias = "Fake Owner";
ret.OwnerId = Guid.NewGuid();
ret.PermanentLink = "http://www.kitchenpc.com/123";
ret.ServingSize = 5;
ret.Tags = tags;
return ret;
}
// What should IToken have? Should Token be a Generic Item<T>?
public static IEnumerable<IToken> Tokenize(Recipe recipe)
{
var tokens = new List<IToken>();
tokens.AddRange(ParseText(recipe.Title ?? string.Empty));
tokens.AddRange(ParseText(recipe.Description ?? string.Empty));
tokens.AddRange(ParseText(recipe.Method ?? string.Empty));
tokens.Add(new TimeToken(recipe.CookTime + recipe.PrepTime));
tokens.AddRange(
recipe.Ingredients.NeverNull()
.Select(ingredientUsage => new IngredientToken(ingredientUsage.Ingredient)));
return tokens;
}
public void Add(Recipe recipe)
{
var tokens = Tokenizer.Tokenize(recipe);
foreach (var token in tokens)
{
if (this.index.ContainsKey(token))
{
this.index[token]++;
}
else
{
this.index.Add(token, 1);
}
}
}
private void CategorizeDiet(Recipe recipe, CategorizationResult result)
{
var ingredientMeta = recipe.Ingredients.Select(ing => ing.Ingredient.Metadata).ToArray();
var glutenFree = ingredientMeta.All(ing => ing.HasGluten == false);
var noAnimals = ingredientMeta.All(ing => ing.HasAnimal == false);
var noMeat = ingredientMeta.All(ing => ing.HasMeat == false);
var noPork = ingredientMeta.All(ing => ing.HasPork == false);
var noRedMeat = ingredientMeta.All(ing => ing.HasRedMeat == false);
result.DietGlutenFree = glutenFree;
result.DietNoAnimals = noAnimals;
result.DietNoMeat = noMeat;
result.DietNoPork = noPork;
result.DietNoRedMeat = noRedMeat;
}
static void CategorizeDiet(Recipe recipe, CategorizationResult result)
{
var ingmeta = (from ing in recipe.Ingredients select ing.Ingredient.Metadata).ToArray();
var glutenFree = ingmeta.All(ing => ing.HasGluten == false);
var noAnimals = ingmeta.All(ing => ing.HasAnimal == false);
var noMeat = ingmeta.All(ing => ing.HasMeat == false);
var noPork = ingmeta.All(ing => ing.HasPork == false);
var noRed = ingmeta.All(ing => ing.HasRedMeat == false);
result.Diet_GlutenFree = glutenFree;
result.Diet_NoAnimals = noAnimals;
result.Diet_NoMeat = noMeat;
result.Diet_NoPork = noPork;
result.Diet_NoRedMeat = noRed;
}
public AnalyzerResult GetPrediction(Recipe recipe)
{
var winsBreakfast = new Ranking(Category.Breakfast);
var winsLunch = new Ranking(Category.Lunch);
var winsDinner = new Ranking(Category.Dinner);
var winsDessert = new Ranking(Category.Dessert);
// Setup Tournament
this.Compete(recipe, this.breakfastIndex, this.lunchIndex, winsBreakfast, winsLunch, winsDinner, winsDessert);
this.Compete(recipe, this.breakfastIndex, this.dinnerIndex, winsBreakfast, winsLunch, winsDinner, winsDessert);
this.Compete(recipe, this.breakfastIndex, this.dessertIndex, winsBreakfast, winsLunch, winsDinner, winsDessert);
this.Compete(recipe, this.lunchIndex, this.dinnerIndex, winsBreakfast, winsLunch, winsDinner, winsDessert);
this.Compete(recipe, this.lunchIndex, this.dessertIndex, winsBreakfast, winsLunch, winsDinner, winsDessert);
this.Compete(recipe, this.dinnerIndex, this.dessertIndex, winsBreakfast, winsLunch, winsDinner, winsDessert);
// Choose winner
var result = GetWinner(winsBreakfast, winsLunch, winsDinner, winsDessert);
return result;
}
private void CategorizeMeal(Recipe recipe, CategorizationResult result)
{
IRecipeClassification trainedRecipe = this.analyzer.GetTrainedRecipe(recipe.Id);
if (trainedRecipe != null)
{
result.MealBreakfast = trainedRecipe.IsBreakfast;
result.MealLunch = trainedRecipe.IsLunch;
result.MealDinner = trainedRecipe.IsDinner;
result.MealDessert = trainedRecipe.IsDessert;
}
else
{
var analysis = this.analyzer.GetPrediction(recipe);
result.MealBreakfast = analysis.FirstPlace.Equals(Category.Breakfast) || analysis.SecondPlace.Equals(Category.Breakfast);
result.MealLunch = analysis.FirstPlace.Equals(Category.Lunch) || analysis.SecondPlace.Equals(Category.Lunch);
result.MealDinner = analysis.FirstPlace.Equals(Category.Dinner) || analysis.SecondPlace.Equals(Category.Dinner);
result.MealDessert = analysis.FirstPlace.Equals(Category.Dessert) || analysis.SecondPlace.Equals(Category.Dessert);
}
}
public static IngredientSection[] GetSections(Recipe recipe)
{
//TODO: This code can probably be done in a LINQ expression, or more efficiently.
var nullSection = new IngredientSection(null);
var map = new Dictionary<string, IngredientSection>();
foreach (var usage in recipe.Ingredients)
{
if (string.IsNullOrEmpty(usage.Section))
{
nullSection.Ingredients.Add(usage);
}
else
{
var sectionKey = usage.Section.ToLower();
IngredientSection sectionList;
if (map.TryGetValue(sectionKey, out sectionList))
{
sectionList.Ingredients.Add(usage);
}
else
{
sectionList = new IngredientSection(usage.Section);
sectionList.Ingredients.Add(usage);
map.Add(sectionKey, sectionList);
}
}
}
var result = new List<IngredientSection>();
if (nullSection.Ingredients.Count > 0)
{
result.Add(nullSection);
}
result.AddRange(map.Values);
return result.ToArray();
}
public AnalyzerResult GetPrediction(Recipe recipe)
{
var winsBr = new Ranking(Category.Breakfast);
var winsLu = new Ranking(Category.Lunch);
var winsDi = new Ranking(Category.Dinner);
var winsDe = new Ranking(Category.Dessert);
//Setup Tournament
Compete(recipe, BreakfastIndex, LunchIndex, winsBr, winsLu, winsDi, winsDe);
Compete(recipe, BreakfastIndex, DinnerIndex, winsBr, winsLu, winsDi, winsDe);
Compete(recipe, BreakfastIndex, DessertIndex, winsBr, winsLu, winsDi, winsDe);
Compete(recipe, LunchIndex, DinnerIndex, winsBr, winsLu, winsDi, winsDe);
Compete(recipe, LunchIndex, DessertIndex, winsBr, winsLu, winsDi, winsDe);
Compete(recipe, DinnerIndex, DessertIndex, winsBr, winsLu, winsDi, winsDe);
//Choose winner
Ranking tag1, tag2;
var result = GetWinner(winsBr, winsLu, winsDi, winsDe, out tag1, out tag2);
return result;
}
public RecipeResult CreateRecipe(Recipe recipe)
{
throw new NotImplementedException();
}
public RecipeLoader(IKPCContext context, Recipe recipe)
{
this.context = context;
this.recipesToLoad = new List<Recipe>() { recipe };
}
public RecipeLoader Load(Recipe recipe)
{
this.recipesToLoad.Add(recipe);
return this;
}
private void Compete(Recipe entry, RecipeIndex first, RecipeIndex second, Ranking rankBreakfast, Ranking rankLunch, Ranking rankDinner, Ranking rankDessert)
{
var chance = this.GetPrediction(entry, first, second);
if (chance > 0.5f - Tolerance && chance < 0.5f + Tolerance)
{
return; // No winner
}
var diff = (float)Math.Abs(chance - 0.5);
var winner = chance < 0.5 ? second : first;
if (winner == this.breakfastIndex)
{
rankBreakfast.Score += diff;
}
if (winner == this.lunchIndex)
{
rankLunch.Score += diff;
}
if (winner == this.dinnerIndex)
{
rankDinner.Score += diff;
}
if (winner == this.dessertIndex)
{
rankDessert.Score += diff;
}
}
public RecipeResult CreateRecipe(Recipe recipe)
{
this.CRCalledTimes++;
return new RecipeResult();
}
public static void Validate(Recipe recipe)
{
if (String.IsNullOrEmpty(recipe.Title) || recipe.Title.Trim().Length == 0)
{
throw new InvalidRecipeDataException("A recipe title is required.");
}
if (recipe.PrepTime < 0)
{
throw new InvalidRecipeDataException("PrepTime must be equal to or greater than zero.");
}
if (recipe.CookTime < 0)
{
throw new InvalidRecipeDataException("CookTime must be equal to or greater than zero.");
}
if (recipe.ServingSize <= 0)
{
throw new InvalidRecipeDataException("ServingSize must be greater than zero.");
}
if (recipe.Ingredients == null || recipe.Ingredients.Length == 0)
{
throw new InvalidRecipeDataException("Recipes must contain at least one ingredient.");
}
if (recipe.Tags == null || recipe.Tags.Length == 0)
{
throw new InvalidRecipeDataException("Recipes must contain at least one tag.");
}
if (recipe.Description != null && recipe.Description.Length > 250)
{
recipe.Description = recipe.Description.Substring(0, 250) + "...";
}
if (recipe.CreditUrl != null)
{
const string pattern = @"^https?\://(?<domain>[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3})(/\S*)?$";
var m = Regex.Match(recipe.CreditUrl, pattern);
if (m.Success && m.Groups["domain"].Success)
{
recipe.CreditUrl = m.Value;
recipe.Credit = m.Groups["domain"].Value.ToLower(); //TODO: Clean up domain name
}
else //Bad URL, clear Credit info
{
recipe.Credit = null;
recipe.CreditUrl = null;
}
}
}
public ProfileCreator AddRating(Recipe recipe, byte rating)
{
ratings.Add(new RecipeRating
{
RecipeId = recipe.Id,
Rating = rating
});
return this;
}
public ShoppingListResult CreateShoppingList(string name, Recipe[] recipes, Ingredient[] ingredients, IngredientUsage[] usages, string[] items)
{
throw new NotImplementedException();
}
public RecipeEnqueuer Recipe(Recipe recipe)
{
this.recipesQueue.Add(recipe);
return this;
}
private float GetPrediction(Recipe recipe, RecipeIndex first, RecipeIndex second)
{
// Reset probability and invertedProbability
this.invertedProbability = 0;
this.probability = 0;
var tokens = Tokenizer.Tokenize(recipe);
foreach (var token in tokens)
{
var firstRITokensCount = first.GetTokenCount(token);
var secondRITokensCount = second.GetTokenCount(token);
this.CalcProbability(firstRITokensCount, first.EntryCount, secondRITokensCount, second.EntryCount);
}
var prediction = this.probability / (this.probability + this.invertedProbability);
return prediction;
}
public ProfileCreator AvoidRecipe(Recipe recipe)
{
avoidRecipe = recipe.Id;
return this;
}
public RecipeRater Rate(Recipe recipe, Rating rating)
{
var result = new RecipeRater(this.context, recipe, rating);
return result;
}
