Example #1
0
        public ActionResult Create([Bind(Include = "IdCartelera,IdSede,IdPelicula,HoraInicio,FechaInicio,FechaFin,NumeroSala,IdVersion,Lunes,Martes,Miercoles,Jueves,Viernes,Sabado,Domingo")] Cartelera cartelera)
        {
            if (Session["Admin"] == null)
            {
                TempData["urlController"] = Request.RequestContext.RouteData.Values["controller"].ToString();
                TempData["urlAction"]     = Request.RequestContext.RouteData.Values["action"].ToString();
                return(RedirectToAction("Login", "Usuario"));
            }

            if (ModelState.IsValid)
            {
                String validacion = negocio.validarCartelera(cartelera);

                if (validacion != null)
                {
                    ModelState.AddModelError("validacion", validacion);
                }

                else
                {
                    cartelera.FechaCarga = DateTime.Now;
                    db.Carteleras.Add(cartelera);
                    db.SaveChanges();
                    return(RedirectToAction("Index"));
                }
            }

            ViewBag.IdPelicula = new SelectList(db.Peliculas, "IdPelicula", "Nombre", cartelera.IdPelicula);
            ViewBag.IdSede     = new SelectList(db.Sedes, "IdSede", "Nombre", cartelera.IdSede);
            ViewBag.IdVersion  = new SelectList(db.Versiones, "IdVersion", "Nombre", cartelera.IdVersion);
            return(View(cartelera));
        }
Example #2
0
        // GET: Cartelera/Edit/5
        public ActionResult Edit(int?id)
        {
            if (Session["Admin"] == null)
            {
                TempData["urlController"] = Request.RequestContext.RouteData.Values["controller"].ToString();
                TempData["urlAction"]     = Request.RequestContext.RouteData.Values["action"].ToString();
                return(RedirectToAction("Login", "Usuario"));
            }

            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Cartelera cartelera = db.Carteleras.Find(id);

            if (cartelera == null)
            {
                return(HttpNotFound());
            }
            ViewBag.IdPelicula  = new SelectList(db.Peliculas, "IdPelicula", "Nombre", cartelera.IdPelicula);
            ViewBag.IdSede      = new SelectList(db.Sedes, "IdSede", "Nombre", cartelera.IdSede);
            ViewBag.IdVersion   = new SelectList(db.Versiones, "IdVersion", "Nombre", cartelera.IdVersion);
            ViewBag.FechaCarga  = cartelera.FechaCarga.ToShortDateString();
            ViewBag.FechaInicio = cartelera.FechaInicio.ToShortDateString();
            ViewBag.FechaFin    = cartelera.FechaFin.ToShortDateString();
            return(View(cartelera));
        }
Example #3
0
        public ActionResult Index()
        {
            CarteleraDBEntities db = new CarteleraDBEntities();
            var data = db.Pasas
                       .Include(p => p.Pelicula)
                       .Include(p => p.Pelicula.Genero)
                       .Include(p => p.Pelicula.Actores)
                       .Include(p => p.Tanda)
                       .Include(p => p.Cine)
                       .Include(p => p.Cine.Direccion)
                       .Include(p => p.Cine.Tarifas);
            var query = (from c in data
                         //group c by new { c.CineId, c.PeliculaId } into Cartelera
                         group c by c.CineId into Cartelera
                         orderby Cartelera.Key
                         select new
            {
                CineId = Cartelera.Key,
                Tandas = Cartelera.Select(x => x.Tanda.Hora),
                Peliculas = Cartelera.Select(x => x.Pelicula),
                Cartelera.FirstOrDefault().Cine,
            })
                        .ToList()
                        .Select(c => new ViewModel.CarteleraViewModel
            {
                Cine      = c.Cine,
                Peliculas = c.Peliculas,
                Tandas    = c.Tandas,
                CineId    = c.CineId
            }).ToList();

            ViewBag.Cartelera = query;
            return(View());
        }
Example #4
0
 public FuncionPage(Cartelera cartelera)
 {
     InitializeComponent();
     BindingContext          = cartelera;
     listFuncion.ItemsSource = cartelera.Funciones;
     infopeli = cartelera;
 }
Example #5
0
 public FuncionesPage(Cartelera cartelera)
 {
     InitializeComponent();
     BindingContext            = cartelera;
     listFunciones.ItemsSource = cartelera.Funciones;
     globalcar = cartelera;
 }
Example #6
0
        public void borrarCartelera(int idCartelera)
        {
            Cartelera cartelera = ctx.Carteleras.Where(c => c.IdCartelera == idCartelera).FirstOrDefault();

            ctx.Carteleras.Remove(cartelera);
            ctx.SaveChanges();
        }
 public void insertar(int int_pIdPelicula, int int_pIdSala, string str_pFechaHora)
 {
     Cartelera objCartelera = new Cartelera();
     objCartelera.IdPelicula = int_pIdPelicula;
     objCartelera.IdSala = int_pIdSala;
     objCartelera.FechaHora = DateTime.ParseExact(str_pFechaHora,  "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
     new CarteleraDAO().insertar(objCartelera);
 }
Example #8
0
        public ActionResult DeleteConfirmed(int id)
        {
            Cartelera cartelera = db.Carteleras.Find(id);

            db.Carteleras.Remove(cartelera);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
 public void insertar(Cartelera objCartelera)
 {
     using (var context = new FideCineEntities())
     {
         context.Cartelera.AddObject(objCartelera);
         context.SaveChanges();
     }
 }
        public ActionResult Crear(Cartelera carte, int idpelicula)
        {
            var proxy = new TransaccionesClient();
            var peli  = proxy.obtenerPelicula(idpelicula);

            carte.pelicula = peli;
            proxy.crearCartelera(carte);
            return(RedirectToAction("Index"));
        }
Example #11
0
        public DetallePage(Funciones funciones, Cartelera pelicula, int valor)
        {
            int total = valor * (funciones.Precio);

            InitializeComponent();
            carteleral.BindingContext = pelicula;
            lbltotal.Text             = Convert.ToString(total);
            Label21.Text = Convert.ToString(valor);
            stackLayout.BindingContext = funciones;
        }
        public ResumenPage(Funciones funcion, Cartelera cartelera, int precio)
        {
            int valor = precio * (funcion.Precio);

            InitializeComponent();
            infopeli.BindingContext    = funcion;
            resumenpeli.BindingContext = cartelera;
            lbl1.Text = Convert.ToString(precio);
            lbl1.Text = Convert.ToString(valor);
        }
        public ContenidoPage(Funciones funciones, Cartelera cartelera, int valor)
        {
            int total = valor * (funciones.Precio);

            InitializeComponent();
            stackLayout.BindingContext = funciones;
            cartelerajp.BindingContext = cartelera;
            miLabel.Text  = Convert.ToString(valor);
            lbltotal.Text = Convert.ToString(total);
        }
        public Cartelera Cartelera()
        {
            var PeliculasService = new PeliculasService();
            var TandasService    = new TandasService();
            var Cartelera        = new Cartelera()
            {
                Peliculas = PeliculasService.Peliculas(),
                Tandas    = TandasService.Tandas()
            };

            return(Cartelera);
        }
Example #15
0
        public ActionResult EditarCartelera(Cartelera c, Carteleras cartelera)
        {
            if (ModelState.IsValid)
            {
                cservice.EditarCartelera(cartelera);
                return(RedirectToAction("Carteleras"));
            }

            ViewBag.Peliculas = pservice.ObtenerPeliculas();
            ViewBag.Versiones = pservice.ObtenerVersiones();
            ViewBag.Sedes     = cservice.ObtenerSedesDisponiblesCarteleras();
            return(View(c));
        }
Example #16
0
        // GET: Cartelera/Delete/5
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Cartelera cartelera = db.Carteleras.Find(id);

            if (cartelera == null)
            {
                return(HttpNotFound());
            }
            return(View(cartelera));
        }
Example #17
0
        public ActionResult NuevaCartelera(Carteleras c, Cartelera cartelera)
        {
            if (ModelState.IsValid)
            {
                c.FechaCarga = DateTime.Now;
                cservice.AgregarCartelera(c);
                return(RedirectToAction("Carteleras"));
            }

            ViewBag.Peliculas = pservice.ObtenerPeliculas();
            ViewBag.Versiones = pservice.ObtenerVersiones();
            ViewBag.Sedes     = cservice.ObtenerSedesDisponiblesCarteleras();
            return(View(cartelera));
        }
        public ResumenCompraPage(Funcion func, int cantid, Cartelera cartelera)
        {
            InitializeComponent();
            datos.BindingContext   = cartelera;
            funcion.BindingContext = func;

            Tiquete tiquete = new Tiquete();

            tiquete.Precio    = func.Precio;
            tiquete.Cantidad  = cantid;
            tiquete.TotalPago = func.Precio * cantid;

            tiquetes.BindingContext = tiquete;
        }
Example #19
0
        private void btnMostrar_Click(object sender, EventArgs e)
        {
            Cartelera cartel = new Cartelera();

            cartel.Id      = 799546;
            cartel.Fecha   = "11/03/2019";
            cartel.Horario = "Vespertino";
            cartel.Tipo    = "Publica";
            cartel.Costo   = 52;

            textId.Text      = cartel.Id.ToString();
            textFecha.Text   = cartel.Fecha;
            textHorario.Text = cartel.Horario;
            textTipo.Text    = cartel.Tipo;
            textCosto.Text   = cartel.Costo.ToString();
        }
Example #20
0
        public eventos updateeventos(Cartelera pEvento)
        {
            eventos event_carte = new eventos();

            event_carte.PK_eventos              = pEvento.Id;
            event_carte.nombreEve               = pEvento.Nombre;
            event_carte.ubicacion               = pEvento.Ubicacion;
            event_carte.FK_EVENTOS_PAISES       = _manejadorDB.obtenerPais(pEvento.Pais).PK_paises;
            event_carte.fechaInicio             = pEvento.FechaInicioFestival;
            event_carte.fechaFinal              = pEvento.FechaInicioFestival;
            event_carte.finalVotacion           = pEvento.FechaFinalVotacion;
            event_carte.FK_EVENTOS_TIPOSEVENTOS = _manejadorDB.obtenerTipoEvento(pEvento.TipoEvento).PK_tiposEventos;
            event_carte.FK_EVENTOS_ESTADOS      = _manejadorDB.obtenerEstado(pEvento.Estado).PK_estados;

            return(event_carte);
        }
Example #21
0
        private async void cartelera_ItemSelected(object sender, SelectedItemChangedEventArgs e)
        {
            var       item  = (Funcion)e.SelectedItem;
            Cartelera carte = (Cartelera)datos.BindingContext;

            if (cantidadBoletas.Text != null && cantidadBoletas.Text != " ")
            {
                int cantidad = int.Parse(cantidadBoletas.Text);

                if (cantidad > 0)
                {
                    await Navigation.PushAsync(new ResumenCompraPage(item, cantidad, carte));
                }
                else
                {
                    await DisplayAlert("Alerta", "La cantidad minima es 1", "Ok");
                }
            }
        }
Example #22
0
        public ActionResult diasYHorarios(int idSede, int idPelicula, int idVersion)
        {
            Cartelera  carte = cMng.obtenerCarteleraPorSedeYPeliculaYVersion(idSede, idPelicula, idVersion);
            List <int> dias  = new List <int>();

            if (carte.Domingo)
            {
                dias.Add(0);
            }
            if (carte.Lunes)
            {
                dias.Add(1);
            }
            if (carte.Martes)
            {
                dias.Add(2);
            }
            if (carte.Miercoles)
            {
                dias.Add(3);
            }
            if (carte.Jueves)
            {
                dias.Add(4);
            }
            if (carte.Viernes)
            {
                dias.Add(5);
            }
            if (carte.Sabado)
            {
                dias.Add(6);
            }

            DiasYHorarioRespuesta respuesta = new DiasYHorarioRespuesta();

            respuesta.Dias  = dias;
            respuesta.Hora  = carte.HoraInicio;
            respuesta.Hasta = carte.FechaFin;

            return(Json(respuesta, JsonRequestBehavior.AllowGet));
        }
Example #23
0
        public Evento createEvento(eventos pEvento)
        {
            Evento evento;
            string country, event_type, state, chef;

            country    = _manejadorDB.obtenerPais(pEvento.FK_EVENTOS_PAISES).pais;
            event_type = _manejadorDB.obtenerTipoEvento(pEvento.FK_EVENTOS_TIPOSEVENTOS).tipo;
            state      = _manejadorDB.obtenerEstado(pEvento.FK_EVENTOS_ESTADOS).estado;

            if (pEvento.FK_EVENTOS_TIPOSEVENTOS == 1)
            {
                evento =
                    new Cartelera(pEvento.PK_eventos,
                                  pEvento.nombreEve,
                                  pEvento.ubicacion,
                                  country,
                                  pEvento.fechaInicio,
                                  pEvento.fechaFinal,
                                  pEvento.finalVotacion.Value,
                                  event_type,
                                  state);
            }
            else
            {
                chef   = _manejadorDB.obtenerBanda((int)pEvento.FK_EVENTOS_BANDAS_CHEF).nombreBan;
                evento =
                    new Festival(pEvento.PK_eventos,
                                 pEvento.nombreEve,
                                 pEvento.ubicacion,
                                 country,
                                 pEvento.fechaInicio,
                                 pEvento.finalVotacion.Value,
                                 event_type,
                                 state,
                                 pEvento.comida,
                                 pEvento.transporte,
                                 pEvento.servicios,
                                 chef);
            }

            return(evento);
        }
Example #24
0
        public ActionResult Edit([Bind(Include = "IdCartelera,IdSede,IdPelicula,HoraInicio,FechaInicio,FechaFin,NumeroSala,IdVersion,Lunes,Martes,Miercoles,Jueves,Viernes,Sabado,Domingo,FechaCarga")] Cartelera cartelera)
        {
            if (Session["Admin"] == null)
            {
                TempData["urlController"] = Request.RequestContext.RouteData.Values["controller"].ToString();
                TempData["urlAction"]     = Request.RequestContext.RouteData.Values["action"].ToString();
                return(RedirectToAction("Login", "Usuario"));
            }

            if (ModelState.IsValid)
            {
                db.Entry(cartelera).State = EntityState.Modified;
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }
            ViewBag.IdPelicula = new SelectList(db.Peliculas, "IdPelicula", "Nombre", cartelera.IdPelicula);
            ViewBag.IdSede     = new SelectList(db.Sedes, "IdSede", "Nombre", cartelera.IdSede);
            ViewBag.IdVersion  = new SelectList(db.Versiones, "IdVersion", "Nombre", cartelera.IdVersion);
            return(View(cartelera));
        }
Example #25
0
        // GET: Cartelera/Details/5
        public ActionResult Details(int?id)
        {
            if (Session["Admin"] == null)
            {
                TempData["urlController"] = Request.RequestContext.RouteData.Values["controller"].ToString();
                TempData["urlAction"]     = Request.RequestContext.RouteData.Values["action"].ToString();
                return(RedirectToAction("Login", "Usuario"));
            }

            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Cartelera cartelera = db.Carteleras.Find(id);

            if (cartelera == null)
            {
                return(HttpNotFound());
            }
            return(View(cartelera));
        }
Example #26
0
        public void actualizarCartelera(Cartelera cartelera)
        {
            Cartelera carteBase = ctx.Carteleras.Where(car => car.IdCartelera == cartelera.IdCartelera).FirstOrDefault();

            carteBase.IdSede      = cartelera.IdSede;
            carteBase.IdPelicula  = cartelera.IdPelicula;
            carteBase.IdVersion   = cartelera.IdVersion;
            carteBase.HoraInicio  = cartelera.HoraInicio;
            carteBase.FechaInicio = cartelera.FechaInicio;
            carteBase.FechaFin    = cartelera.FechaFin;
            carteBase.NumeroSala  = cartelera.NumeroSala;
            carteBase.FechaCarga  = DateTime.Now;
            carteBase.Domingo     = cartelera.Domingo;
            carteBase.Lunes       = cartelera.Lunes;
            carteBase.Martes      = cartelera.Martes;
            carteBase.Miercoles   = cartelera.Miercoles;
            carteBase.Jueves      = cartelera.Jueves;
            carteBase.Viernes     = cartelera.Viernes;
            carteBase.Sabado      = cartelera.Sabado;
            ctx.SaveChanges();
        }
Example #27
0
        public Cartelera ObtenerDetalle(int?id)
        {
            Cartelera pelicula = db.Carteleras.Find(id);

            return(pelicula);
        }
Example #28
0
 public FormularioReserva()
 {
     miCartelera = new Cartelera();
     InitializeComponent();
 }
Example #29
0
 public xmlParsing()
 {
     cartel = new Cartelera();
     cartel.ComplejoID = 125;
     cartel.CiudadID = 51;
 }
Example #30
0
        public Cartelera BorrarCalificacion(int?id)
        {
            Cartelera pelicula = db.Carteleras.Find(id);

            return(pelicula);
        }
Example #31
0
        //Crear evento nuevo
        public Respuesta crearEvento(string pTipoEvento, JObject pDatosEventoJSON, JArray pListaCategorias)
        {
            Respuesta respuesta = null;

            try
            {
                string nombreEvento = null;
                switch (pTipoEvento)
                {
                //Si el evento a crear es una cartelera
                case "cartelera":
                    //Verificar si cartelera existe
                    Cartelera nuevaCartelera = _serial.leerDatosCartelera(pDatosEventoJSON);
                    nombreEvento = nuevaCartelera.Nombre;
                    eventos eveAux = _manejador.obtenerEvento(nuevaCartelera.Nombre);
                    if (eveAux != null)
                    {
                        return(_fabricaRespuestas.crearRespuesta(false, "Error: Evento ya existente. Intentar de nuevo por favor."));
                    }

                    //Verificar que existan categorias en la cartelera
                    FestivalCategoriaBanda[] categoriasSerial = _serial.getArrayFestivalCategoriaBanda(pListaCategorias);
                    if (categoriasSerial.Length == 0)
                    {
                        return(_fabricaRespuestas.crearRespuesta(false, "No se puede crear cartelera sin categorías. Por favor intente de nuevo."));
                    }

                    //Organiza información para envío
                    List <categoriasevento> categoriasEvento = _convertidor.updatecategoriasevento(categoriasSerial);

                    //Verificar existencia de bandas en categoria
                    foreach (categoriasevento catEve in categoriasEvento)
                    {
                        if (_manejador.obtenerBanda(catEve.FK_CATEGORIASEVENTO_BANDAS) == null)
                        {
                            string nombreCategoria = _manejador.obtenerCategoria(catEve.FK_CATEGORIASEVENTO_CATEGORIAS).categoria;
                            return(_fabricaRespuestas.crearRespuesta(false, "No se puede crear una cartelera si " + nombreCategoria
                                                                     + " no tiene bandas asociadas. Por favor intente de nuevo."));
                        }
                        bandas bandaAuxiliar = _manejador.obtenerBanda(catEve.FK_CATEGORIASEVENTO_BANDAS);
                        if (_manejador.comprobarBandaEnCartelera(nuevaCartelera.FechaInicioFestival, nuevaCartelera.FechaFinalFestival, bandaAuxiliar))
                        {
                            return(_fabricaRespuestas.crearRespuesta(false, "La banda " + bandaAuxiliar.nombreBan + " no se encuentra disponible para las fechas indicadas."));
                        }
                    }

                    //Almacena nuevo evento en persistencia
                    _manejador.añadirCartelera(_convertidor.updateeventos(nuevaCartelera), categoriasEvento);

                    //Publicar tweets de bandas agregadas a evento
                    publicarBandasTwitter(nombreEvento, categoriasEvento);

                    //Operación completada
                    respuesta = _fabricaRespuestas.crearRespuesta(true, "Cartelera creada exitosamente.");
                    break;

                //Si el evento a crear es un festival
                case "festival":
                    //Verificar si festival existe
                    Festival nuevoFestival = _serial.leerDatosFestival(pDatosEventoJSON);
                    eventos  eveAux1       = _manejador.obtenerEvento(nuevoFestival.Nombre);
                    if (eveAux1 == null)
                    {
                        return(_fabricaRespuestas.crearRespuesta(false, "Error: Cartelera no existente. Intentar de nuevo por favor. Se necesita partir de una cartelera para convertir a festival."));
                    }

                    FestivalCategoriaBanda[] categoriasFestival = _serial.getArrayFestivalCategoriaBanda(pListaCategorias);

                    eventos nuevoEvento = _convertidor.updateeventos(nuevoFestival);


                    //Organiza la información para envío
                    List <bandas>     bandasGanadorasFestival = parseBandas(categoriasFestival);
                    List <categorias> categoriasCartelera     = _manejador.obtenerCategoriasEvento(nuevoEvento.PK_eventos);
                    List <bandas>     todasBandasCartelera    = extraerBandasEvento(nuevoEvento, categoriasCartelera);

                    List <bandas> bandasPerdedoras = extraerBandasNoSeleccionadas(bandasGanadorasFestival, todasBandasCartelera);

                    Console.WriteLine("*** Cartelera ***");
                    printList(todasBandasCartelera);

                    Console.WriteLine("*** Ganadoras ***");
                    printList(bandasGanadorasFestival);

                    Console.WriteLine("*** Perdedoras ***");
                    printList(bandasPerdedoras);

                    List <string> bandasGanadoras        = bandasToString(bandasGanadorasFestival);
                    List <string> bandasPerdedorasString = bandasToString(bandasPerdedoras);

                    string bandaRecomendada = _chef.executeChefProcess(bandasGanadoras, bandasGanadorasFestival, nuevoEvento.PK_eventos);

                    nuevoEvento.FK_EVENTOS_BANDAS_CHEF = _manejador.obtenerBanda(bandaRecomendada).PK_bandas;

                    //Almacena nuevo evento en persistencia
                    _manejador.crearFestival(nuevoEvento, bandasPerdedoras);

                    //Publica tweet de nuevo festival
                    publicarFestivalNuevoTwitter(nuevoEvento.nombreEve);

                    //Operación completada
                    respuesta = _fabricaRespuestas.crearRespuesta(true, "Festival creado exitosamente. Nuestra banda recomendada por el chef para el festival es: " + bandaRecomendada);
                    break;

                default:
                    //Tipo de evento no existe
                    respuesta = _fabricaRespuestas.crearRespuesta(false, "Tipo de evento no existente.");
                    break;
                }
            } catch (Exception e)
            {
                //respuesta = _fabricaRespuestas.crearRespuesta(false, "Error al crear evento por falta de información. Verifique los datos ingresados por favor.");
                respuesta = _fabricaRespuestas.crearRespuesta(false, "Error al crear evento. Por favor intente de nuevo.", e.ToString());
            }

            //Retorna respuesta
            return(respuesta);
        }
Example #32
0
 public FuncionesPage(Cartelera cartelera)
 {
     InitializeComponent();
     datos.BindingContext  = cartelera;
     funciones.ItemsSource = cartelera.Funciones;
 }
Example #33
0
 public xmlParsing(int ciudadID, int complejoID)
 {
     cartel = new Cartelera();
     cartel.CiudadID = ciudadID;
     cartel.ComplejoID = complejoID;
 }
Example #34
0
 public Cartelera eliminarCartelera(Cartelera CarteleraEliminar)
 {
     throw new NotImplementedException();
 }