Esempio n. 1
0
        public void DevolverPeliculaTest()
        {
            AlquileresCN alquileresCN = new AlquileresCN();
            PeliculasCN  peliculasCN  = new PeliculasCN();
            Pelicula     pelicula;
            string       nifSocio          = "00000000T";
            string       codBarrasPelicula = "0686983675479";
            int          unidadesAlquiladas;
            Alquiler     alquiler;
            AlquileresAD alquileresAD = new AlquileresAD();
            Historico    historico;

            // Necesitamos ser administrador para devolver, impersonamos
            ConnectionHelper.ImpersonateAdmin();

            // Recuperamos datos para comprobar
            pelicula           = peliculasCN.ObtenerPeliculaPorCodBarras(codBarrasPelicula, false, false);
            unidadesAlquiladas = pelicula.UnidadesAlquiladas;

            using (TransactionScope tx = new TransactionScope())
            {
                alquileresCN.AlquilarPelicula(nifSocio, codBarrasPelicula);
                alquileresCN.RecogerPelicula(nifSocio, codBarrasPelicula);
                alquileresCN.DevolverPelicula(nifSocio, codBarrasPelicula, out historico);

                pelicula = peliculasCN.ObtenerPeliculaPorCodBarras(codBarrasPelicula, false, false);
                Assert.AreEqual(unidadesAlquiladas, pelicula.UnidadesAlquiladas);

                Assert.AreEqual((Decimal)0.15, historico.Precio);

                alquiler = alquileresAD.ObtenerAlquilerSinDevolverPorSocioPelicula(nifSocio, codBarrasPelicula);
                Assert.IsNull(alquiler);
            }
        }
Esempio n. 2
0
        private decimal CalcularPrecioAlquilerInternal(string nifSocio, string peliculaCodBarras)
        {
            Alquiler     alquiler;
            AlquileresAD alquileresAD = new AlquileresAD();

            alquiler = alquileresAD.ObtenerAlquilerSinDevolverPorSocioPelicula(nifSocio, peliculaCodBarras);
            if (alquiler == null)
            {
                throw new ArgumentException();
            }

            return(CalcularPrecio(alquiler.FechaAlquiler, alquiler.FechaRecogida.Value, DateTime.Now));
        }
Esempio n. 3
0
        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);
        }