//here the unit of work will instaniate the repositories and use it across all of the application
public UnitOfWork(MovieManagerContext context)
{
_context = context;
//Example Below
Filmes = new FilmeRepository(_context);
Generos = new GeneroRepository(_context);
}
// 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));
}
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 LivroTest()
{
context = new LivrariaContext(dbContextOptions);
repository = new LivroRepository(context);
repositoryGenero = new GeneroRepository(context);
repositoryAutor = new AutorRepository(context);
}
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: 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 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());
}
}
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());
}
}
// 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: 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));
}
public UnitOfWork(RdioContext context)
{
_context = context;
Musics = new MusicRepository(_context);
Generos = new GeneroRepository(_context);
Artistas = new ArtistaRepository(_context);
Albums = new AlbumRepository(_context);
}
public void Delete(int id)
{
Genero genero = new Genero()
{
CodGenero = id
};
GeneroRepository.DeleteNow(genero);
}
// 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));
}
public EmprestimoTest()
{
context = new LivrariaContext(dbContextOptions);
repository = new EmprestimoRepository(context);
repositoryUsuario = new UsuarioRepository(context);
repositoryLivro = new LivroRepository(context);
repositoryGenero = new GeneroRepository(context);
repositoryAutor = new AutorRepository(context);
}
public ReservaTest()
{
context = new LivrariaContext(dbContextOptions);
repository = new ReservaRepository(context);
repositoryUsuario = new UsuarioRepository(context);
repositoryLivro = new LivroRepository(context);
repositoryGenero = new GeneroRepository(context);
repositoryAutor = new AutorRepository(context);
}
// 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 bool Create()
{
var libro = new Libro();
libro.Titulo = this.Titulo;
libro.Autor = this.Autor;
libro.Genero = GeneroRepository.Get(this.GeneroID);
return(LibroRepository.Create(libro));
}
public bool Edit()
{
var libro = LibroRepository.Get(this.LibroID);
libro.Titulo = this.Titulo;
libro.Autor = this.Autor;
libro.Genero = GeneroRepository.Get(this.GeneroID);
return(LibroRepository.Edit(libro));
}
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);
}
public UnitOfWork(TiendaDbContext dbContext)
{
//Todos los repositorios aca papa;
_dbContext = dbContext;
Libros = new LibroRepository(_dbContext);
Autores = new AutorRepository(_dbContext);
AutoresLibros = new AutoresLibrosRepository(_dbContext);
Compras = new CompraRepository(_dbContext);
ComprasLibros = new CompraLibroRepository(_dbContext);
DetallesUsuarios = new DetalleUsuarioRepository(_dbContext);
GenerosLibors = new GeneroLibroRepository(_dbContext);
Generos = new GeneroRepository(_dbContext);
}
// 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 IEnumerable <MusicaDAL.Models.Musica> Get()
{
var todasMusicas = MusicaRepository.GetAll();
foreach (var musica in todasMusicas)
{
musica.generos = GeneroRepository.GetAllByMusic(musica.CODMUSICA);
foreach (var genero in musica.generos)
{
musica.GenerosTexto += genero.NOME + ",";
}
}
return(todasMusicas);
}
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()
{
var auxfilmes = new FilmeRepository();
var generos = new GeneroRepository();
var lstgenerostmDb = tmDbClient.GetMovieGenres("pt");
var lstFilmetmDb = tmDbClient.GetMovieList(MovieListType.Popular, "pt", 0);
var lstGenero = generos.ListAll();
var lstFilmes = auxfilmes.ListAll();
var percentGenero = Math.Round(((Double)(lstGenero.Count() * 100) / lstgenerostmDb.Count), 2);
var _percent = Math.Round(((Double)(lstFilmes.Count() * 100) / lstFilmetmDb.TotalResults), 2);
Session.Add("percent", _percent);
Session.Add("percentGenero", percentGenero);
return(View());
}
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));
}
private void onOk(object sender, EventArgs e)
{
if (formValidator.Validate())
{
try
{
using (GeneroRepository repo = new GeneroRepository())
{
genero = repo.SaveNew(genero);
}
}
catch (BusinessEntityRepositoryException ex)
{
MessageBox.Show(this, ex.Message + ":\n\n" + ex.InnerException.Message,
"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
DialogResult = DialogResult.None;
return;
}
DialogResult = DialogResult.OK;
}
}
