// GET: Movie
public ActionResult Index(int?idGenero, string nombre = "")
{
MovieRepository repository = new MovieRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
var genero = generoRepository.Query(g => g.Eliminado == false, "Nombre");
Expression <Func <Movie, bool> > expr = m => m.estado != EEstatusMedia.ELIMINADO;
if (idGenero != null)
{
expr = expr.And(x => x.Generos.Any(y => y.Id == idGenero));
}
if (!string.IsNullOrEmpty(nombre))
{
expr = expr.And(x => x.nombre.Contains(nombre));
}
var lst = repository.Query(expr, "Nombre");
var model = MapHelper.Map <IEnumerable <MovieViewModel> >(lst);
var lstGenero = generoRepository.Query(g => g.Eliminado == false, "Nombre");
ViewBag.ListaGenero = GeneroList(lstGenero);
return(View(model));
}
public ActionResult Edit(int id, GeneroViewModel model)
{
try
{
if (ModelState.IsValid)
{
GeneroRepository repository = new GeneroRepository(context);
#region Validaciones
//validar nombre unico
bool existeGenero = repository.Query(x => x.Nombre == model.Nombre && x.GeneroId != model.GeneroId).Count > 0;
if (existeGenero)
{
ModelState.AddModelError("Name", "El nombre del genero ya existe.");
return(View(model));
}
#endregion
Genero genero = MapHelper.Map <Genero>(model);
repository.Update(genero);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Delete(int id, GeneroViewModel model)
{
try
{
GeneroRepository repository = new GeneroRepository(context);
var genero = repository.Query(e => e.GeneroId == id).First();
context.Entry(genero).Collection(g => g.Medias).Load();
if (genero.Medias.Count() == 0)
{
genero.Activo = false;
repository.Update(genero);
context.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("Index"));
}
}
catch
{
return(View());
}
}
public ActionResult Create(GeneroViewModel model)
{
try
{
if (ModelState.IsValid)
{
GeneroRepository repository = new GeneroRepository(context);
repository.Query(g => g.Activo == true);
#region Validaciones
//validar nombre unico
var geneQry = new Genero {
Nombre = model.Nombre
};
bool existeGenero = repository.QueryByExample(geneQry).Count > 0;
if (existeGenero)
{
ModelState.AddModelError("Nombre", "El nombre del genero ya existe.");
return(View(model));
}
#endregion
Genero genero = MapHelper.Map <Genero>(model);
genero.Activo = true;
repository.Insert(genero);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View());
}
}
// GET: MovieCatalogo
public ActionResult Index(int page = 1, string busqueda = null, string genero = null, int pageSize = 3)
{
MovieRepository movieRepository = new MovieRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
var includes = new Expression <Func <Movie, object> >[] { s => s.Generos };
int totalDePaginas;
int totalDeFilas;
ICollection <Movie> movies;
movies = movieRepository.QueryPageByNombreAndGeneroIncluding(busqueda, genero, includes, out totalDePaginas, out totalDeFilas, "Nombre", page - 1, pageSize);
ViewBag.Busqueda = busqueda;
ViewBag.Genero = genero;
ViewBag.ListaGeneros = generoRepository.Query(x => x.Activo == true).Select(g => g.Nombre).Where(g => g != genero).ToList();
var paginador = new PaginatorViewModel <ThumbnailMovieViewModel>();
paginador.Page = page;
paginador.PageSize = pageSize;
paginador.Results = MapHelper.Map <ICollection <ThumbnailMovieViewModel> >(movies);
paginador.TotalPages = totalDePaginas;
paginador.TotalRows = totalDeFilas;
return(View(paginador));
}
// 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
}
public ActionResult Edit(int id, MovieViewModel model)
{
PersonaRepository personaRepository = new PersonaRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
try
{
MovieRepository repository = new MovieRepository(context);
if (ModelState.IsValid)
{
var movie = MapHelper.Map <Movie>(model);
repository.UpdateComplete(movie, model.ActoresSeleccionados, model.GenerosSeleccionados);
context.SaveChanges();
return(RedirectToAction("Index"));
}
var actores = personaRepository.Query(a => a.Status == true);
var generos = generoRepository.Query(g => g.Activo == true);
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
return(View(model));
}
catch
{
var actores = personaRepository.Query(a => a.Status == true);
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
return(View(model));
}
}
// GET: Genero/Delete/5
public ActionResult Delete(int?id)
{
var repository = new GeneroRepository(context);
var genero = repository.Query(t => t.GeneroId == id).First();
var model = MapHelper.Map <GeneroViewModel>(genero);
return(View(model));
}
// GET: Genero
public ActionResult Index()
{
VideoOnDemandContext context = new VideoOnDemandContext();
GeneroRepository repository = new GeneroRepository(context);
var lst = repository.Query(g => g.Activo == true);
var models = MapHelper.Map <IEnumerable <GeneroViewModel> >(lst);
return(View(models));
}
// GET: Genero
public ActionResult Index()
{
GeneroRepository repository = new GeneroRepository(context);
//consulte los cursos del repositorio
var lst = repository.Query(g => g.Eliminado != true, "Nombre");
//mapeamos la lista de cursos con una lista de cursos view model
var models = MapHelper.Map <IEnumerable <GeneroViewModel> >(lst);
return(View(models));
}
public SelectList GeneroList(object selectecItem = null)
{
var repository = new GeneroRepository(context);
var genero = repository.Query(g => g.Eliminado == false, "Nombre").ToList();
genero.Insert(0, new Genero {
Id = null, Nombre = "Seleccione"
});
return(new SelectList(genero, "Id", "Nombre", selectecItem));
}
public SerieViewModel LinkLists(SerieViewModel model)
{
GeneroRepository generoRepository = new GeneroRepository(context);
PersonaRepository personaRepository = new PersonaRepository(context);
var lstGeneros = generoRepository.Query(g => g.Eliminado == false, "Nombre");
var lstPersonas = personaRepository.Query(p => p.Eliminado == false, "Nombre");
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(lstGeneros);
model.PersonasDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(lstPersonas);
return(model);
}
// GET: Movie/Create
public ActionResult Create()
{
PersonaRepository personaRepository = new PersonaRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
var model = new MovieViewModel();
var actores = personaRepository.Query(a => a.Status == true);
var generos = generoRepository.Query(g => g.Activo == true);
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
return(View(model));
}
// GET: Movie/Create
public ActionResult Create()
{
var model = new MovieViewModel();
GeneroRepository generoRepository = new GeneroRepository(context);
PersonaRepository personaRepository = new PersonaRepository(context);
var lst = generoRepository.Query(g => g.Eliminado == false, "Nombre");
var lst2 = personaRepository.Query(p => p.Eliminado == false, "Nombre");
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(lst);
model.PersonasDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(lst2);
model.estado = EEstatusMedia.VISIBLE;
return(View(model));
}
public ActionResult Create(MovieViewModel model)
{
GeneroRepository generoRepository = new GeneroRepository(context);
PersonaRepository personaRepository = new PersonaRepository(context);
var lst = generoRepository.Query(g => g.Eliminado == false, "Nombre");
var lst2 = personaRepository.Query(p => p.Eliminado == false, "Nombre");
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(lst);
model.PersonasDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(lst2);
MovieRepository mov = new MovieRepository(context);
try
{
MovieRepository repository = new MovieRepository(context);
// TODO: Add insert logic here
if (ModelState.IsValid)
{
Movie movie = MapHelper.Map <Movie>(model);
var lstmov = mov.Query(m => m.estado != EEstatusMedia.ELIMINADO);
foreach (var m in lstmov)
{
if (m.nombre.ToLower() == movie.nombre.ToLower())
{
if (m.fechaLanzamiento == movie.fechaLanzamiento)
{
ViewBag.Error = 1;
return(Create());
}
}
}
repository.InsertComplete(movie, model.SeleccionarGeneros, model.SeleccionarPersonas);
context.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
return(Create());
}
}
catch
{
return(Create());
}
}
public ActionResult Index(int?idg, string nombre = "", int paginado = 40)
{
if (paginado <= 0)
{
paginado = 40;
}
//paginacion
int totalPages = 0;
int totalRows = 0;
int pageSize = paginado;
int page = Request.QueryString["page"] == null ? 1 : int.Parse(Request.QueryString["page"]);
MovieRepository repository = new MovieRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
var genero = generoRepository.Query(g => g.Eliminado == false);
Expression <Func <Movie, bool> > expr = m => m.estado == EEstatusMedia.VISIBLE && m.nombre.Contains(nombre);
if (idg != null)
{
expr = expr.And(x => x.Generos.Any(y => y.Id == idg));
}
var lst = repository.QueryPage(expr, out totalPages, out totalRows, "Nombre", page - 1, pageSize);
var models = MapHelper.Map <IEnumerable <MovieViewModel> >(lst);
var generos = MapHelper.Map <ICollection <GeneroViewModel> >(generoRepository.GetAll());
var model = new PaginatorViewModel <MovieViewModel>
{
Page = page,
TotalPages = totalPages,
TotalRows = totalRows,
PageSize = pageSize,
Results = models
};
ViewBag.ListaGenero = GeneroList(genero);
ViewBag.Nombre = nombre;
ViewBag.Idg = idg + "";
ViewBag.Paginado = paginado + "";
return(View(model));
}
// GET: Genero/Delete/5
public ActionResult Delete(int?id)
{
GeneroRepository repository = new GeneroRepository(context);
var genero = repository.Query(t => t.Id == id).First();
var model = MapHelper.Map <GeneroViewModel>(genero);
if (ViewBag.Error == 1)
{
ViewBag.Salto = 1;
}
else
{
ViewBag.Salto = 0;
}
return(View(model));
}
public ActionResult Edit(int id, MovieViewModel model)
{
var generoRepository = new GeneroRepository(context);
var personaRepository = new PersonaRepository(context);
MovieRepository mov = new MovieRepository(context);
try
{
var repository = new MovieRepository(context);
if (ModelState.IsValid)
{
var movie = repository.Query(m => m.id == id).First();
movie = Update(movie, model);
var lstmov = mov.Query(m => m.estado != EEstatusMedia.ELIMINADO);
foreach (var m in lstmov)
{
if (m.id != movie.id)
{
if (m.nombre.ToLower() == movie.nombre.ToLower())
{
if (m.fechaLanzamiento == movie.fechaLanzamiento)
{
ViewBag.Error = 1;
return(Edit(model.id));
}
}
}
}
repository.UpdateComplete(movie, model.SeleccionarGeneros, model.SeleccionarPersonas);
context.SaveChanges();
return(RedirectToAction("Index"));
}
var generos = generoRepository.Query(g => g.Eliminado == false, "Nombre");
var personas = personaRepository.Query(p => p.Eliminado == false, "Nombre");
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
model.PersonasDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(personas);
return(Edit(model.id));
}
catch
{
return(Edit(model.id));
}
}
// GET: Movie/Edit/5
public ActionResult Edit(int id)
{
var repository = new MovieRepository(context);
var personaRepository = new PersonaRepository(context);
var generoRepository = new GeneroRepository(context);
// Expresión lambda para incluir las relaciones (No hay carga perezosa)
var includes = new Expression <Func <Movie, object> >[] { s => s.Actores, s => s.Generos };
var movie = repository.QueryIncluding(x => x.MediaId == id, includes).SingleOrDefault();
var model = MapHelper.Map <MovieViewModel>(movie);
var actores = personaRepository.Query(a => a.Status == true);
var generos = generoRepository.Query(g => g.Activo == true);
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
model.ActoresSeleccionados = movie.Actores.Select(a => a.Id.Value).ToArray();
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
model.GenerosSeleccionados = movie.Generos.Select(g => g.GeneroId.Value).ToArray();
return(View(model));
}
public ActionResult Create(NuevoSerieViewModel model)
{
try
{
SerieRepository serieRepository = new SerieRepository(context);
if (ModelState.IsValid)
{
var serie = MapHelper.Map <Serie>(model);
serie.EstadosMedia = EEstatusMedia.VISIBLE;
serie.FechaRegistro = DateTime.Now;
serie.DuracionMin = 0;
serieRepository.InsertComplete(serie, model.ActoresSeleccionados, model.GenerosSeleccionados);
// Guardar y registrar cambios
context.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
PersonaRepository personaRepository = new PersonaRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
var actores = personaRepository.Query(a => a.Status == true);
var generos = generoRepository.Query(g => g.Activo == true);
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
return(View(model));
}
}
catch (Exception e)
{
ModelState.AddModelError("ActoresSeleccionados", e.Message);
return(View());
}
}
// GET: Movie/Edit/5
public ActionResult Edit(int?id)
{
var repository = new MovieRepository(context);
var generoRepository = new GeneroRepository(context);
var personaRepository = new PersonaRepository(context);
var includes = new Expression <Func <Movie, object> >[] { x => x.Generos };
var includes2 = new Expression <Func <Movie, object> >[] { x => x.Actores };
var movie = repository.QueryIncluding(x => x.id == id, includes).SingleOrDefault();
var movie2 = repository.QueryIncluding(x => x.id == id, includes2).SingleOrDefault();
var model = MapHelper.Map <MovieViewModel>(movie);
var generos = generoRepository.Query(g => g.Eliminado == false, "Nombre");
var personas = personaRepository.Query(p => p.Eliminado == false, "Nombre");
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
model.PersonasDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(personas);
model.SeleccionarGeneros = movie.Generos.Select(x => x.Id.Value).ToArray();
model.SeleccionarPersonas = movie.Actores.Select(x => x.Id.Value).ToArray();
return(View(model));
}
// GET: Genero/Details/5
public ActionResult Details(int id)
{
MovieRepository repository = new MovieRepository(context);
GeneroRepository GeneroRepository = new GeneroRepository(context);
PersonaRepository PersonaRepository = new PersonaRepository(context);
FavoritoRepository FavoritoRepository = new FavoritoRepository(context);
var includes = new Expression <Func <Movie, object> >[] { s => s.Actores, s => s.Generos };
var movie = repository.QueryIncluding(x => x.MediaId == id, includes).SingleOrDefault();
var model = MapHelper.Map <MovieViewModel>(movie);
bool enFav = FavoritoRepository.Query(x => x.mediaId == id).Count() > 0;
bool enMedia = FavoritoRepository.Query(x => x.mediaId == id).Count() < 0;
if (enFav == true)
{
var TodoFav = FavoritoRepository.Query(x => x.mediaId == id).First();
var ValidacionMe = repository.Query(x => x.MediaId == id).Count() > 0;
if (ValidacionMe == false)
{
return(RedirectToAction("Details/" + id, "Serie"));
}
var idFav = TodoFav.id;
model.IdFavorito = idFav;
}
model.esMovie = enMedia;
var generos = GeneroRepository.Query(g => g.Activo == true);
var actores = PersonaRepository.Query(a => a.Status == true);
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
model.GenerosSeleccionados = movie.Generos.Select(g => g.GeneroId.Value).ToArray();
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
model.ActoresSeleccionados = movie.Actores.Select(a => a.Id.Value).ToArray();
model.MiFavorito = enFav;
return(View(model));
}
public ActionResult Delete(int id, GeneroViewModel model)
{
try
{
GeneroRepository repo = new GeneroRepository(context);
var genero = repo.Query(g => g.Id == id).FirstOrDefault();
context.Entry(genero).Collection(g => g.Medias).Load();
if (genero.Medias.Count() == 0)
{
repo.LogicalDelete(genero);
context.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
List <lstMedias> lista = new List <lstMedias>();
var repository = new MovieRepository(context);
var repository2 = new SerieRepository(context);
foreach (var media in genero.Medias)
{
var mov = repository.Query(m => m.id == media.id && media.estado != EEstatusMedia.ELIMINADO);
var ser = repository2.Query(s => s.id == media.id && media.estado != EEstatusMedia.ELIMINADO);
if (mov.Count() == 1)
{
lista.Add(new lstMedias()
{
id = media.id, nombre = media.nombre, tipo = "Película"
});
}
else if (ser.Count() == 1)
{
lista.Add(new lstMedias()
{
id = media.id, nombre = media.nombre, tipo = "Serie"
});
}
}
if (lista.Count == 0)
{
repo.LogicalDelete(genero);
context.SaveChanges();
return(RedirectToAction("Index"));
}
ViewData["inUsing"] = lista;
ViewBag.Error = 1;
model = MapHelper.Map <GeneroViewModel>(genero);
return(Delete(genero.Id));
}
}
catch
{
return(View());
}
}
public ActionResult Index(int?idg, string nombre = "", int paginado = 40, string UserId = "")
{
if (paginado <= 0)
{
paginado = 40;
}
//paginacion
int totalPages = 0;
int totalRows = 0;
int pageSize = paginado;
int page = Request.QueryString["page"] == null ? 1 : int.Parse(Request.QueryString["page"]);
MediaRepository mediaRepo = new MediaRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
UsuarioRepository userRepo = new UsuarioRepository(context);
FavoritoRepository favRepo = new FavoritoRepository(context);
var yo = userRepo.Query(u => u.IdentityId == UserId).FirstOrDefault();
var misFavoritos = favRepo.Query(f => f.usuarioId == yo.Id);
var genero = generoRepository.Query(g => g.Eliminado == false);
Expression <Func <Media, bool> > expr = m => m.estado == EEstatusMedia.VISIBLE;
int count = 0;
foreach (var item in misFavoritos)
{
if (count == 0)
{
expr = expr.And(m => m.id == item.mediaId);
count++;
}
else
{
expr = expr.Or(m => m.id == item.mediaId);
}
}
if (idg != null)
{
expr = expr.And(x => x.Generos.Any(y => y.Id == idg));
}
expr = expr.And(m => m.estado == EEstatusMedia.VISIBLE && m.nombre.Contains(nombre));
var lst = mediaRepo.QueryPage(expr, out totalPages, out totalRows, "Nombre", page - 1, pageSize);
var models = MapHelper.Map <IEnumerable <MediaViewModel> >(lst);
var model = new PaginatorViewModel <MediaViewModel>
{
Page = page,
TotalPages = totalPages,
TotalRows = totalRows,
PageSize = pageSize,
Results = models
};
ViewBag.ListaGenero = GeneroList(genero);
ViewBag.Nombre = nombre;
ViewBag.Idg = idg + "";
ViewBag.Paginado = paginado + "";
ViewBag.UserId = UserId;
ViewBag.numList = misFavoritos.Count();
return(View(model));
}