Errores reales en .htaccess y permisos de WordPress: ejemplos prácticos en Indaga.net y Puntocomunica

Valencia, 20/11/2026, G.B.
Cuando gestiono sitios en WordPress (especialmente manteniendo desarrollos propios, plugins a medida y alojamientos compartidos), muchos sustos vienen de dos frentes muy concretos: un archivo .htaccess acumulado con reglas antiguas o duplicadas y unos permisos de archivos o carpetas mal ajustados.

Como explican en la guía de LucusHost sobre permisos en WordPress, una mala configuración de permisos es una de las causas habituales de errores 403 o 500, además de abrir puertas innecesarias a nivel de seguridad o bloquear tareas básicas si nos pasamos de restrictivos. En mi día a día administrando Indaga.net y Puntocomunica, he comprobado cómo pequeños desajustes en el .htaccess o en los permisos se van sumando y generan comportamientos poco claros.

Qué son los permisos en WordPress y por qué importan

En sistemas Linux y Apache, los permisos controlan quién puede leer (4), escribir (2) o ejecutar (1) un archivo o carpeta para tres perfiles: propietario, grupo y otros (el público general), tal como detalla el artículo de LucusHost sobre permisos en WordPress.

  • Estándar recomendado: 644 (rw-r--r--) en archivos (incluido .htaccess) y 755 (rwxr-xr-x) en carpetas.
  • Atención especial a wp-config.php: guarda las credenciales de base de datos y claves de seguridad, así que conviene evitar permisos abiertos como 666 y mantener un ajuste restrictivo compatible con tu hosting (como 644, 640 o 440/400 según cómo ejecute PHP el servidor).
  • Por qué no usar 604: dejar un .htaccess en 604 (rw-------r--) suele dar problemas en alojamientos compartidos según cómo se ejecute PHP o Apache frente al propietario del fichero.
  • Por qué evitar 777 o 666: dar escritura abierta a todo el mundo expone archivos sensibles y facilita modificaciones no autorizadas; por otro lado, bajar a 400 o 000 puede bloquear subidas de medios o actualizaciones desde el panel de WordPress.

Ejemplo 1: el .htaccess de Indaga.net

En Indaga.net, el .htaccess tenía una base funcional con WP Fastest Cache, redirección SSL, el bloque estándar de WordPress y la protección de Wordfence para .user.ini. Sin embargo, al revisarlo con lupa aparecían detalles que conviene afinar:

  • Dominio sin anclar y sin unificar: la condición de caché comprobaba ^indaga.net sin anclar el final ($), mientras la redirección HTTPS usaba https://%{HTTP_HOST}/$1. Unificar la redirección hacia https://indaga.net/$1 antes de evaluar la caché evita que peticiones HTTP pasen por lógica de reescritura antes de saltar a HTTPS.
  • Exclusión de validación SSL (.well-known/acme-challenge/): mantener la excepción de ^/\.well-known/acme-challenge/ antes de forzar HTTPS evita interferencias en la renovación automática de certificados.
  • Rutas de caché en alojamiento compartido: la comprobación de /homepages/.../htdocs/W3/wp-content/cache/all/$1/index.html funciona si el sitio vive en esa subcarpeta mapeada como raíz, pero conviene revisar siempre que coincida con la ruta real del servidor.
  • Respetar el bloque # BEGIN WordPress: cualquier regla propia o de caché debe ir fuera de los marcadores de WordPress para que no se pierda o mezcle al regenerar enlaces permanentes.

Así queda la propuesta revisada para el .htaccess de Indaga.net:

# BEGIN HTTPS Redirect
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteCond %{HTTPS} !=on [NC]
RewriteCond %{REQUEST_URI} !^/\.well-known/acme-challenge/
RewriteRule ^(.*)$ https://indaga.net/$1 [R=301,L]
</IfModule>
# END HTTPS Redirect

# BEGIN WpFastestCache
# Modified Time: 02-08-26 22:45:00
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteCond %{HTTPS} on
RewriteCond %{HTTP_HOST} ^indaga\.net$ [NC]
# Start WPFC Exclude
# End WPFC Exclude
# Start_WPFC_Exclude_Admin_Cookie
RewriteCond %{HTTP:Cookie} !wordpress_logged_in_[^\=]+\=Directorio%20Indaga
# End_WPFC_Exclude_Admin_Cookie
RewriteCond %{HTTP_USER_AGENT} !(facebookexternalhit|WP_FASTEST_CACHE_CSS_VALIDATOR|Twitterbot|LinkedInBot|WhatsApp|Mediatoolkitbot)
RewriteCond %{HTTP_USER_AGENT} !(WP\sFastest\sCache\sPreload(\siPhone\sMobile)?\s*Bot)
RewriteCond %{REQUEST_METHOD} !POST
RewriteCond %{REQUEST_URI} !(\/){2,}
RewriteCond %{THE_REQUEST} !(\/){2,}
RewriteCond %{REQUEST_URI} \/$
RewriteCond %{QUERY_STRING} !.+ [OR]
RewriteCond %{QUERY_STRING} fbclid=
RewriteCond %{HTTP:Cookie} !wordpress_logged_in
RewriteCond %{HTTP:Cookie} !comment_author_
RewriteCond %{HTTP:Profile} !^[a-z0-9\"]+ [NC]
RewriteCond %{DOCUMENT_ROOT}/wp-content/cache/all/$1/index.html -f [OR]
RewriteCond /homepages/.../htdocs/W3/wp-content/cache/all/$1/index.html -f
RewriteRule ^(.*) "/wp-content/cache/all/$1/index.html" [L]
</IfModule>
<FilesMatch "index\.(html|htm)$">
AddDefaultCharset UTF-8
<IfModule mod_headers.c>
FileETag None
Header unset ETag
Header set Cache-Control "max-age=0, no-cache, no-store, must-revalidate"
Header set Pragma "no-cache"
Header set Expires "Mon, 29 Oct 1923 20:30:00 GMT"
</IfModule>
</FilesMatch>
# END WpFastestCache

# BEGIN WordPress
# Las directivas (líneas) entre «BEGIN WordPress» y «END WordPress» son
# generadas dinámicamente y solo deberían ser modificadas mediante filtros de WordPress.
# Cualquier cambio en las directivas que hay entre esos marcadores serán sobrescritas.
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
RewriteBase /
RewriteRule ^index\.php$ - [L]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]
</IfModule>
# END WordPress

# Wordfence WAF
<Files ".user.ini">
<IfModule mod_authz_core.c>
	Require all denied
</IfModule>
<IfModule !mod_authz_core.c>
	Order deny,allow
	Deny from all
</IfModule>
</Files>
# END Wordfence WAF

Ejemplo 2: el .htaccess de Puntocomunica

El caso de Puntocomunica (www.puntocomunica.com) es un ejemplo clásico de cómo un .htaccess va acumulando capas con el tiempo y acaba teniendo reglas duplicadas o desfasadas:

  • Bloques de reescritura duplicados: retiré la regla duplicada de reenvío a /index.php que estaba fuera del bloque # BEGIN WordPress, dejando el enrutamiento limpio dentro de su bloque correspondiente y respetando la exclusión de .well-known/acme-challenge/.
  • Redirección HTTPS dependiente de una sola cabecera: el bloque de SSL solo miraba %{HTTP:CF-Visitor} ("scheme":"http"). Combinar la comprobación de %{HTTPS} !=on, la cabecera de Cloudflare y el host canónico (https://www.puntocomunica.com/) hace la redirección más robusta (vigilando siempre que el modo SSL de Cloudflare no provoque bucles).
  • Listas largas de IPs con sintaxis antigua (!mod_authz_core.c): quité el bloque antiguo de rangos de IP con Order allow,deny y Deny from pensado para Apache 2.2, ya que añade carga en cada petición y puede no aplicarse igual en Apache 2.4; conviene resolver ese filtrado desde el firewall o WAF. En cuanto al bloque vacío de WPO Tweaks, puedes limpiarlo si ya no lo usas o dejarlo si algún ajuste activo lo gestiona.

Así queda la propuesta limpia para el .htaccess de Puntocomunica:

# BEGIN HTTPS & Canonical Host Redirect
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST_URI} !^/\.well-known/acme-challenge/
RewriteCond %{HTTPS} !=on [OR]
RewriteCond %{HTTP:CF-Visitor} '"scheme":"http"' [OR]
RewriteCond %{HTTP_HOST} !^www\.puntocomunica\.com$ [NC]
RewriteRule ^(.*)$ https://www.puntocomunica.com/$1 [R=301,L]
</IfModule>
# END HTTPS & Canonical Host Redirect

# BEGIN WpFastestCache
# Modified Time: 02-08-26 22:42:25
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteCond %{HTTPS} on
RewriteCond %{HTTP_HOST} ^www\.puntocomunica\.com$ [NC]
# Start WPFC Exclude
# End WPFC Exclude
# Start_WPFC_Exclude_Admin_Cookie
RewriteCond %{HTTP:Cookie} !wordpress_logged_in_[^\=]+\=admin
# End_WPFC_Exclude_Admin_Cookie
RewriteCond %{HTTP_USER_AGENT} !(facebookexternalhit|WP_FASTEST_CACHE_CSS_VALIDATOR|Twitterbot|LinkedInBot|WhatsApp|Mediatoolkitbot)
RewriteCond %{HTTP_USER_AGENT} !(WP\sFastest\sCache\sPreload(\siPhone\sMobile)?\s*Bot)
RewriteCond %{REQUEST_METHOD} !POST
RewriteCond %{REQUEST_URI} !(\/){2,}
RewriteCond %{THE_REQUEST} !(\/){2,}
RewriteCond %{REQUEST_URI} \/$
RewriteCond %{QUERY_STRING} !.+ [OR]
RewriteCond %{QUERY_STRING} fbclid=
RewriteCond %{HTTP:Cookie} !comment_author_
RewriteCond %{HTTP:Profile} !^[a-z0-9\"]+ [NC]
RewriteCond %{DOCUMENT_ROOT}/wp-content/cache/all/$1/index.html -f [OR]
RewriteCond /homepages/.../htdocs/puntocomunica/wp-content/cache/all/$1/index.html -f
RewriteRule ^(.*) "/wp-content/cache/all/$1/index.html" [L]
</IfModule>
<FilesMatch "index\.(html|htm)$">
AddDefaultCharset UTF-8
<IfModule mod_headers.c>
FileETag None
Header unset ETag
Header set Cache-Control "max-age=0, no-cache, no-store, must-revalidate"
Header set Pragma "no-cache"
Header set Expires "Mon, 29 Oct 1923 20:30:00 GMT"
</IfModule>
</FilesMatch>
# END WpFastestCache

# BEGIN WordPress
# Las directivas (líneas) entre «BEGIN WordPress» y «END WordPress» son
# generadas dinámicamente y solo deberían ser modificadas mediante filtros de WordPress.
# Cualquier cambio en las directivas que hay entre esos marcadores serán sobrescritas.
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
RewriteBase /
RewriteRule ^index\.php$ - [L]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]
</IfModule>
# END WordPress

# Wordfence WAF
<Files ".user.ini">
<IfModule mod_authz_core.c>
	Require all denied
</IfModule>
<IfModule !mod_authz_core.c>
	Order deny,allow
	Deny from all
</IfModule>
</Files>
# END Wordfence WAF

Comprobación rápida antes de tocar nada

  1. Haz copia de seguridad del .htaccess antes de editarlo: un error de sintaxis devuelve un 500 Internal Server Error al instante.
  2. Aplica permisos 644 en .htaccess y archivos, y 755 en carpetas, revisando que no haya 777 ni bloqueos raros tras migraciones.
  3. Prueba en incógnito la redirección 301 a HTTPS y host canónico, la carga de páginas con caché y el acceso a /wp-admin.

Indaga Directorio de Personal (v1.2.6): alternativa nativa a Name Directory y evolución de Import to Excel

Valencia, 20/11/2026, G.B.
He desarrollado el plugin Indaga Directorio de Personal (versión 1.2.6) porque me falló el plugin Name Directory y quise ampliar las funcionalidades de mi plugin Import to Excel. Mi objetivo ha sido contar con una herramienta propia, estable y totalmente integrada en WordPress para gestionar directorios de personal con campos estructurados, importación y exportación CSV y búsqueda rápida sin depender de plugins de terceros.

Por qué creé este plugin

Al fallarme Name Directory y buscar ampliar las capacidades de Import to Excel, decidí construir una solución nativa bajo el patrón Singleton (Indaga_Directorio_Personal::get_instance()) que separara los datos de cada persona en campos limpios en base de datos, manteniendo al mismo tiempo compatibilidad con el formato CSV heredado para poder migrar y trabajar sin fricciones.

Principales funciones de la versión 1.2.6

  • Gestión estructurada en administración: alta, edición y borrado de fichas con campos independientes (name, role_title, department, extension, email, profile_url, photo_url, tamaño y dimensiones de imagen, status y submitter), conservando raw_description por retrocompatibilidad.
  • Acciones en lote y paginación: selección masiva (publish, draft, delete) protegida con nonce y paginación de 50 registros por página en el listado administrativo.
  • Conservación temporal de formularios: uso de transients (indaga_dp_form_{user_id} durante 10 minutos) para no perder los datos introducidos ante errores de validación o nombres duplicados.
  • Importación y exportación CSV: detección automática de delimitador (, o ;), limpieza de BOM UTF-8, conversión a UTF-8 cuando corresponde, validación de extensión (.csv o .txt), normalización de dimensiones de imagen y exportación en formato estructurado o compatible con Name Directory.
  • Shortcodes y filtrado en cliente: shortcodes [indaga_directorio_personal] y [name_directory] con soporte multi-instancia, índice alfabético (# y A–Z), búsqueda sin tildes y filtros combinados por departamento y categoría o cargo.

Ficha técnica

  • Versión mínima de WordPress: 5.8 o superior
  • Versión mínima de PHP: 7.4 o superior
  • Arquitectura: Patrón Singleton (Indaga_Directorio_Personal::get_instance())
  • Dependencias de otros plugins: Ninguna (100 % autónomo)
  • Dependencias externas (CDNs / APIs): Ninguna (0 dependencias externas; sin peticiones a servicios de terceros como cdnjs o Google Fonts)
  • Compatibilidad con caché / proxy: Compatible con proxy inverso y plugins de caché (p. ej., WP Fastest Cache), con filtrado en cliente sin recarga
  • Tabla personalizada: {prefijo}indaga_directorio_personal, gestionada mediante dbDelta() en activate() y maybe_upgrade_schema(), con los campos id, name, profile_url, photo_url, photo_size, photo_width, photo_height, role_title, department, extension, email, raw_description, submitter, status, created_at y updated_at
  • Opciones y datos temporales (wp_options): indaga_dp_db_version, indaga_dp_hidden_categories (autoload = false) y indaga_dp_form_{user_id} (transient de 10 minutos)
  • Rutas y recursos estáticos: carga condicional de admin.css, admin.js, frontend.css y frontend.js únicamente en las pantallas de administración del plugin o páginas con el shortcode activo
  • Funcionalidad principal e integración: gestión integral del directorio de personal con alta/edición, gestión de categorías/cargos, importación/exportación CSV y visualización filtrable mediante los shortcodes [indaga_directorio_personal] y [name_directory]

Seguridad y retrocompatibilidad

Todo el código utiliza exclusivamente las APIs oficiales de WordPress ($wpdb con consultas preparadas y esc_like(), admin-post.php, Options API, Transients API y wp_enqueue_*), comprobando capacidades (manage_options), validando nonces frente a CSRF, sanitizando entradas y escapando salidas. Las novedades se añaden de forma acumulativa manteniendo la retrocompatibilidad con Name Directory.

Ficha técnica y descarga

Actualización plugin Control de Prórrogas de Email, cuaderno técnico

Actualizado el 19/11/2026 para incluir la versión 2.1.0

Valencia, 18/11/2026, G.B.
Actualizo el plugin Control de Prórrogas de Email de la versión 1.4.0 a la 2.1.0. Lo hice en dos pasos: la 2.0.0 trajo importación, campos propios, usuarios gestores y exportación con filtros, y la 2.1.0 añade tres avisos de vencimiento y la gestión completa desde el front end. Lo cuento por partes y con las preguntas que yo mismo me hacía.

¿Qué cambia en la versión 2.0.0?

¿Quién puede gestionar las prórrogas sin ser administrador?

Cualquier usuario que marques en la pestaña dedicada, creada con cpe_render_usuarios(). Tiene un buscador que usa la API de usuarios de WordPress y casillas para elegir a quién das acceso.

  • La función cpe_usuario_autorizado() sigue validando a los administradores (manage_options) y los IDs guardados en la opción cpe_usuarios_permitidos, así que lo que ya tenías configurado sigue valiendo.
  • Los usuarios autorizados pueden ver, crear, editar, eliminar, importar y exportar registros. Los campos personalizados, la lista de usuarios y los ajustes quedan solo para administradores.

¿Se puede importar desde Excel, LibreOffice o CSV?

Sí. El plugin lee ficheros .csv, .xlsx y .ods con código propio, sin librerías externas.

  • Los formatos .xlsx y .ods se leen con ZipArchive y SimpleXML. Si el servidor no tiene ZipArchive, el plugin avisa y solo admite CSV.
  • La importación es un asistente por pasos: subes el fichero, el plugin analiza las columnas, tú asignas cada una a un campo y confirmas. No deja asignar dos columnas al mismo campo.
  • Por defecto omite los duplicados, que son registros con el mismo email y las mismas fechas de prórroga.

¿Se pueden crear campos nuevos desde el panel?

Sí, desde la pestaña Campos, con cpe_render_campos(). Puedes crear campos de texto corto, texto largo, fecha o número, y marcarlos como obligatorios.

  • Cada campo nuevo es una columna real de la tabla, creada con ALTER TABLE sobre una lista blanca de validación y con el prefijo cx_.
  • El campo aparece en el formulario, el listado, los filtros, la importación y la exportación.
  • Borrar un campo borra también sus datos, así que el plugin pide confirmación y solo lo permite a los administradores.

¿Cómo queda el panel de administración?

Organizado en pestañas: Gestión, Importar, Campos, Usuarios autorizados, Ajustes, Instrucciones y Ficha técnica, siguiendo el estándar de Indaga.net. Los usuarios que no son administradores solo ven las pestañas que pueden usar.

¿Cómo se exporta con filtros?

El bloque de exportación, gestionado por cpe_accion_exportar(), genera el fichero con exactamente los filtros que tienes aplicados en pantalla.

  • Se puede filtrar por texto, estado, solicitante, rango de fechas de cualquier campo de fecha y por el contenido de cualquier campo, incluidos los personalizados.
  • Tú eliges qué columnas incluir.
  • El formato puede ser Excel nativo (.xlsx), con panel congelado y autofiltros, o CSV con delimitador ; y BOM UTF-8, para que Excel y LibreOffice Calc respeten tildes y eñes.
  • Los textos que empiezan por símbolos de fórmula se neutralizan al exportar, para evitar la inyección de fórmulas en hojas de cálculo.

¿Qué hay de la seguridad?

Todas las acciones llevan nonces (CSRF) y consultas preparadas con $wpdb->prepare. Las columnas se validan siempre contra una lista blanca y cada dato se sanea según su tipo (sanitize_text_field, sanitize_email, cpe_validar_fecha). Al leer ficheros XML se rechazan las entidades externas.

¿Qué añade la versión 2.1.0?

¿Cómo funcionan los tres avisos de vencimiento?

Cada prórroga recibe tres avisos, uno por semana, cuando faltan 21, 14 y 7 días para su final. El calendario está fijo en una sola función:

function cpe_etapas_aviso() {
	return array( 21, 14, 7 );
}
  • Cada registro lleva un contador de avisos enviados, de 0 a 3, así que ningún aviso se manda dos veces.
  • Si un día no se ejecuta la tarea programada, la siguiente vez se envía el aviso pendiente. Una prórroga dada de alta con menos de tres semanas por delante recibe el aviso que le corresponda y los siguientes en su fecha.
  • Cada día de envío salen dos tipos de email: un resumen para los destinatarios internos que configuras en Ajustes, y un aviso individual a la dirección de correo del propio registro, es decir, a la persona cuya cuenta va a caducar. Este segundo envío se activa con una casilla y admite un mensaje adicional, por ejemplo para explicar cómo pedir una ampliación.
  • Si editas la fecha final de un registro, su ciclo de avisos vuelve a empezar. Los registros con fecha de baja ya pasada no reciben avisos.
  • El botón de prueba envía el resumen solo a los destinatarios internos y no marca ningún aviso como enviado.

La comprobación se hace una vez al día con WP-Cron, que solo se ejecuta cuando alguien visita el sitio. En un sitio con poco tráfico el aviso puede retrasarse unas horas.

¿Se puede editar y eliminar desde el front end?

Sí. Los usuarios autorizados pueden guardar, editar, eliminar y exportar registros desde la página donde hayas puesto el shortcode, sin entrar en el panel de administración:

[control_prorrogas]
[control_prorrogas por_pagina="50"]

Antes los formularios enviaban los datos a wp-admin/admin-post.php, y muchos sitios bloquean wp-admin a quien no es administrador. Ahora esas acciones se procesan en la propia página, con nonce y con la comprobación de cpe_usuario_autorizado().

¿Qué pasa con los datos al actualizar?

La tabla se migra sola al cargar el plugin y añade la columna del contador de avisos. Los registros que ya habían recibido el aviso único de la versión anterior quedan marcados como avisados del todo, para que nadie reciba tres emails de golpe. Aun así, haz una copia de la tabla antes de actualizar.

¿Cómo lo instalo sobre la versión anterior?

Lo más seguro es sustituir el fichero control-prorrogas-email.php dentro de la misma carpeta de wp-content/plugins/ donde ya está instalado. Si subes un ZIP con otra carpeta, WordPress instala una copia aparte, y no hay que activarla mientras la anterior siga activa, porque las dos usan los mismos nombres de funciones.

El plugin está pensado para funcionar con MySQL y MariaDB.

Ficha técnica y descarga (Control de plugins)

Consentimiento y control: así funcionan mis nuevos plugins de cookies para WordPress

Valencia, 13/11/2026, G.B.
Hola de nuevo. Siguiendo con mi compromiso de desarrollar soluciones totalmente nativas, ligeras y adaptadas a nuestras necesidades reales en WordPress, hoy os presento un tándem de plugins diseñado para resolver de principio a fin la gestión y auditoría de cookies: Indaga Cookies (el banner de consentimiento) y Indaga Cookie Scanner (el escáner y listado automático).

Indaga Cookies: consentimiento, bloqueo y registro seguro

El primer pilar de este sistema es el plugin de consentimiento de cookies, concebido bajo la premisa de no depender de servicios externos de pago ni librerías pesadas:

  • Banner y bloqueo automático: Muestra un aviso limpio y bloquea de forma inteligente los scripts de terceros y los iframes (como vídeos de YouTube o mapas) hasta que el usuario acepta la categoría correspondiente.
  • Modo dual flexible: Permite funcionar en modo Completo (gestionando el banner, el bloqueo y el registro) o en modo Solo registro, ideal si prefieres utilizar la interfaz gráfica de otro banner (como Complianz o CookieYes) pero quieres centralizar toda la auditoría legal en tu propia base de datos.
  • Registro íntegro con firma HMAC: Cada decisión del usuario genera un identificador único (UUID) y se almacena en una tabla propia de la base de datos de WordPress, firmada criptográficamente para garantizar su inalterabilidad y permitiendo la exportación segura a CSV con protección anti-fórmulas.Ficha técnica y descarga (control de plugins)

Indaga Cookie Scanner: auditoría transparente en tiempo real

Para cumplir con las exigencias del RGPD y la LSSI, las páginas de política de cookies deben incluir un listado detallado de los elementos que se utilizan en el sitio. En lugar de depender de scripts lentos o bases de datos externas de pago, he desarrollado Indaga Cookie Scanner.

¿Qué diferencia a Indaga Cookie Scanner de soluciones comerciales como Complianz?

Herramientas como Complianz realizan escaneos profundos consultando bases de datos externas teóricas (como cookiedatabase.org), lo que a menudo genera listas sobredimensionadas con decenas de cookies hipotéticas que tu web ni siquiera está utilizando. En cambio, Indaga Cookie Scanner adopta un enfoque mucho más ligero y real:

  • Escaneo real en el navegador (Client-side): El plugin analiza de forma autónoma y en tiempo real únicamente las cookies que físicamente existen y están activas en el navegador del visitante en el momento de la carga.
  • Rendimiento absoluto: Al no realizar peticiones pesadas a APIs externas en el servidor, la velocidad de tu web se mantiene intacta.
  • Hibridación SEO: Utiliza un sistema inteligente que combina un volcado estático de referencia en PHP (asegurando una indexación perfecta para buscadores y accesibilidad) con un reemplazo dinámico mediante sessionStorage que destaca al instante las cookies activas del usuario.

Ampliación y personalización desde el panel de administración

Para asegurar que tu política de cookies sea exhaustiva y cubra tanto los elementos detectados al vuelo como aquellos propios de pasarelas de pago, plugins de analítica o herramientas específicas, el plugin incluye un panel de control dedicado (Cookie Scanner > Catálogo y Ajustes).

Desde ahí puedes ampliar y personalizar fácilmente el catálogo de reconocimiento mediante una sintaxis muy sencilla (patrones exactos o prefijos terminados en guion bajo, categoría y descripción):

indaga_cc_consent,indaga_cookies_consent|consentimiento|Gestión de la preferencia de cookies del usuario.
_wp_session|técnica|Mantiene la sesión de usuario activa en WordPress.
wordpress_logged_in_,wp-settings-|sesión|Identifica al usuario autenticado en el panel de administración.
_ga,_gid,_gat|analítica|Cookies de Google Analytics para medición de tráfico y estadísticas de uso.
_fbp,_gcl_au|marketing|Cookies de seguimiento publicitario y redes sociales.
_pk_id,_pk_ses,matomo_|analítica|Cookies de Matomo para análisis y estadísticas de tráfico web.
_fbp,_fbc|marketing|Cookies de Meta (Facebook) para seguimiento publicitario y conversiones.
__kla_id|marketing|Cookie de Klaviyo para seguimiento de marketing y campañas de email.
IDE,test_cookie|marketing|Cookies de Google DoubleClick y publicidad conductual.
NID,CONSENT|preferencias|Cookies de Google para recordar preferencias de usuario y personalización de anuncios.
wp-wpml_current_language|preferencias|Cookie de WPML para almacenar la preferencia de idioma del sitio._pk_id,_pk_ses,matomo_|analítica|Cookies de Matomo para análisis y estadísticas de tráfico web.
_fbp,_fbc|marketing|Cookies de Meta (Facebook) para seguimiento publicitario.
NID,CONSENT|preferencias|Cookies de Google para recordar preferencias de usuario.

Listado automático mediante Shortcode

Una vez configurado tu catálogo, integrar la tabla en tu página legal es tan sencillo como insertar el siguiente shortcode donde desees que aparezca el listado:

[indaga_lista_cookies]

El shortcode genera automáticamente una tabla perfectamente maquetada, con estilos visuales totalmente coherentes con el resto de mis plugins de cookies, mostrando de forma transparente el nombre, la categoría y la finalidad de cada elemento.

Con este ecosistema nativo, cierro un poco más el círculo de la privacidad en mis desarrollos: control absoluto sobre los datos, cero dependencias externas, cumplimiento normativo estricto y una velocidad de carga inmejorable.

Ficha técnica y descarga (Control de plugins)

Indaga Galerías: un plugin propio de sliders y galerías sin librerías externas

Presento Indaga Galerías 1.0.0, un plugin nativo para mostrar imágenes de la Biblioteca de medios como carrusel o rejilla, con visor y sin dependencias de terceros

Valencia, 11/11/2026, G.B.
Me apetecía poder mostrar sliders y galerías de fotos en el blog sin instalar nada de terceros, así que me he hecho un plugin propio. Se llama Indaga Galerías, va por la versión 1.0.0 y hace justo eso: coge imágenes de la Biblioteca de medios y las muestra como carrusel o como rejilla, con un visor para ampliarlas. Todo en un único fichero PHP y sin librerías externas.

¿Por qué un plugin propio si WordPress ya tiene galerías?

Porque lo que trae el editor se me quedaba corto. Desde WordPress 6.4 el bloque Imagen incluye la opción de ampliar al hacer clic, pero es un visor básico pensado para imágenes sueltas: según WPBeginner, en una galería hay que activarlo imagen por imagen. Y un carrusel, directamente, no lo trae.

Para cubrir ese hueco lo habitual son plugins de terceros con sus librerías, sus hojas de estilo y sus actualizaciones. Yo prefiero lo que ya he hecho con el resto de plugins del sitio: algo pequeño, que controlo yo y que solo carga lo necesario.

¿Cómo se crea un slider o una galería?

Desde el panel Indaga Galerías del menú de administración, en la pestaña Instancias. Una instancia es un conjunto de imágenes con su configuración, y sirve igual para mostrarlo como slider o como galería.

  • Pulsas Añadir instancia y le pones un identificador (por ejemplo capturas) y un nombre.
  • Con Seleccionar imágenes eliges las fotos de la Biblioteca de medios y las ordenas con las flechas de cada miniatura.
  • Ajustas la proporción (16:9, 21:9, 3:2, 4:3 o 1:1), las columnas, el autoplay, las leyendas y el visor.
  • Guardas y copias el shortcode del listado.

El plugin solo guarda los IDs de las imágenes, así que no duplica nada: el texto alternativo y las leyendas salen de la propia Biblioteca de medios.

¿Qué shortcodes y opciones tiene?

Dos shortcodes, uno para el carrusel y otro para la rejilla (nota: pongo dobles corchetes en vez de uno solo para que no se ejecute, ya que ya lo he instalado):

[indaga_slider id="capturas"]
[indaga_galeria id="capturas"]

Y estos atributos opcionales, que sustituyen a lo guardado en la instancia:

  • id: identificador de la instancia. Es obligatorio salvo que uses ids.
  • ids: lista de IDs de imágenes separados por comas, para usarlo sin instancia.
  • leyendas: si o no.
  • lightbox: si o no, para activar o desactivar el visor.
  • autoplay: segundos entre diapositivas, de 0 a 30 (solo slider). Con 0 no avanza solo.
  • columnas: de 1 a 6 (solo galería). En móvil baja a 2 y después a 1.

Por ejemplo, una rejilla de cuatro columnas sin leyendas:

[indaga_galeria id="capturas" columnas="4" leyendas="no"]

¿Se puede usar sin crear una instancia antes?

Sí, con el atributo ids. Es útil para algo rápido, como un par de capturas en una entrada:

[indaga_slider ids="12,15,18"]

El ID de cada imagen aparece en la barra de direcciones cuando la abres en la Biblioteca de medios. En este modo se aplican las opciones por defecto, y si además indicas un id de instancia, usa las opciones de esa instancia pero con tus imágenes.

Un ejemplo

plugin comandos linux
plugin recursos
autores-plugin

¿Carga librerías externas o pesa mucho?

No carga ninguna librería. El carrusel se apoya en CSS scroll-snap y un JavaScript mínimo para las flechas, los puntos y el teclado, y el visor usa el elemento dialog del propio navegador. MDN clasifica el método showModal() como una funcionalidad bien establecida, disponible en los principales navegadores desde marzo de 2022. Si alguno no lo soporta, el clic abre la imagen a tamaño completo y ya está.

El CSS y el JavaScript van embebidos en el plugin y solo se cargan en las páginas que contienen alguno de los shortcodes. Las imágenes usan los tamaños que WordPress ya genera, con srcset y carga diferida, y el visor solo descarga la imagen grande cuando haces clic.

¿Es accesible?

Sí, en lo básico, y es algo que quería cuidar. El autoplay viene desactivado por defecto. Si lo activas aparece un botón de pausa, el avance se detiene al pasar el ratón o al enfocar con el teclado, y no se activa nunca si el sistema del usuario tiene reducido el movimiento. Va en la línea del criterio 2.2.2 de las pautas WCAG del W3C, que pide poder pausar, detener u ocultar el contenido que se mueve o se actualiza solo y se muestra junto a otro contenido (W3C).

Además, el carrusel se maneja con el teclado (flechas, Inicio y Fin), el visor se cierra con Esc y se recorre con las flechas, hay etiquetas ARIA, foco visible y el texto alternativo de cada imagen sale de la Biblioteca de medios.

¿Qué le falta?

Poco de lo vistoso, a propósito. Es una 1.0.0 y la he dejado sencilla: rejilla uniforme, carrusel horizontal y visor. No hay masonry, ni efectos de transición, ni vídeo. Las imágenes se recortan al centro con la proporción elegida para que el conjunto quede uniforme, así que si quieres ver la foto entera conviene escoger la proporción que más se parezca a la original. Y como con el resto de plugins, lo iré ajustando según lo vaya usando.

Como siempre, lo tienes en la página de plugins del blog.

Ficha técnica

  • Fecha: noviembre 2026
  • Nombre: Indaga Galerías
  • Versión: 1.0.0
  • Autor: Guillermo Beltrán Pilato
  • Descripción: Sliders y galerías de imágenes 100% nativos. Instancias gestionadas desde el panel con selector de la Biblioteca de medios, shortcodes indaga_slider e indaga_galeria (también con ids sin crear instancia), visor con dialog nativo, autoplay con pausa y sin dependencias externas.
  • Tags: slider, galeria, lightbox, imagenes
  • Enlace de descarga: pCloud

Formulario de Contacto Indaga v1.1.1: Control total, diagnóstico avanzado y cero dependencias

Valencia, 09/11/2026, G.B.
Siguiendo con mi filosofía de desarrollo en Indaga.net, donde apuesto por la ligereza, la privacidad de los datos y la ausencia de dependencias innecesarias, hoy presento la versión 1.1.1 del plugin Formulario de Contacto Indaga.

Cuando diseño soluciones propias para WordPress, mi objetivo principal es eliminar el código pesado y los plugins sobredimensionados que suelen acompañar a herramientas genéricas. Un formulario de contacto debe ser rápido, seguro por defecto y muy fácil de administrar desde el propio panel de control.

Novedades de la versión 1.1.1

Esta nueva versión pule la experiencia de administración y añade herramientas internas clave para la gestión diaria y la resolución de incidencias:

  • Sistema de logs y diagnóstico integrado: Para averiguar fácilmente por qué un correo puede fallar (por restricciones del servidor o políticas SMTP), he incorporado una pestaña de Logs que registra automáticamente los eventos recientes (intentos de envío, errores de captcha, validaciones o fallos de transmisión), manteniendo un historial limpio de hasta 100 entradas.
  • Herramienta de prueba de correo directo: En el listado de formularios he añadido un botón de prueba (Probar email) que permite simular y comprobar al instante si la pasarela de correo del servidor o plugin SMTP está entregando los mensajes correctamente (yo tengo instalado SMTP Indaga, por lo que el email receptor debe ser el mismo que el configurado en eses plugin).
  • Generación inteligente de identificadores: Al crear una nueva instancia de formulario, si dejo el ID en blanco, el sistema genera automáticamente un slug limpio y seguro a partir del nombre asignado utilizando sanitize_title().
  • Claves de captcha más robustas: He perfeccionado la generación de los transients temporales del captcha matemático combinando el identificador del formulario, la marca de tiempo y wp_rand(), blindando el proceso frente a colisiones de caché.

Seguridad nativa sin fricción

Manteniendo los estándares habituales de mis desarrollos en Indaga.net, el plugin sigue apostando por una protección invisible pero eficaz:

  • Cero JavaScript externo: Sin llamadas a servicios de terceros ni rastreadores de datos.
  • Honeypot y captcha dinámico: Bloquea bots y envíos automatizados sin obligar a la visita a resolver imágenes complejas o rompecabezas molestos.
  • Patrón Post/Redirect/Get (PRG): Evita el reenvío duplicado de formularios cuando se recarga la página tras enviar una consulta.

Conclusión

Construir mis propias herramientas nativas no solo mejora el rendimiento global de la web, sino que me otorga un control absoluto sobre cada línea de código que se ejecuta. El plugin ya está operativo y funcionando a pleno rendimiento en mi entorno de producción.

Como siempre, cualquier sugerencia o comentario para seguir mejorando el código es más que bienvenido.

Ficha Técnica del Plugin: Formulario de Contacto Indaga

  • Nombre del Plugin: Formulario de Contacto Indaga
  • Slug / Archivo Principal: indaga-contacto/indaga-contacto.php
  • Versión Actual: 1.1.1
  • Autor: Guillermo Beltrán Pilato (Indaga.net)
  • Licencia: GPL v2 or later
  • Acceso en wp-admin: Contacto Indaga (wp-admin/admin.php?page=indaga-contacto)
  • Shortcode Principal: (entre corchetes [ ] )
    indaga_contacto
    indaga_contacto id="mi-formulario"

    Admite parámetro de instancia, como en el segundo ejemplo.

Descripción Breve

Formulario de contacto nativo, seguro y ligero para WordPress, diseñado sin dependencias externas. Permite gestionar múltiples instancias de formularios, incluye captcha matemático temporal, campo oculto anti-bots (Honeypot), validación de privacidad, registro de logs de diagnóstico y herramienta integrada para probar el envío directo de correo.

Especificaciones Técnicas y Características

  • Gestión de Instancias: Soporte para múltiples formularios personalizados mediante shortcode. Si al crear una instancia dejo el ID en blanco, el plugin genera un slug limpio automáticamente con sanitize_title().
  • Seguridad Integrada: Verificación de Nonces anti-CSRF (wp_verify_nonce), honeypot antispam, captcha matemático temporal con set_transient (expiración a 5 minutos) usando claves dinámicas compuestas por ID, tiempo y wp_rand(), y checkbox obligatorio con enlace a la política de privacidad.
  • Sanitización y Escapado: Filtros estrictos de entrada (sanitize_text_field, sanitize_email, sanitize_textarea_field) y escapado seguro en salida (esc_html, esc_attr, esc_url, wp_kses_post).
  • Diagnóstico y Logs: Pestaña de logs en el panel de control con registro de hasta 100 eventos recientes y función para probar el envío directo de emails mediante wp_mail.
  • Rendimiento: Carga condicional de estilos mediante wp_add_inline_style, archivo único, cero librerías externas y cero peticiones HTTP adicionales.

Descargar plugin de mi cuenta de pCloud

[Actualización]: Contabilidad Casera Indaga v1.8.0: cero dependencias, máxima privacidad

Valencia, 04/11/2026, G.B.
Llevo algún tiempo dándole vueltas a una idea que tenía clavada como una espina: mi plugin de contabilidad casera seguía cargando Chart.js desde un CDN externo. Y eso, en un proyecto que defiende la privacidad y el control absoluto del rendimiento, no tenía sentido.
Hoy publico la versión 1.8.0 de Contabilidad Casera Indaga, y lo hago con la satisfacción de haber cerrado esa espina. Los tres gráficos del plugin (evolución mensual, gastos por categoría y evolución de pasos) ahora son SVG nativos generados directamente con PHP. Ni una sola librería externa. Ni un script de más. Ni una petición a un CDN que pueda caer o rastrearte.

Qué hay de nuevo en la v1.8.0

  • Adiós a Chart.js, hola al SVG nativo. El plugin ya es 100% autónomo. Si mañana desaparece Internet, tu contabilidad sigue funcionando.
  • Dos pestañas nuevas en el panel de administración: Instrucciones de uso y Ficha técnica, tal como marca mi estándar de desarrollo.
  • Edición inline más segura. He reescrito la forma en que se cargan los datos al pulsar «Editar»: ahora se usan atributos data-* en cada fila, eliminando cualquier riesgo de XSS.
  • Consultas optimizadas. La pestaña de presupuestos, que antes hacía una consulta por cada categoría, ahora resuelve todo con una única GROUP BY. Con 20 categorías, pasas de 20 queries a 1.
  • Índices nuevos en la tabla de contabilidad para que los filtros por fecha, tipo y categoría vuelen.
  • Paginación en el listado de movimientos (20 por página), para que el plugin siga siendo ágil aunque lleves años registrando datos.
  • Autocompletado de categorías con datalist al escribir en el formulario de movimientos.

Lo que no ha cambiado

La cabecera del plugin sigue siendo prácticamente la misma. Los datos de tu base de datos siguen intactos. Las funcionalidades que ya tenías —exportación CSV con UTF-8 y BOM, presupuestos flexibles, edición de pasos, buscador multicriterio— siguen funcionando exactamente igual. Porque actualizar un plugin de Indaga.net nunca significa perder nada de lo que ya tenías.

Si ya lo usabas, actualiza sin miedo. Si no lo conocías, te invito a echarle un vistazo: es ligero, es tuyo, y vive enteramente dentro de tu WordPress.

PD. Ya está esta última versión en Control de plugins.

Menor superficie de ataque y control total: claves de la arquitectura de plugins en un único archivo PHP

Valencia, 03/11/2026, G.B. (una aclaración…).
Fuente: FAQs Puntocomunica

La seguridad en los plugins de WordPress es un pilar fundamental para garantizar la estabilidad, el rendimiento y la integridad de cualquier sitio web. Al tratarse del gestor de contenidos más utilizado del mundo, WordPress es un blanco frecuente para ataques malintencionados. Un plugin vulnerable o desactualizado puede convertirse en la vía de acceso perfecta para que actores maliciosos comprometan la base de datos o ejecuten código de forma remota.Para mitigar estos riesgos de manera drástica, proyectos como Indaga.net aplican una estrategia de desarrollo muy particular que a menudo genera debate en la comunidad técnica: agrupar gran parte de la funcionalidad en un único archivo PHP centralizado, una aproximación que algunos desarrolladores denominan popularmente como la filosofía de los spaghetti plugins.Lejos de ser una decisión tomada al azar, centralizar el código en un único archivo .php responde a razones estratégicas muy meditadas para mantener el control absoluto sobre la seguridad y el mantenimiento:

  • Menor superficie de ataque: Al concentrar la lógica principal en un único archivo controlado, se simplifica enormemente la auditoría de código y la detección rápida de brechas de seguridad, evitando la dispersión de vulnerabilidades a través de múltiples subcarpetas o dependencias externas ocultas.
  • Control de dependencias: Se evita por completo la inclusión de librerías de terceros obsoletas o vulnerables, un problema muy común en plugins complejos que cargan scripts externos sin supervisión directa.
  • Optimización y rendimiento: Reducir la modularidad excesiva disminuye la sobrecarga de peticiones y llamadas innecesarias al  servidor, mejorando de forma notable los tiempos de carga generales.

Como ejemplo práctico de esta estrategia aplicada en Indaga.net, se han desarrollado utilidades internas y específicas para la importación directa de archivos masivos a bases de datos y la optimización de motores de búsqueda que operan de forma autónoma, ligera y segura bajo este esquema compacto.

Guardar datos

 

En conclusión, aunque una arquitectura basada en un único archivo .php pueda chocar con los patrones de modularidad estándar de WordPress, en determinados entornos orientados al rendimiento y al control de riesgos demuestra ser una alternativa sumamente eficaz y segura frente a las vulnerabilidades asociadas a complementos sobrecargados.

Cuaderno Técnico: Plugin «Control y Reserva de Recursos» (CRR v1.12.0), parte II

Valencia, 02/11/2026, G.B.
Continúo con el cuaderno técnico del plugin Control y Reserva de Recursos (CRR). En la primera parte vimos la cabecera, las tablas y los permisos. Hoy toca el motor de las reservas: cómo se comprueba que un recurso está libre, cómo se calcula el precio, cómo se guarda una reserva, cómo se avisa por email y cómo se gestionan el inventario y las cancelaciones.

Bloque 4: Disponibilidad y precio estimado

¿Cómo sabe el plugin si un recurso está libre?

Un recurso está libre si, sumando las reservas que se solapan con la nueva, no se supera su stock. Esto permite tanto una sala (stock 1) como un lote de portátiles (stock 20) con la misma lógica:

function crr_comprobar_disponibilidad( $recurso_id, $fecha_inicio, $fecha_fin, $hora_inicio, $hora_fin, $cantidad, $reserva_id_excluir = 0 ) {
	global $wpdb;
	$tabla_reservas = $wpdb->prefix . 'crr_reservas';
	$tabla_recursos = $wpdb->prefix . 'crr_recursos';

	$recurso = $wpdb->get_row( $wpdb->prepare( "SELECT stock FROM $tabla_recursos WHERE id = %d", $recurso_id ) );
	if ( ! $recurso ) {
		return false;
	}

	$sql = "SELECT SUM(cantidad) FROM $tabla_reservas 
			WHERE recurso_id = %d 
			AND id != %d
			AND (fecha_inicio <= %s AND fecha_fin >= %s)
			AND (hora_inicio < %s AND hora_fin > %s)";

	$ocupacion = $wpdb->get_var( $wpdb->prepare( $sql, $recurso_id, $reserva_id_excluir, $fecha_fin, $fecha_inicio, $hora_fin, $hora_inicio ) );
	$ocupacion_actual = $ocupacion ? intval( $ocupacion ) : 0;

	return ( $ocupacion_actual + $cantidad ) <= intval( $recurso->stock );
}

¿Qué ocurre paso a paso en esta función?

  1. Recurso inexistente: si el id no existe en el inventario, devuelve false y no se reserva nada.
  2. Solape de fechas: una reserva existente choca con la nueva si empieza antes de que la nueva termine y acaba después de que la nueva empiece. Son dos comparaciones, no cuatro.
  3. Solape de horas: misma idea con las horas, pero con desigualdades estrictas (< y >). Así, una reserva que termina a las 12:00 no bloquea otra que empieza a las 12:00.
  4. id != %d: al editar una reserva se excluye a sí misma del cálculo. Sin esto, cambiar la hora de tu propia reserva te daría «no disponible» por chocar contigo mismo.
  5. SUM(cantidad): suma las unidades ya ocupadas. Si más lo que pides no supera el stock, hay hueco.
  6. Consulta preparada: todos los valores van con $wpdb->prepare(), nunca concatenados.

¿Cómo se calcula el precio estimado?

Es una cuenta sencilla: días, por horas de cada día, por el precio por hora, por la cantidad. Se calcula en el servidor, no en el navegador, para que no se pueda manipular desde el formulario:

function crr_calcular_precio_estimado( $recurso_id, $fecha_inicio, $fecha_fin, $hora_inicio, $hora_fin, $cantidad ) {
	global $wpdb;
	$tabla_recursos = $wpdb->prefix . 'crr_recursos';
	
	$recurso = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $tabla_recursos WHERE id = %d", $recurso_id ) );
	if ( ! $recurso ) {
		return 0;
	}

	$f_inicio = new DateTime( $fecha_inicio );
	$f_fin    = new DateTime( $fecha_fin );
	$dias     = $f_inicio->diff( $f_fin )->days + 1;

	$h_inicio  = new DateTime( $hora_inicio );
	$h_fin     = new DateTime( $hora_fin );
	$intervalo = $h_inicio->diff( $h_fin );
	$horas     = $intervalo->h + ( $intervalo->i / 60 );

	if ( $horas <= 0 ) {
		$horas = 1;
	}

	$total = $dias * $horas * floatval( $recurso->precio_hora ) * absint( $cantidad );
	return round( $total, 2 );
}
  1. diff()->days + 1: la diferencia entre el día 10 y el 10 es 0, pero una reserva de un solo día cuenta como 1, de ahí el + 1.
  2. Horas con decimales: 9:00 a 13:30 son 4,5 horas (h más los minutos entre 60).
  3. Mínimo de una hora: si el intervalo sale a cero o negativo, se factura una hora en lugar de devolver un precio de cero.
  4. Cantidad saneada: absint() evita cantidades negativas.

Una limitación que conviene tener presente: el cálculo toma las horas de un mismo día, así que no contempla horarios que crucen la medianoche. Para salas y equipos de oficina no me ha hecho falta, pero queda anotado como posible mejora.

Bloque 5: Guardar una reserva y avisar por email

¿Cómo se crea o se edita una reserva?

Una única función se ocupa de las dos cosas. Si recibe un $reserva_id mayor que cero, edita; si no, inserta. Siempre devuelve un array con un mensaje y un tipo (success, warning o error), que luego se pinta como aviso en pantalla:

function crr_procesar_reserva( $recurso_id, $email_solicitante, $fecha_inicio, $fecha_fin, $hora_inicio, $hora_fin, $cantidad, $observaciones = '', $reserva_id = 0, $enviar_presupuesto = false ) {
	global $wpdb;
	$tabla_reservas = $wpdb->prefix . 'crr_reservas';
	$current_user = wp_get_current_user();

	if ( ! crr_comprobar_disponibilidad( $recurso_id, $fecha_inicio, $fecha_fin, $hora_inicio, $hora_fin, $cantidad, $reserva_id ) ) {
		return array( 'mensaje' => 'El recurso no está disponible en el horario y cantidad seleccionados.', 'tipo' => 'error' );
	}

	$precio_estimado = crr_calcular_precio_estimado( $recurso_id, $fecha_inicio, $fecha_fin, $hora_inicio, $hora_fin, $cantidad );

	$datos = array(
		'recurso_id'        => $recurso_id,
		'user_id'           => $current_user->ID,
		'email_solicitante' => $email_solicitante,
		'fecha_inicio'      => $fecha_inicio,
		'fecha_fin'         => $fecha_fin,
		'hora_inicio'       => $hora_inicio,
		'hora_fin'          => $hora_fin,
		'cantidad'          => $cantidad,
		'observaciones'     => $observaciones,
		'precio_estimado'   => $precio_estimado,
	);

	$formato = array( '%d', '%d', '%s', '%s', '%s', '%s', '%s', '%d', '%s', '%f' );

	if ( $reserva_id > 0 ) {
		$reserva_existente = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $tabla_reservas WHERE id = %d", $reserva_id ) );
		if ( ! $reserva_existente || ( ! current_user_can( 'manage_options' ) && ! crr_es_usuario_autorizado() && (int) $reserva_existente->user_id !== $current_user->ID ) ) {
			return array( 'mensaje' => 'No tienes permisos para editar esta reserva.', 'tipo' => 'error' );
		}

		$resultado = $wpdb->update( $tabla_reservas, $datos, array( 'id' => $reserva_id ), $formato, array( '%d' ) );
		if ( false !== $resultado ) {
			crr_enviar_notificaciones( $reserva_id, true, $enviar_presupuesto );
			return array( 'mensaje' => 'Reserva #' . $reserva_id . ' actualizada correctamente.', 'tipo' => 'success' );
		}
	} else {
		$resultado = $wpdb->insert( $tabla_reservas, $datos, $formato );
		if ( false !== $resultado ) {
			$nuevo_id = $wpdb->insert_id;
			crr_enviar_notificaciones( $nuevo_id, false, $enviar_presupuesto );
			return array( 'mensaje' => 'Reserva #' . $nuevo_id . ' realizada correctamente.', 'tipo' => 'success' );
		}
	}

	return array( 'mensaje' => 'Error al procesar la reserva en la base de datos.', 'tipo' => 'error' );
}

¿Qué ocurre paso a paso en esta función?

  1. Primero disponibilidad: si no hay hueco, se corta aquí con un error y no se toca la base de datos.
  2. Precio en servidor: se recalcula siempre, aunque el formulario muestre una estimación.
  3. Array de formatos: $formato tiene un marcador por cada campo de $datos, en el mismo orden (%d enteros, %s textos, %f decimal). $wpdb los usa para escapar cada valor.
  4. Quién puede editar: un administrador, un usuario autorizado (la función de la parte I) o el propio autor de la reserva. Nadie más.
  5. false !== $resultado: update() devuelve 0 si no cambió ninguna fila, y eso no es un error. Por eso se compara con false estricto.
  6. Aviso por email: solo se envía cuando el guardado ha ido bien.

¿Cómo se envían los emails de la reserva?

Cada reserva genera un correo en HTML para el solicitante y otro para el responsable del recurso. Se recupera la reserva con un LEFT JOIN para traer en una sola consulta el nombre del recurso y el email del responsable:

function crr_enviar_notificaciones( $reserva_id, $es_edicion = false, $incluir_precio = true ) {
	global $wpdb;
	$tabla_reservas = $wpdb->prefix . 'crr_reservas';
	$tabla_recursos = $wpdb->prefix . 'crr_recursos';

	$reserva = $wpdb->get_row( $wpdb->prepare( "SELECT r.*, rec.nombre as recurso_nombre, rec.email_propietario FROM $tabla_reservas r LEFT JOIN $tabla_recursos rec ON r.recurso_id = rec.id WHERE r.id = %d", $reserva_id ) );
	if ( ! $reserva ) {
		return;
	}

	$asunto  = ( $es_edicion ? '[Actualización] ' : '[Nueva Reserva] ' ) . 'Reserva #' . $reserva->id . ' - ' . $reserva->recurso_nombre;
	$headers = array('Content-Type: text/html; charset=UTF-8');

	$mensaje = "<h2>Detalles de la Reserva #" . esc_html( $reserva->id ) . "</h2>";
	$mensaje .= "<p><strong>Recurso:</strong> " . esc_html( $reserva->recurso_nombre ) . "</p>";
	$mensaje .= "<p><strong>Solicitante:</strong> " . esc_html( $reserva->email_solicitante ) . "</p>";
	$mensaje .= "<p><strong>Fechas:</strong> Del " . esc_html( $reserva->fecha_inicio ) . " al " . esc_html( $reserva->fecha_fin ) . "</p>";
	$mensaje .= "<p><strong>Horario:</strong> De " . esc_html( $reserva->hora_inicio ) . " a " . esc_html( $reserva->hora_fin ) . "</p>";
	$mensaje .= "<p><strong>Cantidad:</strong> " . esc_html( $reserva->cantidad ) . "</p>";
	if ( $incluir_precio ) {
		$mensaje .= "<p><strong>Precio Estimado:</strong> " . esc_html( $reserva->precio_estimado ) . " €</p>";
	}
	if ( ! empty( $reserva->observaciones ) ) {
		$mensaje .= "<p><strong>Observaciones:</strong> " . esc_html( $reserva->observaciones ) . "</p>";
	}

	wp_mail( $reserva->email_solicitante, $asunto, $mensaje, $headers );
	if ( ! empty( $reserva->email_propietario ) && $reserva->email_propietario !== $reserva->email_solicitante ) {
		wp_mail( $reserva->email_propietario, $asunto, $mensaje, $headers );
	}
}
  1. Asunto según el caso: [Nueva Reserva] o [Actualización], seguido del número y el nombre del recurso, para localizarlos rápido en la bandeja de entrada.
  2. Cabecera HTML: Content-Type: text/html hace que wp_mail() envíe el cuerpo con formato en lugar de texto plano.
  3. Todo escapado: cada dato que viene de la base de datos pasa por esc_html() antes de entrar en el correo.
  4. Presupuesto opcional: la línea del precio solo aparece si $incluir_precio es verdadero, que es lo que decide la casilla «Enviar desglose de presupuesto» del formulario.
  5. Sin duplicados: si el solicitante es también el responsable del recurso, solo recibe un correo.

Bloque 6: Inventario y cancelaciones

¿Cómo se modifican y se eliminan los recursos del inventario?

Solo los administradores (manage_options) tocan el inventario. La edición valida los campos obligatorios y comprueba que el recurso existe. El borrado, además, se niega si el recurso tiene reservas asociadas, para no dejar reservas huérfanas apuntando a algo que ya no existe:

function crr_actualizar_recurso( $recurso_id, $datos ) {
	global $wpdb;

	if ( ! current_user_can( 'manage_options' ) ) {
		return array( 'mensaje' => 'No tienes permisos para modificar el inventario.', 'tipo' => 'error' );
	}

	if ( empty( $datos['nombre'] ) || empty( $datos['email_propietario'] ) ) {
		return array( 'mensaje' => 'Por favor, rellena todos los campos obligatorios.', 'tipo' => 'error' );
	}

	$tabla_recursos = $wpdb->prefix . 'crr_recursos';
	$existe         = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $tabla_recursos WHERE id = %d", $recurso_id ) );
	if ( ! $existe ) {
		return array( 'mensaje' => 'El recurso especificado no existe.', 'tipo' => 'error' );
	}

	$resultado = $wpdb->update(
		$tabla_recursos,
		$datos,
		array( 'id' => $recurso_id ),
		array( '%s', '%s', '%d', '%f', '%s' ),
		array( '%d' )
	);

	if ( false === $resultado ) {
		return array( 'mensaje' => 'Error al actualizar el recurso. ' . esc_html( $wpdb->last_error ), 'tipo' => 'error' );
	}

	return array( 'mensaje' => 'Recurso #' . $recurso_id . ' actualizado correctamente.', 'tipo' => 'success' );
}

function crr_eliminar_recurso( $recurso_id ) {
	global $wpdb;

	if ( ! current_user_can( 'manage_options' ) ) {
		return array( 'mensaje' => 'No tienes permisos para modificar el inventario.', 'tipo' => 'error' );
	}

	$tabla_recursos = $wpdb->prefix . 'crr_recursos';
	$tabla_reservas = $wpdb->prefix . 'crr_reservas';

	$existe = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $tabla_recursos WHERE id = %d", $recurso_id ) );
	if ( ! $existe ) {
		return array( 'mensaje' => 'El recurso especificado no existe.', 'tipo' => 'error' );
	}

	$con_reservas = (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $tabla_reservas WHERE recurso_id = %d", $recurso_id ) );
	if ( $con_reservas > 0 ) {
		return array(
			'mensaje' => 'No se puede eliminar el recurso #' . $recurso_id . ': tiene ' . $con_reservas . ' reserva(s) asociada(s). Cancélalas primero.',
			'tipo'    => 'error',
		);
	}

	$borrado = $wpdb->delete( $tabla_recursos, array( 'id' => $recurso_id ), array( '%d' ) );
	if ( $borrado ) {
		return array( 'mensaje' => 'Recurso #' . $recurso_id . ' eliminado del inventario.', 'tipo' => 'warning' );
	}

	return array( 'mensaje' => 'Error al intentar eliminar el recurso.', 'tipo' => 'error' );
}
  1. Permisos dentro de la función: aunque el formulario solo se muestre a administradores, la comprobación está también aquí, por si alguien llama a la función por otra vía.
  2. Formatos en el update(): cinco marcadores (%s %s %d %f %s) para nombre, tipo, stock, precio por hora y email del responsable, en el mismo orden en que el formulario construye el array.
  3. Error legible: si la actualización falla, se muestra $wpdb->last_error escapado, lo que ayuda mucho a depurar.
  4. Borrado protegido: si hay reservas asociadas, el mensaje dice cuántas son y qué hacer (cancelarlas primero).

¿Quién puede cancelar una reserva?

La misma regla que para editar: administrador, usuario autorizado o el autor de la reserva. La cancelación borra la fila, y devuelve un aviso de tipo warning en vez de success, porque es una acción destructiva:

function crr_cancelar_reserva( $reserva_id ) {
	global $wpdb;
	$tabla_reservas = $wpdb->prefix . 'crr_reservas';
	$current_user = wp_get_current_user();

	$reserva = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $tabla_reservas WHERE id = %d", $reserva_id ) );
	if ( ! $reserva ) {
		return array( 'mensaje' => 'La reserva especificada no existe.', 'tipo' => 'error' );
	}

	if ( ! current_user_can( 'manage_options' ) && ! crr_es_usuario_autorizado() && (int) $reserva->user_id !== $current_user->ID ) {
		return array( 'mensaje' => 'No tienes permiso para cancelar esta reserva.', 'tipo' => 'error' );
	}

	$borrado = $wpdb->delete( $reserva_id ? $tabla_reservas : $tabla_reservas, array( 'id' => $reserva_id ), array( '%d' ) );
	if ( $borrado ) {
		return array( 'mensaje' => 'Reserva #' . $reserva_id . ' cancelada con éxito.', 'tipo' => 'warning' );
	}

	return array( 'mensaje' => 'Error al intentar cancelar la reserva.', 'tipo' => 'error' );
}

Fíjate en el patrón que se repite en todo el bloque: cada función comprueba permisos, valida, actúa y devuelve el mismo formato de array. Esa uniformidad es lo que permite que el formulario muestre cualquier resultado con un único bloque de aviso, algo que veremos en la tercera parte.

En la próxima entrega cierro la serie con la exportación a Excel y CSV con filtros, el calendario mensual, el formulario con selector de recursos, los shortcodes y el panel de administración.

Continuará en la parte III.

Control y Reserva de Recursos (CRR v1.12.0): cimientos, lógica de negocio y paneles de Control (cuaderno técnico, parte I)

Valencia, 31/10/2026, G.B.
El plugin Control y Reserva de Recursos (CRR v1.12.0) es una herramienta propia para gestionar salas, equipos y servicios con reservas, presupuesto automático, calendario y paneles de control, sin dependencias externas. Continuando con la serie de cuadernos técnicos, hoy hago un primer recorrido general por el plugin. Mi filosofía es siempre la misma: herramientas 100 % nativas, sin librerías pesadas de terceros y con los datos en mi propia base de datos. En las siguientes partes iré profundizando en cada pieza.

Bloque 1: Cabecera y seguridad del archivo

Lo primero es la cabecera que lee WordPress para mostrar el plugin en el listado:

<?php
/**
 * Plugin Name: Control y Reserva de Recursos (CRR)
 * Plugin URI:  https://indaga.net
 * Description: Sistema completo e independiente para la gestión y reserva de recursos, salas y servicios con presupuestos automáticos, vista de calendario, ficha desplegable de detalles, selector por tipo con buscador, gestión de inventario y panel frontal de filtrado por responsable y exportación avanzada.
 * Version:     1.12.0
 * Author:      Guillermo Beltrán Pilato
 * Author URI:  https://indaga.net
 * Text Domain: crr
 */

WordPress identifica un plugin por su ruta (carpeta y archivo principal), no por su nombre. Por eso mantengo siempre la misma carpeta y el mismo archivo entre versiones: si la ruta cambia, WordPress lo trata como un plugin distinto y no como una actualización. Entre versiones lo único que cambia es Version. El Text Domain crr está declarado, aunque ahora mismo el plugin no usa funciones de traducción.

Para evitar que alguien abra el archivo directamente, aplico la comprobación de siempre: si la constante ABSPATH no existe, el archivo se ha pedido por fuera de WordPress y corto la ejecución. A continuación defino una constante con la versión, que uso para controlar la base de datos:

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Seguridad: Salir si se accede directamente
}

define( 'CRR_VERSION', '1.12.0' );

A diferencia de otros desarrollos, como Agenda Indaga, en el CRR no uso una clase con patrón Singleton. Es un conjunto de funciones con el prefijo crr_, lo que reduce muchísimo el riesgo de choques de nombres con otros plugins y mantiene todo directo. Expliqué mis motivos en este apunte sobre el patrón Singleton.

Bloque 2: Base de datos propia y actualización controlada

El sistema crea dos tablas propias, sin depender de nada externo: crr_recursos (el inventario de salas, equipos y servicios) y crr_reservas (cada reserva, enlazada a un recurso por recurso_id). Se despliegan al activar el plugin:

function crr_instalar() {
	global $wpdb;
	$charset_collate = $wpdb->get_charset_collate();

	$tabla_recursos = $wpdb->prefix . 'crr_recursos';
	$sql_recursos   = "CREATE TABLE $tabla_recursos (
		id bigint(20) NOT NULL AUTO_INCREMENT,
		nombre varchar(255) NOT NULL,
		tipo varchar(100) DEFAULT 'General' NOT NULL,
		stock int(11) DEFAULT 1 NOT NULL,
		precio_hora decimal(10,2) DEFAULT '0.00' NOT NULL,
		email_propietario varchar(100) NOT NULL,
		PRIMARY KEY  (id)
	) $charset_collate;";

	$tabla_reservas = $wpdb->prefix . 'crr_reservas';
	$sql_reservas   = "CREATE TABLE $tabla_reservas (
		id bigint(20) NOT NULL AUTO_INCREMENT,
		recurso_id bigint(20) NOT NULL,
		user_id bigint(20) NOT NULL,
		email_solicitante varchar(100) NOT NULL,
		fecha_inicio date NOT NULL,
		fecha_fin date NOT NULL,
		hora_inicio time NOT NULL,
		hora_fin time NOT NULL,
		cantidad int(11) DEFAULT 1 NOT NULL,
		observaciones text NULL,
		precio_estimado decimal(10,2) DEFAULT '0.00' NOT NULL,
		fecha_creacion datetime DEFAULT CURRENT_TIMESTAMP NOT NULL,
		PRIMARY KEY  (id)
	) $charset_collate;";

	require_once( ABSPATH . 'wp-admin/includes/upgrade.php' );
	dbDelta( $sql_recursos );
	dbDelta( $sql_reservas );

	update_option( 'crr_db_version', CRR_VERSION );
}
register_activation_hook( __FILE__, 'crr_instalar' );

Un detalle clave: dbDelta es muy estricto y espera exactamente dos espacios entre PRIMARY KEY y el paréntesis. Además, para no depender únicamente del gancho de activación (que no salta cuando actualizo el plugin por FTP), compruebo la versión en cada carga con la acción plugins_loaded:

function crr_comprobar_actualizacion_db() {
	if ( get_option( 'crr_db_version' ) !== CRR_VERSION ) {
		crr_instalar();
	}
}
add_action( 'plugins_loaded', 'crr_comprobar_actualizacion_db' );

Bloque 3: Lógica de reservas, validaciones y presupuesto automático

El punto de entrada del formulario valida el nonce, limpia cada dato de entrada y delega todo el trabajo en crr_procesar_reserva():

if ( isset( $_POST['crr_nueva_reserva'] ) && check_admin_referer( 'crr_reserva_nonce', 'crr_reserva_nonce' ) ) {
	$res_id      = isset( $_POST['reserva_id'] ) ? absint( $_POST['reserva_id'] ) : 0;
	$enviar_pres = isset( $_POST['enviar_presupuesto'] ) ? true : false;
	$alerta      = crr_procesar_reserva(
		absint( $_POST['recurso_id'] ),
		sanitize_email( $_POST['email_solicitante'] ),
		sanitize_text_field( $_POST['fecha_inicio'] ),
		sanitize_text_field( $_POST['fecha_fin'] ),
		sanitize_text_field( $_POST['hora_inicio'] ),
		sanitize_text_field( $_POST['hora_fin'] ),
		absint( $_POST['cantidad'] ),
		sanitize_textarea_field( $_POST['observaciones'] ),
		$res_id,
		$enviar_pres
	);
}

Antes de guardar nada, esa función comprueba la disponibilidad con crr_comprobar_disponibilidad(). Es la pieza que más me importa del plugin:

function crr_comprobar_disponibilidad( $recurso_id, $fecha_inicio, $fecha_fin, $hora_inicio, $hora_fin, $cantidad, $reserva_id_excluir = 0 ) {
	global $wpdb;
	$tabla_reservas = $wpdb->prefix . 'crr_reservas';
	$tabla_recursos = $wpdb->prefix . 'crr_recursos';

	$recurso = $wpdb->get_row( $wpdb->prepare( "SELECT stock FROM $tabla_recursos WHERE id = %d", $recurso_id ) );
	if ( ! $recurso ) {
		return false;
	}

	$sql = "SELECT SUM(cantidad) FROM $tabla_reservas
			WHERE recurso_id = %d
			AND id != %d
			AND (fecha_inicio <= %s AND fecha_fin >= %s)
			AND (hora_inicio < %s AND hora_fin > %s)";

	$ocupacion = $wpdb->get_var( $wpdb->prepare( $sql, $recurso_id, $reserva_id_excluir, $fecha_fin, $fecha_inicio, $hora_fin, $hora_inicio ) );
	$ocupacion_actual = $ocupacion ? intval( $ocupacion ) : 0;

	return ( $ocupacion_actual + $cantidad ) <= intval( $recurso->stock );
}

La consulta suma la cantidad de todas las reservas del mismo recurso que se solapan con la nueva, tanto en fechas como en horas, y comprueba que esa suma más lo solicitado no supere el stock. El parámetro $reserva_id_excluir permite editar una reserva sin que choque consigo misma.

Si hay disponibilidad, se calcula el presupuesto estimado con crr_calcular_precio_estimado(). Este es el extracto con la fórmula:

$dias  = $f_inicio->diff( $f_fin )->days + 1;
$horas = $intervalo->h + ( $intervalo->i / 60 );

if ( $horas <= 0 ) {
	$horas = 1;
}

$total = $dias * $horas * floatval( $recurso->precio_hora ) * absint( $cantidad );
return round( $total, 2 );

Es decir: días × horas diarias × tarifa por hora × cantidad. El resultado se guarda en el campo precio_estimado. Tengo pendiente revisar este cálculo: ahora mismo no valido que la fecha de fin sea posterior a la de inicio ni que la hora de fin sea posterior a la de inicio, y con las horas invertidas DateTime::diff devuelve igualmente un valor positivo, así que el precio saldría incorrecto.

  • Seguridad y sanitización: nonces con check_admin_referer, limpieza de variables con funciones nativas de WordPress (absint, sanitize_email, sanitize_text_field) y consultas preparadas con $wpdb->prepare
  • Alta y edición: la misma función sirve para ambas, según venga o no el ID de la reserva
  • Permisos: solo puede editar o cancelar una reserva quien la creó, un administrador o un usuario autorizado
  • Control de stock: se contrasta lo solicitado con las reservas solapadas y el stock del recurso antes de insertar o actualizar

Bloque 4: Visualización en calendario interactivo y paneles avanzados

Con el shortcode [crr_calendario] cualquier página se convierte en una cuadrícula mensual con las reservas del mes. Al hacer clic en una de ellas se abre una ficha flotante (modal) con los detalles clave, sin recargar la página, porque los datos viajan en un atributo data-reserva que lee JavaScript. El cambio de mes sí recarga la página, ya que navega mediante parámetros por URL (crr_mes y crr_anio).

Por otro lado, el panel frontal de gestión lo ven los administradores y los usuarios autorizados (una lista de emails que configuro en la pestaña «Usuarios Autorizados» del panel de administración). Permite filtrar por fechas, categoría, responsable del recurso y texto libre, con soporte de comodín *.

La exportación admite dos formatos: un CSV estándar y una variante «Excel», que en realidad es también un CSV, pero con codificación UTF-8 con BOM y punto y coma como delimitador, para que Excel muestre bien los acentos. Y la descarga respeta los filtros que tenga aplicados en ese momento.

Para mostrar el calendario en cualquier página basta con insertar el shortcode, sin parámetros:

[crr_calendario]

Y para el formulario de reservas con su panel de gestión, el shortcode es [crr_reservas].

Con esto cerramos este primer recorrido técnico por el CRR v1.12.0. Continuaré…