public void ComprarPeliculaSinStockTest()
{
ComprasCN comprasCN = new ComprasCN();
PeliculasAD peliculasAD = new PeliculasAD();
string nifSocio = "00000000T";
string codBarrasPelicula = "0686983675479";
Pelicula pelicula, peliculaOriginal;
// Necesitamos ser administrador para comprar, impersonamos
ConnectionHelper.ImpersonateAdmin();
using (TransactionScope tx = new TransactionScope())
{
// Quitamos el stock a la pelicula
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(codBarrasPelicula, false, false);
peliculaOriginal = (Pelicula)OperacionesEntidad.CreateDataCopy(pelicula, false);
pelicula.UnidadesVenta = 0;
pelicula.UnidadesVentaAlquiler = 1;
pelicula.UnidadesAlquiladas = 1;
pelicula.UnidadesAlquiler = 0;
peliculasAD.ActualizarPelicula(pelicula, peliculaOriginal);
// Intentamos alquilar
EstadoPedido estadoPedido = comprasCN.ComprarPelicula(nifSocio, codBarrasPelicula);
Assert.AreEqual(EstadoPedido.StockInsuficiente, estadoPedido);
}
}
public BindingList <Pelicula> ObtenerMisPeliculasPendienteDevolver()
{
string nifUsuario = Thread.CurrentPrincipal.Identity.Name;
PeliculasAD peliculasAD = new PeliculasAD();
return(peliculasAD.ObtenerPeliculasPendienteDevolver(nifUsuario));
}
/// <summary>
/// Obtiene la carátula asociada a la película indicada
/// Seguridad: Público
/// </summary>
/// <param name="codBarras">Código de barras de la película</param>
/// <param name="ancho">Ancho deseado de la imagen</param>
/// <param name="alto">Alto deseado de la imagen</param>
/// <returns>Array de bytes con la imagen de la carátula</returns>
public byte[] ObtenerCaratula(string codBarras, int ancho, int alto)
{
PeliculasAD peliculasAD = new PeliculasAD();
byte[] buffer;
Bitmap bmpSource, bmpDest;
MemoryStream memStream;
buffer = peliculasAD.ObtenerCaratula(codBarras);
if (ancho == 0 && alto == 0)
{
return(buffer);
}
bmpSource = new Bitmap(new MemoryStream(buffer));
if (ancho >= bmpSource.Width || alto >= bmpSource.Height)
{
return(buffer);
}
bmpDest = new Bitmap(ancho, alto, bmpSource.PixelFormat);
Graphics g = Graphics.FromImage(bmpDest);
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
g.DrawImage(bmpSource, 0, 0, bmpDest.Width, bmpDest.Height);
g.Dispose();
memStream = new MemoryStream();
bmpDest.Save(memStream, ImageFormat.Jpeg);
return(memStream.ToArray());
}
public void ModificarPeliculaYEliminarActorTest()
{
PeliculasAD peliculasAD = new PeliculasAD();
ChangeSetAD changesetAD = new ChangeSetAD();
string codBarras = "0045907014545";
Pelicula pelicula;
int actoresCount;
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(codBarras, true, false);
DisconnectedDataContext <EntidadesDataContext> dataContext = new DisconnectedDataContext <EntidadesDataContext>();
dataContext.Attach(pelicula);
pelicula.Duracion = 100;
actoresCount = pelicula.ActoresPeliculas.Count;
pelicula.ActoresPeliculas.RemoveAt(0);
using (TransactionScope tx = new TransactionScope())
{
DisconnectedChangeSet changeSet = dataContext.GetChangeSet();
changesetAD.ActualizarChangeSet(changeSet);
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(codBarras, true, false);
Assert.AreEqual(100, pelicula.Duracion);
Assert.AreEqual(actoresCount - 1, pelicula.ActoresPeliculas.Count);
}
}
public void ObtenerPeliculaConPuntuacionPorCodBarrasTest()
{
PeliculasAD target = new PeliculasAD();
string codBarras = "0045907014545";
Pelicula actual;
actual = target.ObtenerPeliculaPorCodBarras(codBarras, false, true);
Assert.IsTrue(actual.PuntuacionMedia > 0);
}
public void ObtenerPeliculaNoExistenteTest()
{
PeliculasAD target = new PeliculasAD();
string codBarras = "0000000000000";
bool incluirActores = true;
Pelicula actual;
actual = target.ObtenerPeliculaPorCodBarras(codBarras, incluirActores, false);
Assert.IsNull(actual);
}
public void ModificarPeliculaYEliminarModificarAgregarActorTest()
{
PeliculasAD peliculasAD = new PeliculasAD();
ChangeSetAD changesetAD = new ChangeSetAD();
string codBarras = "0045907014545";
Pelicula pelicula;
int actoresCount;
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(codBarras, true, false);
DisconnectedDataContext <EntidadesDataContext> dataContext = new DisconnectedDataContext <EntidadesDataContext>();
dataContext.Attach(pelicula);
pelicula.Duracion = 100;
actoresCount = pelicula.ActoresPeliculas.Count;
pelicula.ActoresPeliculas[0].Papel = "Nuevo papel";
pelicula.ActoresPeliculas.RemoveAt(0);
ActoresPelicula nuevoActorPelicula = new ActoresPelicula();
nuevoActorPelicula.ActorID = 100;
nuevoActorPelicula.Papel = "Nuevo actor";
pelicula.ActoresPeliculas.Add(nuevoActorPelicula);
using (TransactionScope tx = new TransactionScope())
{
DisconnectedChangeSet changeSet = dataContext.GetChangeSet();
changesetAD.ActualizarChangeSet(changeSet);
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(codBarras, true, false);
Assert.AreEqual(100, pelicula.Duracion);
Assert.AreEqual(actoresCount, pelicula.ActoresPeliculas.Count);
bool foundNuevo = false;
bool foundAntiguo = false;
foreach (ActoresPelicula actor in pelicula.ActoresPeliculas)
{
if (actor.Papel == "Nuevo actor")
{
foundNuevo = true;
}
if (actor.Papel == "Nuevo papel")
{
foundAntiguo = true;
}
}
Assert.IsTrue(foundNuevo);
Assert.IsFalse(foundAntiguo);
}
}
public void ObtenerPeliculaConActoresPorCodBarrasTest()
{
PeliculasAD target = new PeliculasAD();
string codBarras = "0045907014545";
bool incluirActores = true;
Pelicula actual;
actual = target.ObtenerPeliculaPorCodBarras(codBarras, incluirActores, false);
Assert.AreEqual("María Antonieta", actual.Titulo);
Assert.AreEqual(9, actual.ActoresPeliculas.Count);
}
public void ObtenerPeliculaPorFiltro2Test()
{
PeliculasAD target = new PeliculasAD();
bool incluirActores = false;
BindingList <Pelicula> actual;
FiltroPeliculas filtro = new FiltroPeliculas();
filtro.CamposFiltrado = (int)CamposFiltro.Titulo;
filtro.Titulo = "dos";
int total;
actual = target.ObtenerPeliculasPorFiltro(filtro, incluirActores, false, out total);
Assert.AreEqual(4, actual.Count);
}
public void EliminarPeliculaTest()
{
PeliculasAD peliculasAD = new PeliculasAD();
string codBarras = "0045907014545";
Pelicula pelicula;
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(codBarras, false, false);
using (TransactionScope tx = new TransactionScope())
{
peliculasAD.EliminarPelicula(pelicula);
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(codBarras, false, false);
Assert.IsNull(pelicula);
}
}
public void ObtenerPeliculaPorFiltro1Test()
{
PeliculasAD target = new PeliculasAD();
string codBarras = "0045907014545";
bool incluirActores = false;
BindingList <Pelicula> actual;
FiltroPeliculas filtro = new FiltroPeliculas();
filtro.CamposFiltrado = (int)CamposFiltro.CodBarras;
filtro.CodBarras = codBarras;
int total;
actual = target.ObtenerPeliculasPorFiltro(filtro, incluirActores, false, out total);
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(codBarras, actual[0].CodBarras);
}
public void ModificarPeliculaTest()
{
PeliculasAD peliculasAD = new PeliculasAD();
string codBarras = "0045907014545";
Pelicula pelicula, peliculaOriginal;
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(codBarras, false, false);
peliculaOriginal = (Pelicula)OperacionesEntidad.CreateDataCopy(pelicula, false);
pelicula.Duracion = 100;
using (TransactionScope tx = new TransactionScope())
{
peliculasAD.ActualizarPelicula(pelicula, peliculaOriginal);
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(codBarras, false, false);
Assert.AreEqual(100, pelicula.Duracion);
}
}
public void AgregarPeliculaTest()
{
PeliculasAD peliculasAD = new PeliculasAD();
Pelicula pelicula;
string codBarras = "1111111111111";
string titulo = "Titulo prueba";
pelicula = new Pelicula();
pelicula.CodBarras = codBarras;
pelicula.Titulo = titulo;
pelicula.Sinopsis = "Sinopsis";
using (TransactionScope tx = new TransactionScope())
{
peliculasAD.AgregarPelicula(pelicula);
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(codBarras, false, false);
Assert.IsNotNull(pelicula);
Assert.AreEqual(codBarras, pelicula.CodBarras);
Assert.AreEqual(titulo, pelicula.Titulo);
}
}
/// <summary>
/// Obtiene las películas más vendidas
/// Seguridad: Público
/// </summary>
/// <returns>Lista de películas</returns>
public BindingList <Pelicula> ObtenerTopPeliculasVentas()
{
PeliculasAD peliculasAD = new PeliculasAD();
return(peliculasAD.ObtenerTopPeliculasVentas());
}
public BindingList <Pelicula> ObtenerPeliculasPendienteDevolver(string nifUsuario)
{
PeliculasAD peliculasAD = new PeliculasAD();
return(peliculasAD.ObtenerPeliculasPendienteDevolver(nifUsuario));
}
public Pelicula ObtenerPeliculaPorCodBarras(string codBarras, bool incluirActores, bool incluirPuntuacionMedia)
{
PeliculasAD peliculasAD = new PeliculasAD();
return(peliculasAD.ObtenerPeliculaPorCodBarras(codBarras, incluirActores, incluirPuntuacionMedia));
}
/// <summary>
/// Obtiene las películas que cumplen el filtro dinámico indicado
/// Seguridad: Público
/// </summary>
/// <param name="filtro">Filtro dinámico</param>
/// <param name="incluirActores">Incluir actores asociados</param>
/// <param name="incluirPuntuaciones">Incluir puntuaciones asociadas</param>
/// <param name="total">Número total de registros sin paginar</param>
/// <returns>Lista de películas</returns>
public BindingList <Pelicula> ObtenerPeliculasPorFiltro(FiltroPeliculas filtro, bool incluirActores, bool incluirPuntuaciones, out int total)
{
PeliculasAD peliculasAD = new PeliculasAD();
return(peliculasAD.ObtenerPeliculasPorFiltro(filtro, incluirActores, incluirPuntuaciones, out total));
}
public BindingList <Pelicula> ObtenerPeliculas(bool incluirActores)
{
PeliculasAD peliculasAD = new PeliculasAD();
return(peliculasAD.ObtenerPeliculas(incluirActores));
}
public void ModificarCaratula(byte[] caratula, string codBarras)
{
PeliculasAD peliculasAD = new PeliculasAD();
peliculasAD.ModificarCaratula(caratula, codBarras);
}
public void AgregarPelicula(Pelicula pelicula)
{
PeliculasAD peliculasAD = new PeliculasAD();
peliculasAD.AgregarPelicula(pelicula);
}
public void EliminarPelicula(Pelicula pelicula)
{
PeliculasAD peliculasAD = new PeliculasAD();
peliculasAD.EliminarPelicula(pelicula);
}
public void ActualizarPelicula(Pelicula pelicula, Pelicula original)
{
PeliculasAD peliculasAD = new PeliculasAD();
peliculasAD.ActualizarPelicula(pelicula, original);
}
/// <summary>
/// Obtiene las películas más valoradas
/// Seguridad: Público
/// </summary>
/// <returns>Lista de películas</returns>
public BindingList <Pelicula> ObtenerTopPeliculasPuntuacion()
{
PeliculasAD peliculasAD = new PeliculasAD();
return(peliculasAD.ObtenerTopPeliculasPuntuacion());
}
private EstadoPedido DevolverPeliculaInternal(string nifSocio, string peliculaCodBarras, out Historico historico)
{
Alquiler alquiler;
Pelicula pelicula, peliculaOriginal;
Socio socio, socioOriginal;
AlquileresAD alquileresAD = new AlquileresAD();
HistoricosAD historicosAD = new HistoricosAD();
PeliculasAD peliculasAD = new PeliculasAD();
UsuariosAD usuariosAD = new UsuariosAD();
historico = null;
using (TransactionScope tx = new TransactionScope())
{
// Buscamos alquiler pendiente de devolver
alquiler = alquileresAD.ObtenerAlquilerSinDevolverPorSocioPelicula(nifSocio, peliculaCodBarras);
if (alquiler == null)
{
throw new ArgumentException();
}
// Actualización de stock
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(peliculaCodBarras, false, false);
peliculaOriginal = (Pelicula)OperacionesEntidad.CreateDataCopy(pelicula, false);
pelicula.UnidadesAlquiladas--;
try
{
peliculasAD.ActualizarPelicula(pelicula, peliculaOriginal);
}
catch (ChangeConflictException)
{
// Error de concurrencia
return(EstadoPedido.ErrorConcurrencia);
}
// Almacenamos en históricos
historico = new Historico();
historico.PeliculaID = alquiler.PeliculaID;
historico.SocioID = alquiler.SocioID;
historico.Fecha = alquiler.FechaAlquiler;
historico.FechaRecogida = alquiler.FechaRecogida;
historico.FechaDevolucion = DateTime.Now;
historico.TipoOperacion = TipoOperacion.Devolucion;
historico.Precio = CalcularPrecio(alquiler.FechaAlquiler, alquiler.FechaRecogida.Value, historico.FechaDevolucion.Value);
historicosAD.AgregarHistorico(historico);
// Borrado alquiler
try
{
alquileresAD.EliminarAlquiler(alquiler);
}
catch (ChangeConflictException)
{
// Error de concurrencia
return(EstadoPedido.ErrorConcurrencia);
}
// Actualización saldo
socio = usuariosAD.ObtenerSocioPorNIF(nifSocio);
socioOriginal = (Socio)OperacionesEntidad.CreateDataCopy(socio, false);
socio.Saldo -= historico.Precio;
if (socio.Saldo < 0)
{
return(EstadoPedido.SaldoInsuficiente);
}
try
{
usuariosAD.ActualizarUsuario(socio, socioOriginal);
}
catch (ChangeConflictException)
{
// Error de concurrencia
return(EstadoPedido.ErrorConcurrencia);
}
tx.Complete();
}
return(EstadoPedido.Realizado);
}
private EstadoPedido AlquilarPeliculaIntento(string nifSocio, string peliculaCodBarras)
{
Socio socio, socioOriginal;
Pelicula pelicula, peliculaOriginal;
Historico historico;
Alquiler alquiler;
UsuariosAD usuariosAD = new UsuariosAD();
PeliculasAD peliculasAD = new PeliculasAD();
HistoricosAD historicosAD = new HistoricosAD();
AlquileresAD alquileresAD = new AlquileresAD();
// Recuperamos película y usuario
pelicula = peliculasAD.ObtenerPeliculaPorCodBarras(peliculaCodBarras, false, false);
socio = usuariosAD.ObtenerSocioPorNIF(nifSocio);
if (pelicula == null || socio == null)
{
throw new ArgumentException();
}
peliculaOriginal = (Pelicula)OperacionesEntidad.CreateDataCopy(pelicula, false);
socioOriginal = (Socio)OperacionesEntidad.CreateDataCopy(socio, false);
using (TransactionScope tx = new TransactionScope())
{
// Comprobamos stock
if (pelicula.DisponibleAlquiler == 0)
{
if (pelicula.UnidadesVentaAlquiler + pelicula.UnidadesAlquiler == 0)
{
return(EstadoPedido.ModalidadNoDisponible);
}
else
{
return(EstadoPedido.StockInsuficiente);
}
}
// Comprobamos saldo
if (socio.Saldo < _minSaldoParaAlquilar)
{
return(EstadoPedido.SaldoInsuficiente);
}
// Actualizamos stock
pelicula.UnidadesAlquiladas++;
try
{
peliculasAD.ActualizarPelicula(pelicula, peliculaOriginal);
}
catch (ChangeConflictException)
{
return(EstadoPedido.ErrorConcurrencia);
}
// Creamos alquiler
alquiler = new Alquiler();
alquiler.SocioID = socio.UsuarioID;
alquiler.PeliculaID = pelicula.PeliculaID;
alquiler.FechaAlquiler = DateTime.Now;
alquileresAD.AgregarAlquiler(alquiler);
// Almacenamos en histórico
historico = new Historico();
historico.SocioID = socio.UsuarioID;
historico.PeliculaID = pelicula.PeliculaID;
historico.TipoOperacion = TipoOperacion.Alquiler;
historico.Fecha = alquiler.FechaAlquiler;
historicosAD.AgregarHistorico(historico);
tx.Complete();
}
return(EstadoPedido.Realizado);
}
