Esempio n. 1
0
        // GET: Serie/Details/5
        public ActionResult Details(int id)
        {
            #region Repositorios necesarios
            SerieRepository    serieRepository    = new SerieRepository(context);
            FavoritoRepository favoritoRepository = new FavoritoRepository(context);
            EpisodioRepository episodioRepository = new EpisodioRepository(context);
            #endregion

            #region Consulta la serie en la bd
            var   relaciones = new Expression <Func <Serie, object> >[] { s => s.Generos, s => s.Actores };
            Serie serie      = serieRepository.QueryIncluding(s => s.MediaId == id, relaciones, "FechaRegistro").SingleOrDefault();


            #endregion

            #region Mapeo de la serie con su view model adecuado
            var model = MapHelper.Map <CompletoSerieViewModel>(serie);

            bool enFav = favoritoRepository.Query(x => x.mediaId == id).Count() > 0;
            if (enFav == true)
            {
                var TodoFav = favoritoRepository.Query(x => x.mediaId == id).First();
                var idFav   = TodoFav.id;
                model.IdFavorito = idFav;
            }
            model.MiFavorito = enFav;
            model.Temporadas = episodioRepository.Query(e => e.SerieId == model.MediaId && e.EstadosMedia == EEstatusMedia.VISIBLE).OrderBy(e => e.Temporada).Select(e => e.Temporada.Value).Distinct().ToArray();
            model.esMovie    = true;
            #endregion

            return(View(model));
        }
        public ActionResult Delete(int id, EliminadoSerieViewModel model)
        {
            SerieRepository repository = new SerieRepository(context);

            try
            {
                EpisodioRepository episodioRepository = new EpisodioRepository(context);

                var serie     = repository.Find(id);
                var episodios = episodioRepository.Query(e => e.SerieId == id);
                serie.EstadosMedia = EEstatusMedia.ELIMINADO;
                repository.Update(serie);
                foreach (var episodio in episodios)
                {
                    episodio.EstadosMedia = EEstatusMedia.ELIMINADO;
                    episodioRepository.Update(episodio);
                }

                context.SaveChanges();
                return(RedirectToAction("Index"));
            }

            catch
            {
                var modeloNuevo = repository.Find(id);
                var includes    = new Expression <Func <Serie, object> >[] { s => s.Actores, s => s.Generos };
                var serie       = repository.QueryIncluding(s => s.MediaId == id, includes).SingleOrDefault();
                model = MapHelper.Map <EliminadoSerieViewModel>(serie);

                return(View(model));
            }
        }
        // GET: ManageSerie/Edit/5
        public ActionResult Edit(int id)
        {
            //Repositorios necesarios
            var repository        = new SerieRepository(context);
            var personaRepository = new PersonaRepository(context);
            var generoRepository  = new GeneroRepository(context);

            // Expresión lambda para incluir las relaciones con actores y generos (No hay carga perezosa)
            var includes = new Expression <Func <Serie, object> >[] { s => s.Actores, s => s.Generos };

            //Creacion del modelo de la consulta obtenida
            var serie = repository.QueryIncluding(s => s.MediaId == id, includes).SingleOrDefault();
            var model = MapHelper.Map <ModificadoSerieViewModel>(serie);

            //Obtención de todos los actores y generos disponibles
            var actores = personaRepository.Query(a => a.Status == true);
            var generos = generoRepository.Query(g => g.Activo == true);

            //Establecimiento de los actores y generos que tiene nuestra serie
            model.ActoresDisponibles   = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
            model.ActoresSeleccionados = serie.Actores.Select(a => a.Id.Value).ToArray();
            model.GenerosDisponibles   = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
            model.GenerosSeleccionados = serie.Generos.Select(g => g.GeneroId.Value).ToArray();

            return(View(model)); //Llama a la vista de edición y le pasa el modelo de la serie
        }
        // GET: ManageSerie/Delete/5
        public ActionResult Delete(int id)
        {
            var repository = new SerieRepository(context);

            var includes = new Expression <Func <Serie, object> >[] { s => s.Actores, s => s.Generos };
            var serie    = repository.QueryIncluding(s => s.MediaId == id, includes).SingleOrDefault();

            serie.Generos = serie.Generos.Where(g => g.Activo == true).ToList();
            serie.Actores = serie.Actores.Where(a => a.Status == true).ToList();
            var model = MapHelper.Map <EliminadoSerieViewModel>(serie);

            return(View(model));
        }