public Guid CreateAnimal(AnimalViewData animalViewData)
        {
            using (var entities = this.EntityContext)
            {
                var animalEntity = new Animal { Id = Guid.NewGuid() };

                entities.AddToAnimal(animalEntity);
                this.SaveOrUpdateAnimal(animalViewData, animalEntity, entities);
                entities.SaveChanges();

                return animalEntity.Id;
            }
        }
        private void SaveOrUpdateAnimal(AnimalViewData animalViewData, Animal animalEntity, ZoosManagementSystemEntities entities)
        {
            animalEntity.Name = animalViewData.Name;
            animalEntity.Species = animalViewData.Species;
            animalEntity.Sex = (animalViewData.Sex.ToLowerInvariant() == "macho") ? "M" : "F";
            animalEntity.Cost = animalViewData.Cost;
            animalEntity.BornInCaptivity = animalViewData.BornInCaptivity;
            animalEntity.BirthDate = DateTime.Parse(animalViewData.BirthDate);
            animalEntity.NextHealthMeasure = DateTime.Parse(animalViewData.NextHealthMeasure);

            var responsibleId = new Guid(animalViewData.ResponsibleId);
            animalEntity.Responsible = entities.Responsible.FirstOrDefault(r => r.Id == responsibleId);

            if (!string.IsNullOrEmpty(animalViewData.EnvironmentId))
            {
                var environmentId = new Guid(animalViewData.EnvironmentId);
                animalEntity.Environment = entities.Environment.FirstOrDefault(r => r.Id == environmentId);
            }
            else
            {
                animalEntity.Environment = null;
            }

            foreach (var feedingTime in animalViewData.FeedingTimes.Where(ft => !ft.FeedingTimeStatus.Equals("None", StringComparison.InvariantCultureIgnoreCase)))
            {
                FeedingTime feedingTimeEntity = null;
                if (feedingTime.FeedingTimeStatus.Equals("New", StringComparison.InvariantCultureIgnoreCase))
                {
                    feedingTimeEntity = new FeedingTime
                        {
                            Id = Guid.NewGuid(),
                            Animal = animalEntity
                        };

                    entities.AddToFeedingTime(feedingTimeEntity);
                }
                else
                {
                    var feedingTimeId = new Guid(feedingTime.FeedingTimeId);
                    feedingTimeEntity = entities.FeedingTime
                        .Include("Feeding")
                        .Where(ft => ft.Id == feedingTimeId)
                        .FirstOrDefault();

                    if (feedingTimeEntity == null)
                    {
                        throw new ArgumentException(
                            string.Format(
                                CultureInfo.CurrentCulture,
                                "No existe ningún horario de alimentación con el Id {0} para actualizar.",
                                feedingTime.FeedingTimeId));
                    }
                }

                if (feedingTime.FeedingTimeStatus.Equals("Remove", StringComparison.InvariantCultureIgnoreCase))
                {
                    entities.DeleteObject(feedingTimeEntity);
                }
                else
                {
                    var feedingId = new Guid(feedingTime.FeedingId);

                    feedingTimeEntity.Amount = feedingTime.Amount;
                    feedingTimeEntity.Time = TimeSpan.Parse(feedingTime.Time);
                    feedingTimeEntity.Feeding = entities.Feeding.FirstOrDefault(f => f.Id == feedingId);
                }
            }
        }
        public void UpdateAnimal(AnimalViewData animalViewData)
        {
            using (var entities = this.EntityContext)
            {
                var id = new Guid(animalViewData.AnimalId);
                var animalEntity = entities.Animal
                    .Include("Environment")
                    .Include("FeedingTime")
                    .Include("Responsible")
                    .Include("HealthMeasure")
                    .FirstOrDefault(e => e.Id == id);

                if (animalEntity == null)
                {
                    throw new ArgumentException(
                        string.Format(
                            CultureInfo.CurrentCulture,
                            "No existe ningún animal con el Id {0} para actualizar.",
                            animalViewData.EnvironmentId));
                }

                this.SaveOrUpdateAnimal(animalViewData, animalEntity, entities);

                entities.SaveChanges();
            }
        }
        public ActionResult UpdateAnimal(string animalId)
        {
            var animalViewData = new AnimalViewData();
            var updateModelResult = this.TryUpdateModel<AnimalViewData>(animalViewData, null, null, new[] { "AnimalId", "freeanimals" });

            if (!updateModelResult)
            {
                animalViewData.AnimalId = animalId;
                animalViewData.FeedingsAvailable = this.repository.GetFeedings()
                    .Select(f => f.ToViewData())
                    .ToList();
                animalViewData.ResponsiblesAvailable= this.repository.GetResponsibles()
                    .Select(r => r.ToViewData())
                    .ToList();
                animalViewData.EnvironmentsAvailable = this.repository.GetEnvironments()
                    .Select(r => r.ToViewData(this.repository))
                    .ToList();
                return View(animalViewData);
            }

            try
            {
                animalViewData.AnimalId = animalId;
                this.repository.UpdateAnimal(animalViewData);
                this.TempData["ActionSucess"] = true;
                this.TempData["EnvironmentMessage"] = "Se editaron correctamente los datos del animal";
            }
            catch (Exception exception)
            {
                this.TempData["ActionSucess"] = false;
                this.TempData["EnvironmentMessage"] = exception.Message;
            }

            return this.RedirectToRoute("SearchAnimals", new { searchCriteria = animalViewData.AnimalId });
        }
        public ActionResult SaveNewAnimal()
        {
            var animalViewData = new AnimalViewData();
            var updateModelResult = this.TryUpdateModel<AnimalViewData>(animalViewData, null, null, new[] { "freeanimals" });

            if (!updateModelResult)
            {
                animalViewData.EnvironmentsAvailable = this.repository.GetEnvironments()
                        .Select(e => e.ToViewData(this.repository))
                        .ToList();
                animalViewData.ResponsiblesAvailable = this.repository.GetResponsibles()
                    .Select(r => r.ToViewData())
                    .ToList();
                animalViewData.FeedingsAvailable = this.repository.GetFeedings()
                    .Select(f => f.ToViewData())
                    .ToList();
                return View(animalViewData);
            }

            var animalId = Guid.Empty;
            try
            {
                animalId = this.repository.CreateAnimal(animalViewData);
                this.TempData["ActionSucess"] = true;
                this.TempData["EnvironmentMessage"] = "Se creó correctamente el ambiente";
            }
            catch (Exception exception)
            {
                this.TempData["ActionSucess"] = false;
                this.TempData["EnvironmentMessage"] = exception.Message;
            }

            return this.RedirectToRoute("SearchAnimals", new { searchCriteria = animalId.ToString() });
        }
        public ActionResult NewAnimal()
        {
            var environmentViewData = new AnimalViewData
            {
                EnvironmentsAvailable = this.repository.GetEnvironments()
                        .Select(e => e.ToViewData(this.repository))
                        .ToList(),
                ResponsiblesAvailable = this.repository.GetResponsibles()
                    .Select(r => r.ToViewData())
                    .ToList(),
                FeedingsAvailable = this.repository.GetFeedings()
                    .Select(f => f.ToViewData())
                    .ToList()
            };

            return this.View(environmentViewData);
        }