Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/jpbarbatic/webapp/llms.txt

Use this file to discover all available pages before exploring further.

El panel de administración sigue una arquitectura de tres capas inspirada en el patrón MVC. Los controladores viven en public/ y responden directamente a las peticiones HTTP; la lógica de negocio y acceso a datos se centraliza en includes/; y las vistas se construyen como fragmentos .html.php dentro de html/. La plantilla maestra html/plantilla.html.php actúa de pegamento: combina navegación, mensajes flash y el fragmento de contenido específico de cada página en un único documento HTML coherente.

​
Ciclo de vida de una petición

Cada petición que llega al servidor recorre el siguiente camino, desde Apache hasta el HTML que ve el usuario:
1

Apache recibe la petición y aplica mod_rewrite

El fichero public/.htaccess intercepta la URL antes de que PHP entre en juego. Las reglas de mod_rewrite traducen rutas limpias como /productos/42 o /productos/nuevo a sus controladores PHP correspondientes (productos/editar.php?id=42 y productos/nuevo.php). Las URLs que no coinciden con ninguna regla se resuelven directamente como ficheros.
2

PHP ejecuta el controlador del módulo

El controlador correspondiente en public/<modulo>/ (por ejemplo public/productos/index.php) toma el control. Es el único fichero con lógica de negocio específica del módulo: consultas SQL, procesado de formularios y preparación de variables para la vista.
3

El controlador incluye backend.php como guard

La primera línea significativa de cualquier controlador protegido es:
$db = require_once('../../includes/backend.php');
Este fichero actúa de portero: inicia la sesión, verifica que el usuario está autenticado, abre la conexión PDO, carga los permisos del rol desde la base de datos y comprueba que el usuario tiene el permiso requerido para esa página concreta. Si cualquier verificación falla, el script termina con una redirección o un die().
4

El controlador construye los datos y prepara la vista

Con la conexión $db ya disponible, el controlador ejecuta sus consultas, procesa los datos y asigna las variables que necesita la plantilla: $titulo (texto que aparece en el <title> HTML) y $vista (ruta relativa al directorio html/, sin extensión, como 'productos/listado').
5

plantilla.html.php renderiza el HTML completo

La última línea del controlador llama a la plantilla maestra:
require('../../html/plantilla.html.php');
La plantilla incluye dinámicamente los fragmentos de la vista indicada por $vista: el markup principal (.html.php), los estilos específicos (.css.php, si existe) y el JavaScript específico (.script.php, si existe), además de los scripts compartidos y la barra de navegación. Al finalizar, elimina los mensajes flash de la sesión con unset($_SESSION['mensaje']).

​
Las tres capas

includes/

Lógica de backend compartida. Contiene backend.php (guard de autenticación y permisos), db_pdo.php (wrapper PDO con funciones db_open, db_query, db_insert, db_update, db_delete_by_id, db_filter y la clase DB), permisos.php (consultas RBAC) y utilidades.php (funciones auxiliares de HTML y paginación).

html/

Fragmentos de vista. Agrupa la plantilla maestra (plantilla.html.php), la barra de navegación (nav.html.php), los scripts compartidos (comun.script.php) y los subdirectorios de cada módulo (productos/, categorias/, usuarios/, etc.) con sus fragmentos .html.php, .css.php y .script.php.

public/

Controladores y punto de entrada web. Es la única carpeta expuesta al servidor web. Contiene index.php (raíz de la aplicación), login.php, logout.php, error.php y los subdirectorios de cada módulo con sus controladores específicos (index.php, nuevo.php, editar.php, guardar.php, borrar.php, etc.).

​
El guard pattern (backend.php)

Todos los controladores protegidos del panel comienzan incluyendo backend.php mediante require_once. Este fichero actúa como un guard centralizado que garantiza que ninguna página del panel sea accesible sin autenticación válida ni sin el permiso adecuado. Al devolver $db con return $db, el controlador recibe la conexión PDO lista para usar en la misma línea de require_once. El código fuente completo del guard es el siguiente: 
<?php
require(__DIR__.'/../config.php');
require_once('permisos.php');
require_once('utilidades.php');
// Iniciamos las sesiones
session_start();

// Comprobamos si la sesión está inicializada. Si no lo está, redirigimos a login
if (!isset($_SESSION['usuario'])) {
    header('Location: '.URL_BASE);
    exit;
}

require('db_pdo.php');
// Creamos una conexión de base de datos
$db = db_open();

if (!$db) {
    die('Se ha producido un error');
}

$_SESSION['permisos'] = obtener_permisos_rol($db, $_SESSION['usuario']['id_rol']);
if(!$_SESSION['usuario']['id_rol']===1 && (isset($permiso) && !in_array($permiso, array_column($_SESSION['permisos'], 'nombre')))){
  die('No tienes permiso');
}

return $db;
Los pasos que ejecuta el guard son:
  1. Carga de configuración — incluye config.php (constantes de base de datos y URL), permisos.php y utilidades.php.
  2. Inicio de sesión — session_start() reanuda la sesión PHP existente.
  3. Verificación de autenticación — si $_SESSION['usuario'] no existe, redirige a URL_BASE (la página de login) y termina.
  4. Apertura de la conexión PDO — db_open() crea la conexión con los parámetros definidos en config.php.
  5. Carga de permisos — obtener_permisos_rol() consulta la tabla roles_permisos y actualiza $_SESSION['permisos'] con los permisos del rol del usuario.
  6. Verificación de permiso — si el controlador declaró la variable $permiso antes del require_once, comprueba que ese permiso está en la lista del rol. Si no lo está, termina con die('No tienes permiso').
  7. Retorno de la conexión — return $db devuelve el objeto PDO al controlador.
Existe un error de precedencia de operadores en la línea de comprobación de rol. La expresión !$_SESSION['usuario']['id_rol']===1 se evalúa como (!$_SESSION['usuario']['id_rol']) === 1, no como !($a === 1). Esto significa que la condición de exención del rol 1 nunca se cumple tal como está escrita. Consulta la página de Autenticación para un análisis detallado.

​
Más sobre la arquitectura

Autenticación

Flujo de login, sesiones PHP y sistema RBAC de permisos por rol.

Plantilla

Sistema de plantillas: inclusión dinámica de fragmentos y mensajes flash.

Enrutamiento

Reglas mod_rewrite en .htaccess y mapa completo de rutas.

Build docs developers (and LLMs) love

Get started for freeTalk to us