public void Add(Beer beer)
 {
     using (var context = new MicrobrewitContext())
     {
         context.Entry(beer).State = EntityState.Added;
         try
         {
             context.SaveChanges();
         }
         catch (DbEntityValidationException dbEx)
         {
             foreach (var validationErrors in dbEx.EntityValidationErrors)
             {
                 foreach (var validationError in validationErrors.ValidationErrors)
                 {
                     Trace.TraceInformation("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
                     Log.DebugFormat("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
                 }
             }
         }
     }
 }
 private void GetBrewers(DbConnection context, Beer beer)
 {
     var brewers = context.Query<UserBeer, User, UserBeer>(
         "SELECT * FROM UserBeers ub " +
         "LEFT JOIN Users u ON ub.Username = u.Username " +
         "WHERE ub.BeerId = @BeerId;",
         (userBeer, user) =>
         {
             userBeer.User = user;
             return userBeer;
         }, new { beer.BeerId }, splitOn: "Username");
     beer.Brewers = brewers.ToList();
 }
 private void GetForkOf(DbConnection context, Beer beer)
 {
     var forkOf = context.Query<Beer, BeerStyle, SRM, ABV, IBU, Beer>(
             "SELECT * FROM Beers b " +
             "LEFT JOIN BeerStyles bs ON bs.BeerStyleId = b.BeerStyleId " +
             "LEFT JOIN SRMs s ON s.SrmId = b.BeerId " +
             "LEFT JOIN ABVs a ON a.AbvId = b.BeerId " +
             "LEFT JOIN IBUs i ON i.IbuId = b.BeerId " +
             "WHERE BeerId = @BeerId"
             , (b, beerStyle, srm, abv, ibu) =>
             {
                 if (beerStyle != null)
                     b.BeerStyle = beerStyle;
                 if (srm != null)
                     b.SRM = srm;
                 if (abv != null)
                     b.ABV = abv;
                 if (ibu != null)
                     b.IBU = ibu;
                 return b;
             },
             new { beer.BeerId },
             splitOn: "BeerStyleId,SrmId,AbvId,IbuId"
             );
     beer.ForkeOf = forkOf.SingleOrDefault();
 }
 public Task RemoveAsync(Beer beer)
 {
     throw new NotImplementedException();
 }
        public async Task<int> UpdateAsync(Beer beer)
        {
            using (var context = DapperHelper.GetOpenConnection())
            {
                using (var transaction = context.BeginTransaction())
                {
                    try
                    {
                        beer.UpdatedDate = DateTime.Now;
                        var result = await context.ExecuteAsync(
                            "UPDATE Beers set Name = @Name, BeerStyleId = @BeerStyleId, UpdatedDate = @UpdatedDate, ForkeOfId = @ForkeOfId WHERE BeerId = @BeerId;",
                            beer, transaction);

                        await context.ExecuteAsync("UPDATE SRMs set Standard = @Standard, Mosher = @Mosher, Daniels = @Daniels, Morey = @Morey " +
                                        "WHERE SrmId = @SrmId;",
                            new { SrmId = beer.BeerId, beer.SRM.Standard, beer.SRM.Mosher, beer.SRM.Daniels, beer.SRM.Morey }, transaction);

                        await context.ExecuteAsync("UPDATE ABVs set Standard = @Standard, Miller = @Miller, Advanced = @Advanced, AdvancedAlternative = @AdvancedAlternative, Simple = @Simple, AlternativeSimple = @AlternativeSimple " +
                                        "WHERE AbvId = @AbvId;",
                           new { AbvId = beer.BeerId, beer.ABV.Standard, beer.ABV.Miller, beer.ABV.Advanced, beer.ABV.AdvancedAlternative, beer.ABV.Simple, beer.ABV.AlternativeSimple }, transaction);

                        await context.ExecuteAsync("UPDATE IBUs set Standard = @Standard,Tinseth =@Tinseth,Rager =@Rager WHERE IbuId = @IbuId;",
                            new { IbuId = beer.BeerId, beer.IBU.Standard, beer.IBU.Tinseth, beer.IBU.Rager }, transaction);

                        beer.Recipe.RecipeId = beer.BeerId;
                        UpdateRecipe(context, transaction, beer.Recipe);
                        transaction.Commit();
                        return result;
                    }
                    catch (Exception exception)
                    {
                        Log.Error(exception.ToString());
                        transaction.Rollback();
                        throw;
                    }
                }
            }
        }
 private void AddBrewers(Beer beer, DbConnection context, DbTransaction transaction)
 {
     //TODO: FIX THIS.
     if (beer.Brewers == null || !beer.Brewers.Any()) return;
     //foreach (var userBeer in beer.Brewers)
     //{
     //    userBeer.Username = userBeer.Username.ToLower();
     //}
     var brewers = beer.Brewers.DistinctBy(u => u.Username.ToLower());
     var distinct =  brewers.Select(b => new {beer.BeerId, b.Username, b.Confirmed});
     context.Execute("INSERT UserBeers(BeerId,Username,Confirmed) VALUES(@BeerId,@Username,@Confirmed);", distinct, transaction);
 }
        public async Task AddAsync(Beer beer)
        {
            using (var context = DapperHelper.GetOpenConnection())
            {
                using (var transaction = context.BeginTransaction())
                {
                    try
                    {
                        beer.CreatedDate = DateTime.Now;
                        beer.UpdatedDate = DateTime.Now;
                        var beerId = await context.QueryAsync<int>(
                            "INSERT Beers(Name,BeerStyleId,CreatedDate,UpdatedDate,ForkeOfId) " +
                            "VALUES(@Name,@BeerStyleId,@CreatedDate,@UpdatedDate,@ForkeOfId);" +
                            "SELECT CAST(Scope_Identity() as int);", beer, transaction);
                        beer.BeerId = beerId.SingleOrDefault();

                        beer.SRM.SrmId = beer.BeerId;
                        await context.ExecuteAsync("INSERT SRMs(SrmId,Standard,Mosher,Daniels,Morey) VALUES(@SrmId,@Standard,@Mosher,@Daniels,@Morey);",
                            new { beer.SRM.SrmId, beer.SRM.Standard, beer.SRM.Mosher, beer.SRM.Daniels, beer.SRM.Morey }, transaction);

                        beer.ABV.AbvId = beer.BeerId;
                        await context.ExecuteAsync("INSERT ABVs(AbvId,Standard,Miller,Advanced,AdvancedAlternative,Simple,AlternativeSimple) " +
                                        "VALUES(@AbvId,@Standard,@Miller,@Advanced,@AdvancedAlternative,@Simple,@AlternativeSimple);",
                            new { AbvId = beer.BeerId, beer.ABV.Standard, beer.ABV.Miller, beer.ABV.Advanced, beer.ABV.AdvancedAlternative, beer.ABV.Simple, beer.ABV.AlternativeSimple }, transaction);

                        beer.IBU.IbuId = beer.BeerId;
                        await context.ExecuteAsync("INSERT IBUs(IbuId,Standard,Tinseth,Rager) " +
                                        "VALUES(@IbuId,@Standard,@Tinseth,@Rager);",
                            new { IbuId = beer.BeerId, beer.IBU.Standard, beer.IBU.Tinseth, beer.IBU.Rager }, transaction);

                        AddBrewers(beer, context, transaction);

                        if (beer.Recipe != null)
                        {
                            beer.Recipe.RecipeId = beer.BeerId;
                            AddRecipe(beer.Recipe, context, transaction);
                        }
                        transaction.Commit();
                    }
                    catch (Exception e)
                    {
                        Log.Error(e.ToString());
                        transaction.Rollback();
                        throw;
                    }
                }
            }
        }
        public async Task AddAsync(Beer beer)
        {
            using (var context = new MicrobrewitContext())
            {
                context.Entry(beer).State = EntityState.Added;
                await context.SaveChangesAsync();

            }
        }
        public void Add_Gets_Added()
        {
            var newBeer = new Beer
            {
                Name = "TestBeer" + DateTime.Now.Ticks,
                BeerStyleId = 1,
                ForkeOfId = 17,
                SRM = new SRM
                {
                    Daniels = 1,
                    Morey = 1,
                    Mosher = 1,
                    Standard = 1
                },
                ABV = new ABV
                {
                    Advanced = 2,
                    AdvancedAlternative = 2,
                    AlternativeSimple = 2,
                    Miller = 2,
                    Simple = 2,
                    Standard = 2,
                },
                IBU = new IBU
                {
                    Rager = 20,
                    Standard = 20,
                    Tinseth = 25
                },

            };
            var newRecipe = new Recipe
            {
                Volume = 20,
                Notes = "SOmething",
                Efficiency = 75,
                MashSteps = new List<MashStep>
                {
                    new MashStep
                    {
                        StepNumber = 1,
                        Temperature = 56,
                        Type = "Infusion",
                        Notes = "Notes",
                        Length = 10,
                        Volume = 20,
                        Fermentables = new List<MashStepFermentable>
                        {
                             new MashStepFermentable{Amount = 1000,Lovibond = 23,PPG = 12, FermentableId = 2},
                             new MashStepFermentable{Amount = 1000,Lovibond = 23,PPG = 12, FermentableId = 1},
                        },
                        Hops = new List<MashStepHop>
                        {
                            new MashStepHop
                            {
                                Amount = 30,
                                AAValue = 5,
                                HopFormId = 1,
                                HopId = 1,
                            }
                        },
                        Others = new List<MashStepOther>
                        {
                            new MashStepOther
                            {
                                Amount = 10,
                                OtherId = 1,
                            }
                        }

                    },
                     new MashStep
                    {
                        StepNumber = 2,
                        Temperature = 56,
                        Type = "Infusion",
                        Notes = "Notes",
                        Length = 10,
                        Volume = 20
                    }
                },
                BoilSteps = new List<BoilStep>
                {
                    new BoilStep
                    {
                        StepNumber = 3,
                        Volume = 21,
                        Notes = "Notes",
                        Length = 60,
                              Fermentables = new List<BoilStepFermentable>
                        {
                             new BoilStepFermentable{Amount = 1000,Lovibond = 23,PPG = 12, FermentableId = 2},
                             new BoilStepFermentable{Amount = 1000,Lovibond = 23,PPG = 12, FermentableId = 1},
                        },
                        Hops = new List<BoilStepHop>
                        {
                            new BoilStepHop
                            {
                                Amount = 30,
                                AAValue = 5,
                                HopFormId = 1,
                                HopId = 1,
                            }
                        },
                        Others = new List<BoilStepOther>
                        {
                            new BoilStepOther
                            {
                                Amount = 10,
                                OtherId = 1,
                            }
                        }
                    }
                },
                FermentationSteps = new List<FermentationStep>
                {
                    new FermentationStep
                    {
                        StepNumber = 4,
                        Length = 14,
                        Temperature = 21,
                        Notes = "Somehting more",
                        Volume = 19,
                               Fermentables = new List<FermentationStepFermentable>
                        {
                             new FermentationStepFermentable{Amount = 1000,Lovibond = 23,PPG = 12, FermentableId = 2},
                             new FermentationStepFermentable{Amount = 1000,Lovibond = 23,PPG = 12, FermentableId = 1},
                        },
                        Hops = new List<FermentationStepHop>
                        {
                            new FermentationStepHop
                            {
                                Amount = 30,
                                AAValue = 5,
                                HopFormId = 1,
                                HopId = 1,
                            }
                        },
                        Others = new List<FermentationStepOther>
                        {
                            new FermentationStepOther
                            {
                                Amount = 10,
                                OtherId = 1,
                            }
                        },
                        Yeasts = new List<FermentationStepYeast>
                        {
                            new FermentationStepYeast
                            {
                                Amount = 1,
                                YeastId = 1,
                            }
                        } 
                    }
                }

            };
            newBeer.Recipe = newRecipe;
            _beerRepository.Add(newBeer);
            var beer = _beerRepository.GetSingle(newBeer.BeerId);
            Assert.NotNull(beer);
            Assert.True(beer.Name.Any());
        }
Example #10
0
        private static void BeerCalculations(Beer beer)
        {
            if (beer.Recipe.FG <= 0) beer.Recipe.FG = 1.015;
            if (beer.Recipe.Efficiency <= 0) beer.Recipe.Efficiency = 75;

            beer.Recipe.OG = Calculation.CalculateOG(beer.Recipe);
            var abv = Calculation.CalculateABV(beer.Recipe);
            beer.ABV = abv;
            var srm = Calculation.CalculateSRM(beer.Recipe);
            beer.SRM = srm;
            var ibu = Calculation.CalculateIBU(beer.Recipe);
            beer.IBU = ibu;
        }
        public async Task RemoveAsync(Beer beer)
        {
            using (var context = new MicrobrewitContext())
            {

                context.Entry(beer).State = EntityState.Deleted;
                try
                {
                    await context.SaveChangesAsync();
                }
                catch (Exception e)
                {
                    Log.Debug(e);
                    throw;
                }
            }
        }
        public void Update(Beer beer)
        {
            using (var context = new MicrobrewitContext())
            {
                var originalBeer = context.Beers.SingleOrDefault(b => b.BeerId == beer.BeerId);
                SetChanges(context, originalBeer, beer);

                var originalAbv = context.ABVs.SingleOrDefault(a => a.AbvId == beer.ABV.AbvId);
                if (originalAbv != null)
                    SetChanges(context, originalAbv, beer.ABV);

                var originalSrm = context.SRMs.SingleOrDefault(s => s.SrmId == beer.SRM.SrmId);
                if (originalSrm != null)
                    SetChanges(context, originalSrm, beer.SRM);

                var originalIbu = context.IBUs.SingleOrDefault(i => i.IbuId == beer.IBU.IbuId);
                if (originalIbu == null)
                    SetChanges(context, originalIbu, beer.IBU);

                // Brewers
                foreach (var userBeer in beer.Brewers)
                {
                    var originalUserBeer = context.UserBeers.SingleOrDefault(u => u.Username.Equals(userBeer.Username) && u.BeerId == beer.BeerId);
                    if (originalUserBeer != null)
                    {
                        SetChanges(context, originalUserBeer, userBeer);
                    }
                    else
                    {
                        context.UserBeers.Add(userBeer);
                    }
                }
                // Brewery
                foreach (var breweryBeer in beer.Breweries)
                {
                    var originalBreweryBeer = context.BreweryBeers.SingleOrDefault(b => b.BreweryId == breweryBeer.BreweryId && b.BeerId == beer.BeerId);
                    if (originalBreweryBeer != null)
                    {
                        SetChanges(context, originalBreweryBeer, breweryBeer);
                    }
                    else
                    {
                        context.BreweryBeers.Add(breweryBeer);
                    }
                }
                // Recipe 
                var originalRecipe = context.Recipes.SingleOrDefault(r => r.RecipeId == beer.Recipe.RecipeId);
                if (originalRecipe == null)
                {
                    context.Recipes.Add(beer.Recipe);
                }
                else
                {
                    SetChanges(context, originalRecipe, beer.Recipe);
                    // Fermentation Step
                    foreach (var fermentationStep in beer.Recipe.FermentationSteps)
                    {
                        var originalFermentationStep = context.FermentationSteps.SingleOrDefault(s =>
                            s.StepNumber == fermentationStep.StepNumber &&
                            s.RecipeId == fermentationStep.RecipeId);
                        if (originalFermentationStep == null)
                        {
                            context.FermentationSteps.Add(fermentationStep);
                        }
                        else
                        {
                            SetChanges(context, originalFermentationStep, fermentationStep);
                            //Fermentable
                            foreach (var fermentable in fermentationStep.Fermentables)
                            {
                                var originalFermentable = context.FermentationStepFermentables
                                    .SingleOrDefault(f => f.StepNumber == fermentable.StepNumber && f.FermentableId == fermentable.FermentableId && f.RecipeId == fermentable.RecipeId);
                                if (originalFermentable != null)
                                {
                                    SetChanges(context, originalFermentable, fermentable);
                                }
                                else
                                {
                                    context.FermentationStepFermentables.Add(fermentable);
                                }
                            }
                            //Hop
                            foreach (var hop in fermentationStep.Hops)
                            {
                                var originalHop = context.FermentationStepHops
                                    .SingleOrDefault(h => h.StepNumber == hop.StepNumber && h.HopId == hop.HopId && h.RecipeId == hop.RecipeId);
                                if (originalHop != null)
                                {
                                    SetChanges(context, originalHop, hop);
                                }
                                else
                                {
                                    context.FermentationStepHops.Add(hop);
                                }
                            }
                            //Other
                            foreach (var other in fermentationStep.Others)
                            {
                                var originalOther = context.FermentationStepOthers
                                    .SingleOrDefault(o => o.StepNumber == other.StepNumber && o.OtherId == other.OtherId && o.RecipeId == other.RecipeId);
                                if (originalOther != null)
                                {
                                    SetChanges(context, originalOther, other);
                                }
                                else
                                {
                                    context.FermentationStepOthers.Add(other);
                                }
                            }
                            //Yeast
                            foreach (var yeast in fermentationStep.Yeasts)
                            {
                                var originalYeast = context.FermentationStepYeasts
                                    .SingleOrDefault(y => y.StepNumber == yeast.StepNumber && y.YeastId == yeast.YeastId && y.RecipeId == yeast.RecipeId);
                                if (originalYeast != null)
                                {
                                    SetChanges(context, originalYeast, yeast);
                                }
                                else
                                {
                                    context.FermentationStepYeasts.Add(yeast);
                                }
                            }
                        }
                    }

                    // Boil step
                    foreach (var boilStep in beer.Recipe.BoilSteps)
                    {
                        var originalBoilStep = context.BoilSteps.SingleOrDefault(s => s.RecipeId == boilStep.RecipeId && s.StepNumber == boilStep.StepNumber);
                        if (originalBoilStep == null)
                        {
                            context.BoilSteps.Add(boilStep);
                        }
                        else
                        {
                            SetChanges(context, originalBoilStep, boilStep);
                            //Fermentable
                            foreach (var fermentable in boilStep.Fermentables)
                            {
                                var originalFermentable = context.BoilStepFermentables
                                    .SingleOrDefault(f =>
                                        f.StepNumber == fermentable.StepNumber &&
                                        f.FermentableId == fermentable.FermentableId &&
                                        f.RecipeId == boilStep.RecipeId);

                                if (originalFermentable != null)
                                {
                                    SetChanges(context, originalFermentable, fermentable);
                                }
                                else
                                {
                                    context.BoilStepFermentables.Add(fermentable);
                                }
                            }
                            //Hop
                            foreach (var hopStep in boilStep.Hops)
                            {
                                var originalHopStep = context.BoilStepHops
                                    .SingleOrDefault(h => h.StepNumber == hopStep.StepNumber && h.HopId == hopStep.HopId && h.RecipeId == hopStep.RecipeId);
                                if (originalHopStep != null)
                                {
                                    SetChanges(context, originalHopStep, hopStep);
                                }
                                else
                                {
                                    context.BoilStepHops.Add(hopStep);
                                }
                            }
                            //Other
                            foreach (var otherStep in boilStep.Others)
                            {
                                var originalOtherStep = context.BoilStepOthers
                                    .SingleOrDefault(o => o.StepNumber == otherStep.StepNumber && o.OtherId == otherStep.OtherId && o.RecipeId == otherStep.RecipeId);
                                if (originalOtherStep != null)
                                {
                                    SetChanges(context, originalOtherStep, otherStep);
                                }
                                else
                                {
                                    context.BoilStepOthers.Add(otherStep);
                                }

                            }
                        }
                    }
                    // Updates changes to the mash steps
                    foreach (var step in beer.Recipe.MashSteps)
                    {
                        var originalStep = context.MashSteps.SingleOrDefault(s => s.StepNumber == step.StepNumber && s.RecipeId == step.RecipeId);
                        if (originalStep == null)
                        {
                            context.MashSteps.Add(step);
                        }
                        else
                        {
                            SetChanges(context, originalStep, step);
                            //Fermentable
                            foreach (var fermentableStep in step.Fermentables)
                            {
                                var originalFermentableStep = context.MashStepFermentables
                                    .SingleOrDefault(f => f.StepNumber == fermentableStep.StepNumber && f.FermentableId == fermentableStep.FermentableId && f.RecipeId == step.RecipeId);
                                if (originalFermentableStep != null)
                                {
                                    SetChanges(context, originalFermentableStep, fermentableStep);
                                }
                                else
                                {
                                    context.MashStepFermentables.Add(fermentableStep);
                                }
                            }
                            //Hop
                            foreach (var hopStep in step.Hops)
                            {
                                var originalHopStep = context.MashStepHops
                                    .SingleOrDefault(h => h.StepNumber == hopStep.StepNumber && h.HopId == hopStep.HopId && h.RecipeId == step.RecipeId);
                                if (originalHopStep != null)
                                {
                                    SetChanges(context, originalHopStep, hopStep);
                                }
                                else
                                {
                                    context.MashStepHops.Add(hopStep);
                                }
                            }
                            //Other
                            foreach (var otherStep in step.Others)
                            {
                                var originalOtherStep = context.MashStepOthers
                                    .SingleOrDefault(o => o.StepNumber == otherStep.StepNumber && o.OtherId == otherStep.OtherId && o.RecipeId == step.RecipeId);
                                if (originalOtherStep != null)
                                {
                                    SetChanges(context, originalOtherStep, otherStep);
                                }
                                else
                                {
                                    context.MashStepOthers.Add(otherStep);
                                }
                            }
                        }
                    }
                }

                try
                {
                    context.SaveChanges();
                }
                catch (Exception e)
                {

                    throw;

                }
            }
        }
        public async Task<int> UpdateAsync(Beer newBeer)
        {
            using (var context = new MicrobrewitContext())
            {
                var dbBeer = context.Beers
                    .Include(b => b.ABV)
                    .Include(b => b.SRM)
                    .Include(b => b.IBU)
                    .Include(b => b.Brewers)
                    .Include(b => b.Breweries)
                    .SingleOrDefault(b => b.BeerId == newBeer.BeerId);

                newBeer.BeerStyle = null;
                newBeer.CreatedDate = dbBeer.CreatedDate;
                newBeer.UpdatedDate = DateTime.Now;
                context.Entry(dbBeer).CurrentValues.SetValues(newBeer);

                if (newBeer.ABV != null)
                {
                    var dbAbv = context.ABVs.SingleOrDefault(a => a.AbvId == newBeer.ABV.AbvId);
                    if (dbAbv != null)
                    {
                        context.Entry(dbBeer.ABV).CurrentValues.SetValues(newBeer.ABV);
                    }
                    else
                    {
                        dbBeer.ABV = newBeer.ABV;
                    }
                }
                if (newBeer.SRM != null)
                {
                    var dbSrm = context.SRMs.SingleOrDefault(s => s.SrmId == newBeer.SRM.SrmId);
                    if (dbSrm != null)
                    {
                        context.Entry(dbBeer.SRM).CurrentValues.SetValues(newBeer.SRM);
                    }
                    else
                    {
                        dbBeer.SRM = newBeer.SRM;
                    }
                }

                if (newBeer.IBU != null)
                {
                    var dbIbu = context.IBUs.SingleOrDefault(i => i.IbuId == newBeer.IBU.IbuId);
                    if (dbIbu != null)
                    {
                        context.Entry(dbBeer.IBU).CurrentValues.SetValues(newBeer.IBU);
                    }
                    else
                    {
                        dbBeer.IBU = newBeer.IBU;
                    }
                }

                // Brewers
                foreach (var brewers in dbBeer.Brewers.ToList())
                {
                    if (newBeer.Brewers.All(b => b.Username != brewers.Username))
                        context.UserBeers.Remove(brewers);
                }

                foreach (var newUserBeer in newBeer.Brewers)
                {
                    var dbUserBeer = context.UserBeers.SingleOrDefault(u => u.Username.Equals(newUserBeer.Username) && u.BeerId == newBeer.BeerId);
                    if (dbUserBeer != null)
                    {
                        context.Entry(dbUserBeer).CurrentValues.SetValues(newUserBeer);
                    }
                    else
                    {
                        context.UserBeers.Add(newUserBeer);
                    }
                }
                // Brewery
                foreach (var dbBreweryBeers in dbBeer.Breweries.ToList())
                {
                    if (newBeer.Breweries.All(b => b.BreweryId != dbBreweryBeers.BreweryId))
                        context.BreweryBeers.Remove(dbBreweryBeers);
                }

                foreach (var newBreweryBeer in newBeer.Breweries)
                {
                    var dbBreweryBeer = context.BreweryBeers.SingleOrDefault(b => b.BreweryId == newBreweryBeer.BreweryId && b.BeerId == newBeer.BeerId);
                    if (dbBreweryBeer != null)
                    {
                        context.Entry(dbBreweryBeer).CurrentValues.SetValues(newBreweryBeer);
                    }
                    else
                    {
                        context.BreweryBeers.Add(newBreweryBeer);
                    }
                }
                // Recipe 
                if (newBeer.Recipe != null)
                {
                    var dbRecipe = context.Recipes
                        .Include(r => r.FermentationSteps)
                        .Include(r => r.MashSteps)
                        .Include(r => r.BoilSteps)
                        //   .Include(r => r.SpargeStep)
                        .SingleOrDefault(r => r.RecipeId == newBeer.Recipe.RecipeId);
                    if (dbRecipe != null)
                    {
                        context.Entry(dbRecipe).CurrentValues.SetValues(newBeer.Recipe);
                        //Sparge step
                        //if (newBeer.Recipe.SpargeStep != null)
                        //{
                        //    var newSpargeStep = newBeer.Recipe.SpargeStep;
                        //    var dbSpargeStep = context.SpargeSteps.SingleOrDefault(i => i.StepNumber == newSpargeStep.StepNumber && i.RecipeId == newSpargeStep.RecipeId);
                        //    if (dbSpargeStep != null)
                        //    {
                        //        context.Entry(dbSpargeStep).CurrentValues.SetValues(newSpargeStep);
                        //    }
                        //    else
                        //    {
                        //        dbRecipe.SpargeStep = newSpargeStep;
                        //    }
                        //}

                        // Fermentation Step
                        foreach (var dbFermentationStep in dbRecipe.FermentationSteps)
                        {
                            if (
                                newBeer.Recipe.FermentationSteps.All(
                                    f => f.StepNumber != dbFermentationStep.StepNumber))
                                context.FermentationSteps.Remove(dbFermentationStep);
                        }
                        foreach (var newFermentationStep in newBeer.Recipe.FermentationSteps)
                        {
                            var dbFermentationStep = context.FermentationSteps.SingleOrDefault(s =>
                                s.StepNumber == newFermentationStep.StepNumber &&
                                s.RecipeId == newFermentationStep.RecipeId);
                            if (dbFermentationStep != null)
                            {
                                context.Entry(dbFermentationStep).CurrentValues.SetValues(newFermentationStep);

                                //Fermentable
                                if (dbFermentationStep.Fermentables != null)
                                {
                                    foreach (var dbFermentable in dbFermentationStep.Fermentables)
                                    {
                                        if (
                                            newFermentationStep.Fermentables.All(
                                                f => f.FermentableId != dbFermentable.FermentableId))
                                            context.FermentationStepFermentables.Remove(dbFermentable);
                                    }
                                }

                                if (newFermentationStep.Fermentables != null)
                                {
                                    foreach (var newFermentable in newFermentationStep.Fermentables)
                                    {
                                        var dbFermentable = context.FermentationStepFermentables
                                            .SingleOrDefault(
                                                f =>
                                                    f.StepNumber == newFermentable.StepNumber &&
                                                    f.FermentableId == newFermentable.FermentableId &&
                                                    f.RecipeId == newFermentable.RecipeId);
                                        if (dbFermentable != null)
                                        {
                                            context.Entry(dbFermentable).CurrentValues.SetValues(newFermentable);
                                        }
                                        else
                                        {
                                            context.FermentationStepFermentables.Add(newFermentable);
                                        }
                                    }
                                }
                                //Hop
                                if (dbFermentationStep.Hops != null)
                                {
                                    foreach (var dbFermentationStepHop in dbFermentationStep.Hops)
                                    {
                                        if (newFermentationStep.Hops.All(h => h.HopId != dbFermentationStepHop.HopId))
                                            context.FermentationStepHops.Remove(dbFermentationStepHop);
                                    }
                                }
                                if (newFermentationStep.Hops != null)
                                {
                                    foreach (var newHop in newFermentationStep.Hops)
                                    {
                                        var dbHop = context.FermentationStepHops
                                            .SingleOrDefault(
                                                h =>
                                                    h.StepNumber == newHop.StepNumber && h.HopId == newHop.HopId &&
                                                    h.RecipeId == newHop.RecipeId);
                                        if (dbHop != null)
                                        {
                                            context.Entry(dbHop).CurrentValues.SetValues(newHop);
                                        }
                                        else
                                        {
                                            context.FermentationStepHops.Add(newHop);
                                        }
                                    }
                                }
                                //Other
                                if (dbFermentationStep.Others != null)
                                {
                                    foreach (var dbFermentationStepOther in dbFermentationStep.Others)
                                    {
                                        if (
                                            newFermentationStep.Others.All(
                                                o => o.OtherId != dbFermentationStepOther.OtherId))
                                            context.FermentationStepOthers.Remove(dbFermentationStepOther);
                                    }
                                }
                                if (newFermentationStep.Others != null)
                                {
                                    foreach (var newOther in newFermentationStep.Others)
                                    {
                                        var dbOther = context.FermentationStepOthers
                                            .SingleOrDefault(
                                                o =>
                                                    o.StepNumber == newOther.StepNumber &&
                                                    o.OtherId == newOther.OtherId &&
                                                    o.RecipeId == newOther.RecipeId);
                                        if (dbOther != null)
                                        {
                                            context.Entry(dbOther).CurrentValues.SetValues(newOther);
                                        }
                                        else
                                        {
                                            context.FermentationStepOthers.Add(newOther);
                                        }
                                    }
                                }
                                //Yeast
                                if (dbFermentationStep.Yeasts != null)
                                {
                                    foreach (var dbFermentationStepYeast in dbFermentationStep.Yeasts)
                                    {
                                        if (
                                            newFermentationStep.Yeasts.All(
                                                y => y.YeastId != dbFermentationStepYeast.YeastId))
                                            context.FermentationStepYeasts.Remove(dbFermentationStepYeast);
                                    }
                                }
                                if (newFermentationStep.Yeasts != null)
                                {
                                    foreach (var newFermentationStepYeast in newFermentationStep.Yeasts)
                                    {
                                        var dbYeast = context.FermentationStepYeasts
                                            .SingleOrDefault(
                                                y =>
                                                    y.StepNumber == newFermentationStepYeast.StepNumber &&
                                                    y.YeastId == newFermentationStepYeast.YeastId &&
                                                    y.RecipeId == newFermentationStepYeast.RecipeId);
                                        if (dbYeast != null)
                                        {
                                            context.Entry(dbYeast).CurrentValues.SetValues(newFermentationStepYeast);
                                        }
                                        else
                                        {
                                            context.FermentationStepYeasts.Add(newFermentationStepYeast);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                dbRecipe.FermentationSteps.Add(newFermentationStep);
                            }
                        }
                        // Boil step
                        foreach (var dbBoilStep in dbRecipe.BoilSteps)
                        {
                            if (newBeer.Recipe.BoilSteps.All(f => f.StepNumber != dbBoilStep.StepNumber))
                                context.BoilSteps.Remove(dbBoilStep);
                        }
                        foreach (var newBoilStep in newBeer.Recipe.BoilSteps)
                        {
                            var dbBoilStep = context.BoilSteps.SingleOrDefault(s =>
                                s.StepNumber == newBoilStep.StepNumber &&
                                s.RecipeId == newBoilStep.RecipeId);
                            if (dbBoilStep != null)
                            {
                                context.Entry(dbBoilStep).CurrentValues.SetValues(newBoilStep);

                                //Fermentable
                                if (dbBoilStep.Fermentables != null)
                                {
                                    foreach (var dbFermentable in dbBoilStep.Fermentables)
                                    {
                                        if (
                                            newBoilStep.Fermentables.All(
                                                f => f.FermentableId != dbFermentable.FermentableId))
                                            context.BoilStepFermentables.Remove(dbFermentable);
                                    }
                                }
                                if (newBoilStep.Fermentables != null)
                                {
                                    foreach (var newFermentable in newBoilStep.Fermentables)
                                    {
                                        var dbFermentable = context.BoilStepFermentables
                                            .SingleOrDefault(
                                                f =>
                                                    f.StepNumber == newFermentable.StepNumber &&
                                                    f.FermentableId == newFermentable.FermentableId &&
                                                    f.RecipeId == newFermentable.RecipeId);
                                        if (dbFermentable != null)
                                        {
                                            context.Entry(dbFermentable).CurrentValues.SetValues(newFermentable);
                                        }
                                        else
                                        {
                                            context.BoilStepFermentables.Add(newFermentable);
                                        }
                                    }
                                }
                                //Hop
                                if (dbBoilStep.Hops != null)
                                {
                                    foreach (var dbBoilStepHop in dbBoilStep.Hops)
                                    {
                                        if (newBoilStep.Hops.All(h => h.HopId != dbBoilStepHop.HopId))
                                            context.BoilStepHops.Remove(dbBoilStepHop);
                                    }
                                }
                                if (newBoilStep.Hops != null)
                                {
                                    foreach (var newHop in newBoilStep.Hops)
                                    {
                                        var dbHop = context.BoilStepHops
                                            .SingleOrDefault(
                                                h =>
                                                    h.StepNumber == newHop.StepNumber && h.HopId == newHop.HopId &&
                                                    h.RecipeId == newHop.RecipeId);
                                        if (dbHop != null)
                                        {
                                            context.Entry(dbHop).CurrentValues.SetValues(newHop);
                                        }
                                        else
                                        {
                                            context.BoilStepHops.Add(newHop);
                                        }
                                    }
                                }
                                //Other
                                if (dbBoilStep.Others != null)
                                {
                                    foreach (var dbBoilStepOther in dbBoilStep.Others)
                                    {
                                        if (
                                            newBoilStep.Others.All(
                                                o => o.OtherId != dbBoilStepOther.OtherId))
                                            context.BoilStepOthers.Remove(dbBoilStepOther);
                                    }
                                }
                                if (newBoilStep.Others != null)
                                {
                                    foreach (var newOther in newBoilStep.Others)
                                    {
                                        var dbOther = context.BoilStepOthers
                                            .SingleOrDefault(
                                                o =>
                                                    o.StepNumber == newOther.StepNumber &&
                                                    o.OtherId == newOther.OtherId &&
                                                    o.RecipeId == newOther.RecipeId);
                                        if (dbOther != null)
                                        {
                                            context.Entry(dbOther).CurrentValues.SetValues(newOther);
                                        }
                                        else
                                        {
                                            context.BoilStepOthers.Add(newOther);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                dbRecipe.BoilSteps.Add(newBoilStep);
                            }
                        }
                        // Updates changes to the mash steps
                        foreach (var dbMashStep in dbRecipe.MashSteps)
                        {
                            if (
                                newBeer.Recipe.MashSteps.All(
                                    f => f.StepNumber != dbMashStep.StepNumber))
                                context.MashSteps.Remove(dbMashStep);
                        }
                        foreach (var newMashStep in newBeer.Recipe.MashSteps)
                        {
                            var dbMashStep = context.MashSteps.SingleOrDefault(s =>
                                s.StepNumber == newMashStep.StepNumber &&
                                s.RecipeId == newMashStep.RecipeId);
                            if (dbMashStep != null)
                            {
                                context.Entry(dbMashStep).CurrentValues.SetValues(newMashStep);

                                //Fermentable
                                if (dbMashStep.Fermentables != null)
                                {
                                    foreach (var dbFermentable in dbMashStep.Fermentables)
                                    {
                                        if (
                                            newMashStep.Fermentables.All(
                                                f => f.FermentableId != dbFermentable.FermentableId))
                                            context.MashStepFermentables.Remove(dbFermentable);
                                    }
                                }
                                if (newMashStep.Fermentables != null)
                                {
                                    foreach (var newFermentable in newMashStep.Fermentables)
                                    {
                                        var dbFermentable = context.MashStepFermentables
                                            .SingleOrDefault(
                                                f =>
                                                    f.StepNumber == newFermentable.StepNumber &&
                                                    f.FermentableId == newFermentable.FermentableId &&
                                                    f.RecipeId == newFermentable.RecipeId);
                                        if (dbFermentable != null)
                                        {
                                            context.Entry(dbFermentable).CurrentValues.SetValues(newFermentable);
                                        }
                                        else
                                        {
                                            context.MashStepFermentables.Add(newFermentable);
                                        }
                                    }
                                }
                                //Hop
                                if (dbMashStep.Hops != null)
                                {
                                    foreach (var dbMashStepHop in dbMashStep.Hops)
                                    {
                                        if (newMashStep.Hops.All(h => h.HopId != dbMashStepHop.HopId))
                                            context.MashStepHops.Remove(dbMashStepHop);
                                    }
                                }
                                if (newMashStep.Hops != null)
                                {
                                    foreach (var newHop in newMashStep.Hops)
                                    {
                                        var dbHop = context.MashStepHops
                                            .SingleOrDefault(
                                                h =>
                                                    h.StepNumber == newHop.StepNumber && h.HopId == newHop.HopId &&
                                                    h.RecipeId == newHop.RecipeId);
                                        if (dbHop != null)
                                        {
                                            context.Entry(dbHop).CurrentValues.SetValues(newHop);
                                        }
                                        else
                                        {
                                            context.MashStepHops.Add(newHop);
                                        }
                                    }
                                }
                                //Other
                                if (dbMashStep.Others != null)
                                {
                                    foreach (var dbMashStepOther in dbMashStep.Others)
                                    {
                                        if (
                                            newMashStep.Others.All(
                                                o => o.OtherId != dbMashStepOther.OtherId))
                                            context.MashStepOthers.Remove(dbMashStepOther);
                                    }
                                }
                                if (newMashStep.Others != null)
                                {
                                    foreach (var newOther in newMashStep.Others)
                                    {
                                        var dbOther = context.MashStepOthers
                                            .SingleOrDefault(
                                                o =>
                                                    o.StepNumber == newOther.StepNumber &&
                                                    o.OtherId == newOther.OtherId &&
                                                    o.RecipeId == newOther.RecipeId);
                                        if (dbOther != null)
                                        {
                                            context.Entry(dbOther).CurrentValues.SetValues(newOther);
                                        }
                                        else
                                        {
                                            context.MashStepOthers.Add(newOther);
                                        }
                                    }
                                }

                            }
                            else
                            {
                                dbRecipe.MashSteps.Add(newMashStep);
                            }
                        }
                    }
                    else
                    {
                        context.Recipes.Add(newBeer.Recipe);
                    }
                }
                try
                {
                    return await context.SaveChangesAsync();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    throw;
                }
            }
        }
 private void GetBreweries(DbConnection context, Beer beer)
 {
     var breweries = context.Query<BreweryBeer, Brewery, BreweryBeer>(
                "SELECT * " +
                "FROM BreweryBeers bb " +
                "LEFT JOIN Breweries b ON bb.BreweryId = b.BreweryId " +
                "WHERE bb.BeerId = @BeerId", (breweryBeer, brewery) =>
                {
                    breweryBeer.Brewery = brewery;
                    return breweryBeer;
                }, new { beer.BeerId }, splitOn: "BreweryId");
     beer.Breweries = breweries.ToList();
 }
 public void Remove(Beer beer)
 {
     throw new NotImplementedException();
 }
 private void GetForks(DbConnection context, Beer beer)
 {
     var forks = context.Query<Beer, SRM, ABV, IBU, BeerStyle, Beer>(
             "SELECT * " +
             "FROM Beers b " +
             "LEFT JOIN SRMs s ON s.SrmId = b.BeerId " +
             "LEFT JOIN ABVs a ON a.AbvId = b.BeerId " +
             "LEFT JOIN IBUs i ON i.IbuId = b.BeerId " +
             "LEFT JOIN BeerStyles bs ON bs.BeerStyleId = b.BeerStyleId " +
             "WHERE b.ForkeOfId = @BeerId", (fork, srm, abv, ibu, beerStyle) =>
             {
                 if (srm != null)
                     fork.SRM = srm;
                 if (abv != null)
                     fork.ABV = abv;
                 if (ibu != null)
                     fork.IBU = ibu;
                 if (beerStyle != null)
                     fork.BeerStyle = beerStyle;
                 return beer;
             }, new { beer.BeerId }, splitOn: "SrmId,AbvId,IbuId,BeerStyleId");
     beer.Forks = forks.ToList();
 }
 public void Remove(Beer beer)
 {
     using (var context = new MicrobrewitContext())
     {
         context.Entry(beer).State = EntityState.Deleted;
         context.SaveChanges();
     }
 }