Tutorial 21: Crear Datos con PDO Parte 2

 


¡Hola de nuevo! En el tutorial pasado, nuestros datos viajaron desde el formulario hasta el modelo. Hoy vamos a terminar el viaje: vamos a escribir la consulta SQL de manera segura usando PDO, y lograremos que los datos se guarden en la base de datos.

Paso 1: La Sentencia SQL (La Receta)

Lo primero que necesitamos es la "receta" para guardar datos en nuestra tabla de MySQL. Vamos a phpMyAdmin, seleccionamos nuestra base de datos, y luego la tabla usuarios. Ahí hay una pestaña que dice SQL. Al hacer clic, podemos escribir comandos SQL directamente.

El comando para insertar datos es INSERT. Una consulta típica se ve así:

sql
INSERT INTO usuarios (id, usuario, password, email) VALUES (NULL, 'juan', '1234', 'juan@correo.com')

Pero espera, ¡no vamos a copiar esto exactamente! Vamos a adaptarla para nuestro código.

  1. La tabla: Nosotros ya recibimos el nombre de la tabla como parámetro ($tabla), que en este caso es "usuarios". Así que en lugar de escribir "usuarios" fijo, usaremos la variable $tabla.

  2. Los campos: No necesitamos incluir el campo id porque en nuestra base de datos es AUTO_INCREMENT. Esto significa que MySQL le asignará un número único automáticamente. Solo vamos a insertar usuario, password y email.

  3. Los valores: Aquí viene lo más importante y seguro. NUNCA vamos a pegar directamente las variables del usuario ($_POST["usuario"]) dentro de la consulta SQL. Eso es como invitar a un hacker a entrar a nuestra base de datos. En lugar de eso, usaremos marcadores de posición.

Nuestra consulta final preparada se verá así:

sql
INSERT INTO $tabla(usuario, password, email) VALUES (:usuario, :password, :email)

Los :usuario, :password y :email son los marcadores de parámetros con nombre. Son como "huecos" que llenaremos más tarde, de forma segura.

Paso 2: Preparar la Consulta con PDO (prepare)

Ahora vamos a nuestro modelo (crud.php). Dentro de la función registroUsuarioModel, vamos a usar el método prepare() de PDO.

¿Qué hace prepare()? Le envía la consulta SQL a la base de datos y le dice: "Oye, aquí tengo una consulta que quiero ejecutar, pero aún no tiene los valores. Por favor, prepárate para recibirla después con los datos". Esto es clave para la seguridad.

php
public function registroUsuarioModel($datosModel, $tabla){

    // Usamos Conexion::conectar() para conectarnos a la BD,
    // y luego llamamos a prepare() con nuestra consulta SQL.
    $stmt = Conexion::conectar()->prepare("INSERT INTO $tabla(usuario, password, email) VALUES (:usuario, :password, :email)");

    // ... (siguiente paso)
}

Explicación:

  • Conexion::conectar(): Nos da la conexión activa a la base de datos.

  • ->prepare(...): Preparamos la consulta SQL con los marcadores :usuario, etc.

  • Guardamos todo en una variable llamada $stmt (que viene de "statement", o declaración/preparación).

Paso 3: Vincular los Parámetros (bindParam)

Ya tenemos la consulta preparada con sus "huecos" (:usuario, :password, :email). Ahora tenemos que llenar esos huecos con los valores reales que el usuario escribió. Para eso usamos bindParam().

bindParam() vincula (o asocia) una variable PHP con un marcador de posición. Así, cuando la consulta se ejecute, PDO tomará el valor de esa variable y lo colocará en el hueco correspondiente, de manera segura.

php
public function registroUsuarioModel($datosModel, $tabla){

    $stmt = Conexion::conectar()->prepare("INSERT INTO $tabla(usuario, password, email) VALUES (:usuario, :password, :email)");

    // Vinculamos los marcadores con los valores reales que vienen en $datosModel
    $stmt->bindParam(":usuario", $datosModel["usuario"], PDO::PARAM_STR);
    $stmt->bindParam(":password", $datosModel["password"], PDO::PARAM_STR);
    $stmt->bindParam(":email", $datosModel["email"], PDO::PARAM_STR);

    // ... (siguiente paso)
}

Explicación:

  • $stmt->bindParam(...): Sobre nuestra consulta preparada ($stmt), usamos bindParam.

  • ":usuario": El nombre del marcador que queremos llenar (debe coincidir exactamente con el de la consulta).

  • $datosModel["usuario"]: La variable PHP que contiene el dato real (por ejemplo, "juan").

  • PDO::PARAM_STR: Le decimos a PDO que el dato que vamos a insertar es de tipo texto (STRING). Esto es una capa extra de seguridad.

Paso 4: Ejecutar la Consulta (execute)

Todo está listo. La consulta está preparada y los parámetros están vinculados. El último paso es ejecutarla con el método execute().

El método execute() ejecuta la consulta y devuelve true si todo salió bien, o false si hubo algún error.

php
public function registroUsuarioModel($datosModel, $tabla){

    $stmt = Conexion::conectar()->prepare("INSERT INTO $tabla(usuario, password, email) VALUES (:usuario, :password, :email)");

    $stmt->bindParam(":usuario", $datosModel["usuario"], PDO::PARAM_STR);
    $stmt->bindParam(":password", $datosModel["password"], PDO::PARAM_STR);
    $stmt->bindParam(":email", $datosModel["email"], PDO::PARAM_STR);

    // Ejecutamos y verificamos el resultado
    if($stmt->execute()){
        return "success";
    } else {
        return "error";
    }

}

Explicación:

  • if($stmt->execute()): Preguntamos: "¿La ejecución fue exitosa?".

  • Si es true, la función registroUsuarioModel devuelve la palabra "success".

  • Si es false, devuelve "error".

Este resultado ("success" o "error") viaja de regreso al controlador y se guarda en la variable $respuesta.

Paso 5: Validar que el Formulario se Envió (Corrigiendo un Error)

Ahora, si probamos nuestro formulario tal como está, nos encontraremos con un error: "Undefined index: usuario...". Esto pasa porque cuando entramos a la página por primera vez, el formulario no se ha enviado, ¡pero nuestro código dentro del controlador aún intenta leer $_POST["usuario"]!

Para solucionarlo, debemos preguntar si el formulario ya fue enviado. Esto lo hacemos con isset(), que verifica si una variable existe y no es nula.

En nuestro controlador (controller.php), envolvemos toda la lógica dentro de un if:

php
public function registroUsuarioController(){

    // Preguntamos: ¿Ya se envió el formulario? (¿Existe $_POST["usuario"]?)
    if(isset($_POST["usuario"])){

        $datosController = array(
            "usuario"=>$_POST["usuario"],
            "password"=>$_POST["password"],
            "email"=>$_POST["email"]
        );

        $respuesta = Datos::registroUsuarioModel($datosController, "usuarios");

        echo $respuesta; // Por ahora, solo muestra "success" o "error"
    }

}

Ahora, el código dentro del if solo se ejecutará cuando alguien haya hecho clic en "Enviar". El primer error ha desaparecido.

Paso 6: ¡Probamos! (Y Corregimos un Error más)

Vamos a probar. Llenamos el formulario con:

  • Usuario: juan

  • Contraseña: 1234

  • Email: juan@hotmail.com

Hacemos clic en "Enviar" y... ¡aparece "success"! Ahora, si revisamos nuestra tabla usuarios en phpMyAdmin, veremos algo como esto:

idusuariopasswordemail
1juan1234juan@hotmail.com

¡Funcionó! Los datos están en la base de datos.

Paso 7: Mejorando la Experiencia del Usuario (Redireccionar y Mostrar Mensajes)

Tenemos un pequeño problema. Si después de ver "success", actualizamos la página, el formulario se reenviará y se creará otro usuario duplicado (esto se llama "reenvío de formulario"). Para evitarlo, usaremos una técnica llamada PRG (Post-Redirect-Get).

La idea es: después de procesar el formulario (POST), en lugar de mostrar un mensaje directamente, redirigimos al usuario a otra página (GET) usando header(). Luego, en esa página, mostramos un mensaje.

Paso 7.1: Redirigir desde el Controlador

Cambiamos el controlador. Si el registro fue exitoso, redirigimos a index.php?action=ok. Si no, redirigimos a index.php?action=error.

php
public function registroUsuarioController(){

    if(isset($_POST["usuario"])){

        $datosController = array(
            "usuario"=>$_POST["usuario"],
            "password"=>$_POST["password"],
            "email"=>$_POST["email"]
        );

        $respuesta = Datos::registroUsuarioModel($datosController, "usuarios");

        if($respuesta == "success"){
            header("location:index.php?action=ok");
        } else {
            header("location:index.php?action=error");
        }

    }

}

Paso 7.2: Mostrar el Mensaje en la Vista

En nuestro archivo de vista (registro.php), debemos agregar la lógica para mostrar el mensaje según lo que venga en la URL (action).

php
<h1>REGISTRO DE USUARIO</h1>

<?php
// Verificamos si existe la variable 'action' en la URL
if(isset($_GET["action"])){

    if($_GET["action"] == "ok"){
        echo "<p style='color:green;'>¡Registro Exitoso!</p>";
    }

    if($_GET["action"] == "error"){
        echo "<p style='color:red;'>Hubo un error en el registro.</p>";
    }

}
?>

<form method="post">
    <input type="text" placeholder="Usuario" name="usuario" required>
    <input type="password" placeholder="Contraseña" name="password" required>
    <input type="email" placeholder="Email" name="email" required>
    <input type="submit" value="Enviar">
</form>

<?php
$registro = new MvcController();
$registro -> registroUsuarioController();
?>

Paso 7.3: Actualizar la Lista Blanca de Enlaces

Recuerda que tenemos un archivo de enlaces.php (o similar) que controla a qué páginas podemos navegar. Debemos agregar "ok" y "error" a la lista de páginas permitidas para que la redirección funcione correctamente.

Resumen de la Parte 2

¡Felicidades! Hemos completado el ciclo completo de registro.

  1. Preparamos la consulta SQL con prepare(), usando marcadores :nombre para los datos del usuario.

  2. Vinculamos los parámetros con bindParam(), asociando cada marcador con el valor real que viene del controlador.

  3. Ejecutamos la consulta con execute() y verificamos si fue exitosa.

  4. Protegimos nuestra aplicación comprobando que el formulario fue enviado con isset().

  5. Mejoramos la experiencia del usuario usando el patrón PRG (Post/Redirect/Get) para evitar el reenvío del formulario al actualizar la página.

Ahora tienes un sistema de registro funcional y, lo más importante, ¡seguro contra ataques de inyección SQL!

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