24: Leer Datos con PDO Parte 3

 


En el tutorial anterior, aprendimos a validar el ingreso de un usuario. Ahora, vamos a dar el siguiente paso: una vez que el usuario inicia sesión correctamente y es dirigido a la sección de usuarios, necesitamos que en esa vista se listen todos los registros que existen en nuestra base de datos. Es decir, vamos a reemplazar los datos quemados (estáticos) del HTML por datos dinámicos provenientes de la tabla usuarios.

Objetivo: Mostrar en una tabla HTML la lista completa de usuarios registrados en la base de datos, utilizando PDO para la consulta y el patrón MVC para la estructura.

Paso 1: Crear el método en el Controlador

Abrimos nuestro archivo controlador.php. Aquí vamos a crear una nueva función pública que actuará como el puente entre la vista (la página usuario.php) y el modelo (la clase Datos). Llamaremos a este método vistaUsuariosController.

php
<?php
// controlador.php

require_once "modelos.php";

class MvcController {

    // ... (otros métodos como ingresoUsuarioController) ...

    # VISTA DE USUARIOS
    #-------------------------------------
    public function vistaUsuariosController(){
        // Llamamos al método del modelo para obtener los datos.
        // Le pasamos el nombre de la tabla 'usuarios' como parámetro.
        $respuesta = Datos::vistaUsuariosModel("usuarios");

        // Por ahora, usaremos var_dump para ver qué datos nos devuelve.
        // Esto nos ayudará a entender la estructura de la respuesta.
        var_dump($respuesta);
    }

}
?>

Explicación:

  • vistaUsuariosController(): Esta función se encargará de pedir los datos al modelo.

  • Datos::vistaUsuariosModel("usuarios"): Llamamos a un método estático de la clase Datos (que está en modelos.php) y le enviamos el nombre de la tabla que queremos consultar.

  • $respuesta: Almacenará la información que nos devuelva el modelo.

  • var_dump($respuesta): Es una función de PHP que muestra información estructurada sobre una variable, incluyendo su tipo y valor. La usamos temporalmente para verificar que la conexión y la consulta funcionan.

Paso 2: Crear el método en el Modelo

Ahora, vamos al archivo modelos.php. Aquí implementaremos el método vistaUsuariosModel que acabamos de invocar desde el controlador. Este método ejecutará la consulta SQL para seleccionar todos los registros de la tabla usuarios.

php
<?php
// modelos.php

require_once "conexion.php";

class Datos extends Conexion {

    // ... (otros métodos como ingresoUsuarioModel) ...

    # VISTA DE USUARIOS
    #-------------------------------------
    public static function vistaUsuariosModel($tabla){
        // 1. Conectamos a la base de datos y preparamos la sentencia SQL.
        //    Seleccionamos todos los campos (id, usuario, password, email) de la tabla.
        //    A diferencia del método de ingreso, aquí NO usamos WHERE para traer todos los registros.
        $stmt = Conexion::conectar()->prepare("SELECT id, usuario, password, email FROM $tabla");

        // 2. Ejecutamos la consulta.
        $stmt->execute();

        // 3. Devolvemos todos los resultados.
        //    Usamos fetchAll() en lugar de fetch().
        //    - fetch(): Obtiene una sola fila.
        //    - fetchAll(): Obtiene un array con todas las filas del resultado.
        return $stmt->fetchAll();

        // 4. Cerramos la conexión (buena práctica, aunque PDO la cierra automáticamente al finalizar el script).
        $stmt->close();
    }

}
?>

Explicación:

  • static: Nótese que el método también es static para que pueda ser llamado sin instanciar la clase.

  • prepare("SELECT ... FROM $tabla"): La consulta SQL selecciona las columnas que nos interesan.

  • Sin WHERE: Al omitir la cláusula WHERE, la consulta trae todos los registros de la tabla, que es exactamente lo que necesitamos para listarlos.

  • fetchAll(): Este método es clave. Devuelve un array numérico que contiene todos los registros de la consulta. Cada registro es, a su vez, un array asociativo (por defecto) con los nombres de las columnas.

  • return $stmt->fetchAll(): Enviamos el array de resultados de vuelta al controlador.

Paso 3: Invocar el método del Controlador desde la Vista

Finalmente, modificamos la vista, que es el archivo usuario.php. Aquí eliminaremos el dato "quemado" (la fila de ejemplo) y llamaremos al controlador para que, mediante un bucle, pinte dinámicamente todas las filas de la tabla.

php
<!-- vista.php (usuario.php) -->
<html>
<head>
    <title>Lista de Usuarios</title>
</head>
<body>
    <h1>Sección de Usuarios</h1>

    <table border="1">
        <thead>
            <tr>
                <th>ID</th>
                <th>Usuario</th>
                <th>Email</th>
                <th>Editar</th>
                <th>Borrar</th>
            </tr>
        </thead>
        <tbody>

            <?php
            // Llamamos al controlador para que ejecute su método y nos traiga los datos.
            $ingreso = new MvcController();
            // ¡OJO! Temporalmente, el controlador tiene un var_dump.
            // Esto hará que la página se vea extraña. Más abajo veremos cómo arreglarlo.
            $ingreso->vistaUsuariosController();
            ?>

            <!-- Esta fila es un ejemplo de datos quemados que ya no nos sirve -->
            <!-- <tr>
                <td>juan</td>
                <td>1234</td>
                <td>juan@hotmail.com</td>
                <td><button>Editar</button></td>
                <td><button>Borrar</button></td>
            </tr> -->
        </tbody>
    </table>
</body>
</html>

¿Qué veremos al cargar usuario.php?
Veremos el resultado del var_dump($respuesta) que dejamos en el controlador. Debería mostrarnos algo como esto en la parte superior de la página:

text
array(3) {
  [0]=> array(6) {
    ["id"]=> string(1) "1"
    [0]=> string(1) "1"
    ["usuario"]=> string(4) "juan"
    [1]=> string(4) "juan"
    ["password"]=> string(4) "1234"
    [2]=> string(4) "1234"
    ["email"]=> string(15) "juan@hotmail.com"
    [3]=> string(15) "juan@hotmail.com"
  }
  [1]=> ... (datos del segundo usuario) ...
  [2]=> ... (datos del tercer usuario) ...
}

Este var_dump nos muestra que $respuesta es un array que contiene 3 registros (índices 0, 1 y 2). Cada registro tiene índices numéricos y asociativos, lo que nos da flexibilidad para acceder a los datos.

Paso 4: Acceder a los datos específicos (Ejemplo)

Para acceder a un dato específico, podemos hacerlo desde el controlador. Modificaremos temporalmente el controlador para entender cómo acceder a la información.

En controlador.php, cambiamos:

php
public function vistaUsuariosController(){
    $respuesta = Datos::vistaUsuariosModel("usuarios");

    // Mostrar el ID del primer usuario
    echo $respuesta[0]['id']; // Salida: 1

    echo "<br>";

    // Mostrar el nombre del segundo usuario
    echo $respuesta[1]['usuario']; // Salida: pepe (asumiendo que es el segundo usuario)

    echo "<br>";

    // Mostrar el email del tercer usuario
    echo $respuesta[2]['email']; // Salida: ana@email.com (asumiendo que es el tercer usuario)
}

Si actualizamos usuario.php, veremos los datos específicos que hemos pedido. Esto confirma que podemos navegar por el array para obtener la información que necesitamos.

Paso 5: Eliminar el var_dump y preparar el bucle

Ya que hemos comprobado que los datos llegan correctamente, eliminamos el var_dump y los echo de prueba del controlador, y preparamos el método para que simplemente devuelva los datos a la vista.

Controlador final (por ahora):

php
public function vistaUsuariosController(){
    $respuesta = Datos::vistaUsuariosModel("usuarios");
    return $respuesta;
}

Ahora, en la vista, podemos recibir este array y recorrerlo con un bucle foreach para generar las filas de la tabla dinámicamente, pero eso lo veremos a detalle en el siguiente tutorial.

Resumen del Tutorial 24:
Hemos creado un nuevo método en el controlador (vistaUsuariosController) que solicita datos al modelo. En el modelo, implementamos vistaUsuariosModel, que ejecuta un SELECT sin WHERE y utiliza fetchAll() para obtener todos los registros de la tabla. Finalmente, integramos la llamada al controlador en la vista y usamos var_dump para inspeccionar la estructura de los datos recibidos, confirmando que tenemos un array multidimensional listo para ser utilizado. En el próximo tutorial, recorreremos este array para pintar la tabla completa.

Comentarios

Publicar un comentario

Entradas más populares de este blog

token

  ¿Qué es un token? Un  token  es una cadena de caracteres que representa información específica, como credenciales de acceso, identificadores únicos o datos de sesión. Se utilizan comúnmente en: Autenticación y autorización (JWT, tokens de acceso) Protección CSRF (Cross-Site Request Forgery) Identificación única de recursos Contraseñas de un solo uso Ejemplo pequeño en PHP: Token de autenticación simple php <?php // Función para generar un token aleatorio function generarToken ( $longitud = 32 ) { return bin2hex ( random_bytes ( $longitud ) ) ; } // Generar un token $token = generarToken ( ) ; echo "Token generado: " . $token . "\n\n" ; // Simular verificación del token (en una aplicación real se guardaría en base de datos) function verificarToken ( $tokenAlmacenado , $tokenRecibido ) { return hash_equals ( $tokenAlmacenado , $tokenRecibido ) ; } // Ejemplo de uso $tokenAlmacenado = $token ; // En la práctica, esto ven...
Leer más

¿Qué es un token y cómo se utiliza en una API?

  ¿Qué es un token y cómo se utiliza en una API? ¿Qué es un token? Un  token  es una cadena de caracteres que actúa como credencial de acceso para autenticar y autorizar a un usuario o aplicación en una API. Funciona como una "llave digital" que permite acceder a recursos protegidos sin necesidad de compartir credenciales sensibles como usuario y contraseña en cada solicitud. Tipos comunes de tokens: JWT (JSON Web Token) : Token auto-contenido con información codificada Access Token : Para acceso a recursos Refresh Token : Para renovar access tokens expirados API Key : Clave simple de identificación Ejemplo con PHP usando JWT 1. Instalación de dependencias bash composer require firebase/php-jwt 2. Generar un token JWT php <?php require 'vendor/autoload.php' ; use Firebase \ JWT \ JWT ; use Firebase \ JWT \ Key ; class TokenManager { private $secretKey = "tu_clave_secreta_muy_segura" ; private $algorithm = 'HS256' ; ...
Leer más

Generación de Credenciales API

   Generación de Credenciales API Método 1: Credenciales básicas (API Key + Secret) php <?php // Generar credenciales seguras function generarCredencialesAPI ( ) { $api_key = bin2hex ( random_bytes ( 32 ) ) ; // 64 caracteres hexadecimales $api_secret = bin2hex ( random_bytes ( 64 ) ) ; // 128 caracteres hexadecimales return [ 'api_key' => $api_key , 'api_secret' => password_hash ( $api_secret , PASSWORD_DEFAULT ) ] ; } // Generar y guardar credenciales $credenciales = generarCredencialesAPI ( ) ; // Guardar en base de datos (ejemplo) // INSERT INTO api_credentials (api_key, api_secret_hash, created_at) // VALUES (:api_key, :api_secret, NOW()) ?> Método 2: Credenciales JWT php <?php use Firebase \ JWT \ JWT ; use Firebase \ JWT \ Key ; class JWTCredentials { private $secret_key ; public function __construct ( ) { $this -> secret_key = bin2hex ( r...
Leer más