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 EstablecerClave(string nif, string clave)
{
string hashClave;
UsuariosAD usuariosAD = new UsuariosAD();
hashClave = HashHelper.CalcularHash(clave);
usuariosAD.EstablecerClave(nif, hashClave);
}
/// <summary>
/// Obtiene el usuario actual
/// Seguridad: Público
/// </summary>
/// <returns>Usuario</returns>
public Usuario ObtenerMiUsuario()
{
UsuariosAD usuariosAD = new UsuariosAD();
string nif;
if (Thread.CurrentPrincipal == null || Thread.CurrentPrincipal.Identity.Name == "invitado")
{
return(null);
}
nif = Thread.CurrentPrincipal.Identity.Name;
return(usuariosAD.ObtenerUsuarioPorNIF(nif));
}
private async void frmPrincipal_Load(object sender, EventArgs e)
{
usuario = UsuariosAD.GetUsuario();
ConfiguraFormulario();
await RecuperaTextos();
//SegundoMonitor();
Hide();
await RegistraVisita();
}
/// <summary>
/// Obtiene el rol del usuario dado
/// Seguridad: Público
/// </summary>
/// <param name="nifUsuario">NIF del usuario</param>
/// <returns>Rol</returns>
public Rol ObtenerRolUsuario(string nifUsuario)
{
Usuario usuario;
UsuariosAD usuariosAD = new UsuariosAD();
usuario = usuariosAD.ObtenerUsuarioPorNIF(nifUsuario);
if (usuario != null)
{
return(usuario.Rol);
}
else
{
return(Rol.Socio);
}
}
public static int ValidarUsuario(string nombreUsuario, string contrasenaEncriptada, ref Usuarios objetoUsuario)
{
try
{
var usuario = UsuariosAD.ObtenerUsuariosPorNombres(nombreUsuario);
if (usuario != null)
{
objetoUsuario = usuario;
return(usuario.Contrasena != contrasenaEncriptada ? 0 :
!usuario.Estado ? 2 :
objetoUsuario.Reseteo ? 3 : 1);
}
return(-1);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Valida que el usuario es correcto y que la clave es válida
/// Seguridad: Público
/// </summary>
/// <param name="nifUsuario">NIF del usuario</param>
/// <param name="clave">Clave a validar</param>
/// <returns>Usuario</returns>
public Usuario ValidarUsuario(string nifUsuario, string clave)
{
string claveHashed;
UsuariosAD usuariosAD = new UsuariosAD();
claveHashed = usuariosAD.ObtenerClave(nifUsuario);
if (claveHashed == null)
{
return(null);
}
if (HashHelper.ValidarClave(clave, claveHashed))
{
// Usuario correcto, devolvemos el registro del usuario
return(usuariosAD.ObtenerUsuarioPorNIF(nifUsuario));
}
else
{
return(null);
}
}
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);
}
public UsersController()
{
objUser = new UsuariosAD();
}
public AccesoController()
{
objUser = new UsuariosAD();
}
public Socio ObtenerSocioPorNIF(string nif)
{
UsuariosAD usuariosAD = new UsuariosAD();
return(usuariosAD.ObtenerSocioPorNIF(nif));
}
public void ActualizarUsuario(Usuario usuario, Usuario original)
{
UsuariosAD usuariosAD = new UsuariosAD();
usuariosAD.ActualizarUsuario(usuario, original);
}
public BindingList <Socio> ObtenerSociosPorNombre(string nombre)
{
UsuariosAD usuariosAD = new UsuariosAD();
return(usuariosAD.ObtenerSociosPorNombre(nombre));
}
public BindingList <Socio> ObtenerSocios()
{
UsuariosAD usuariosAD = new UsuariosAD();
return(usuariosAD.ObtenerSocios());
}
public void EliminarUsuario(Usuario usuario)
{
UsuariosAD usuariosAD = new UsuariosAD();
usuariosAD.EliminarUsuario(usuario);
}
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);
}
public void AgregarUsuario(Usuario usuario)
{
UsuariosAD usuariosAD = new UsuariosAD();
usuariosAD.AgregarUsuario(usuario);
}
