// PUT api/Default1/5
public HttpResponseMessage PutPelicula(int id, Pelicula pelicula)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
if (id != pelicula.PeliculaID)
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
db.Entry(pelicula).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return Request.CreateErrorResponse(HttpStatusCode.NotFound, ex);
}
return Request.CreateResponse(HttpStatusCode.OK);
}
public void insertar(Pelicula entidad)
{
using (var context = new FideCineEntities())
{
context.Pelicula.AddObject(entidad);
context.SaveChanges();
}
}
private void LlenaCampos(Pelicula pelicula)
{
PeliculasIdTextBox.Text = pelicula.PeliculasId.ToString();
TituloTextBox.Text = pelicula.Titulo;
SignosisTextBox.Text = pelicula.Signosis;
CalificacionTextBox.Text = pelicula.Calificacion.ToString();
anoNumericUpDown.Text = pelicula.Anno.ToString();
IdiomaTextBox.Text = pelicula.Idioma;
GeneroTextBox.Text = pelicula.Genero;
CategoriaIdComboBox.Text = pelicula.CategoriaId.ToString();
}
public Cartelera getCartelCine()
{
doc = new XmlDocument();
try
{
doc.Load("http://www.cinepolis.com.mx/iphone/xml-iphone.aspx?query=cartelera&ci=" + cartel.CiudadID);
}
catch (Exception e) { return null; }
try
{
complejoInfo = doc.SelectSingleNode("//Cartelera//Complejo[@Complejoid='" + cartel.ComplejoID + "']");
cartel.Complejo = complejoInfo.Attributes.GetNamedItem("Nombre").Value;
cartel.Latitud = complejoInfo.ChildNodes[1].InnerText.Trim();
cartel.Longitud = complejoInfo.ChildNodes[2].InnerText.Trim();
Complejos_peli = doc.SelectNodes("//Cartelera//Complejo[@Complejoid='" + cartel.ComplejoID + "']/Pelicula");
foreach (XmlNode complejo_peli in Complejos_peli)
{
peli = new Pelicula();
string Horario_Peli = "";
peli.PeliculaID = complejo_peli.FirstChild.InnerText;
Complejos_hora = doc.SelectNodes("//Cartelera//Complejo/Pelicula[Peliculaid='" + peli.PeliculaID + "']/Horarios/Horario");
foreach (XmlNode horario in Complejos_hora)
{
Horario_Peli += horario.InnerText + " - ";
}
peliculaInfo = doc.SelectSingleNode("//Peliculas//Pelicula[@Peliculaid='" + peli.PeliculaID + "']");
peli.Nombre = peliculaInfo.Attributes.GetNamedItem("Nombre").Value;
peli.Clasificacion = peliculaInfo.ChildNodes[1].InnerText;
peli.Calificacion = peliculaInfo.ChildNodes[4].InnerText;
peli.Descripcion = peliculaInfo.ChildNodes[6].InnerText;
peli.Director = peliculaInfo.ChildNodes[7].InnerText;
peli.Actor = peliculaInfo.ChildNodes[8].InnerText;
peli.Duracion = peliculaInfo.ChildNodes[16].InnerText;
peli.Trailer = peliculaInfo.ChildNodes[19].InnerText;
peli.Horarios = Horario_Peli;
cartel.Peliculas.Add(peli);
}
}
catch (Exception e) { return null;}
return cartel;
}
// POST api/Default1
public HttpResponseMessage PostPelicula(Pelicula pelicula)
{
if (ModelState.IsValid)
{
db.Peliculas.Add(pelicula);
db.SaveChanges();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, pelicula);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = pelicula.PeliculaID }));
return response;
}
else
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
}
public PeliculaBE InsertarPelicula(PeliculaBE entidad)
{
Pelicula objeto = new Pelicula();
objeto.IdPelicula = entidad.IdPelicula;
objeto.Nombre = entidad.Nombre;
objeto.idcategoria = entidad.IdCategoria;
objeto.trailer = entidad.Trailer;
objeto.descripcion = entidad.Descripcion;
objeto.idtipo = entidad.IdTipo;
objeto.Estado = entidad.Estado;
objeto.idgenero = entidad.IdGenero;
objeto.duracion = entidad.Duracion;
dao.insertar(objeto);
return null;
}
public ActionResult Create(Pelicula pelicula)
{
try
{
using (var uow = LightSpeed_Expo.MvcApplication.LightSpeedContext.CreateUnitOfWork())
{
uow.Add(pelicula);
uow.SaveChanges();
uow.Dispose();
}
return RedirectToAction("Index");
}
catch
{
return View();
}
}
public static bool Insertar(Pelicula pelicula)
{
bool retorno = false;
try
{
using (var db = new PeliculasDb())
{
db.Pelicula.Add(pelicula);
db.SaveChanges();
retorno = true;
}
}
catch(Exception ex)
{
throw ex;
}
return retorno;
}
private List <PeliculaActorDTO> MapearPeliculasActores(Pelicula pelicula, PeliculaDTO peliculaDTO)
{
var resultado = new List <PeliculaActorDTO>();
if (pelicula.PeliculasActores != null)
{
foreach (var actorPeliculas in pelicula.PeliculasActores)
{
resultado.Add(new PeliculaActorDTO()
{
Id = actorPeliculas.ActorId,
Nombre = actorPeliculas.Actor.Nombre,
Foto = actorPeliculas.Actor.Foto,
Orden = actorPeliculas.Orden,
Personaje = actorPeliculas.Personaje
});
}
}
return(resultado);
}
/*
* da de alta una pelicula
*/
private void BtnAceptar_Click(object sender, RoutedEventArgs e)
{
Pelicula oPeli = new Pelicula();
capturar_datos(oPeli);
if (true) //validaciones luego
{
var confirmResult = MessageBox.Show(oPeli.ToString(),
"Agregar? Si/No",
MessageBoxButton.YesNo, MessageBoxImage.Question);
if (confirmResult == MessageBoxResult.Yes)
{
MessageBox.Show("Se agrego correctamente", "Agregado", MessageBoxButton.OK, MessageBoxImage.Information);
limpiar_campos();
}
}
else
{
MessageBox.Show("algo incorrecto");
}
}
public async Task <ActionResult <int> > Post(Pelicula pelicula)
{
if (!string.IsNullOrEmpty(pelicula.Poster))
{
var posterPelicula = Convert.FromBase64String(pelicula.Poster);
pelicula.Poster = await almacenadorArchivos.GuardarArchivo(posterPelicula, ".jpg", contenedor);
}
if (pelicula.PeliculaActor != null)
{
for (int i = 0; i < pelicula.PeliculaActor.Count; i++)
{
pelicula.PeliculaActor[i].Orden = i + 1;
}
}
context.Add(pelicula);
await context.SaveChangesAsync();
return(pelicula.Id);
}
/// <summary>
///
/// </summary>
/// <param name="peliculaCreacionDTO"></param>
/// <param name="pelicula"></param>
/// <returns></returns>
private List <PeliculaActores> MapPeliculasActores(PeliculaCreacionDTO peliculaCreacionDTO,
Pelicula pelicula)
{
var resultado = new List <PeliculaActores>();
if (peliculaCreacionDTO.Actores == null)
{
return(resultado);
}
foreach (var actor in peliculaCreacionDTO.Actores)
{
resultado.Add(new PeliculaActores()
{
ActorId = actor.ActorId, Personaje = actor.Personaje
});
}
return(resultado);
}
/// <summary>
///
/// </summary>
/// <param name="peliculaCreacionDTO"></param>
/// <param name="pelicula"></param>
/// <returns></returns>
private List <PeliculasGeneros> MapPeliculasGeneros(PeliculaCreacionDTO peliculaCreacionDTO,
Pelicula pelicula)
{
var resultado = new List <PeliculasGeneros>();
if (peliculaCreacionDTO.GenerosIDs == null)
{
return(resultado);
}
foreach (var id in peliculaCreacionDTO.GenerosIDs)
{
resultado.Add(new PeliculasGeneros()
{
GeneroId = id
});
}
return(resultado);
}
private static Pelicula crearPelicula(Registro reg)
{
Pelicula pel = null;
if (reg != null)
{
pel = new Pelicula
{
Id = int.Parse(reg.Get(0)),
Nombre = reg.Get(1),
Imagen = reg.Get(2),
Calificacion = int.Parse(reg.Get(3)),
Formato3D = bool.Parse(reg.Get(4)),
Duracion = int.Parse(reg.Get(5)),
Genero = int.Parse(reg.Get(6)),
Sinopsis = reg.Get(7),
Activa = bool.Parse(reg.Get(8))
};
}
return(pel);
}
public ActionResult Delete(int id, FormCollection collection)
{
using (var uow = LightSpeed_Expo.MvcApplication.LightSpeedContext.CreateUnitOfWork())
{
try
{
Pelicula pelicula = uow.Peliculas.FirstOrDefault(p => p.Id == id);
if (pelicula == null)
{
return(HttpNotFound());
}
uow.Remove(pelicula);
uow.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
}
public ActionResult Delete(int id, Pelicula collection)
{
try
{
// TODO: Add delete logic here
PeliculaCEN cen = new PeliculaCEN();
cen.Destroy(id);
string action = System.Web.HttpContext.Current.Session["action"] as String;
string controller = System.Web.HttpContext.Current.Session["controller"] as String;
Object arg = System.Web.HttpContext.Current.Session["arg"];
return(RedirectToAction(action, controller, arg));
}
catch
{
return(View());
}
}
private List <ActorPeliculaDetalleDTO> MapPeliculasActores(Pelicula pelicula, PeliculaDetallesDTO peliculaDetallesDTO)
{
var resultado = new List <ActorPeliculaDetalleDTO>();
if (pelicula.PeliculasActores is null)
{
return(resultado);
}
foreach (var peliculaActor in pelicula.PeliculasActores)
{
resultado.Add(new ActorPeliculaDetalleDTO()
{
ActorId = peliculaActor.ActorId,
Personaje = peliculaActor.Actor.Nombre,
NombrePersona = peliculaActor.Actor.Nombre
});
}
return(resultado);
}
private List <ActorPeliculaDto> mapPeliculasActores(Pelicula pelicula, PeliculaDetallesDTO peliculaDetallesDto)
{
var resultado = new List <ActorPeliculaDto>();
if (pelicula.PeliculasActoreses == null)
{
return(resultado);
}
foreach (var actoresPelicula in pelicula.PeliculasActoreses)
{
resultado.Add(new ActorPeliculaDto()
{
ActorId = actoresPelicula.ActorId,
Personaje = actoresPelicula.Personaje,
NombrePErsona = actoresPelicula.Actor.Nombre
});
}
return(resultado);
}
public async Task <ActionResult <int> > Post(Pelicula pelicula)
{
if (!string.IsNullOrWhiteSpace(pelicula.Poster))
{
var fotoPersona = Convert.FromBase64String(pelicula.Poster);
pelicula.Poster = await almacenadorDeArchivos.GuardarArchivo(fotoPersona, "jpg", "peliculas");
}
if (pelicula.PeliculasActor != null)
{
for (int i = 0; i < pelicula.PeliculasActor.Count; i++)
{
pelicula.PeliculasActor[i].Orden = i + 1;
}
}
context.Add(pelicula);
await context.SaveChangesAsync();
return(pelicula.Id);
}
// GET: Pelicula/Edit/5
public ActionResult Edit(int id)
{
PeliculaCEN cen = new PeliculaCEN();
PeliculaEN en = new PeliculaEN();
en = cen.ReadOID(id);
// SessionInitializeTransaction();
//IProducto productoCAD = new productoCAD(session);
// ProductoEN en = new Pro;
AssemblerPelicula ass = new AssemblerPelicula();
Pelicula sol = ass.ConvertENToModelUI(en);
ViewData["controller"] = System.Web.HttpContext.Current.Session["controller"] as String;
ViewData["action"] = System.Web.HttpContext.Current.Session["action"] as String;
ViewData["arg"] = System.Web.HttpContext.Current.Session["arg"];
return(View(sol));
}
public static void Delete(int?id)
{
using (Entities db = new Entities())
{
using (var transaction = db.Database.BeginTransaction())
{
try
{
Pelicula pelicula = db.Pelicula.Find(id);
db.Entry(pelicula).State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
}
}
public static void ValidarBoleto(string mensaje, out int num, Pelicula pelicula)
{
bool isNumber;
do
{
Console.Clear();
Colorful.Console.WriteAscii(pelicula.Nombre, ColorTranslator.FromHtml("#e91e63"));
Console.WriteLine("Sinopsis: ");
Console.WriteLine(pelicula.Sinopsis);
Console.WriteLine("\n\n");
Console.WriteLine("Adultos: $4.25 Adulto mayor: $3.25 Niños: $2.25");
Console.WriteLine(mensaje);
isNumber = int.TryParse(Console.ReadLine(), out num);
if (isNumber == false || num < 0)
{
Console.WriteLine("Valor no válido. Intentelo nuevamente.");
Console.ReadKey();
}
} while (isNumber == false || num < 0);
}
public ActionResult Edit(string nombre, FormCollection collection)
{
try
{
// TODO: Add update logic here
var model = new Pelicula
{
Nombre = collection["Nombre"],
Tipo = collection["Tipo"],
Genero = collection["genero"],
Año = Convert.ToInt16(collection["lanzamiento"])
};
Data1.Instance.Pelicula.Remove(Data1.Instance.Pelicula.First(x => x.Nombre == nombre));
Data1.Instance.Pelicula.Add(model);
return(RedirectToAction("Importar"));
}
catch
{
return(View());
}
}
public static void Update(Pelicula pelicula)
{
using (Entities db = new Entities())
{
using (var transaction = db.Database.BeginTransaction())
{
try
{
db.Pelicula.Attach(pelicula);
db.Entry(pelicula).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
}
}
public ActionResult Create(FormCollection collection)
{
try
{
// TODO: Add insert logic here
var model = new Pelicula
{
Nombre = collection["Nombre"],
Tipo = collection["Tipo"],
Genero = collection["genero"],
Año = Convert.ToInt16(collection["lanzamiento"])
};
Data1.Instance.Pelicula.Add(model);
return(RedirectToAction("Importar"));
}
catch
{
return(View());
}
}
protected void Button1_Click(object sender, EventArgs e)
{
Pelicula pelicula = new Pelicula();
pelicula.Nombre = txtTitulo.Text;
pelicula.Year = Convert.ToInt32(txtyear.Text);
pelicula.Genero = txtGenero.Text;
pelicula.Nacionalidad = txtNacionalidad.Text;
pelicula.IdDirector = Convert.ToInt32(txtIdDirector.Text);
WebService w = new WebService();
if (w.InsertarPelicula(pelicula) == 0)
{
Page.ClientScript.RegisterStartupScript(this.GetType(), "Scripts", "<script>alert('Ha ocurrido un error al insertar');</script>");
}
else
{
Page.ClientScript.RegisterStartupScript(this.GetType(), "Scripts", "<script>alert('Se ha insertado correctamente');</script>");
}
}
private void comprarButton_Click(object sender, EventArgs e)
{
EstadoPedido estadoPedido;
if (ValidarNIF())
{
Socio socio = (Socio)socioBindingSource.Current;
Pelicula pelicula = (Pelicula)peliculasBindingSource.Current;
estadoPedido = ConnectionHelper.ServiceClient.ComprarPelicula(socio.NIF, pelicula.CodBarras);
if (estadoPedido == EstadoPedido.Realizado)
{
MessageBox.Show("Se realizó la compra correctamente", "MSDN Video", MessageBoxButtons.OK, MessageBoxIcon.Information);
Refrescar();
}
}
else
{
MessageBox.Show("Corrija la información no válida antes de guardar", "MSDN Video", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public HttpResponseMessage Post([FromBody] Pelicula data)
{
Pelicula pelicula = new Pelicula();
pelicula.id = data.id;
pelicula.titulo = data.titulo;
pelicula.descripcion = data.descripcion;
pelicula.director = data.director;
pelicula.costo_alquiler = data.costo_alquiler;
pelicula.cantidad = data.cantidad;
pelicula.actores = data.actores;
try
{
pelicula.insertar();
return(new HttpResponseMessage(HttpStatusCode.Created));
}
catch (SqlException ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.ToString()));
}
}
public ActionResult AgregarPelicula(PeliculaModel p)
{
var file = Request.Files[0];
List <Genero> generos = pMng.obtenerGeneros();
List <Calificacione> cal = pMng.obtnerClasificaciones();
ViewBag.generos = generos;
ViewBag.calificaciones = cal;
if (ModelState.IsValid)
{
try
{
if (file.ContentLength > 0)
{
Pelicula pe = new Pelicula();
string _filename = Path.GetFileName(file.FileName);
string _patch = Path.Combine(Server.MapPath("~/UploadFiles"), _filename);
file.SaveAs(_patch);
pe.Nombre = p.Nombre;
pe.Descripcion = p.Descripcion;
pe.Duracion = p.Duracion;
pe.IdGenero = p.IdGenero;
pe.IdCalificacion = p.IdCalificacion;
pe.Imagen = _patch;
pMng.guardarPeliculas(pe);
return(RedirectToAction("Peliculas", "Peliculas"));
}
}
catch (Exception e)
{
ViewBag.Message = "Error al subir el archivo";
}
}
return(RedirectToAction("AgregarPelicula", "Peliculas"));
}
public Pelicula findPeliculaById(int id)
{
connection.ConnectionString = conexionADO.GetCnx();
command.Connection = connection;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "usp_FindPeliculaById";
try
{
command.Parameters.Clear();
command.Parameters.AddWithValue("@vid_pel", id);
connection.Open();
SqlDataReader dataReader = command.ExecuteReader();
Pelicula pelicula = new Pelicula();
while (dataReader.Read())
{
pelicula.IdPelicula = Convert.ToInt16(dataReader["IdPelicula"]);
pelicula.IdDirector = Convert.ToInt16(dataReader["IdDirector"]);
pelicula.Nombre = dataReader["Nombre"].ToString();
pelicula.Genero = dataReader["Genero"].ToString();
pelicula.Sinopsis = dataReader["Sinopsis"].ToString();
pelicula.FchEstreno = Convert.ToDateTime(dataReader["FchEstreno"]);
}
return(pelicula);
}
catch (SqlException ex)
{
throw new Exception(ex.Message);
}
finally
{
if (connection.State == ConnectionState.Open)
{
connection.Close();
}
}
}
public bool agregar(Pelicula pelicula)
{
try
{
conexion.abrir();
query = "INSERT INTO Peliculas VALUES(@cod, @nombre, @duracion, @actores, @director, @codGenero, @CodClasificacion, @descripcion, @portada, @estado)";
comando = new SqlCommand(query, conexion.getSqlConnection());
comando.Parameters.Add("@cod", SqlDbType.Int);
comando.Parameters["@cod"].Value = pelicula.getId();
comando.Parameters.Add("@nombre", SqlDbType.VarChar);
comando.Parameters["@nombre"].Value = pelicula.getNombre();
comando.Parameters.Add("@duracion", SqlDbType.Int);
comando.Parameters["@duracion"].Value = pelicula.getDuracion();
comando.Parameters.Add("@actores", SqlDbType.VarChar);
comando.Parameters["@actores"].Value = pelicula.getActores() ?? (object)DBNull.Value;
comando.Parameters.Add("@director", SqlDbType.VarChar);
comando.Parameters["@director"].Value = pelicula.getDirector() ?? (object)DBNull.Value;
comando.Parameters.Add("@codGenero", SqlDbType.Int);
comando.Parameters["@codGenero"].Value = pelicula.getGenero().getId();
comando.Parameters.Add("@codClasificacion", SqlDbType.Int);
comando.Parameters["@codClasificacion"].Value = pelicula.getClasificacion().getId();
comando.Parameters.Add("@descripcion", SqlDbType.VarChar);
comando.Parameters["@descripcion"].Value = pelicula.getDescripcion() ?? (object)DBNull.Value;
comando.Parameters.Add("@portada", SqlDbType.Image);
comando.Parameters["@portada"].Value = pelicula.getImagen() ?? (object)DBNull.Value;
comando.Parameters.Add("@estado", SqlDbType.Bit);
comando.Parameters["@estado"].Value = pelicula.getEstado();
comando.ExecuteNonQuery();
conexion.cerrar();
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
conexion.cerrar();
return(false);
}
}
public IHttpActionResult PutPelicula(int id, Pelicula pelicula)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != pelicula.Id)
{
return(BadRequest());
}
try
{
SqlParameter[] parameters = new[] {
new SqlParameter("@operacion", "U"),
new SqlParameter("@id", id),
new SqlParameter("@titulo", pelicula.Titulo),
new SqlParameter("@descripcion", pelicula.Descripcion),
new SqlParameter("@director", pelicula.Director),
new SqlParameter("@disponible", pelicula.Disponible),
};
db.Database.ExecuteSqlCommand("proc_peliculas @operacion,@id,@titulo,@descripcion,@director,@disponible", parameters);
return(Ok("Exitoso"));
}
catch (DbUpdateConcurrencyException)
{
if (!PeliculaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
//PELÍCULAS
public void InsertarPelicula(Pelicula pelicula)
{
_conexion.Open();
_comando = _conexion.CreateCommand();
_comando.CommandText = "INSERT INTO peliculas VALUES (@idPelicula,@titulo,@cartel,@año,@genero,@calificacion)";
_comando.Parameters.Add("@idPelicula", SqliteType.Integer);
_comando.Parameters.Add("@titulo", SqliteType.Text);
_comando.Parameters.Add("@cartel", SqliteType.Text);
_comando.Parameters.Add("@año", SqliteType.Integer);
_comando.Parameters.Add("@genero", SqliteType.Text);
_comando.Parameters.Add("@calificacion", SqliteType.Text);
_comando.Parameters["@idPelicula"].Value = pelicula.IdPelicula;
_comando.Parameters["@titulo"].Value = pelicula.Titulo;
_comando.Parameters["@cartel"].Value = pelicula.Cartel;
_comando.Parameters["@año"].Value = pelicula.Año;
_comando.Parameters["@genero"].Value = pelicula.Genero;
_comando.Parameters["@calificacion"].Value = pelicula.Calificacion;
_comando.ExecuteNonQuery();
_conexion.Close();
}
public ActionResult Create2(Pelicula pelicula, HttpPostedFileBase image)
{
pelicula.Fecha_estreno = DateTime.Today;
if (!ModelState.IsValid)
{
return(View("Create", pelicula));
}
else
{
if (image != null)
{
pelicula.ImageMimeType = image.ContentType;
pelicula.Poster = new byte[image.ContentLength];
image.InputStream.Read(pelicula.Poster, 0, image.ContentLength);
}
db.Pelicula.Add(pelicula);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
//For when you click a generated button of "GenerarBotonesPeliculas()"
public void peli_click(object sender, RoutedEventArgs e)
{
var aux = e.OriginalSource;
if (aux.GetType() == typeof(Button))
{
Button boton = (Button)aux;
String[] btname = boton.Name.Split('_');
int idPeli = Convert.ToInt32(btname[1].Trim());
Pelicula aReservar = uow.RepositorioPelicula.ObtenerUno(c => c.PeliculaId.Equals(idPeli));
MessageBoxResult confirmation = MessageBox.Show("¿Quieres alquilar esta película? ", "Confirmación", MessageBoxButton.YesNo, MessageBoxImage.Question);
switch (confirmation)
{
case MessageBoxResult.Yes:
rentWindow = new RentdataWindow(usuario, aReservar, this);
rentWindow.ShowDialog();
break;
}
}
}
public Pelicula EncontrarPelicula(int idPelicula)
{
SqliteCommand _comandoLocal;
_comandoLocal = _conexion.CreateCommand();
_comandoLocal.CommandText = "SELECT * FROM peliculas WHERE idPelicula=@idPelicula";
_comandoLocal.Parameters.Add("@idPelicula", SqliteType.Integer);
_comandoLocal.Parameters["@idPelicula"].Value = idPelicula;
SqliteDataReader lectorPelicula = _comandoLocal.ExecuteReader();
Pelicula resultado = null;
if (lectorPelicula.HasRows)
{
lectorPelicula.Read();
resultado = new Pelicula(lectorPelicula.GetInt32(0), lectorPelicula.GetString(1), lectorPelicula.GetString(2), lectorPelicula.GetInt32(3), lectorPelicula.GetString(4), lectorPelicula.GetString(5));
}
lectorPelicula.Close();
return(resultado);
}
public override void mostrar()
{
base.mostrar();
var pelicula = prompt("Ingrese el nombre de la pelicula: ");
Pelicula = new Pelicula()
{
Nombre = pelicula
};
try
{
AdoAdministrador.ADO.agregarPelicula(Pelicula);
Console.WriteLine("Pelicula agregado con exito");
}
catch (Exception e)
{
Console.WriteLine($"No se pudo agregar la pelicula :{e.Message}");
}
Console.ReadKey();
}
public List <Pelicula> ObtenerPeliculas()
{
Pelicula p1 = new Pelicula()
{
titulo = "La Matraca",
duracion = 115,
publicacion = new DateTime(2010, 02, 11),
pais = "USA"
};
Pelicula p2 = new Pelicula()
{
titulo = "Rambo",
duracion = 1224,
publicacion = new DateTime(2002, 11, 11),
pais = "COL"
};
return(new List <Pelicula> {
p1, p2
});
}
private void LlenarClase(Pelicula pelicula)
{
pelicula.PeliculasId = StringToInt(PeliculasIdTextBox.Text);
pelicula.Titulo = TituloTextBox.Text;
pelicula.Signosis = SignosisTextBox.Text;
pelicula.Calificacion = StringToInt(CalificacionTextBox.Text);
pelicula.Anno = StringToInt(anoNumericUpDown.Text);
pelicula.Idioma = IdiomaTextBox.Text;
pelicula.Genero = GeneroTextBox.Text;
pelicula.CategoriaId = (int)CategoriaIdComboBox.SelectedValue;
}
public ActionResult Edit(int id, Pelicula pelicula)
{
using (var uow = LightSpeed_Expo.MvcApplication.LightSpeedContext.CreateUnitOfWork())
{
try
{
if (ModelState.IsValid)
{
Pelicula peliculaOriginal = uow.Peliculas.FirstOrDefault(p => p.Id == id);
if (peliculaOriginal == null)
{
return HttpNotFound();
}
peliculaOriginal.Titulo = pelicula.Titulo;
peliculaOriginal.Descripcion = pelicula.Descripcion;
uow.SaveChanges();
return RedirectToAction("Index");
}
return View(pelicula);
}
catch
{
return View(pelicula);
}
}
}
public Pelicula obtener(Pelicula objCliente)
{
return new FideCineEntities().Pelicula.Where(" it.IdPelicula = @pi_IdPelicula", new ObjectParameter[] { new ObjectParameter("pi_IdPelicula", objCliente.IdPelicula) }).First<Pelicula>();
}
