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();
            }
        }
        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);
        }