public void ComprarPeliculaSinSaldoTest()
{
ComprasCN comprasCN = new ComprasCN();
UsuariosAD usuariosAD = new UsuariosAD();
string nifSocio = "00000000T";
string codBarrasPelicula = "0686983675479";
Socio socio, socioOriginal;
// Necesitamos ser administrador para comprar, impersonamos
ConnectionHelper.ImpersonateAdmin();
using (TransactionScope tx = new TransactionScope())
{
// Quitamos el saldo al socio
socio = usuariosAD.ObtenerSocioPorNIF(nifSocio);
socioOriginal = (Socio)OperacionesEntidad.CreateDataCopy(socio, false);
socio.Saldo = 0;
usuariosAD.ActualizarUsuario(socio, socioOriginal);
// Intentamos comprar
EstadoPedido estadoPedido = comprasCN.ComprarPelicula(nifSocio, codBarrasPelicula);
Assert.AreEqual(EstadoPedido.SaldoInsuficiente, estadoPedido);
}
}
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);
}
}
private void RecogerPeliculaInternal(string nifSocio, string peliculaCodBarras)
{
Alquiler alquiler, alquilerOriginal;
Historico historico;
AlquileresAD alquileresAD = new AlquileresAD();
HistoricosAD historicosAD = new HistoricosAD();
using (TransactionScope tx = new TransactionScope())
{
// Buscamos alquiler pendiente de recoger
alquiler = alquileresAD.ObtenerAlquilerSinRecogerPorSocioPelicula(nifSocio, peliculaCodBarras);
if (alquiler == null)
{
throw new ArgumentException();
}
// Actualización estado alquiler
alquilerOriginal = (Alquiler)OperacionesEntidad.CreateDataCopy(alquiler, false);
alquiler.FechaRecogida = DateTime.Now;
alquileresAD.ActualizarAlquiler(alquiler, alquilerOriginal);
// Almacenamos en históricos
historico = new Historico();
historico.PeliculaID = alquiler.PeliculaID;
historico.SocioID = alquiler.SocioID;
historico.Fecha = alquiler.FechaAlquiler;
historico.FechaRecogida = alquiler.FechaRecogida;
historico.TipoOperacion = TipoOperacion.Recogida;
historicosAD.AgregarHistorico(historico);
tx.Complete();
}
}
public void ChangeSetModificacionBorradoTest()
{
IMSDNVideoServices client = ConnectionHelper.ServiceClient;
int actoresCount;
Pelicula pelicula = client.Peliculas_ObtenerPeliculaPorCodBarras("0045907014545", true, false);
ActoresPelicula actorPeliculaBorrado;
DisconnectedDataContext <EntidadesDataContext> dataContext = new DisconnectedDataContext <EntidadesDataContext>();
dataContext.Attach(pelicula);
pelicula.Duracion = 119;
actoresCount = pelicula.ActoresPeliculas.Count;
actorPeliculaBorrado = (ActoresPelicula)OperacionesEntidad.CreateDataCopy(pelicula.ActoresPeliculas[0], false);
pelicula.ActoresPeliculas.RemoveAt(0);
DisconnectedChangeSet changeSet = dataContext.GetChangeSet();
client.ChangeSet_ActualizarChangeSet(changeSet);
pelicula = client.Peliculas_ObtenerPeliculaPorCodBarras("0045907014545", true, false);
Assert.AreEqual(119, pelicula.Duracion);
Assert.AreEqual(actoresCount - 1, pelicula.ActoresPeliculas.Count);
// Compensación
dataContext.AcceptChanges();
dataContext.Attach(pelicula);
pelicula.Duracion = 118;
pelicula.ActoresPeliculas.Add(actorPeliculaBorrado);
changeSet = dataContext.GetChangeSet();
client.ChangeSet_ActualizarChangeSet(changeSet);
}
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 ModificarActorTest()
{
ActoresAD target = new ActoresAD();
string nombre = "Robin Williams";
Actor actor, actorOriginal;
BindingList <Actor> result;
actor = target.ObtenerActoresPorNombre(nombre)[0];
actorOriginal = (Actor)OperacionesEntidad.CreateDataCopy(actor, false);
actor.UrlPersonal = "nueva url";
using (TransactionScope tx = new TransactionScope())
{
target.ActualizarActor(actor, actorOriginal);
result = target.ObtenerActoresPorNombre(nombre);
Assert.AreEqual(1, result.Count);
Assert.AreEqual("nueva url", result[0].UrlPersonal);
}
}
/// <summary>
/// Actualiza la base de datos con todos los cambios incluidos en un Changeset
/// </summary>
/// <param name="changeSet">Changeset con cambios</param>
public void ActualizarChangeSet(DisconnectedChangeSet changeSet)
{
EntidadesDataContext dc = GetDC();
int i;
object entidad;
ITable tabla;
if (changeSet.Agregados != null)
{
for (i = 0; i < changeSet.Agregados.Count; i++)
{
entidad = changeSet.Agregados[i];
tabla = OperacionesEntidad.GetTablaFromEntidad(dc, entidad);
tabla.InsertOnSubmit(entidad);
}
}
if (changeSet.Modificados != null)
{
for (i = 0; i < changeSet.Modificados.Count; i++)
{
entidad = changeSet.Modificados[i];
tabla = OperacionesEntidad.GetTablaFromEntidad(dc, entidad);
tabla.Attach(entidad, changeSet.ModificadosOriginal[i]);
}
}
if (changeSet.Eliminados != null)
{
for (i = 0; i < changeSet.Eliminados.Count; i++)
{
entidad = changeSet.Eliminados[i];
tabla = OperacionesEntidad.GetTablaFromEntidad(dc, entidad);
tabla.Attach(entidad);
tabla.DeleteOnSubmit(entidad);
}
}
dc.SubmitChanges();
}
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);
}
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);
}
