private void UpdateEntity(IBreedEntryEntity entity)
        {
            using (var ctx = new HappyDogShowContext())
            {
                DogShow selectedShow = ctx.DogShows.Where(i => i.ID == entity.ShowId).First();

                BreedEntry foundEntity = ctx.BreedEntries.Where(d => d.ID == entity.Id).Include(b => b.EnteredClasses).First();

                if (foundEntity != null)
                {
                    if (entity.Classes != null)
                    {
                        foreach (var i in entity.Classes)
                        {
                            // existing class entry
                            if (i.ID > 0)
                            {
                                if (i.IsSelected)
                                {
                                    // nothing to do, keep it
                                }
                                else
                                {
                                    var foundEntries = ctx.BreedClassEntries.Where(ec => ec.ID == i.ID);
                                    if (foundEntries.Count() == 1)
                                    {
                                        ctx.BreedClassEntries.Remove(foundEntries.First());
                                    }
                                }
                            }
                            // potential new class entry
                            else
                            {
                                if (i.IsSelected)
                                {
                                    BreedClass breedClass = ctx.BreedClasses.Where(k => k.ID == i.BreedClassID).First();

                                    foundEntity.EnteredClasses.Add(new BreedClassEntry()
                                    {
                                        Class = breedClass
                                    });
                                }
                                else
                                {
                                    // ignore
                                }
                            }
                        }
                    }

                    foundEntity.Show   = selectedShow;
                    foundEntity.Number = entity.Number;

                    ctx.SaveChanges();
                }
            }
        }
        public async override void Prepare()
        {
            DogShowList = await _dogShowService.GetDogShowListAsync <DogShowDetail>();

            CurrentEntity = new BreedEntry();
            (CurrentEntity as IBreedEntryEntity).Classes = await _dogShowService.GetListOfClassEntriesForNewBreedEntryAsync <BreedClassEntryEntityWithClassDetailForSelection>();

            (CurrentEntity as IBreedEntryEntity).Dog = SelectedDogRegistration;
            CurrentEntity.MarkEntityAsClean();
        }
        private int CreateEntity(IBreedEntryEntity entity)
        {
            int newid = -1;

            using (var ctx = new HappyDogShowContext())
            {
                DogRegistration        selectedDog    = ctx.DogRegistrations.Where(i => i.ID == entity.Dog.Id).First();
                DogShow                selectedShow   = ctx.DogShows.Where(i => i.ID == entity.ShowId).First();
                List <BreedClassEntry> enteredClasses = new List <BreedClassEntry>();
                foreach (var i in entity.Classes.Where(j => j.IsSelected))
                {
                    BreedClass breedClass = ctx.BreedClasses.Where(k => k.ID == i.BreedClassID).First();

                    enteredClasses.Add(new BreedClassEntry()
                    {
                        Class = breedClass
                    });;
                }

                if (string.IsNullOrEmpty(entity.Number))
                {
                    var usednumbers = ctx.BreedEntries.Where(be => be.Show.ID == entity.ShowId).Select(be => be.Number).ToList().Distinct().ToList();

                    if (usednumbers.Count > 0)
                    {
                        int temp;
                        int max = usednumbers.Select(n => int.TryParse(n, out temp) ? temp : 0).Max();

                        if (max > 0)
                        {
                            entity.Number = (max + 1).ToString();
                        }
                    }
                    else
                    {
                        entity.Number = "";
                    }
                }

                BreedEntry newEntity = new BreedEntry()
                {
                    Dog            = selectedDog,
                    EnteredClasses = enteredClasses,
                    Show           = selectedShow,
                    Number         = entity.Number
                };

                ctx.BreedEntries.Add(newEntity);
                ctx.SaveChanges();

                newid = newEntity.ID;
            }

            return(newid);
        }
        private void DeleteEntity(IEntityWithID entity)
        {
            using (var ctx = new HappyDogShowContext())
            {
                BreedEntry foundEntity = ctx.BreedEntries.Where(d => d.ID == entity.Id).Include(b => b.EnteredClasses).First();

                if (foundEntity != null)
                {
                    if (foundEntity.EnteredClasses != null)
                    {
                        foundEntity.EnteredClasses.Clear();
                    }
                    ctx.BreedEntries.Remove(foundEntity);
                    ctx.SaveChanges();
                }
            }
        }
        private IBreedEntryEntity GetEntity <T>(int id) where T : IBreedEntryEntity, new()
        {
            IBreedEntryEntity result = new T();

            using (var ctx = new HappyDogShowContext())
            {
                BreedEntry foundEntry = ctx.BreedEntries.Where(i => i.ID == id).Include(b => b.Show).First();
                if (foundEntry != null)
                {
                    result.Id      = foundEntry.ID;
                    result.ShowId  = foundEntry.Show.ID;
                    result.Dog     = null;
                    result.Classes = null;
                    result.Number  = foundEntry.Number;
                }
            }

            return(result);
        }
        public async override void Prepare()
        {
            DogShowList = await _dogShowService.GetDogShowListAsync <DogShowDetail>();

            CurrentEntity = new MultipleBreedEntry();
            foreach (IDogShowEntity dogShow in DogShowList)
            {
                BreedEntry newEntry = new BreedEntry();
                newEntry.ShowId  = dogShow.Id;
                newEntry.DogShow = dogShow;
                newEntry.Dog     = SelectedDogRegistration;

                newEntry.Classes = await _dogShowService.GetListOfClassEntriesForNewBreedEntryAsync <BreedClassEntryEntityWithClassDetailForSelection>();

                newEntry.Classes.ForEach(c =>
                {
                    (c as BreedClassEntryEntityWithClassDetailForSelection).IsOutOfAgeRange = DetermineIfDogAgeIsOutOfRangeBasedOnClassMinAndMaxDates(newEntry.DogAgeInMonthsAtTimeOfShow, c.MinAgeInMonths, c.MaxAgeInMonths);
                });

                (CurrentEntity as MultipleBreedEntry).BreedEntries.Add(newEntry);
                (CurrentEntity as MultipleBreedEntry).NotifyEntriesChanged();
            }
        }