// 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));
}
// GET: api/Serie
public IEnumerable <Serie> Get()
{
var repo = new SerieRepository();
List <Serie> series = repo.GetSeries();
return(series);
}
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));
}
}
public UnitOfWork(NovaEscolaContext context)
{
_context = context;
Escolas = new EscolaRepository(_context);
Turmas = new TurmasRepository(_context);
Series = new SerieRepository(_context);
}
public SeriesController()
{
var writeRepository = new SerieRepository();
_serieReadRepository = new SerieReadRepository();
_serieCommandHandler = new SerieCommandHandler(writeRepository);
}
// GET: api/Serie/5
public IEnumerable <Serie> Get(int id)
{
var repo = new SerieRepository();
List <Serie> serie = repo.GetSerieUsuario(id);
return(serie);
}
// POST: api/Serie
public string Post([FromBody] Serie serie)
{
var repo = new SerieRepository();
string result = repo.Save(serie);
return(result);
}
public ActionResult Edit(ModificadoSerieViewModel model)
{
PersonaRepository personaRepository = new PersonaRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
try
{
SerieRepository repository = new SerieRepository(context);
if (ModelState.IsValid)
{
var serie = MapHelper.Map <Serie>(model);
repository.UpdateComplete(serie, 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: Serie
public ActionResult Index(int page = 1, string busqueda = null, string genero = null, int pageSize = 3)
{
SerieRepository serieRepository = new SerieRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
var includes = new Expression <Func <Serie, object> >[] { s => s.Generos };
int totalDePaginas;
int totalDeFilas;
ICollection <Serie> series;
series = serieRepository.QueryPageByNombreAndGeneroIncluding(busqueda, genero, includes, out totalDePaginas, out totalDeFilas, "Nombre", page - 1, pageSize);
ViewBag.Busqueda = busqueda;
ViewBag.Genero = genero;
ViewBag.ListaGeneros = generoRepository.Query(g => g.Activo == true).OrderBy(g => g.Nombre).Select(g => g.Nombre).Where(g => g != genero).ToList();
var paginador = new PaginatorViewModel <ThumbnailSerieViewModel>();
paginador.Page = page;
paginador.PageSize = pageSize;
paginador.Results = MapHelper.Map <ICollection <ThumbnailSerieViewModel> >(series);
paginador.TotalPages = totalDePaginas;
paginador.TotalRows = totalDeFilas;
return(View(paginador));
}
public ArticleService()
{
articleRepository = new ArticleRepository(context);
serieRepository = new SerieRepository(context);
keywordRepository = new KeywordRepository(context);
userRepository = new UserRepository(context);
}
static void Main(string[] args)
{
ISerieRepository serieRepository = new SerieRepository();
Serie serie = serieRepository.ObtenirSerieParId(456);
Console.ReadKey();
}
// 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
public ActionResult Index()
{
SerieRepository repository = new SerieRepository(context);
var lst = repository.Query(s => s.EstadosMedia == EEstatusMedia.VISIBLE | s.EstadosMedia == EEstatusMedia.INVISIBLE);
var models = MapHelper.Map <IEnumerable <SerieViewModel> >(lst);
return(View(models));
}
// GET: ManageSerie/Delete/5
public ActionResult Delete(int id)
{
SerieRepository serieRepository = new SerieRepository(context);
var serie = serieRepository.Query(s => s.id == id).First();
var model = MapHelper.Map <SerieViewModel>(serie);
return(View(model));
}
// GET: ManageSerie/Edit/5
public ActionResult Edit(int id)
{
SerieRepository serieRepository = new SerieRepository(context);
var serie = serieRepository.Query(t => t.id == id).First();
var model = MapHelper.Map <SerieViewModel>(serie);
model = LinkLists(model);
return(View(model));
}
// 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));
}
// GET: Episodio/5
public ActionResult Index(int id)
{
var serieRepository = new SerieRepository(context);
var episodioRepository = new EpisodioRepository(context);
var serie = serieRepository.Find(id);
var serieModel = MapHelper.Map <DetalladoSerieViewModel>(serie);
var episodios = episodioRepository.Query(e => e.SerieId == id).Where(e => e.EstadosMedia == EEstatusMedia.VISIBLE || e.EstadosMedia == EEstatusMedia.INVISIBLE);
var episodiosModel = MapHelper.Map <ICollection <EpisodioViewModel> >(episodios);
serieModel.Episodios = episodiosModel;
return(View(serieModel));
}
public void cargarSeries(User user)
{
//cargamos las series en el listBox
serieRepo = new SerieRepository();
string genre = cmbGenresSerie.SelectedItem != null?cmbGenresSerie.SelectedItem.ToString() : string.Empty;
int genreInt = getGenre(genre);
var allSeries = serieRepo.getAll();
var SerieById = serieRepo.GetByUser(allSeries, genreInt, _user).ToList();
listBoxSeries.Items.Clear();
foreach (var serie in SerieById)
{
listBoxSeries.Items.Add(serie.Title);
}
}
public static List <Serie> GetAll()
{
try
{
List <Serie> result;
using (var context = new MediaManagerContext())
using (var repository = new SerieRepository(context))
{
result = repository.GetAll();
}
return(result);
}
catch (Exception ex)
{
throw new MediaManagerException($"Erreur : {ex.Message}", ExceptionReturnType.Error);
}
}
public BaseUnitOfWork(ExtraInfo extra = null)
{
_context = new ClassicsContext(extra);
ProfileRepository = new ProfileRepository(_context);
UserRepository = new UserRepository(_context);
AddressRepository = new AddressRepository(_context);
BlobFileRepository = new BlobFileRepository(_context);
BrandRepository = new BrandRepository(_context);
CarModelRepository = new CarModelRepository(_context);
MyCarRepository = new MyCarRepository(_context);
ProductRepository = new ProductRepository(_context);
SerieRepository = new SerieRepository(_context);
SupplierRepository = new SupplierRepository(_context);
AlertRepository = new AlertRepository(_context);
UserAlertRepository = new UserAlertRepository(_context);
}
// GET: ManageEpisodio
public ActionResult Index(int id)
{
VideoOnDemandContext context = new VideoOnDemandContext();
EpisodioRepository episodioRepository = new EpisodioRepository(context);
SerieRepository serieRepository = new SerieRepository(context);
// Consultar los episodios de la serie asignada
var lstEpisodio = episodioRepository.Query(e => e.serieId.Value == id && e.estado != EEstatusMedia.ELIMINADO).OrderBy(e => e.numEpisodio).OrderBy(e => e.temporada);
// Mapear la lista de series con una lista de SerieViewModel
var models = MapHelper.Map <IEnumerable <EpisodioViewModel> >(lstEpisodio);
ViewBag.Serie = serieRepository.Query(s => s.id == id).FirstOrDefault().nombre;
ViewBag.SerieId = serieRepository.Query(s => s.id == id).FirstOrDefault().id;
return(View(models));
}
// GET: ManageEpisodio/Create
public ActionResult Create(int id)
{
var model = new EpisodioViewModel();
SerieRepository serieRepository = new SerieRepository(context);
var serie = serieRepository.Query(s => s.id == id).FirstOrDefault();
model.Serie = MapHelper.Map <SerieViewModel>(serie);
model.serieId = id;
model.estado = EEstatusMedia.VISIBLE;
ViewBag.Serie = serie.nombre;
return(View(model));
}
// GET: Serie
public ActionResult Index(int?idg, string nombre = "", int paginado = 40)
{
if (paginado <= 0)
{
paginado = 40;
}
int totalPages = 0;
int totalRows = 0;
int pageSize = paginado;
int page = Request.QueryString["page"] == null ? 1 : int.Parse(Request.QueryString["page"]);
SerieRepository repository = new SerieRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
var genero = generoRepository.Query(g => g.Eliminado == false);
Expression <Func <Serie, 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 <SerieViewModel> >(lst);
var generos = MapHelper.Map <ICollection <GeneroViewModel> >(generoRepository.GetAll());
var model = new PaginatorViewModel <SerieViewModel>
{
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));
}
public ActionResult Delete(int id, SerieViewModel model)
{
try
{
// TODO: Add delete logic here
var serieRepository = new SerieRepository(context);
var serie = serieRepository.Query(s => s.id == id).First();
serieRepository.LogicalDelete(serie);
context.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View(model));
}
}
public static void Save(Serie element)
{
if (element == null)
{
throw new MediaManagerException($"Erreur : {nameof(element)} is null", ExceptionReturnType.Error);
}
try
{
using (var context = new MediaManagerContext())
using (var repository = new SerieRepository(context))
{
repository.Save(element);
context.SaveChanges();
}
}
catch (Exception ex)
{
throw new MediaManagerException($"Erreur :{ex.Message}", ExceptionReturnType.Error);
}
}
public static void Delete(int id)
{
if (id <= 0)
{
throw new MediaManagerException($"Erreur : {nameof(id)} <= 0", ExceptionReturnType.Error);
}
try
{
using (var context = new MediaManagerContext())
using (var repository = new SerieRepository(context))
{
repository.Delete(id);
context.SaveChanges();
}
}
catch (Exception ex)
{
throw new MediaManagerException($"Erreur : {ex.Message}", ExceptionReturnType.Error);
}
}
public ActionResult Edit(int id, SerieViewModel model)
{
model = LinkLists(model);
try
{
var serieRepository = new SerieRepository(context);
if (ModelState.IsValid)
{
var serie = serieRepository.Query(s => s.id == id).First();
serie = Update(serie, model);
var lstSerie = serieRepository.Query(s => s.estado != EEstatusMedia.ELIMINADO);
foreach (var s in lstSerie)
{
if (s.id != id)
{
if (s.nombre.ToLower() == serie.nombre.ToLower())
{
if (s.fechaLanzamiento == serie.fechaLanzamiento)
{
model = MapHelper.Map <SerieViewModel>(serie);
model = LinkLists(model);
ViewBag.Error = 1;
return(Edit(id));
}
}
}
}
serieRepository.UpdateComplete(serie, model.GenerosSeleccionados, model.PersonasSeleccionadas);
context.SaveChanges();
return(RedirectToAction("Index"));
}
return(Edit(id));
}
catch
{
return(Edit(id));
}
}
public static Serie Get(int id)
{
if (id <= 0)
{
throw new MediaManagerException($"Erreur : {nameof(id)} <= 0", ExceptionReturnType.Error);
}
try
{
Serie result;
using (var context = new MediaManagerContext())
using (var repository = new SerieRepository(context))
{
result = repository.Get(id);
}
return(result);
}
catch (Exception ex)
{
throw new MediaManagerException($"Erreur : {ex.Message}", ExceptionReturnType.Error);
}
}
public ActionResult Create(SerieViewModel model)
{
model = LinkLists(model);
model.duracionMin = 0;
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
SerieRepository repository = new SerieRepository(context);
Serie serie = MapHelper.Map <Serie>(model);
var lstSerie = repository.Query(s => s.estado != EEstatusMedia.ELIMINADO);
foreach (var s in lstSerie)
{
if (s.nombre.ToLower() == serie.nombre.ToLower())
{
if (s.fechaLanzamiento == serie.fechaLanzamiento)
{
ViewBag.Error = 1;
return(Create());
}
}
}
repository.InsertComplete(serie, model.GenerosSeleccionados, model.PersonasSeleccionadas);
context.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
return(Create());
}
}
catch
{
return(Create());
}
}
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());
}
}
