public async Task <IActionResult> SeleccionarEntradas(PagoViewModel vm, long eventoId)
        {
            try
            {
                ViewBag.DatosInvalidos      = false;
                ViewBag.EntradaInsuficiente = false;
                ViewBag.ClienteExistente    = false;
                ViewBag.EventoId            = eventoId;

                if (!ModelState.IsValid)
                {
                    ViewBag.DatosInvalidos = true;
                    throw new Exception("Error de validacion no controlado.");
                }

                var evento = await _helperEvento.Obtener(eventoId);

                if (evento.CupoDisponible < vm.Cantidad)
                {
                    ViewBag.EntradaInsuficiente = true;
                    throw new Exception("Cantidad de entradas insuficiente.");
                }

                long clienteId = vm.Cliente.Id;
                var  clienteVm = vm.Cliente;

                if (!User.Identity.IsAuthenticated)
                {
                    var existe = await _helperCliente.ExisteCliente(vm.Cliente.Dni, vm.Cliente.Email);

                    if (existe)
                    {
                        ViewBag.ClienteExistente = true;
                        throw new Exception("Ya existe un cliente con los datos especificados.");
                    }

                    var clienteDto = new ClienteDto()
                    {
                        Apellido = vm.Cliente.Apellido,
                        Nombre   = vm.Cliente.Nombre,
                        Dni      = vm.Cliente.Dni,
                        Email    = vm.Cliente.Email
                    };
                    clienteId = await _clienteServicio.InsertarDevuelveId(clienteDto);

                    clienteVm = await _helperCliente.Obtener(clienteId);
                }

                await _helperEvento.ActualizarCupoDisponible(evento.Id, vm.Cantidad);


                // guardo la forma de pago
                var formaPagoDto = new FormaPagoTarjetaDto()
                {
                    Nombre               = vm.FormaPago.Nombre,
                    NumeroTarjeta        = vm.FormaPago.NumeroTarjeta,
                    AnioExp              = vm.FormaPago.AnioExp,
                    MesExp               = vm.FormaPago.MesExp,
                    CodigoSeguridad      = vm.FormaPago.CodigoSeguridad,
                    CodigoPostal         = vm.FormaPago.CodigoPostal,
                    DireccionFacturacion = vm.FormaPago.DireccionFacturacion
                };
                var formaPagoId = await _formaPagoTarjetaServicio.InsertarDevuelveId(formaPagoDto);

                var formaPagoVm = await _helperFormaPagoTarjeta.Obtener(formaPagoId);

                // guardo las entradas para el cliente (for int i=0; 1 < cantidad; i++)
                var entradaVm = await _helperEntrada.ObtenerEntrada(vm.EntradaId);

                long[] entradas = new long[vm.Cantidad];
                for (int i = 0; i < vm.Cantidad; i++)
                {
                    var entrada = new EntradaDto()
                    {
                        ClienteId     = clienteId,
                        EventoId      = entradaVm.EventoId,
                        Precio        = entradaVm.Precio,
                        TipoEntradaId = entradaVm.TipoEntradaId
                    };
                    var entradaId = await _entradaServicio.InsertarDevuelveId(entrada);

                    entradas[i] = entradaId;
                }

                return(RedirectToAction("AltaFacturaRedirect", "FacturaPDF", new { clienteId = clienteVm.Id, formaPagoId = formaPagoVm.Id, entradaId = entradaVm.Id, cantidad = vm.Cantidad, entradas }));
            }
            catch (Exception)
            {
                vm.EntradasGenericas = await _helperEntrada.PoblarComboGeneric(eventoId);

                return(View(vm));
            }
        }
        public async Task <IActionResult> Register(UsuarioClienteViewModel vm, long?eventoId = null)
        {
            try
            {
                ViewBag.ClienteDuplicado = false;
                ViewBag.EmailRequerido   = false;
                ViewBag.EventoId         = eventoId;
                ViewBag.Error            = null;
                if (!ModelState.IsValid)
                {
                    if (vm.Cliente.Email == null)
                    {
                        ViewBag.EmailRequerido = true;
                    }
                    throw new Exception("Error de validacion no controlado.");
                }

                // verificar que no exista un cliente con el mismo dni
                var existeCliente = await _helperCliente.ExisteCliente(vm.Cliente.Dni);

                if (existeCliente)
                {
                    var cliente = await _helperCliente.Obtener(vm.Cliente.Dni);

                    var clienteUser = await _userManager.FindByEmailAsync(cliente.Email);

                    if (clienteUser != null)
                    {
                        ViewBag.ClienteDuplicado = true;
                        throw new Exception("Cliente existente.");
                    }
                }

                // validar el usuario
                var user = new AppUser()
                {
                    UserName      = vm.Cliente.Email,
                    Email         = vm.Cliente.Email,
                    NombreMostrar = $"{vm.Cliente.Nombre} {vm.Cliente.Apellido}",
                };

                var usuarioCreado = await _userManager.CreateAsync(user, vm.Password);

                if (!usuarioCreado.Succeeded)
                {
                    ViewBag.UsuarioDuplicado = usuarioCreado;
                    ViewBag.ClienteDuplicado = false;
                    ViewBag.Error            = "Contraseña demaciado corta.";
                    throw new Exception("Error al crear usuario");
                }

                // verificar si existe el rol "Cliente" -> si no existe crearlo
                var existeRol = await _roleManager.FindByNameAsync("Cliente");

                if (existeRol == null)
                {
                    var rol = new AppRole()
                    {
                        Name = "Cliente"
                    };
                    await _roleManager.CreateAsync(rol);
                }

                // asignar rol "Cliente" al usuario
                await _userManager.AddToRoleAsync(user, "Cliente");

                // guardar el cliente si lo anterior es valido -> si no es valido eliminar el usuario y arrojar Exception()
                var clienteCreado = await _helperCliente.NuevoCliente(vm.Cliente);

                if (!clienteCreado)
                {
                    await _userManager.DeleteAsync(user);

                    throw new Exception("Error al crear cliente.");
                }

                // realizar login y redireccionar a index
                var result = await _signInManager.PasswordSignInAsync(user, vm.Password, false, false);

                if (!result.Succeeded)
                {
                    throw new Exception("Error al inicir sesion.");
                }

                if (eventoId.HasValue)
                {
                    return(RedirectToAction("SeleccionarEntradas", "Pago", new { eventoId = eventoId.Value }));
                }

                return(RedirectToAction("Index", "Home"));
            }
            catch (Exception)
            {
                return(View(vm));
            }
        }