Esempio n. 1
0
        public static async Task <RecipeBook> AddRecipeBook(RecipeBook recipeBook)
        {
            var           dbHandler     = new CoffeeBookDbHandlerFactory().GetDbHandler();
            RecipeBookDto recipeBookDto = ConvertFromRecipeBook(recipeBook);

            return(ConvertToRecipeBook(await dbHandler.AddRecipeBookAsync(recipeBookDto)));
        }
Esempio n. 2
0
 public async Task <RecipeBookDto> AddRecipeBookAsync(RecipeBookDto newRecipeBook)
 {
     using (var db = new CoffeBookContext())
     {
         var recipeBook = ConvertDtoToEntity(newRecipeBook, db);
         return(new RecipeBookDto(recipeBook));
     }
 }
Esempio n. 3
0
        public static RecipeBookDto ConvertFromRecipeBook(RecipeBook recipeBook)
        {
            RecipeBookDto recipeBookDto = new RecipeBookDto
            {
                Id          = recipeBook.Id,
                Name        = recipeBook.Name,
                Description = recipeBook.Description,
                Recipes     = RecipeHelper.ConvertFromRecipes(recipeBook.Recipes)
            };

            return(recipeBookDto);
        }
Esempio n. 4
0
        public static RecipeBook ConvertToRecipeBook(RecipeBookDto recipeBookDto)
        {
            RecipeBook recipeBook = new RecipeBook
            {
                Id          = recipeBookDto.Id,
                Name        = recipeBookDto.Name,
                Description = recipeBookDto.Description,
                Recipes     = RecipeHelper.ConvertToRecipes(recipeBookDto.Recipes)
            };

            return(recipeBook);
        }
Esempio n. 5
0
 public static async Task <RecipeBook> AddOrUpdateRecipeBook(RecipeBook recipeBook)
 {
     if (recipeBook.Id <= 0)
     {
         return(await AddRecipeBook(recipeBook));
     }
     else
     {
         var           dbHandler     = new CoffeeBookDbHandlerFactory().GetDbHandler();
         RecipeBookDto recipeBookDto = ConvertFromRecipeBook(recipeBook);
         return(ConvertToRecipeBook(await dbHandler.UpdateRecipeBookAsync(recipeBookDto)));
     }
 }
Esempio n. 6
0
 public async Task <RecipeBookDto> UpdateRecipeBookAsync(RecipeBookDto updatedRecipeBook)
 {
     using (var db = new CoffeBookContext())
     {
         var recipeBook = ConvertDtoToEntity(updatedRecipeBook, db);
         recipeBook.Description = updatedRecipeBook.Description;
         recipeBook.Name        = updatedRecipeBook.Name;
         var recipes = new List <Recipe>();
         foreach (var recipe in updatedRecipeBook.Recipes)
         {
             recipes.Add(ConvertDtoToEntity(recipe, db));
         }
         recipeBook.Recipes = recipes;
         db.SaveChanges();
         return(new RecipeBookDto(recipeBook));
     }
 }
Esempio n. 7
0
        public async Task <BlCallResult <RecipeBookDto> > RemoveRecipeFromRecipeBook(RecipeBookDto recipeBookDto, RecipeDto recipeDto)
        {
            Console.WriteLine("RemoveRecipeFromRecipeBook enter");
            using (var db = new CoffeBookContext())
            {
                try
                {
                    recipeBookDto.Recipes.Remove(recipeDto);
                    var updatedRecipeBook = await UpdateRecipeBookAsync(recipeBookDto);

                    recipeBookDto = updatedRecipeBook;
                }
                catch (Exception e)
                {
                    Console.WriteLine("AddRecipeToRecipeBook exit");
                    return(new BlCallResult <RecipeBookDto>(BlCallResult.BlResult.RecipeBookError, e));
                }
                Console.WriteLine("RemoveRecipeFromRecipeBook exit");
                return(new BlCallResult <RecipeBookDto>(recipeBookDto));
            }
        }
Esempio n. 8
0
        private RecipeBook ConvertDtoToEntity(RecipeBookDto recipeBookDto, CoffeBookContext db)
        {
            var recipeBook = GetRecipeBook(recipeBookDto.Id, db);

            if (recipeBook == null)
            {
                recipeBook = new RecipeBook
                {
                    Description = recipeBookDto.Description,
                    Name        = recipeBookDto.Name
                };
                var recipes = new List <Recipe>();
                foreach (var recipe in recipeBookDto.Recipes)
                {
                    recipes.Add(ConvertDtoToEntity(recipe, db));
                }
                recipeBook.Recipes = recipes;
                db.RecipeBooks.Add(recipeBook);
                db.SaveChanges();
                recipeBookDto.Id = recipeBook.Id;
            }
            return(recipeBook);
        }
Esempio n. 9
0
        private void TestBL()
        {
            var dbHandler = new CoffeeBookDbHandlerFactory().GetDbHandler();

            //Coffee
            var coffeeNew = new CoffeeDto {
                Name = "GoodCoffee"
            };
            var coffeeAdded  = dbHandler.AddCoffeeAsync(coffeeNew).Result;
            var coffeeFromDb = dbHandler.GetCoffeeAsync(coffeeAdded.Id).Result;

            coffeeFromDb.Name = "Not GoodCoffee";
            var coffeeUpdated = dbHandler.UpdateCoffeeAsync(coffeeFromDb).Result;

            //Recipe
            var recipeNew = new RecipeDto
            {
                CoffeeType  = coffeeNew,
                Description = "Very good recipe",
                Name        = "Recipe for good coffee"
            };
            var recipeAdded  = dbHandler.AddRecipeAsync(recipeNew).Result;
            var recipeFromDb = dbHandler.GetRecipeAsync(recipeAdded.Id).Result;

            recipeFromDb.Name = "Useless Recipe";
            var recipeUpdated = dbHandler.UpdateRecipeAsync(recipeFromDb).Result;

            //RecipeBook
            var recipeBookNew = new RecipeBookDto
            {
                Description = "RBook fro user Feri",
                Name        = "FeriBook",
                Recipes     = new List <RecipeDto> {
                    recipeUpdated
                }
            };
            var recipeBookAdded  = dbHandler.AddRecipeBookAsync(recipeBookNew).Result;
            var recipeBookFromDb = dbHandler.GetRecipeBookAsync(recipeBookAdded.Id).Result;

            recipeBookFromDb.Recipes.Add(new RecipeDto
            {
                CoffeeType  = coffeeFromDb,
                Description = "Added Recipe",
                Name        = "Added"
            });
            var recipeBookUpdated = dbHandler.UpdateRecipeBookAsync(recipeBookFromDb).Result;

            //User
            var userNew = new UserDto
            {
                RecipeBooks = new List <RecipeBookDto> {
                    recipeBookUpdated
                },
                Name     = "Feri",
                Password = "******",
            };
            var userAdded  = dbHandler.AddUserAsync(userNew).Result;
            var userFromDb = dbHandler.GetUserAsync(userAdded.Id).Result;

            userFromDb.Name = "Galaktikus Johnny";
            userFromDb.RecipeBooks.RemoveAt(0);
            var userUpdated = dbHandler.UpdateUserAsync(userFromDb).Result;

            //GetAll
            var users = dbHandler.GetAllUsersAsync().Result;
            var rbs   = dbHandler.GetAllRecipeBooksAsync().Result;
            var rs    = dbHandler.GetAllRecipesAsync().Result;
            var cs    = dbHandler.GetAllCoffeesAsync().Result;

            //Delete
            dbHandler.DeleteUserAsync(userNew.Id);
            dbHandler.DeleteRecipeBookAsync(recipeBookNew.Id);
            dbHandler.DeleteRecipeAsync(recipeNew.Id);
            dbHandler.DeleteCoffeeAsync(coffeeNew.Id);

            var usersafterDelete       = dbHandler.GetAllUsersAsync().Result;
            var recipebooksafterDelete = dbHandler.GetAllRecipeBooksAsync().Result;
            var recipesafterDelete     = dbHandler.GetAllRecipesAsync().Result;
            var coffeesafterDelete     = dbHandler.GetAllCoffeesAsync().Result;
        }