public void DequeueRecipe(AuthorIdentity identity, params Guid[] recipeIds)
{
using (var session = this.GetSession())
{
var recipes = (from recipe in recipeIds select new Recipes { RecipeId = recipe }).ToArray();
var databaseRecipes = session.QueryOver<QueuedRecipes>().Where(p => p.UserId == identity.UserId);
if (recipeIds.Any())
{
databaseRecipes = databaseRecipes.AndRestrictionOn(p => p.Recipe).IsInG(recipes);
}
using (var transaction = session.BeginTransaction())
{
databaseRecipes.List().ForEach(session.Delete);
transaction.Commit();
}
}
}
public SearchResults Search(AuthorIdentity identity, RecipeQuery query)
{
var index = this.store.GetSearchIndex();
var q = index.Where(p => !p.Recipe.Hidden);
if (!string.IsNullOrWhiteSpace(query.Keywords))
{
q = q.Where(p =>
(p.Recipe.Title ?? string.Empty).IndexOf(query.Keywords, StringComparison.OrdinalIgnoreCase) >= 0 ||
(p.Recipe.Description ?? string.Empty).IndexOf(query.Keywords, StringComparison.OrdinalIgnoreCase) >= 0);
}
if (query.Time.MaxPrep.HasValue)
{
q = q.Where(p => p.Recipe.PrepTime <= query.Time.MaxPrep.Value);
}
if (query.Time.MaxCook.HasValue)
{
q = q.Where(p => p.Recipe.CookTime <= query.Time.MaxCook.Value);
}
if (query.Rating > 0)
{
q = q.Where(p => p.Recipe.Rating >= (int)query.Rating.Value);
}
if (query.Include != null && query.Include.Length > 0)
{
// Add ingredients to include
q = q.Where(p => p.Ingredients.Any(i => query.Include.Contains(i.IngredientId)));
}
if (query.Exclude != null && query.Exclude.Length > 0)
{
// Add ingredients to exclude
q = q.Where(p => !p.Ingredients.Any(i => query.Exclude.Contains(i.IngredientId)));
}
if (query.Photos == PhotoFilter.Photo || query.Photos == PhotoFilter.HighRes)
{
q = q.Where(p => p.Recipe.ImageUrl != null);
}
if (query.Diet || query.Nutrition || query.Skill || query.Taste || (query.Meal != MealFilter.All) || (query.Photos == PhotoFilter.HighRes))
{
// Meal
if (query.Meal != MealFilter.All)
{
if (query.Meal == MealFilter.Breakfast)
{
q = q.Where(p => p.Metadata.MealBreakfast);
}
if (query.Meal == MealFilter.Dessert)
{
q = q.Where(p => p.Metadata.MealDessert);
}
if (query.Meal == MealFilter.Dinner)
{
q = q.Where(p => p.Metadata.MealDinner);
}
if (query.Meal == MealFilter.Lunch)
{
q = q.Where(p => p.Metadata.MealLunch);
}
}
// High-res photos
if (query.Photos == PhotoFilter.HighRes)
{
q = q.Where(p => p.Metadata.PhotoRes >= 1024 * 768);
}
// Diet
if (query.Diet.GlutenFree)
{
q = q.Where(p => p.Metadata.DietGlutenFree);
}
if (query.Diet.NoAnimals)
{
q = q.Where(p => p.Metadata.DietNoAnimals);
}
if (query.Diet.NoMeat)
{
q = q.Where(p => p.Metadata.DietNomeat);
}
if (query.Diet.NoPork)
{
q = q.Where(p => p.Metadata.DietNoPork);
}
if (query.Diet.NoRedMeat)
{
q = q.Where(p => p.Metadata.DietNoRedMeat);
}
// Nutrition
if (query.Nutrition.LowCalorie)
{
q = q.Where(p => p.Metadata.NutritionLowCalorie);
}
if (query.Nutrition.LowCarb)
{
q = q.Where(p => p.Metadata.NutritionLowCarb);
}
if (query.Nutrition.LowFat)
{
q = q.Where(p => p.Metadata.NutritionLowFat);
}
if (query.Nutrition.LowSodium)
{
q = q.Where(p => p.Metadata.NutritionLowSodium);
}
if (query.Nutrition.LowSugar)
{
q = q.Where(p => p.Metadata.NutritionLowSugar);
}
// Skill
if (query.Skill.Common)
{
q = q.Where(p => p.Metadata.SkillCommon).OrderByDescending(p => p.Metadata.Commonality);
}
if (query.Skill.Easy)
{
q = q.Where(p => p.Metadata.SkillEasy);
}
if (query.Skill.Quick)
{
q = q.Where(p => p.Metadata.SkillQuick);
}
// Taste
if (query.Taste.MildToSpicy != SpicinessLevel.Medium)
{
q = query.Taste.MildToSpicy < SpicinessLevel.Medium
? q.Where(p => p.Metadata.TasteMildToSpicy <= query.Taste.Spiciness).OrderBy(p => p.Metadata.TasteMildToSpicy)
: q.Where(p => p.Metadata.TasteMildToSpicy >= query.Taste.Spiciness).OrderByDescending(p => p.Metadata.TasteMildToSpicy);
}
if (query.Taste.SavoryToSweet != SweetnessLevel.Medium)
{
q = query.Taste.SavoryToSweet < SweetnessLevel.Medium
? q.Where(p => p.Metadata.TasteSavoryToSweet <= query.Taste.Sweetness).OrderBy(p => p.Metadata.TasteSavoryToSweet)
: q.Where(p => p.Metadata.TasteSavoryToSweet >= query.Taste.Sweetness).OrderByDescending(p => p.Metadata.TasteSavoryToSweet);
}
}
switch (query.Sort)
{
case SortOrder.Title:
q = (query.Direction == SortDirection.Ascending) ? q.OrderBy(p => p.Recipe.Title) : q.OrderByDescending(p => p.Recipe.Title);
break;
case SortOrder.PrepTime:
q = (query.Direction == SortDirection.Ascending) ? q.OrderBy(p => p.Recipe.PrepTime) : q.OrderByDescending(p => p.Recipe.PrepTime);
break;
case SortOrder.CookTime:
q = (query.Direction == SortDirection.Ascending) ? q.OrderBy(p => p.Recipe.CookTime) : q.OrderByDescending(p => p.Recipe.CookTime);
break;
case SortOrder.Image:
q = (query.Direction == SortDirection.Ascending) ? q.OrderBy(p => p.Recipe.ImageUrl) : q.OrderByDescending(p => p.Recipe.ImageUrl);
break;
default:
q = (query.Direction == SortDirection.Ascending) ? q.OrderBy(p => p.Recipe.Rating) : q.OrderByDescending(p => p.Recipe.Rating);
break;
}
return new SearchResults
{
Briefs = q.Select(r => Provisioning.DTO.Recipes.ToRecipeBrief(r.Recipe)).ToArray(),
TotalCount = q.Count()
};
}
public void DeleteShoppingLists(AuthorIdentity identity, ShoppingList[] lists)
{
if (!lists.Any())
{
throw new ArgumentException("DeleteShoppingLists requires at least one list to delete.");
}
using (var session = this.GetSession())
{
using (var transaction = session.BeginTransaction())
{
var databaseLists =
session.QueryOver<ShoppingLists>()
.AndRestrictionOn(p => p.ShoppingListId)
.IsInG(lists.Where(l => l.Id.HasValue).Select(l => l.Id.Value))
.Where(p => p.UserId == identity.UserId)
.List();
databaseLists.ForEach(session.Delete);
transaction.Commit();
}
}
}
public Recipe[] ReadRecipes(AuthorIdentity identity, Guid[] recipeIds, ReadRecipeOptions options)
{
using (var session = this.GetSession())
{
var databaseRecipes =
session.QueryOver<Recipes>()
.Fetch(prop => prop.RecipeMetadata)
.Eager.Fetch(prop => prop.Ingredients)
.Eager.Fetch(prop => prop.Ingredients[0].Ingredient)
.Eager.Fetch(prop => prop.Ingredients[0].IngredientForm)
.Eager.AndRestrictionOn(p => p.RecipeId)
.IsInG(recipeIds)
.TransformUsing(Transformers.DistinctRootEntity)
.List();
if (!databaseRecipes.Any())
{
throw new RecipeNotFoundException();
}
var recipes = new List<Recipe>();
foreach (var databaseRecipe in databaseRecipes)
{
var recipe = new Recipe
{
Id = databaseRecipe.RecipeId,
Title = databaseRecipe.Title,
Description = databaseRecipe.Description,
DateEntered = databaseRecipe.DateEntered,
ImageUrl = databaseRecipe.ImageUrl,
ServingSize = databaseRecipe.ServingSize,
PreparationTime = databaseRecipe.PrepTime,
CookingTime = databaseRecipe.CookTime,
Credit = databaseRecipe.Credit,
CreditUrl = databaseRecipe.CreditUrl,
AverageRating = databaseRecipe.Rating
};
if (options.ReturnMethod)
{
recipe.Method = databaseRecipe.Steps;
}
if (options.ReturnUserRating)
{
// TODO: We should JOIN this on the databaseRecipes for faster loading
var id = databaseRecipe.RecipeId;
var rating =
session.QueryOver<RecipeRatings>()
.Where(p => p.Recipe.RecipeId == id)
.Where(p => p.UserId == identity.UserId)
.SingleOrDefault();
recipe.UserRating = rating == null ? Rating.None : (Rating)rating.Rating;
}
recipe.Ingredients =
databaseRecipe.Ingredients.Select(
i =>
new IngredientUsage
{
Amount = i.Qty.HasValue ? new Amount(i.Qty.Value, i.Unit) : null,
PrepNote = i.PrepNote,
Section = i.Section,
Form =
i.IngredientForm != null
? i.IngredientForm.AsIngredientForm()
: null,
// Note: Form will be null when usage has no amount
Ingredient = i.Ingredient.AsIngredient()
}).ToArray();
recipe.Tags = databaseRecipe.RecipeMetadata.Tags;
recipes.Add(recipe);
}
return recipes.ToArray();
}
}
public MenuResult UpdateMenu(
AuthorIdentity identity,
Guid? menuId,
Guid[] recipesAdd,
Guid[] recipesRemove,
MenuMove[] recipesMove,
bool clear,
string newName = null)
{
var menu = new MenuResult();
using (var session = this.GetSession())
{
using (var transaction = session.BeginTransaction())
{
Menus databaseMenu = null;
IList<Favorites> databaseRecipes = null;
if (menuId.HasValue)
{
databaseMenu =
session.QueryOver<Menus>()
.Fetch(prop => prop.Recipes)
.Eager.Where(p => p.MenuId == menuId)
.SingleOrDefault();
if (databaseMenu == null)
{
throw new MenuNotFoundException();
}
CheckForUserAccess(identity, databaseMenu);
RenameMenu(newName, databaseMenu);
databaseRecipes = databaseMenu.Recipes;
}
else
{
databaseRecipes =
session.QueryOver<Favorites>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.Menu == null)
.List();
}
if (recipesAdd.Any())
{
AddRecipesToMenu(identity, recipesAdd, databaseRecipes, databaseMenu, session);
menu.MenuUpdated = true;
}
if (recipesRemove.Any())
{
RemoveRecipesFromMenu(recipesRemove, databaseRecipes, session);
menu.MenuUpdated = true;
}
if (clear)
{
RemoveAllRecipesFromMenu(databaseRecipes, session);
menu.MenuUpdated = true;
}
if (recipesMove.Any())
{
MoveRecipesToAnotherMenu(identity, recipesMove, session, databaseRecipes);
menu.MenuUpdated = true;
}
transaction.Commit();
}
}
return menu;
}
public RecipeBrief[] GetRecipeQueue(AuthorIdentity identity)
{
using (var session = this.GetSession())
{
var databaseRecipes =
session.QueryOver<QueuedRecipes>()
.Fetch(prop => prop.Recipe)
.Eager.Where(p => p.UserId == identity.UserId)
.List();
return (from recipe in databaseRecipes select recipe.Recipe.AsRecipeBrief()).ToArray();
}
}
public void MoveMenuItem(AuthorIdentity identity, Guid recipeId, Menu fromMenu, Menu toMenu)
{
using (var session = this.GetSession())
{
using (var transaction = session.BeginTransaction())
{
if (!fromMenu.Id.HasValue || !toMenu.Id.HasValue)
{
throw new MenuIdRequiredException();
}
var favorite =
session.QueryOver<Favorites>()
.Where(p => p.Menu.MenuId == fromMenu.Id.Value)
.Where(p => p.Recipe.RecipeId == recipeId)
.SingleOrDefault();
if (favorite == null)
{
throw new RecipeNotFoundException();
}
var databaseToMenu = session.QueryOver<Menus>().Where(p => p.MenuId == toMenu.Id.Value).SingleOrDefault();
if (databaseToMenu == null)
{
throw new MenuNotFoundException();
}
favorite.Menu = databaseToMenu;
session.Update(favorite);
transaction.Commit();
}
}
}
private static void DeleteItems(AuthorIdentity identity, Guid? listId, Guid[] toRemove, ISession session)
{
var deletes =
session.QueryOver<ShoppingListItems>()
.Where(p => p.UserId == identity.UserId)
.Where(
listId.HasValue
? Restrictions.Eq("ShoppingList", listId.Value)
: Restrictions.IsNull("ShoppingList"))
.AndRestrictionOn(p => p.ItemId)
.IsInG(toRemove)
.List();
deletes.ForEach(session.Delete);
}
private static IList<ShoppingListItems> LoadItemsIntoLists(
AuthorIdentity identity,
bool defaultsLoaded,
IList<ShoppingLists> databaseLists,
ISession session)
{
ICriterion filter = defaultsLoaded
? Restrictions.Or(
Restrictions.IsNull("ShoppingList"),
Restrictions.InG("ShoppingList", databaseLists))
// Menu can be null, or in loaded menu list
: Restrictions.InG("ShoppingList", databaseLists); // Menu must be in loaded menu list
var databaseItems =
session.QueryOver<ShoppingListItems>()
.Fetch(prop => prop.Ingredient)
.Eager.Fetch(prop => prop.Recipe)
.Eager.Where(p => p.UserId == identity.UserId)
.Where(filter)
.List();
return databaseItems;
}
private static void CheckForUserAccess(AuthorIdentity identity, Menus databaseMenu)
{
if (databaseMenu.UserId != identity.UserId)
{
throw new UserDoesNotOwnMenuException();
}
}
private static List<Guid> CheckingForRecipeDuplicates(AuthorIdentity identity, Guid[] recipeIds, ISession session)
{
var recipes = (from r in recipeIds select new Recipes { RecipeId = r }).ToArray();
var dupes =
session.QueryOver<QueuedRecipes>()
.Where(p => p.UserId == identity.UserId)
.AndRestrictionOn(p => p.Recipe)
.IsInG(recipes)
.List<QueuedRecipes>();
var existing = (from r in dupes select r.Recipe.RecipeId).ToList();
return existing;
}
public MenuResult CreateMenu(AuthorIdentity identity, Menu menu, params Guid[] recipeIds)
{
using (var session = this.GetSession())
{
menu.Title = menu.Title.Trim();
var newMenu = new MenuResult();
using (var transaction = session.BeginTransaction())
{
Menus databaseMenu;
var duplicates =
session.QueryOver<Menus>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.Title == menu.Title)
.ToRowCountQuery()
.RowCount();
if (duplicates > 0)
{
throw new MenuAlreadyExistsException();
}
session.Save(
databaseMenu = new Menus { UserId = identity.UserId, Title = menu.Title, CreatedDate = DateTime.Now });
foreach (var recipeId in recipeIds.NeverNull())
{
var fav = new Favorites
{
UserId = identity.UserId,
Recipe = new Recipes { RecipeId = recipeId },
Menu = databaseMenu
};
session.Save(fav);
}
transaction.Commit();
newMenu.MenuCreated = true;
newMenu.NewMenuId = databaseMenu.MenuId;
}
return newMenu;
}
}
private static ShoppingListResult AddShopingListItems(
AuthorIdentity identity,
IShoppingListSource[] toAdd,
IList<ShoppingListItems> databaseItems,
ShoppingLists databaseList,
ISession session,
ITransaction transaction)
{
toAdd.ForEach(
item =>
{
var source = item.GetItem();
if (source.Ingredient == null && !string.IsNullOrWhiteSpace(source.Raw))
{
// Raw shopping list item
if (!databaseItems.Any(i => source.Raw.Equals(i.Raw, StringComparison.OrdinalIgnoreCase)))
{
// Add it
var newItem = new ShoppingListItems
{
ShoppingList = databaseList,
UserId = identity.UserId,
Raw = source.Raw
};
session.Save(newItem);
databaseItems.Add(newItem);
}
return;
}
if (source.Ingredient != null && source.Amount == null)
{
// Raw ingredient without any amount
var existingItem =
databaseItems.FirstOrDefault(
i => i.Ingredient != null && i.Ingredient.IngredientId == source.Ingredient.Id);
if (existingItem == null)
{
// Add it
var newItem = new ShoppingListItems
{
ShoppingList = databaseList,
UserId = identity.UserId,
Ingredient =
Ingredients.FromId(source.Ingredient.Id)
};
session.Save(newItem);
databaseItems.Add(newItem);
}
else
{
// Clear out existing amount
existingItem.Amount = null;
}
}
if (source.Ingredient != null && source.Amount != null)
{
// Ingredient with amount, aggregate if necessary
var existingItem =
databaseItems.FirstOrDefault(
i => i.Ingredient != null && i.Ingredient.IngredientId == source.Ingredient.Id);
if (existingItem == null)
{
// Add it
var newItem = new ShoppingListItems
{
ShoppingList = databaseList,
UserId = identity.UserId,
Ingredient =
Ingredients.FromId(source.Ingredient.Id),
Amount = source.Amount
};
session.Save(newItem);
databaseItems.Add(newItem);
}
else if (existingItem.Amount != null)
{
// Add to total
existingItem.Amount += source.Amount;
}
}
});
transaction.Commit();
return new ShoppingListResult
{
List =
new ShoppingList(
databaseList != null ? (Guid?)databaseList.ShoppingListId : null,
databaseList != null ? databaseList.Title : null,
databaseItems.Select(i => i.AsShoppingListItem()))
};
}
private static void AddRecipesToMenu(
AuthorIdentity identity,
Guid[] recipesAdd,
IList<Favorites> databaseRecipes,
Menus databaseMenu,
ISession session)
{
var existing = from r in databaseRecipes select r.Recipe.RecipeId;
recipesAdd = recipesAdd.Except(existing).ToArray(); // Remove duplicates
foreach (var recipeId in recipesAdd)
{
var fav = new Favorites
{
UserId = identity.UserId,
Recipe = new Recipes { RecipeId = recipeId },
Menu = databaseMenu
};
session.Save(fav);
}
}
public void EnqueueRecipes(AuthorIdentity identity, params Guid[] recipeIds)
{
using (var session = this.GetSession())
{
var existing = CheckingForRecipeDuplicates(identity, recipeIds, session);
using (var transaction = session.BeginTransaction())
{
var now = DateTime.Now;
foreach (var rid in recipeIds.Where(rid => !existing.Contains(rid)))
{
session.Save(
new QueuedRecipes
{
Recipe = new Recipes { RecipeId = rid },
UserId = identity.UserId,
QueuedDate = now
});
}
transaction.Commit();
}
}
}
private static IList<Favorites> LoadRecipesInEachMenu(
AuthorIdentity identity,
bool favouritesLoaded,
IList<Menus> databaseMenus,
ISession session)
{
ICriterion filter = favouritesLoaded
? Restrictions.Or(Restrictions.IsNull("Menu"), Restrictions.InG("Menu", databaseMenus))
// Menu can be null, or in loaded menu list
: Restrictions.InG("Menu", databaseMenus); // Menu must be in loaded menu list
var favorites =
session.QueryOver<Favorites>()
.Fetch(prop => prop.Recipe)
.Eager.Where(p => p.UserId == identity.UserId)
.Where(filter)
.List();
return favorites;
}
public Menu[] GetMenus(AuthorIdentity identity, IList<Menu> menus, GetMenuOptions options)
{
using (var session = this.GetSession())
{
// menus will be null if all menus should be loaded, or a list of Menu objects to specify individual menus to load
if (options == null)
{
throw new ArgumentNullException("There are no menu options.");
}
if (identity == null)
{
throw new ArgumentNullException("There are no identities.");
}
var favouritesLoaded = true;
var query = session.QueryOver<Menus>().Where(p => p.UserId == identity.UserId);
if (menus != null)
{
favouritesLoaded = menus.Contains(Menu.Favorites);
query = LoadIndividualMenus(menus, query);
}
var databaseMenus = query.List();
var favouriteMenus = new List<Menu>();
if (favouritesLoaded)
{
favouriteMenus.Add(Menu.Favorites);
}
favouriteMenus.AddRange(databaseMenus.Select(m => m.AsMenu()));
if (!options.LoadRecipes)
{
return favouriteMenus.ToArray();
}
var favorites = LoadRecipesInEachMenu(identity, favouritesLoaded, databaseMenus, session);
return
favouriteMenus.Select(
m =>
new Menu(m)
{
Recipes =
(m.Id.HasValue
? favorites.Where(f => f.Menu != null && f.Menu.MenuId == m.Id)
: favorites.Where(f => f.Menu == null)).Select(
r => r.Recipe.AsRecipeBrief()).ToArray()
}).ToArray();
}
}
private static void MoveRecipesToAnotherMenu(
AuthorIdentity identity,
MenuMove[] recipesMove,
ISession session,
IList<Favorites> databaseRecipes)
{
foreach (var moveAction in recipesMove)
{
Menus databaseTarget = null;
if (moveAction.TargetMenu.HasValue)
{
databaseTarget =
session.QueryOver<Menus>()
.Where(p => p.MenuId == moveAction.TargetMenu.Value)
.Where(p => p.UserId == identity.UserId)
.SingleOrDefault();
if (databaseTarget == null)
{
throw new MenuNotFoundException(moveAction.TargetMenu.Value);
}
}
var recipesToMove = moveAction.MoveAll
? databaseRecipes
: databaseRecipes.Where(r => moveAction.RecipesToMove.Contains(r.Recipe.RecipeId));
recipesToMove.ForEach(a => a.Menu = databaseTarget);
}
}
public ShoppingList[] GetShoppingLists(
AuthorIdentity identity,
IList<ShoppingList> lists,
GetShoppingListOptions options)
{
using (var session = this.GetSession())
{
var defaultsLoaded = true;
var query = session.QueryOver<ShoppingLists>().Where(p => p.UserId == identity.UserId);
defaultsLoaded = LoadIndividualLists(lists, defaultsLoaded, ref query);
var databaseLists = query.List();
var shopingList = new List<ShoppingList>();
if (defaultsLoaded)
{
shopingList.Add(ShoppingList.Default);
}
shopingList.AddRange(databaseLists.Select(l => l.AsShoppingList()));
if (!options.LoadItems)
{
return shopingList.ToArray();
}
var databaseItems = LoadItemsIntoLists(identity, defaultsLoaded, databaseLists, session);
return
shopingList.Select(
m =>
new ShoppingList(
m.Id,
m.Title,
(m.Id.HasValue
? databaseItems.Where(f => f.ShoppingList != null && f.ShoppingList.ShoppingListId == m.Id)
: databaseItems.Where(f => f.ShoppingList == null)).Select(r => r.AsShoppingListItem())))
.ToArray();
}
}
public RecipeResult CreateRecipe(AuthorIdentity identity, Recipe recipe)
{
using (var session = this.GetSession())
{
using (var transaction = session.BeginTransaction())
{
// Create Recipe
var databaseRecipe = new Recipes
{
Title = recipe.Title,
Description = recipe.Description,
CookTime = recipe.CookingTime,
PrepTime = recipe.PreparationTime,
Credit = recipe.Credit,
CreditUrl = recipe.CreditUrl,
DateEntered = recipe.DateEntered,
ImageUrl = recipe.ImageUrl,
Rating = recipe.AverageRating,
ServingSize = recipe.ServingSize,
Steps = recipe.Method
};
session.Save(databaseRecipe);
CreateIngredients(recipe, databaseRecipe, session);
var databaseMetadata = CreateRecipeMetadata(recipe, databaseRecipe);
session.Save(databaseMetadata);
transaction.Commit();
return new RecipeResult { RecipeCreated = true, NewRecipeId = databaseRecipe.RecipeId };
}
}
}
public void RateRecipe(AuthorIdentity identity, Guid recipeId, Rating rating)
{
using (var currentSession = this.GetSession())
{
using (var transaction = currentSession.BeginTransaction())
{
var existingRate =
currentSession.QueryOver<RecipeRatings>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.Recipe.RecipeId == recipeId)
.SingleOrDefault();
if (existingRate != null)
{
// Update existing
existingRate.Rating = (byte)rating;
currentSession.Update(existingRate);
}
else
{
// Create rating
currentSession.Save(
new RecipeRatings
{
UserId = identity.UserId,
Recipe = new Recipes { RecipeId = recipeId },
Rating = (byte)rating
});
}
transaction.Commit();
}
}
}
public ShoppingListResult CreateShoppingList(AuthorIdentity identity, ShoppingList list)
{
using (var session = this.GetSession())
{
var shopingList = new ShoppingListResult();
using (var transaction = session.BeginTransaction())
{
var databaseList = new ShoppingLists();
databaseList.Title = list.Title.Trim();
databaseList.UserId = identity.UserId;
session.Save(databaseList);
CreateShopingList(list, databaseList, session);
transaction.Commit();
shopingList.NewShoppingListId = databaseList.ShoppingListId;
}
shopingList.List = list;
return shopingList;
}
}
public SearchResults RecipeSearch(AuthorIdentity identity, RecipeQuery query)
{
if (this.SearchProvider == null)
{
throw new NoConfiguredSearchProvidersException();
}
return this.SearchProvider.Search(identity, query);
}
public void DeleteMenus(AuthorIdentity identity, params Guid[] menuIds)
{
using (var session = this.GetSession())
{
using (var transaction = session.BeginTransaction())
{
var databaseMenu =
session.QueryOver<Menus>()
.AndRestrictionOn(p => p.MenuId)
.IsInG(menuIds)
.Where(p => p.UserId == identity.UserId)
.Fetch(prop => prop.Recipes)
.Eager()
.List();
databaseMenu.ForEach(session.Delete);
transaction.Commit();
}
}
}
public ShoppingListResult UpdateShoppingList(
AuthorIdentity identity,
Guid? listId,
Guid[] toRemove,
ShoppingListModification[] toModify,
IShoppingListSource[] toAdd,
string newName = null)
{
using (var session = this.GetSession())
{
using (var transaction = session.BeginTransaction())
{
if (toRemove.Any())
{
DeleteItems(identity, listId, toRemove, session);
}
// Updates
ShoppingLists databaseList = null;
IList<ShoppingListItems> databaseItems = null;
if (listId.HasValue)
{
databaseList =
session.QueryOver<ShoppingLists>()
.Fetch(prop => prop.Items)
.Eager.Where(p => p.UserId == identity.UserId)
.Where(p => p.ShoppingListId == listId.Value)
.SingleOrDefault();
if (databaseList == null)
{
throw new ShoppingListNotFoundException();
}
if (!string.IsNullOrWhiteSpace(newName))
{
databaseList.Title = newName;
}
databaseItems = databaseList.Items;
}
else
{
databaseItems =
session.QueryOver<ShoppingListItems>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.ShoppingList == null)
.List();
}
ModifyShopingListItems(toModify, databaseItems);
return AddShopingListItems(identity, toAdd, databaseItems, databaseList, session, transaction);
}
}
}
public SearchResults Search(AuthorIdentity identity, RecipeQuery query)
{
using (var session = this.adapter.GetSession())
{
Recipes recipe = null;
var recipesQuery = session.QueryOver(() => recipe).Where(p => !p.Hidden);
if (!string.IsNullOrWhiteSpace(query.Keywords))
{
// Add keyword search
recipesQuery =
recipesQuery.Where(
Restrictions.Or(
Restrictions.InsensitiveLike(
"Title",
string.Format("%{0}%", query.Keywords.Trim())),
Restrictions.InsensitiveLike("Description", string.Format("%{0}%", query.Keywords.Trim()))));
}
if (query.Time.MaxPrep.HasValue)
{
recipesQuery = recipesQuery.Where(p => p.PrepTime <= query.Time.MaxPrep.Value);
}
if (query.Time.MaxCook.HasValue)
{
recipesQuery = recipesQuery.Where(p => p.CookTime <= query.Time.MaxCook.Value);
}
if (query.Rating > 0)
{
recipesQuery = recipesQuery.Where(p => p.Rating >= (int)query.Rating.Value);
}
recipesQuery = AddIngredientsToInclude(query, recipesQuery, recipe);
recipesQuery = AddIngredientsToExclude(query, recipesQuery, recipe);
if (query.Photos == PhotoFilter.Photo || query.Photos == PhotoFilter.HighRes)
{
recipesQuery = recipesQuery.Where(Restrictions.IsNotNull("ImageUrl"));
}
if (query.Diet || query.Nutrition || query.Skill || query.Taste || (query.Meal != MealFilter.All)
|| (query.Photos == PhotoFilter.HighRes))
{
// Need to search in metadata
RecipeMetadata metadata = null;
recipesQuery = recipesQuery.JoinAlias(r => r.RecipeMetadata, () => metadata);
recipesQuery = SearchByMeal(query, recipesQuery, metadata);
recipesQuery = SearchByHighResolutionPhotos(query, recipesQuery, metadata);
recipesQuery = SearchByDiet(query, recipesQuery, metadata);
recipesQuery = SearchByNutrition(query, recipesQuery, metadata);
recipesQuery = SearchBySkill(query, recipesQuery, metadata);
recipesQuery = SearchByTaste(query, recipesQuery, metadata);
}
IQueryOverOrderBuilder<Recipes, Recipes> orderBy;
switch (query.Sort)
{
case SortOrder.Title:
orderBy = recipesQuery.OrderBy(p => p.Title);
break;
case SortOrder.PrepTime:
orderBy = recipesQuery.OrderBy(p => p.PrepTime);
break;
case SortOrder.CookTime:
orderBy = recipesQuery.OrderBy(p => p.CookTime);
break;
case SortOrder.Image:
orderBy = recipesQuery.OrderBy(p => p.ImageUrl);
break;
default:
orderBy = recipesQuery.OrderBy(p => p.Rating);
break;
}
var results =
(query.Direction == SortDirection.Descending ? orderBy.Desc() : orderBy.Asc()).Skip(query.Offset)
.Take(100)
.List();
return new SearchResults
{
Briefs = results.Select(r => r.AsRecipeBrief()).ToArray(),
TotalCount = results.Count
// TODO: This needs to be the total matches, not the returned matches
};
}
}
