public RecipeDetailViewModel LoadRecipe(int id, bool isFriend)
        {
            RecipeDetailViewModel model = null;

            IRecipeDetailData recipe = _recipeRepository.LoadRecipeDetail(id, true, isFriend);

            if (recipe != null)
            {
                model = new RecipeDetailViewModel()
                {
                    Id              = recipe.Id,
                    Name            = recipe.Name,
                    Description     = recipe.Description,
                    Content         = recipe.Content,
                    PublishDate     = recipe.PublishDate,
                    TeaserImageUrl  = String.IsNullOrEmpty(recipe.TeaserImageUrl) ? "default_teaser_image.png" : recipe.TeaserImageUrl,
                    IngredientCount = recipe.IngredientCount,
                    Measurement     = new MeasurementViewModel()
                    {
                        Id = recipe.Measurement.Id, Name = recipe.Measurement.Name
                    },
                    PreparationTime = recipe.PreparationTime,
                    WaitingTime     = recipe.WaitingTime
                };

                if (model.Id != 0)
                {
                    List <IIngredientListData> ingredientListDatas = _ingredientListRepository.LoadIngredientListFromRecipe(model.Id);
                    foreach (IIngredientListData ingredientListData in ingredientListDatas)
                    {
                        model.Ingredients.Add(new IngredientsViewModel()
                        {
                            Amount      = ingredientListData.Amount,
                            Ingredient  = ingredientListData.IngredientName,
                            Measurement = ingredientListData.MeasurementName
                        });
                    }
                }

                if (model.Id != 0)
                {
                    List <IRecipeContent> contentItems = _recipeRepository.LoadRecipeContents(model.Id);
                    if (contentItems != null)
                    {
                        foreach (IRecipeContent contentItem in contentItems)
                        {
                            model.ContentItems.Add(new LudwigRecipe.Service.Models.Recipe.RecipeContent()
                            {
                                Id          = contentItem.Id,
                                Content     = contentItem.Content,
                                ContentType = (RecipeContentType)contentItem.RecipeContentTypeId,
                                SortOrder   = contentItem.SortOrder
                            });
                        }
                    }
                }
            }
            return(model);
        }
        public IRecipeDetailData LoadRecipeDetail(int id, bool forPublicWeb, bool isFriend)
        {
            using (LudwigRecipeContext context = new LudwigRecipeContext())
            {
                IRecipeDetailData recipe = null;

                var dbRecipeQuery = context.Recipes.AsQueryable();

                dbRecipeQuery = dbRecipeQuery.Where(x => x.Id == id);

                if (forPublicWeb)
                {
                    dbRecipeQuery = dbRecipeQuery.Where(x => x.IsPublished == true && x.PublishDate <= DateTime.Now);
                }
                if (!isFriend)
                {
                    dbRecipeQuery = dbRecipeQuery.Where(x => x.IsOnlyForFriends == false);
                }

                var dbRecipe = dbRecipeQuery.FirstOrDefault();

                if (dbRecipe != null)
                {
                    recipe = new RecipeDetailData()
                    {
                        Id              = dbRecipe.Id,
                        Name            = dbRecipe.Name,
                        Description     = dbRecipe.Description,
                        Content         = dbRecipe.Content,
                        PublishDate     = dbRecipe.PublishDate,
                        Url             = dbRecipe.Url,
                        TeaserImageUrl  = dbRecipe.TeaserImageUrl,
                        IngredientCount = dbRecipe.IngredientCount,
                        Measurement     = (dbRecipe.Measurement != null) ? new MeasurementData()
                        {
                            Id = dbRecipe.Measurement.Id, Name = dbRecipe.Measurement.Name
                        } : null,
                        PreparationTime = dbRecipe.PreparationTime,
                        WaitingTime     = dbRecipe.WaitingTime
                    };
                }

                return(recipe);
            }
        }