internal unsafe static extern int AcquireCredentialsHandleW(
[In] string principal,
[In] string moduleName,
[In] int usage,
[In] void *logonID,
[In] ref AuthIdentity authdata,
[In] void *keyCallback,
[In] void *keyArgument,
ref SSPIHandle handlePtr,
[Out] out long timeStamp
);
public RecipeBrief[] GetRecipeQueue(AuthIdentity identity)
{
using (var session = GetSession())
{
var dbRecipes = session.QueryOver <QueuedRecipes>()
.Fetch(prop => prop.Recipe).Eager
.Where(p => p.UserId == identity.UserId)
.List();
return((from r in dbRecipes select r.Recipe.AsRecipeBrief()).ToArray());
}
}
void SwitchToFacebookUserInternal()
{
_console.LogD(string.Format("Switching to FB user, token: {0}", AccessToken.CurrentAccessToken.TokenString));
GetSocial.User.SwitchUser(AuthIdentity.CreateFacebookIdentity(AccessToken.CurrentAccessToken.TokenString),
() =>
{
_console.LogD("Successfully switched to FB user");
demoController.FetchCurrentUserData();
SetFacebookUserDetails();
},
error => _console.LogE("Switching to FB user failed, reason: " + error));
}
public ShoppingList[] GetShoppingLists(AuthIdentity identity, IList <ShoppingList> lists, GetShoppingListOptions options)
{
using (var session = GetSession())
{
var loadDef = true;
var query = session.QueryOver <Models.ShoppingLists>()
.Where(p => p.UserId == identity.UserId);
if (lists != null) // Load individual lists
{
loadDef = lists.Contains(ShoppingList.Default);
var ids = lists.Where(l => l.Id.HasValue).Select(l => l.Id.Value).ToArray();
query = query.AndRestrictionOn(x => x.ShoppingListId).IsInG(ids);
}
var dbLists = query.List();
var ret = new List <ShoppingList>();
if (loadDef)
{
ret.Add(ShoppingList.Default);
}
ret.AddRange(dbLists.Select(l => l.AsShoppingList()));
if (!options.LoadItems) // We're done!
{
return(ret.ToArray());
}
// Load items into each list
ICriterion filter = (loadDef
? Expression.Or(Expression.IsNull("ShoppingList"), Expression.InG("ShoppingList", dbLists)) // Menu can be null, or in loaded menu list
: Expression.InG("ShoppingList", dbLists)); // Menu must be in loaded menu list
var dbItems = session.QueryOver <ShoppingListItems>()
.Fetch(prop => prop.Ingredient).Eager
.Fetch(prop => prop.Recipe).Eager
.Where(p => p.UserId == identity.UserId)
.Where(filter)
.List();
return(ret.Select(m =>
new ShoppingList(
m.Id,
m.Title,
(m.Id.HasValue
? dbItems.Where(f => f.ShoppingList != null && f.ShoppingList.ShoppingListId == m.Id)
: dbItems.Where(f => f.ShoppingList == null)).Select(r => r.AsShoppingListItem())
)).ToArray());
}
}
public MenuResult CreateMenu(AuthIdentity identity, Menu menu, params Guid[] recipeIds)
{
using (var session = GetSession())
{
menu.Title = menu.Title.Trim();
var ret = new MenuResult();
using (var transaction = session.BeginTransaction())
{
Models.Menus dbMenu;
var dupes = session.QueryOver <Models.Menus>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.Title == menu.Title)
.ToRowCountQuery()
.RowCount();
if (dupes > 0)
{
throw new MenuAlreadyExistsException();
}
session.Save(dbMenu = new Models.Menus
{
UserId = identity.UserId,
Title = menu.Title,
CreatedDate = DateTime.Now,
});
foreach (var rid in recipeIds.NeverNull())
{
var fav = new Favorites
{
UserId = identity.UserId,
Recipe = new Models.Recipes()
{
RecipeId = rid
},
Menu = dbMenu
};
session.Save(fav);
}
transaction.Commit();
ret.MenuCreated = true;
ret.NewMenuId = dbMenu.MenuId;
}
return(ret);
}
}
void AddCustomUserIdentity()
{
GetSocial.User.AddAuthIdentity(
AuthIdentity.CreateCustomIdentity(CustomProviderId, _customUserId, _customProviderToken),
() =>
{
_console.LogD("Successfully added custom identity");
demoController.FetchCurrentUserData();
},
error => _console.LogE(string.Format("Failed to add user identity '{0}', reason: {1}", CustomProviderId,
error)),
OnAddUserIdentityConflict);
}
void AddFacebookUserIdentityInternal()
{
_console.LogD(string.Format("Adding FB identity, token: {0}", AccessToken.CurrentAccessToken.TokenString));
GetSocial.User.AddAuthIdentity(AuthIdentity.CreateFacebookIdentity(AccessToken.CurrentAccessToken.TokenString),
() =>
{
_console.LogD("Successfully added Facebook Identity");
demoController.FetchCurrentUserData();
SetFacebookUserDetails();
},
error => _console.LogE("Adding Facebook identity failed, reason: " + error),
OnAddUserIdentityConflict);
}
private void OnGetSocialInitialized()
{
var user = FirebaseAuth.DefaultInstance.CurrentUser;
var token = Cyphering.GetHashByKey(Credentials.HASH_SECRET, user.UserId);
var authIdentity = AuthIdentity.CreateCustomIdentity(user.ProviderId, user.UserId, token);
GetSocial.User.AddAuthIdentity(authIdentity, SetGetSocialNameAndAvatar,
error => { Utils.ShowMessage("News Feed Login Failed"); },
conflict =>
{
GetSocial.User.SwitchUser(authIdentity,
SetGetSocialNameAndAvatar,
error => { Utils.ShowMessage("News Feed Login Failed"); });
});
}
public void DeleteMenus(AuthIdentity identity, params Guid[] menuIds)
{
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
var dbMenu = session.QueryOver <Models.Menus>()
.AndRestrictionOn(p => p.MenuId).IsInG(menuIds)
.Where(p => p.UserId == identity.UserId)
.Fetch(prop => prop.Recipes).Eager()
.List();
dbMenu.ForEach(session.Delete);
transaction.Commit();
}
}
}
public void DeleteShoppingLists(AuthIdentity identity, ShoppingList[] lists)
{
if (!lists.Any())
{
throw new ArgumentException("DeleteShoppingLists requires at least one list to delete.");
}
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
var dbLists = session.QueryOver <Models.ShoppingLists>()
.AndRestrictionOn(p => p.ShoppingListId).IsInG(lists.Where(l => l.Id.HasValue).Select(l => l.Id.Value))
.Where(p => p.UserId == identity.UserId)
.List();
dbLists.ForEach(session.Delete);
transaction.Commit();
}
}
}
public void DequeueRecipe(AuthIdentity identity, params Guid[] recipeIds)
{
using (var session = GetSession())
{
var recipes = (from r in recipeIds select new Models.Recipes {
RecipeId = r
}).ToArray();
var dbRecipes = session.QueryOver <QueuedRecipes>()
.Where(p => p.UserId == identity.UserId);
if (recipeIds.Any())
{
dbRecipes = dbRecipes.AndRestrictionOn(p => p.Recipe).IsInG(recipes);
}
using (var transaction = session.BeginTransaction())
{
dbRecipes.List().ForEach(session.Delete);
transaction.Commit();
}
}
}
public void MoveMenuItem(AuthIdentity identity, Guid recipeId, Menu fromMenu, Menu toMenu)
{
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
if (!fromMenu.Id.HasValue || !toMenu.Id.HasValue)
{
throw new MenuIdRequiredException();
}
var dbFavorite = session.QueryOver <Favorites>()
.Where(p => p.Menu.MenuId == fromMenu.Id.Value)
.Where(p => p.Recipe.RecipeId == recipeId)
.SingleOrDefault();
if (dbFavorite == null)
{
throw new RecipeNotFoundException();
}
var dbToMenu = session.QueryOver <Models.Menus>()
.Where(p => p.MenuId == toMenu.Id.Value)
.SingleOrDefault();
if (dbToMenu == null)
{
throw new MenuNotFoundException();
}
dbFavorite.Menu = dbToMenu;
session.Update(dbFavorite);
transaction.Commit();
}
}
}
public void EnqueueRecipes(AuthIdentity identity, params Guid[] recipeIds)
{
using (var session = GetSession())
{
// Check for dupes
var recipes = (from r in recipeIds select new Models.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();
// Enqueue each recipe
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 Models.Recipes {
RecipeId = rid
},
UserId = identity.UserId,
QueuedDate = now
});
}
transaction.Commit();
}
}
}
public void RateRecipe(AuthIdentity identity, Guid recipeId, Rating rating)
{
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
var existingRate = session.QueryOver<RecipeRatings>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.Recipe.RecipeId == recipeId)
.SingleOrDefault();
if (existingRate != null) // Update existing
{
existingRate.Rating = (byte) rating;
session.Update(existingRate);
}
else // Create rating
{
session.Save(new RecipeRatings
{
UserId = identity.UserId,
Recipe = new Models.Recipes {RecipeId = recipeId},
Rating = (byte) rating
});
}
transaction.Commit();
}
}
}
public void MoveMenuItem(AuthIdentity identity, Guid recipeId, Menu fromMenu, Menu toMenu)
{
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
if (!fromMenu.Id.HasValue || !toMenu.Id.HasValue)
throw new MenuIdRequiredException();
var dbFavorite = session.QueryOver<Favorites>()
.Where(p => p.Menu.MenuId == fromMenu.Id.Value)
.Where(p => p.Recipe.RecipeId == recipeId)
.SingleOrDefault();
if (dbFavorite == null)
throw new RecipeNotFoundException();
var dbToMenu = session.QueryOver<Models.Menus>()
.Where(p => p.MenuId == toMenu.Id.Value)
.SingleOrDefault();
if (dbToMenu == null)
throw new MenuNotFoundException();
dbFavorite.Menu = dbToMenu;
session.Update(dbFavorite);
transaction.Commit();
}
}
}
public ShoppingList[] GetShoppingLists(AuthIdentity identity, IList<ShoppingList> lists, GetShoppingListOptions options)
{
using (var session = GetSession())
{
var loadDef = true;
var query = session.QueryOver<Models.ShoppingLists>()
.Where(p => p.UserId == identity.UserId);
if (lists != null) // Load individual lists
{
loadDef = lists.Contains(ShoppingList.Default);
var ids = lists.Where(l => l.Id.HasValue).Select(l => l.Id.Value).ToArray();
query = query.AndRestrictionOn(x => x.ShoppingListId).IsInG(ids);
}
var dbLists = query.List();
var ret = new List<ShoppingList>();
if (loadDef)
ret.Add(ShoppingList.Default);
ret.AddRange(dbLists.Select(l => l.AsShoppingList()));
if (!options.LoadItems) // We're done!
return ret.ToArray();
// Load items into each list
ICriterion filter = (loadDef
? Expression.Or(Expression.IsNull("ShoppingList"), Expression.InG("ShoppingList", dbLists)) // Menu can be null, or in loaded menu list
: Expression.InG("ShoppingList", dbLists)); // Menu must be in loaded menu list
var dbItems = session.QueryOver<ShoppingListItems>()
.Fetch(prop => prop.Ingredient).Eager
.Fetch(prop => prop.Recipe).Eager
.Where(p => p.UserId == identity.UserId)
.Where(filter)
.List();
return ret.Select(m =>
new ShoppingList(
m.Id,
m.Title,
(m.Id.HasValue
? dbItems.Where(f => f.ShoppingList != null && f.ShoppingList.ShoppingListId == m.Id)
: dbItems.Where(f => f.ShoppingList == null)).Select(r => r.AsShoppingListItem())
)).ToArray();
}
}
public RecipeBrief[] GetRecipeQueue(AuthIdentity identity)
{
using (var session = GetSession())
{
var dbRecipes = session.QueryOver<QueuedRecipes>()
.Fetch(prop => prop.Recipe).Eager
.Where(p => p.UserId == identity.UserId)
.List();
return (from r in dbRecipes select r.Recipe.AsRecipeBrief()).ToArray();
}
}
public Menu[] GetMenus(AuthIdentity identity, IList<Menu> menus, GetMenuOptions options)
{
using (var session = 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("options");
if (identity == null) throw new ArgumentNullException("identity");
var loadFav = true;
var query = session.QueryOver<Models.Menus>()
.Where(p => p.UserId == identity.UserId);
if (menus != null) // Load individual menus
{
loadFav = menus.Contains(Menu.Favorites);
var ids = menus.Where(m => m.Id.HasValue).Select(m => m.Id.Value).ToArray();
query = query.AndRestrictionOn(p => p.MenuId).IsInG(ids);
}
var dbMenus = query.List();
var ret = new List<Menu>();
if (loadFav)
ret.Add(Menu.Favorites);
ret.AddRange(dbMenus.Select(m => m.AsMenu()));
if (!options.LoadRecipes) // We're done!
return ret.ToArray();
// Load recipes into each menu
ICriterion filter = (loadFav
? Expression.Or(Expression.IsNull("Menu"), Expression.InG("Menu", dbMenus)) // Menu can be null, or in loaded menu list
: Expression.InG("Menu", dbMenus)); // Menu must be in loaded menu list
var dbFavorites = session.QueryOver<Favorites>()
.Fetch(prop => prop.Recipe).Eager
.Where(p => p.UserId == identity.UserId)
.Where(filter)
.List();
return ret.Select(m =>
new Menu(m)
{
Recipes = (m.Id.HasValue
? dbFavorites.Where(f => f.Menu != null && f.Menu.MenuId == m.Id)
: dbFavorites.Where(f => f.Menu == null)
).Select(r => r.Recipe.AsRecipeBrief()).ToArray()
}).ToArray();
}
}
public ShoppingListResult UpdateShoppingList(AuthIdentity identity, Guid?listId, Guid[] toRemove, ShoppingListModification[] toModify, IShoppingListSource[] toAdd, string newName = null)
{
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
// Deletes
if (toRemove.Any())
{
var dbDeletes = session.QueryOver <ShoppingListItems>()
.Where(p => p.UserId == identity.UserId)
.Where(listId.HasValue
? Expression.Eq("ShoppingList", listId.Value)
: Expression.IsNull("ShoppingList")
).AndRestrictionOn(p => p.ItemId).IsInG(toRemove)
.List();
dbDeletes.ForEach(session.Delete);
}
// Updates
Models.ShoppingLists dbList = null;
IList <ShoppingListItems> dbItems = null;
if (listId.HasValue)
{
dbList = session.QueryOver <Models.ShoppingLists>()
.Fetch(prop => prop.Items).Eager
.Where(p => p.UserId == identity.UserId)
.Where(p => p.ShoppingListId == listId.Value)
.SingleOrDefault();
if (dbList == null)
{
throw new ShoppingListNotFoundException();
}
if (!String.IsNullOrWhiteSpace(newName))
{
dbList.Title = newName;
}
dbItems = dbList.Items;
}
else
{
dbItems = session.QueryOver <ShoppingListItems>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.ShoppingList == null)
.List();
}
toModify.ForEach(item =>
{
var dbItem = dbItems.FirstOrDefault(i => i.ItemId == item.ModifiedItemId);
if (dbItem == null)
{
return;
}
if (item.CrossOut.HasValue)
{
dbItem.CrossedOut = item.CrossOut.Value;
}
if (item.NewAmount != null)
{
dbItem.Amount = item.NewAmount;
}
});
toAdd.ForEach(item =>
{
var source = item.GetItem();
if (source.Ingredient == null && !String.IsNullOrWhiteSpace(source.Raw)) // Raw shopping list item
{
if (!dbItems.Any(i => source.Raw.Equals(i.Raw, StringComparison.OrdinalIgnoreCase))) // Add it
{
var newItem = new ShoppingListItems
{
ShoppingList = dbList,
UserId = identity.UserId,
Raw = source.Raw
};
session.Save(newItem);
dbItems.Add(newItem);
}
return;
}
if (source.Ingredient != null && source.Amount == null) // Raw ingredient without any amount
{
var existingItem = dbItems.FirstOrDefault(i => i.Ingredient != null && i.Ingredient.IngredientId == source.Ingredient.Id);
if (existingItem == null) // Add it
{
var newItem = new ShoppingListItems
{
ShoppingList = dbList,
UserId = identity.UserId,
Ingredient = Models.Ingredients.FromId(source.Ingredient.Id)
};
session.Save(newItem);
dbItems.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 = dbItems.FirstOrDefault(i => i.Ingredient != null && i.Ingredient.IngredientId == source.Ingredient.Id);
if (existingItem == null) // Add it
{
var newItem = new ShoppingListItems
{
ShoppingList = dbList,
UserId = identity.UserId,
Ingredient = Models.Ingredients.FromId(source.Ingredient.Id),
Amount = source.Amount
};
session.Save(newItem);
dbItems.Add(newItem);
}
else if (existingItem.Amount != null) // Add to total
{
existingItem.Amount += source.Amount;
}
}
});
transaction.Commit();
return(new ShoppingListResult
{
List = new ShoppingList(
dbList != null ? (Guid?)dbList.ShoppingListId : null,
dbList != null ? dbList.Title : null,
dbItems.Select(i => i.AsShoppingListItem()))
});
}
}
}
public MenuResult UpdateMenu(AuthIdentity identity, Guid? menuId, Guid[] recipesAdd, Guid[] recipesRemove, MenuMove[] recipesMove, bool clear, string newName = null)
{
var ret = new MenuResult();
ret.MenuUpdated = true; // TODO: Verify actual changes were made before setting MenuUpdated to true
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
Models.Menus dbMenu = null;
IList<Favorites> dbRecipes = null;
if (menuId.HasValue)
{
dbMenu = session.QueryOver<Models.Menus>()
.Fetch(prop => prop.Recipes).Eager
.Where(p => p.MenuId == menuId)
.SingleOrDefault();
if (dbMenu == null)
throw new MenuNotFoundException();
if (dbMenu.UserId != identity.UserId) // User does not have access to modify this menu
throw new UserDoesNotOwnMenuException();
if (!String.IsNullOrWhiteSpace(newName) && dbMenu != null) // Rename menu
dbMenu.Title = newName.Trim();
dbRecipes = dbMenu.Recipes;
}
else
{
dbRecipes = session.QueryOver<Favorites>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.Menu == null)
.List();
}
if (recipesAdd.Any()) // Add recipes to menu
{
var existing = (from r in dbRecipes select r.Recipe.RecipeId);
recipesAdd = recipesAdd.Except(existing).ToArray(); //Remove dupes
foreach (var rid in recipesAdd)
{
var fav = new Favorites
{
UserId = identity.UserId,
Recipe = new Models.Recipes() {RecipeId = rid},
Menu = dbMenu
};
session.Save(fav);
}
}
if (recipesRemove.Any()) // Remove recipes from menu
{
var toDelete = (from r in dbRecipes where recipesRemove.Contains(r.Recipe.RecipeId) select r);
toDelete.ForEach(session.Delete);
}
if (clear) // Remove every recipe from menu
{
dbRecipes.ForEach(session.Delete);
}
if (recipesMove.Any()) // Move items to another menu
{
foreach (var moveAction in recipesMove)
{
Models.Menus dbTarget = null;
if (moveAction.TargetMenu.HasValue)
{
dbTarget = session.QueryOver<Models.Menus>()
.Where(p => p.MenuId == moveAction.TargetMenu.Value)
.Where(p => p.UserId == identity.UserId)
.SingleOrDefault();
if (dbTarget == null)
throw new MenuNotFoundException(moveAction.TargetMenu.Value);
}
var rToMove = (moveAction.MoveAll
? dbRecipes
: dbRecipes.Where(r => moveAction.RecipesToMove.Contains(r.Recipe.RecipeId)));
rToMove.ForEach(a => a.Menu = dbTarget);
}
}
transaction.Commit();
}
}
return ret;
}
public SearchResults Search(AuthIdentity 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.PreparationTime <= 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);
}
// Need to search in metadata
if (query.Diet ||
query.Nutrition ||
query.Skill ||
query.Taste ||
query.Meal != MealFilter.All ||
query.Photos == PhotoFilter.HighRes)
{
// Meal
if (query.Meal != MealFilter.All)
{
switch (query.Meal)
{
case MealFilter.Breakfast:
q = q.Where(p => p.Metadata.MealBreakfast);
break;
case MealFilter.Lunch:
q = q.Where(p => p.Metadata.MealLunch);
break;
case MealFilter.Dinner:
q = q.Where(p => p.Metadata.MealDinner);
break;
case MealFilter.Dessert:
q = q.Where(p => p.Metadata.MealDessert);
break;
default:
break;
}
}
// High-resolution photos
if (query.Photos == PhotoFilter.HighRes)
{
q = q.Where(p => p.Metadata.PhotoResolution >= 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.SkillCommonIngredients).OrderByDescending(p => p.Metadata.Commonality);
}
if (query.Skill.Easy)
{
q = q.Where(p => p.Metadata.SkillEasyToMake);
}
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.PreparationTime) : q.OrderByDescending(p => p.Recipe.PreparationTime);
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 => Data.DTO.Recipes.ToRecipeBrief(r.Recipe)).ToArray(),
TotalCount = q.Count()
};
}
public ShoppingListResult CreateShoppingList(AuthIdentity identity, ShoppingList list)
{
using (var session = GetSession())
{
var ret = new ShoppingListResult();
using (var transaction = session.BeginTransaction())
{
var dbList = new Models.ShoppingLists();
dbList.Title = list.Title.Trim();
dbList.UserId = identity.UserId;
session.Save(dbList);
if (list.Any()) // Create ShoppingListItems
{
list.ToList().ForEach(i =>
{
var dbItem = ShoppingListItems.FromShoppingListItem(i);
dbItem.ShoppingList = dbList;
dbItem.UserId = dbList.UserId;
session.Save(dbItem);
});
}
transaction.Commit();
ret.NewShoppingListId = dbList.ShoppingListId;
}
ret.List = list;
return ret;
}
}
public RecipeResult CreateRecipe(AuthIdentity identity, Recipe recipe)
{
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
// Create Recipe
var dbRecipe = new Models.Recipes
{
Title = recipe.Title,
Description = recipe.Description,
CookTime = recipe.CookTime,
PrepTime = recipe.PrepTime,
Credit = recipe.Credit,
CreditUrl = recipe.CreditUrl,
DateEntered = recipe.DateEntered,
ImageUrl = recipe.ImageUrl,
Rating = recipe.AvgRating,
ServingSize = recipe.ServingSize,
Steps = recipe.Method
};
session.Save(dbRecipe);
// Create Ingredients
short displayOrder = 0;
recipe.Ingredients.ForEach(i =>
{
var dbIngredient = new RecipeIngredients
{
Recipe = dbRecipe,
Ingredient = Models.Ingredients.FromId(i.Ingredient.Id),
IngredientForm = (i.Form != null ? IngredientForms.FromId(i.Form.FormId) : null),
Qty = (i.Amount != null ? (float?) i.Amount.SizeHigh : null),
QtyLow = (i.Amount != null ? (float?) i.Amount.SizeLow : null),
Unit = (i.Amount != null ? i.Amount.Unit : Units.Unit),
Section = i.Section,
DisplayOrder = ++displayOrder
};
session.Save(dbIngredient);
});
// Create RecipeMetadata
var dbMetadata = new RecipeMetadata
{
Recipe = dbRecipe,
DietGlutenFree = recipe.Tags.HasTag(RecipeTag.GlutenFree),
DietNoAnimals = recipe.Tags.HasTag(RecipeTag.NoAnimals),
DietNomeat = recipe.Tags.HasTag(RecipeTag.NoMeat),
DietNoPork = recipe.Tags.HasTag(RecipeTag.NoPork),
DietNoRedMeat = recipe.Tags.HasTag(RecipeTag.NoRedMeat),
MealBreakfast = recipe.Tags.HasTag(RecipeTag.Breakfast),
MealDessert = recipe.Tags.HasTag(RecipeTag.Dessert),
MealDinner = recipe.Tags.HasTag(RecipeTag.Dinner),
MealLunch = recipe.Tags.HasTag(RecipeTag.Lunch),
NutritionLowCalorie = recipe.Tags.HasTag(RecipeTag.LowCalorie),
NutritionLowCarb = recipe.Tags.HasTag(RecipeTag.LowCarb),
NutritionLowFat = recipe.Tags.HasTag(RecipeTag.LowFat),
NutritionLowSodium = recipe.Tags.HasTag(RecipeTag.LowSodium),
NutritionLowSugar = recipe.Tags.HasTag(RecipeTag.LowSugar),
SkillCommon = recipe.Tags.HasTag(RecipeTag.Common),
SkillEasy = recipe.Tags.HasTag(RecipeTag.Easy),
SkillQuick = recipe.Tags.HasTag(RecipeTag.Quick)
};
session.Save(dbMetadata);
transaction.Commit();
return new RecipeResult
{
RecipeCreated = true,
NewRecipeId = dbRecipe.RecipeId
};
}
}
}
public MenuResult CreateMenu(AuthIdentity identity, Menu menu, params Guid[] recipeIds)
{
using (var session = GetSession())
{
menu.Title = menu.Title.Trim();
var ret = new MenuResult();
using (var transaction = session.BeginTransaction())
{
Models.Menus dbMenu;
var dupes = session.QueryOver<Models.Menus>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.Title == menu.Title)
.ToRowCountQuery()
.RowCount();
if (dupes > 0)
{
throw new MenuAlreadyExistsException();
}
session.Save(dbMenu = new Models.Menus
{
UserId = identity.UserId,
Title = menu.Title,
CreatedDate = DateTime.Now,
});
foreach (var rid in recipeIds.NeverNull())
{
var fav = new Favorites
{
UserId = identity.UserId,
Recipe = new Models.Recipes() {RecipeId = rid},
Menu = dbMenu
};
session.Save(fav);
}
transaction.Commit();
ret.MenuCreated = true;
ret.NewMenuId = dbMenu.MenuId;
}
return ret;
}
}
public ShoppingListResult UpdateShoppingList(AuthIdentity identity, Guid? listId, Guid[] toRemove, ShoppingListModification[] toModify, IShoppingListSource[] toAdd, string newName = null)
{
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
// Deletes
if (toRemove.Any())
{
var dbDeletes = session.QueryOver<ShoppingListItems>()
.Where(p => p.UserId == identity.UserId)
.Where(listId.HasValue
? Expression.Eq("ShoppingList", listId.Value)
: Expression.IsNull("ShoppingList")
).AndRestrictionOn(p => p.ItemId).IsInG(toRemove)
.List();
dbDeletes.ForEach(session.Delete);
}
// Updates
Models.ShoppingLists dbList = null;
IList<ShoppingListItems> dbItems = null;
if (listId.HasValue)
{
dbList = session.QueryOver<Models.ShoppingLists>()
.Fetch(prop => prop.Items).Eager
.Where(p => p.UserId == identity.UserId)
.Where(p => p.ShoppingListId == listId.Value)
.SingleOrDefault();
if (dbList == null)
throw new ShoppingListNotFoundException();
if (!String.IsNullOrWhiteSpace(newName))
dbList.Title = newName;
dbItems = dbList.Items;
}
else
{
dbItems = session.QueryOver<ShoppingListItems>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.ShoppingList == null)
.List();
}
toModify.ForEach(item =>
{
var dbItem = dbItems.FirstOrDefault(i => i.ItemId == item.ModifiedItemId);
if (dbItem == null) return;
if (item.CrossOut.HasValue) dbItem.CrossedOut = item.CrossOut.Value;
if (item.NewAmount != null) dbItem.Amount = item.NewAmount;
});
toAdd.ForEach(item =>
{
var source = item.GetItem();
if (source.Ingredient == null && !String.IsNullOrWhiteSpace(source.Raw)) // Raw shopping list item
{
if (!dbItems.Any(i => source.Raw.Equals(i.Raw, StringComparison.OrdinalIgnoreCase))) // Add it
{
var newItem = new ShoppingListItems
{
ShoppingList = dbList,
UserId = identity.UserId,
Raw = source.Raw
};
session.Save(newItem);
dbItems.Add(newItem);
}
return;
}
if (source.Ingredient != null && source.Amount == null) // Raw ingredient without any amount
{
var existingItem = dbItems.FirstOrDefault(i => i.Ingredient != null && i.Ingredient.IngredientId == source.Ingredient.Id);
if (existingItem == null) // Add it
{
var newItem = new ShoppingListItems
{
ShoppingList = dbList,
UserId = identity.UserId,
Ingredient = Models.Ingredients.FromId(source.Ingredient.Id)
};
session.Save(newItem);
dbItems.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 = dbItems.FirstOrDefault(i => i.Ingredient != null && i.Ingredient.IngredientId == source.Ingredient.Id);
if (existingItem == null) // Add it
{
var newItem = new ShoppingListItems
{
ShoppingList = dbList,
UserId = identity.UserId,
Ingredient = Models.Ingredients.FromId(source.Ingredient.Id),
Amount = source.Amount
};
session.Save(newItem);
dbItems.Add(newItem);
}
else if (existingItem.Amount != null) // Add to total
{
existingItem.Amount += source.Amount;
}
}
});
transaction.Commit();
return new ShoppingListResult
{
List = new ShoppingList(
dbList != null ? (Guid?) dbList.ShoppingListId : null,
dbList != null ? dbList.Title : null,
dbItems.Select(i => i.AsShoppingListItem()))
};
}
}
}
public void MoveMenuItem(AuthIdentity 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 favorites = session.QueryOver<Favorites>()
.Where(p => p.Menu.MenuId == fromMenu.Id.Value)
.Where(p => p.Recipe.RecipeId == recipeId)
.SingleOrDefault();
if (favorites == null)
{
throw new RecipeNotFoundException();
}
var menus = session.QueryOver<Menus>()
.Where(p => p.MenuId == toMenu.Id.Value)
.SingleOrDefault();
if (menus == null)
{
throw new MenuNotFoundException();
}
favorites.Menu = menus;
session.Update(favorites);
transaction.Commit();
}
}
}
public Recipe[] ReadRecipes(AuthIdentity identity, Guid[] recipeIds, ReadRecipeOptions options)
{
using (var session = GetSession())
{
var dbRecipes = session.QueryOver<Models.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 (!dbRecipes.Any())
throw new RecipeNotFoundException();
var ret = new List<Recipe>();
foreach (var dbRecipe in dbRecipes)
{
var recipe = new Recipe
{
Id = dbRecipe.RecipeId,
Title = dbRecipe.Title,
Description = dbRecipe.Description,
DateEntered = dbRecipe.DateEntered,
ImageUrl = dbRecipe.ImageUrl,
ServingSize = dbRecipe.ServingSize,
PrepTime = dbRecipe.PrepTime,
CookTime = dbRecipe.CookTime,
Credit = dbRecipe.Credit,
CreditUrl = dbRecipe.CreditUrl,
AvgRating = dbRecipe.Rating
};
if (options.ReturnMethod)
recipe.Method = dbRecipe.Steps;
if (options.ReturnUserRating) // TODO: We should JOIN this on the dbRecipes for faster loading
{
var id = dbRecipe.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 = dbRecipe.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 = dbRecipe.RecipeMetadata.Tags;
ret.Add(recipe);
}
return ret.ToArray();
}
}
public SearchResults RecipeSearch(AuthIdentity identity, RecipeQuery query)
{
if (SearchProvider == null)
throw new NoConfiguredSearchProvidersException();
return SearchProvider.Search(identity, query);
}
public SearchResults Search(AuthIdentity identity, RecipeQuery query)
{
var index = store.GetSearchIndex();
var q = index.Where(p => !p.Recipe.Hidden);
if (!String.IsNullOrWhiteSpace(query.Keywords))
{
q = q.Where(p =>
(p.Recipe.Title ?? "").IndexOf(query.Keywords, StringComparison.OrdinalIgnoreCase) >= 0 ||
(p.Recipe.Description ?? "").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);
}
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)) //Need to search in metadata
{
//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 => Data.DTO.Recipes.ToRecipeBrief(r.Recipe)).ToArray(),
TotalCount = q.Count()
});
}
public SearchResults Search(AuthIdentity identity, RecipeQuery query)
{
using (var session = this.adapter.GetSession())
{
Recipes recipe = null;
var q = session.QueryOver<Recipes>(() => recipe)
.Where(p => !p.Hidden);
// Add keyword search
if (!string.IsNullOrWhiteSpace(query.Keywords))
{
q = q.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)
{
q = q.Where(p => p.PrepTime <= query.Time.MaxPrep.Value);
}
if (query.Time.MaxCook.HasValue)
{
q = q.Where(p => p.CookTime <= query.Time.MaxCook.Value);
}
if (query.Rating > 0)
{
q = q.Where(p => p.Rating >= (int)query.Rating);
}
// Add ingredients to include
if (query.Include != null && query.Include.Length > 0)
{
// Create a sub-query for ingredients to include
q = q.WithSubquery
.WhereExists(QueryOver.Of<RecipeIngredients>()
.Where(item => item.Recipe.RecipeId == recipe.RecipeId)
.Where(Restrictions.InG("Ingredient", query.Include.Select(Models.Ingredients.FromId).ToArray()))
.Select(i => i.RecipeIngredientId).Take(1));
}
// Add ingredients to exclude
if (query.Exclude != null && query.Exclude.Length > 0)
{
// Create a sub-query for ingredients to exclude
q = q.WithSubquery
.WhereNotExists(QueryOver.Of<RecipeIngredients>()
.Where(item => item.Recipe.RecipeId == recipe.RecipeId)
.Where(Restrictions.InG("Ingredient", query.Exclude.Select(Models.Ingredients.FromId).ToArray()))
.Select(i => i.RecipeIngredientId).Take(1));
}
if (query.Photos == PhotoFilter.Photo || query.Photos == PhotoFilter.HighRes)
{
q = q.Where(Restrictions.IsNotNull("ImageUrl"));
}
// Need to search in metadata
if (query.Diet || query.Nutrition || query.Skill || query.Taste || (query.Meal != MealFilter.All) || (query.Photos == PhotoFilter.HighRes))
{
RecipeMetadata metadata = null;
q = q.JoinAlias(r => r.RecipeMetadata, () => metadata);
// Meal
if (query.Meal != MealFilter.All)
{
if (query.Meal == MealFilter.Breakfast)
{
q = q.Where(() => metadata.MealBreakfast);
}
if (query.Meal == MealFilter.Dessert)
{
q = q.Where(() => metadata.MealDessert);
}
if (query.Meal == MealFilter.Dinner)
{
q = q.Where(() => metadata.MealDinner);
}
if (query.Meal == MealFilter.Lunch)
{
q = q.Where(() => metadata.MealLunch);
}
}
// High-res photos
if (query.Photos == PhotoFilter.HighRes)
{
q = q.Where(() => metadata.PhotoRes >= 1024 * 768);
}
// Diet
if (query.Diet.GlutenFree)
{
q = q.Where(() => metadata.DietGlutenFree);
}
if (query.Diet.NoAnimals)
{
q = q.Where(() => metadata.DietNoAnimals);
}
if (query.Diet.NoMeat)
{
q = q.Where(() => metadata.DietNomeat);
}
if (query.Diet.NoPork)
{
q = q.Where(() => metadata.DietNoPork);
}
if (query.Diet.NoRedMeat)
{
q = q.Where(() => metadata.DietNoRedMeat);
}
// Nutrition
if (query.Nutrition.LowCalorie)
{
q = q.Where(() => metadata.NutritionLowCalorie);
}
if (query.Nutrition.LowCarb)
{
q = q.Where(() => metadata.NutritionLowCarb);
}
if (query.Nutrition.LowFat)
{
q = q.Where(() => metadata.NutritionLowFat);
}
if (query.Nutrition.LowSodium)
{
q = q.Where(() => metadata.NutritionLowSodium);
}
if (query.Nutrition.LowSugar)
{
q = q.Where(() => metadata.NutritionLowSugar);
}
// Skill
if (query.Skill.Common)
{
q = q.Where(() => metadata.SkillCommon).OrderBy(() => metadata.Commonality).Desc();
}
if (query.Skill.Easy)
{
q = q.Where(() => metadata.SkillEasy);
}
if (query.Skill.Quick)
{
q = q.Where(() => metadata.SkillQuick);
}
// Taste
if (query.Taste.MildToSpicy != SpicinessLevel.Medium)
{
q = query.Taste.MildToSpicy < SpicinessLevel.Medium
? q.Where(() => metadata.TasteMildToSpicy <= query.Taste.Spiciness).OrderBy(() => metadata.TasteMildToSpicy).Asc()
: q.Where(() => metadata.TasteMildToSpicy >= query.Taste.Spiciness).OrderBy(() => metadata.TasteMildToSpicy).Desc();
}
if (query.Taste.SavoryToSweet != SweetnessLevel.Medium)
{
q = query.Taste.SavoryToSweet < SweetnessLevel.Medium
? q.Where(() => metadata.TasteSavoryToSweet <= query.Taste.Sweetness).OrderBy(() => metadata.TasteSavoryToSweet).Asc()
: q.Where(() => metadata.TasteSavoryToSweet >= query.Taste.Sweetness).OrderBy(() => metadata.TasteSavoryToSweet).Desc();
}
}
IQueryOverOrderBuilder<Recipes, Recipes> orderBy;
switch (query.Sort)
{
case SortOrder.Title:
orderBy = q.OrderBy(p => p.Title);
break;
case SortOrder.PrepTime:
orderBy = q.OrderBy(p => p.PrepTime);
break;
case SortOrder.CookTime:
orderBy = q.OrderBy(p => p.CookTime);
break;
case SortOrder.Image:
orderBy = q.OrderBy(p => p.ImageUrl);
break;
default:
orderBy = q.OrderBy(p => p.Rating);
break;
}
var results = (query.Direction == SortDirection.Descending ? orderBy.Desc() : orderBy.Asc())
.Skip(query.Offset)
.List();
return new SearchResults
{
Briefs = results.Select(r => r.AsRecipeBrief()).ToArray(),
TotalCount = results.Count
};
}
}
public MenuResult UpdateMenu(AuthIdentity identity, Guid?menuId, Guid[] recipesAdd, Guid[] recipesRemove, MenuMove[] recipesMove, bool clear, string newName = null)
{
var ret = new MenuResult();
ret.MenuUpdated = true; // TODO: Verify actual changes were made before setting MenuUpdated to true
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
Models.Menus dbMenu = null;
IList <Favorites> dbRecipes = null;
if (menuId.HasValue)
{
dbMenu = session.QueryOver <Models.Menus>()
.Fetch(prop => prop.Recipes).Eager
.Where(p => p.MenuId == menuId)
.SingleOrDefault();
if (dbMenu == null)
{
throw new MenuNotFoundException();
}
if (dbMenu.UserId != identity.UserId) // User does not have access to modify this menu
{
throw new UserDoesNotOwnMenuException();
}
if (!String.IsNullOrWhiteSpace(newName) && dbMenu != null) // Rename menu
{
dbMenu.Title = newName.Trim();
}
dbRecipes = dbMenu.Recipes;
}
else
{
dbRecipes = session.QueryOver <Favorites>()
.Where(p => p.UserId == identity.UserId)
.Where(p => p.Menu == null)
.List();
}
if (recipesAdd.Any()) // Add recipes to menu
{
var existing = (from r in dbRecipes select r.Recipe.RecipeId);
recipesAdd = recipesAdd.Except(existing).ToArray(); //Remove dupes
foreach (var rid in recipesAdd)
{
var fav = new Favorites
{
UserId = identity.UserId,
Recipe = new Models.Recipes()
{
RecipeId = rid
},
Menu = dbMenu
};
session.Save(fav);
}
}
if (recipesRemove.Any()) // Remove recipes from menu
{
var toDelete = (from r in dbRecipes where recipesRemove.Contains(r.Recipe.RecipeId) select r);
toDelete.ForEach(session.Delete);
}
if (clear) // Remove every recipe from menu
{
dbRecipes.ForEach(session.Delete);
}
if (recipesMove.Any()) // Move items to another menu
{
foreach (var moveAction in recipesMove)
{
Models.Menus dbTarget = null;
if (moveAction.TargetMenu.HasValue)
{
dbTarget = session.QueryOver <Models.Menus>()
.Where(p => p.MenuId == moveAction.TargetMenu.Value)
.Where(p => p.UserId == identity.UserId)
.SingleOrDefault();
if (dbTarget == null)
{
throw new MenuNotFoundException(moveAction.TargetMenu.Value);
}
}
var rToMove = (moveAction.MoveAll
? dbRecipes
: dbRecipes.Where(r => moveAction.RecipesToMove.Contains(r.Recipe.RecipeId)));
rToMove.ForEach(a => a.Menu = dbTarget);
}
}
transaction.Commit();
}
}
return(ret);
}
public SearchResults Search(AuthIdentity identity, RecipeQuery query)
{
using (var session = this.adapter.GetSession())
{
Recipes recipe = null;
var q = session.QueryOver <Recipes>(() => recipe)
.Where(p => !p.Hidden);
// Add keyword search
if (!string.IsNullOrWhiteSpace(query.Keywords))
{
q = q.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)
{
q = q.Where(p => p.PrepTime <= query.Time.MaxPrep.Value);
}
if (query.Time.MaxCook.HasValue)
{
q = q.Where(p => p.CookTime <= query.Time.MaxCook.Value);
}
if (query.Rating > 0)
{
q = q.Where(p => p.Rating >= (int)query.Rating);
}
// Add ingredients to include
if (query.Include != null && query.Include.Length > 0)
{
// Create a sub-query for ingredients to include
q = q.WithSubquery
.WhereExists(QueryOver.Of <RecipeIngredients>()
.Where(item => item.Recipe.RecipeId == recipe.RecipeId)
.Where(Restrictions.InG("Ingredient", query.Include.Select(Models.Ingredients.FromId).ToArray()))
.Select(i => i.RecipeIngredientId).Take(1));
}
// Add ingredients to exclude
if (query.Exclude != null && query.Exclude.Length > 0)
{
// Create a sub-query for ingredients to exclude
q = q.WithSubquery
.WhereNotExists(QueryOver.Of <RecipeIngredients>()
.Where(item => item.Recipe.RecipeId == recipe.RecipeId)
.Where(Restrictions.InG("Ingredient", query.Exclude.Select(Models.Ingredients.FromId).ToArray()))
.Select(i => i.RecipeIngredientId).Take(1));
}
if (query.Photos == PhotoFilter.Photo || query.Photos == PhotoFilter.HighRes)
{
q = q.Where(Restrictions.IsNotNull("ImageUrl"));
}
// Need to search in metadata
if (query.Diet || query.Nutrition || query.Skill || query.Taste || (query.Meal != MealFilter.All) || (query.Photos == PhotoFilter.HighRes))
{
RecipeMetadata metadata = null;
q = q.JoinAlias(r => r.RecipeMetadata, () => metadata);
// Meal
if (query.Meal != MealFilter.All)
{
if (query.Meal == MealFilter.Breakfast)
{
q = q.Where(() => metadata.MealBreakfast);
}
if (query.Meal == MealFilter.Dessert)
{
q = q.Where(() => metadata.MealDessert);
}
if (query.Meal == MealFilter.Dinner)
{
q = q.Where(() => metadata.MealDinner);
}
if (query.Meal == MealFilter.Lunch)
{
q = q.Where(() => metadata.MealLunch);
}
}
// High-res photos
if (query.Photos == PhotoFilter.HighRes)
{
q = q.Where(() => metadata.PhotoRes >= 1024 * 768);
}
// Diet
if (query.Diet.GlutenFree)
{
q = q.Where(() => metadata.DietGlutenFree);
}
if (query.Diet.NoAnimals)
{
q = q.Where(() => metadata.DietNoAnimals);
}
if (query.Diet.NoMeat)
{
q = q.Where(() => metadata.DietNomeat);
}
if (query.Diet.NoPork)
{
q = q.Where(() => metadata.DietNoPork);
}
if (query.Diet.NoRedMeat)
{
q = q.Where(() => metadata.DietNoRedMeat);
}
// Nutrition
if (query.Nutrition.LowCalorie)
{
q = q.Where(() => metadata.NutritionLowCalorie);
}
if (query.Nutrition.LowCarb)
{
q = q.Where(() => metadata.NutritionLowCarb);
}
if (query.Nutrition.LowFat)
{
q = q.Where(() => metadata.NutritionLowFat);
}
if (query.Nutrition.LowSodium)
{
q = q.Where(() => metadata.NutritionLowSodium);
}
if (query.Nutrition.LowSugar)
{
q = q.Where(() => metadata.NutritionLowSugar);
}
// Skill
if (query.Skill.Common)
{
q = q.Where(() => metadata.SkillCommon).OrderBy(() => metadata.Commonality).Desc();
}
if (query.Skill.Easy)
{
q = q.Where(() => metadata.SkillEasy);
}
if (query.Skill.Quick)
{
q = q.Where(() => metadata.SkillQuick);
}
// Taste
if (query.Taste.MildToSpicy != SpicinessLevel.Medium)
{
q = query.Taste.MildToSpicy < SpicinessLevel.Medium
? q.Where(() => metadata.TasteMildToSpicy <= query.Taste.Spiciness).OrderBy(() => metadata.TasteMildToSpicy).Asc()
: q.Where(() => metadata.TasteMildToSpicy >= query.Taste.Spiciness).OrderBy(() => metadata.TasteMildToSpicy).Desc();
}
if (query.Taste.SavoryToSweet != SweetnessLevel.Medium)
{
q = query.Taste.SavoryToSweet < SweetnessLevel.Medium
? q.Where(() => metadata.TasteSavoryToSweet <= query.Taste.Sweetness).OrderBy(() => metadata.TasteSavoryToSweet).Asc()
: q.Where(() => metadata.TasteSavoryToSweet >= query.Taste.Sweetness).OrderBy(() => metadata.TasteSavoryToSweet).Desc();
}
}
IQueryOverOrderBuilder <Recipes, Recipes> orderBy;
switch (query.Sort)
{
case SortOrder.Title:
orderBy = q.OrderBy(p => p.Title);
break;
case SortOrder.PrepTime:
orderBy = q.OrderBy(p => p.PrepTime);
break;
case SortOrder.CookTime:
orderBy = q.OrderBy(p => p.CookTime);
break;
case SortOrder.Image:
orderBy = q.OrderBy(p => p.ImageUrl);
break;
default:
orderBy = q.OrderBy(p => p.Rating);
break;
}
var results = (query.Direction == SortDirection.Descending ? orderBy.Desc() : orderBy.Asc())
.Skip(query.Offset)
.List();
return(new SearchResults
{
Briefs = results.Select(r => r.AsRecipeBrief()).ToArray(),
TotalCount = results.Count
});
}
}
public RecipeResult CreateRecipe(AuthIdentity identity, Recipe recipe)
{
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
// Create Recipe
var dbRecipe = new Models.Recipes
{
Title = recipe.Title,
Description = recipe.Description,
CookTime = recipe.CookTime,
PrepTime = recipe.PrepTime,
Credit = recipe.Credit,
CreditUrl = recipe.CreditUrl,
DateEntered = recipe.DateEntered,
ImageUrl = recipe.ImageUrl,
Rating = recipe.AvgRating,
ServingSize = recipe.ServingSize,
Steps = recipe.Method
};
session.Save(dbRecipe);
// Create Ingredients
short displayOrder = 0;
recipe.Ingredients.ForEach(i =>
{
var dbIngredient = new RecipeIngredients
{
Recipe = dbRecipe,
Ingredient = Models.Ingredients.FromId(i.Ingredient.Id),
IngredientForm = (i.Form != null ? IngredientForms.FromId(i.Form.FormId) : null),
Qty = (i.Amount != null ? (float?)i.Amount.SizeHigh : null),
QtyLow = (i.Amount != null ? (float?)i.Amount.SizeLow : null),
Unit = (i.Amount != null ? i.Amount.Unit : Units.Unit),
Section = i.Section,
DisplayOrder = ++displayOrder
};
session.Save(dbIngredient);
});
// Create RecipeMetadata
var dbMetadata = new RecipeMetadata
{
Recipe = dbRecipe,
DietGlutenFree = recipe.Tags.HasTag(RecipeTag.GlutenFree),
DietNoAnimals = recipe.Tags.HasTag(RecipeTag.NoAnimals),
DietNomeat = recipe.Tags.HasTag(RecipeTag.NoMeat),
DietNoPork = recipe.Tags.HasTag(RecipeTag.NoPork),
DietNoRedMeat = recipe.Tags.HasTag(RecipeTag.NoRedMeat),
MealBreakfast = recipe.Tags.HasTag(RecipeTag.Breakfast),
MealDessert = recipe.Tags.HasTag(RecipeTag.Dessert),
MealDinner = recipe.Tags.HasTag(RecipeTag.Dinner),
MealLunch = recipe.Tags.HasTag(RecipeTag.Lunch),
NutritionLowCalorie = recipe.Tags.HasTag(RecipeTag.LowCalorie),
NutritionLowCarb = recipe.Tags.HasTag(RecipeTag.LowCarb),
NutritionLowFat = recipe.Tags.HasTag(RecipeTag.LowFat),
NutritionLowSodium = recipe.Tags.HasTag(RecipeTag.LowSodium),
NutritionLowSugar = recipe.Tags.HasTag(RecipeTag.LowSugar),
SkillCommon = recipe.Tags.HasTag(RecipeTag.Common),
SkillEasy = recipe.Tags.HasTag(RecipeTag.Easy),
SkillQuick = recipe.Tags.HasTag(RecipeTag.Quick)
};
session.Save(dbMetadata);
transaction.Commit();
return(new RecipeResult
{
RecipeCreated = true,
NewRecipeId = dbRecipe.RecipeId
});
}
}
}
public void DequeueRecipe(AuthIdentity identity, params Guid[] recipeIds)
{
using (var session = GetSession())
{
var recipes = (from r in recipeIds select new Models.Recipes {RecipeId = r}).ToArray();
var dbRecipes = session.QueryOver<QueuedRecipes>()
.Where(p => p.UserId == identity.UserId);
if (recipeIds.Any())
{
dbRecipes = dbRecipes.AndRestrictionOn(p => p.Recipe).IsInG(recipes);
}
using (var transaction = session.BeginTransaction())
{
dbRecipes.List().ForEach(session.Delete);
transaction.Commit();
}
}
}
public void EnqueueRecipes(AuthIdentity identity, params Guid[] recipeIds)
{
using (var session = GetSession())
{
// Check for dupes
var recipes = (from r in recipeIds select new Models.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();
// Enqueue each recipe
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 Models.Recipes {RecipeId = rid},
UserId = identity.UserId,
QueuedDate = now
});
}
transaction.Commit();
}
}
}
public void DeleteMenus(AuthIdentity identity, params Guid[] menuIds)
{
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
var dbMenu = session.QueryOver<Models.Menus>()
.AndRestrictionOn(p => p.MenuId).IsInG(menuIds)
.Where(p => p.UserId == identity.UserId)
.Fetch(prop => prop.Recipes).Eager()
.List();
dbMenu.ForEach(session.Delete);
transaction.Commit();
}
}
}
public Menu[] GetMenus(AuthIdentity identity, IList <Menu> menus, GetMenuOptions options)
{
using (var session = 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("options");
}
if (identity == null)
{
throw new ArgumentNullException("identity");
}
var loadFav = true;
var query = session.QueryOver <Models.Menus>()
.Where(p => p.UserId == identity.UserId);
if (menus != null) // Load individual menus
{
loadFav = menus.Contains(Menu.Favorites);
var ids = menus.Where(m => m.Id.HasValue).Select(m => m.Id.Value).ToArray();
query = query.AndRestrictionOn(p => p.MenuId).IsInG(ids);
}
var dbMenus = query.List();
var ret = new List <Menu>();
if (loadFav)
{
ret.Add(Menu.Favorites);
}
ret.AddRange(dbMenus.Select(m => m.AsMenu()));
if (!options.LoadRecipes) // We're done!
{
return(ret.ToArray());
}
// Load recipes into each menu
ICriterion filter = (loadFav
? Expression.Or(Expression.IsNull("Menu"), Expression.InG("Menu", dbMenus)) // Menu can be null, or in loaded menu list
: Expression.InG("Menu", dbMenus)); // Menu must be in loaded menu list
var dbFavorites = session.QueryOver <Favorites>()
.Fetch(prop => prop.Recipe).Eager
.Where(p => p.UserId == identity.UserId)
.Where(filter)
.List();
return(ret.Select(m =>
new Menu(m)
{
Recipes = (m.Id.HasValue
? dbFavorites.Where(f => f.Menu != null && f.Menu.MenuId == m.Id)
: dbFavorites.Where(f => f.Menu == null)
).Select(r => r.Recipe.AsRecipeBrief()).ToArray()
}).ToArray());
}
}
public void DeleteShoppingLists(AuthIdentity identity, ShoppingList[] lists)
{
if (!lists.Any())
throw new ArgumentException("DeleteShoppingLists requires at least one list to delete.");
using (var session = GetSession())
{
using (var transaction = session.BeginTransaction())
{
var dbLists = session.QueryOver<Models.ShoppingLists>()
.AndRestrictionOn(p => p.ShoppingListId).IsInG(lists.Where(l => l.Id.HasValue).Select(l => l.Id.Value))
.Where(p => p.UserId == identity.UserId)
.List();
dbLists.ForEach(session.Delete);
transaction.Commit();
}
}
}
public Recipe[] ReadRecipes(AuthIdentity identity, Guid[] recipeIds, ReadRecipeOptions options)
{
using (var session = GetSession())
{
var dbRecipes = session.QueryOver <Models.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 (!dbRecipes.Any())
{
throw new RecipeNotFoundException();
}
var ret = new List <Recipe>();
foreach (var dbRecipe in dbRecipes)
{
var recipe = new Recipe
{
Id = dbRecipe.RecipeId,
Title = dbRecipe.Title,
Description = dbRecipe.Description,
DateEntered = dbRecipe.DateEntered,
ImageUrl = dbRecipe.ImageUrl,
ServingSize = dbRecipe.ServingSize,
PrepTime = dbRecipe.PrepTime,
CookTime = dbRecipe.CookTime,
Credit = dbRecipe.Credit,
CreditUrl = dbRecipe.CreditUrl,
AvgRating = dbRecipe.Rating
};
if (options.ReturnMethod)
{
recipe.Method = dbRecipe.Steps;
}
if (options.ReturnUserRating) // TODO: We should JOIN this on the dbRecipes for faster loading
{
var id = dbRecipe.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 = dbRecipe.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 = dbRecipe.RecipeMetadata.Tags;
ret.Add(recipe);
}
return(ret.ToArray());
}
}
