Andrés Martínez Soto

🔐 Seguridad en formularios Moodle: buenas prácticas

Aunque en este artículo ya hemos mencionado aspectos clave como el cumplimiento del RGPD y el uso de mecanismos anti-spam como Google reCAPTCHA, es fundamental no descuidar otros aspectos esenciales de seguridad al desarrollar formularios personalizados en Moodle.

Un diseño seguro no solo protege los datos recogidos, sino que garantiza la estabilidad y fiabilidad de tu plataforma. Aquí algunas buenas prácticas específicas:

• Validación exhaustiva del lado del servidor: evita confiar únicamente en la validación JavaScript. Utiliza la validación integrada de moodleform, y valida manualmente los datos críticos con filtros de saneamiento.
• Gestión de permisos y capacidades: define correctamente los capabilities en db/access.php y valida que solo los usuarios con permisos adecuados puedan acceder al formulario o ejecutar acciones sensibles.
• Protección contra XSS: utiliza funciones como clean_param() y format_string() para mostrar cualquier entrada del usuario.
• Prevención de CSRF: Moodle ya gestiona tokens de sesión, pero asegúrate de utilizar require_sesskey() en acciones sensibles que modifican datos.
• Manejo seguro de archivos adjuntos: limita el tamaño, tipo y número de archivos, y usa el sistema de filepickero filemanager con áreas de almacenamiento específicas.

Integrar estas medidas refuerza la robustez del sistema y garantiza que tus formularios personalizados no se conviertan en vectores de vulnerabilidad.

¿Para quién es útil aprender a integrar formularios en Moodle?

Esta guía práctica está pensada para profesionales y equipos que quieren aprovechar al máximo Moodle, transformándolo en una plataforma no solo de enseñanza, sino también de gestión, automatización y recogida de información mediante formularios totalmente integrados.

➤ Para responsables de innovación educativa

Que buscan integrar formularios en Moodle para recoger información de usuarios, automatizar procesos internos o activar flujos en herramientas complementarias como Manage Engine, Microsoft Teams o n8n, sin sacrificar cumplimiento normativo ni coherencia visual.
👉 También te puede interesar: ¿Cuánto cuesta implementar Moodle en 2025?

➤ Para técnicos TIC

Que necesitan formularios personalizables, con lógica condicional, validaciones avanzadas y capacidad de conexión vía API REST o webhooks con sistemas externos (ERPs, CRMs, herramientas de ticketing, etc.). Todo dentro de un entorno controlado, seguro y escalable.
👉 Lectura recomendada: Guía profesional para mantener tu Moodle al día.

➤ Para responsables de formación en empresas

Que desean que su Moodle no solo forme, sino que interactúe con otros departamentos: recursos humanos, compliance, gestión de talento… A través de formularios conectados con flujos de aprobación, seguimiento de empleados o evaluación de desempeño.
👉 Descubre más: Automatizaciones edtech desde el rol del CTO .

➤ Para startups y academias digitales (EdTech)

Que necesitan una plataforma con diseño actual, integración nativa y experiencia de usuario optimizada, donde puedan crear formularios de contacto, inscripción o feedback directamente en Moodle, sin depender de herramientas externas ni sacrificar control sobre los datos.

¿Qué aprenderás en esta guía?

Esta guía está pensada para mostrarte, paso a paso, cómo integrar formularios en Moodle de forma profesional, eficiente y adaptada a las necesidades reales de tu organización. Si trabajas en el ámbito de la educación, la formación o la tecnología, aquí encontrarás respuestas prácticas y ejemplos aplicados.

Aprenderás a:

• Diseñar formularios personalizados en Moodle que se ajusten a tu identidad visual, roles de usuario y flujos de trabajo.
• Conectar formularios con sistemas externos a través de API REST, webhooks o herramientas como n8n, Zapier o Salesforce.
• Incorporar validaciones inteligentes, lógica condicional y formularios multilingües.
• Implementar buenas prácticas para garantizar el cumplimiento del RGPD y la seguridad de los datos recogidos.

Ya seas:

• Un técnico TIC que busca conectividad real entre Moodle y tus sistemas internos,
• Un responsable de innovación educativa que desea mejorar la experiencia del usuario en el campus,
• Una startup EdTech que necesita integrar Moodle con su web o automatizar flujos,
• O un responsable de formación que quiere trazabilidad, notificaciones y formularios que generen resultados concretos…

👉 Aquí descubrirás cómo integrar formularios en Moodle puede transformar tu campus en un entorno mucho más ágil, automatizado y centrado en las personas.

🛠️Cómo integrar formularios personalizados en Moodle usando moodleform

Si estás pensando en integrar formularios en Moodle de forma segura, escalable y conectada a otros sistemas, debes conocer la clase moodleform. Esta clase es el núcleo del sistema de formularios de Moodle y te permite construir interfaces totalmente personalizadas, con validación de datos, lógica condicional y procesamiento estructurado.

🔧 Fundamentos de moodleform

La clase \moodleform forma parte de la API de formularios de Moodle y es el punto de partida para construir formularios reutilizables, compatibles con el core del sistema.

• Definición de la clase
  Cada formulario extiende moodleform, y su lógica se define en el método definition(), donde se añaden los campos y elementos del formulario.

🧩 Tipos de campos disponibles

Moodle ofrece una amplia variedad de elementos (form elements) que puedes utilizar:

• text, textarea: entradas de texto corto o largo.
• select, radio, checkbox: listas desplegables y opciones múltiples.
• date_selector, date_time_selector: selección de fecha y hora.
• filepicker, filemanager: subida de archivos.
• password, hidden: campos ocultos o no editables.
• submit, cancel: botones de acción.

👉 Consulta la documentación oficial del Form API para explorar todos los tipos de campo disponibles.

🧱 Organización y validación

• Agrupación: puedes usar addElement('header', ...) para agrupar campos lógicamente.
• Ayudas contextuales: addHelpButton() permite ofrecer explicaciones adicionales sobre cada campo.
• Validación: Moodle permite validación directa con addRule() o validación personalizada con el método validation($data, $files).

Ejemplo:

$mform->addRule('email', 'Este campo es obligatorio', 'required', null, 'client');
$mform->addRule('email', null, 'email');

$mform->addRule('email', 'Este campo es obligatorio', 'required', null, 'client');
$mform->addRule('email', null, 'email');

🗃️ Gestión de archivos en formularios

• Subida sencilla: con filepicker.
• Manejo de múltiples archivos: con filemanager.
• Restricciones: puedes limitar tamaño, cantidad o tipo de archivo.
• Los archivos se almacenan en el sistema de archivos interno de Moodle, y se gestionan con la File API.

De la teoría a la práctica: tu primer formulario avanzado en Moodle

Ahora que ya tienes claros los fundamentos, limitaciones y ventajas de integrar formularios en Moodle, es el momento de pasar a la acción.
Te mostramos cómo puedes crear un formulario avanzado completamente personalizado en tu plataforma Moodle, sin depender de soluciones externas, y con el control total sobre la experiencia de usuario y la protección de los datos.

¿Para quién es útil este tutorial?

• Técnicos TIC y desarrolladores que buscan ejemplos claros y código reutilizable.
• Responsables de formación o innovación que quieren autonomía para adaptar los procesos internos sin depender del área técnica.
• Equipos de comunicación y soporte que desean personalizar la comunicación con usuarios, tanto en la web como por email.

👇 ¿Qué vas a conseguir siguiendo este tutorial?

• Un formulario multilingüe y totalmente integrado en Moodle, adaptable a cualquier diseño y marca.
• Emails automáticos y personalizables, tanto para el usuario como para tu equipo.
• Protección anti-spam profesional gracias a Google reCAPTCHA.
• Todo gestionable desde el panel de administración, sin editar código cada vez que quieras cambiar el mensaje o la plantilla.

🛠️ Manos a la obra: guía paso a paso

A continuación encontrarás un proyecto práctico modular, pensado para copiar, adaptar y ampliar según tus necesidades.
No solo aprenderás a crear el plugin, sino que entenderás cómo personalizarlo y ampliarlo fácilmente para cualquier escenario real en tu organización.

Sugerencia: Antes de empezar, consulta la tabla resumen de funcionalidades para saber qué puedes adaptar desde el panel de administración, qué parte puedes ampliar por código y qué ventajas tienes respecto a los formularios externos.

Resumen de lo que vas a construir

🚦 ¿Por dónde empezar?

El tutorial está estructurado en módulos breves, con ejemplos prácticos y comentarios en cada sección del código.
Al final, además, encontrarás ideas para ampliarlo (por ejemplo: añadir adjuntos, guardar envíos en base de datos, conectarlo con un CRM…), así como respuestas rápidas a preguntas frecuentes.

1. Estructura y archivos básicos del plugin local

Antes de empezar a programar, es fundamental tener clara la estructura básica de un plugin local en Moodle.
Una buena organización de archivos no solo facilita el desarrollo y el mantenimiento, sino que también asegura que tu plugin sea escalable, cumpla los estándares de Moodle y pueda evolucionar fácilmente en el futuro.

A continuación, te mostramos qué carpetas y archivos son imprescindibles, para qué sirve cada uno y cómo sentar una base sólida para todo el desarrollo posterior.
Tanto si ya has creado plugins antes como si es tu primera vez, este esquema te ayudará a trabajar de forma más eficiente y profesional.

Archivos y carpetas imprescindibles

Crea una carpeta en local/ llamada, por ejemplo, contactform:

local/contactform/
├── db/
│   └── access.php
├── form/
│   └── contact_form.php
├── lang/
│   ├── en/
│   │   └── local_contactform.php
│   └── es/
│       └── local_contactform.php
├── emailtemplates/
│   └── contactform_mail.html
├── settings.php
├── index.php
├── lib.php
├── version.php

local/contactform/
├── db/
│   └── access.php
├── form/
│   └── contact_form.php
├── lang/
│   ├── en/
│   │   └── local_contactform.php
│   └── es/
│       └── local_contactform.php
├── emailtemplates/
│   └── contactform_mail.html
├── settings.php
├── index.php
├── lib.php
├── version.php

Cada archivo y carpeta cumple una función específica para asegurar el correcto funcionamiento, seguridad y personalización del plugin.

¿Qué incluye cada fichero y por qué?

• version.php: identifica el plugin y sus requisitos, ¡imprescindible para instalarlo!
• db/access.php: define quién puede usarlo (permisos y roles).
• settings.php: permite configurar textos, destinatarios y plantilla de email desde la administración.
• form/contact_form.php: aquí va la definición del formulario (campos, validaciones, reCAPTCHA…).
• emailtemplates/contactform_mail.html: la plantilla HTML editable para los emails (puede ser modificada por administración si así lo configuras).
• lang/: archivos de idioma para soporte multilingüe.
• index.php: controla el flujo principal, pinta el formulario, procesa los envíos.
• lib.php: espacio reservado para funciones auxiliares y ampliaciones futuras.

Ahora sí, ¡empezamos con el detalle de cada archivo y cómo te ayudará en tu desarrollo!

Descripción y utilidad de cada archivo del plugin local en Moodle

Con la estructura básica ya definida, el siguiente paso es entender el papel que juega cada uno de los archivos esenciales de tu plugin local.
Esta descripción detallada te ayudará a saber no solo cómo funciona el conjunto, sino también cómo personalizar, ampliar y mantener tu solución de formularios en Moodle de forma profesional.

En los siguientes apartados encontrarás una explicación clara y orientada a la práctica sobre la utilidad, configuración y buenas prácticas asociadas a cada archivo. Así, podrás adaptar el plugin a tus necesidades, resolver incidencias rápidamente y evolucionar tu desarrollo conforme crezcan los requisitos de tu organización.

Recuerda: conocer la función de cada archivo es clave para lograr un desarrollo eficiente, seguro y alineado con los estándares de la comunidad Moodle.

version.php — Declaración de versión y compatibilidad

Este archivo es imprescindible: define el nombre identificador, la versión y los requisitos mínimos de Moodle para que el plugin funcione.
Permite que Moodle gestione las instalaciones, actualizaciones y el control de versiones de manera automática y segura.

<?php
// version.php - Información de versión del plugin

defined('MOODLE_INTERNAL') || die();

$plugin->component = 'local_contactform'; // Nombre identificador del plugin
$plugin->version   = 2025070700;          // Versión del plugin (YYYYMMDDXX)
$plugin->requires  = 2022041900;          // Requiere Moodle 4.0 o superior
$plugin->maturity  = MATURITY_STABLE;
$plugin->release   = '1.0.0';

<?php
// version.php - Información de versión del plugin

defined('MOODLE_INTERNAL') || die();

$plugin->component = 'local_contactform'; // Nombre identificador del plugin
$plugin->version   = 2025070700;          // Versión del plugin (YYYYMMDDXX)
$plugin->requires  = 2022041900;          // Requiere Moodle 4.0 o superior
$plugin->maturity  = MATURITY_STABLE;
$plugin->release   = '1.0.0';

db/access.php — Definición de capacidades y permisos

El archivo db/access.php determina qué roles de usuario pueden acceder y utilizar las funcionalidades de tu plugin. En Moodle, cada acción controlada por un plugin debe estar asociada a una o varias capacidades (capabilities), que pueden habilitarse o restringirse para distintos tipos de usuario: estudiantes, profesores, gestores, invitados, etc.

De este modo, Moodle integra tu plugin en su sistema global de permisos, permitiendo que el administrador defina fácilmente quién puede ver o usar el formulario.

Por ejemplo, en este caso concreto, se define la capacidad local/contactform:view y se permite su uso a todos los roles comunes del sistema, incluidos usuarios anónimos (guest). Así, cualquier persona que acceda al campus podrá utilizar el formulario, a menos que el administrador restrinja expresamente el acceso.

<?php
// access.php - Capabilities for local_contactform

defined('MOODLE_INTERNAL') || die();

$capabilities = [
    'local/contactform:view' => [
        'captype' => 'read',
        'contextlevel' => CONTEXT_SYSTEM,
        'archetypes' => [
            'guest'   => CAP_ALLOW,
            'student' => CAP_ALLOW,
            'teacher' => CAP_ALLOW,
            'manager' => CAP_ALLOW,
        ],
    ],
];

<?php
// access.php - Capabilities for local_contactform

defined('MOODLE_INTERNAL') || die();

$capabilities = [
    'local/contactform:view' => [
        'captype' => 'read',
        'contextlevel' => CONTEXT_SYSTEM,
        'archetypes' => [
            'guest'   => CAP_ALLOW,
            'student' => CAP_ALLOW,
            'teacher' => CAP_ALLOW,
            'manager' => CAP_ALLOW,
        ],
    ],
];

lang/es/local_contactform.php — Cadenas de idioma en español

Este archivo contiene todas las frases y textos que aparecerán en la interfaz del plugin, traducidos al español.
¿Por qué es importante? Permite que el formulario sea totalmente accesible y entendible para usuarios hispanohablantes, además de facilitar la gestión multilingüe y la localización en diferentes regiones.

<?php
// Cadenas de idioma en español para local_contactform

$string['pluginname'] = 'Formulario de contacto';
$string['contactform'] = 'Formulario de contacto';

// Campos del formulario
$string['formintroheading'] = '¿Tienes alguna duda o necesitas ayuda?';
$string['formintromessage'] = 'Rellena este formulario y nos pondremos en contacto contigo lo antes posible. Asegúrate de proporcionar un correo válido.';

$string['name'] = 'Nombre';
$string['email'] = 'Correo electrónico';
$string['phone'] = 'Teléfono (opcional)';
$string['subject'] = 'Asunto';
$string['message'] = 'Mensaje';
$string['submit'] = 'Enviar';

// Mensajes de validación y confirmación
$string['success'] = '¡Tu mensaje ha sido enviado correctamente!';
$string['invalidemail'] = 'Debes introducir un correo electrónico válido.';
$string['invalidphone'] = 'Introduce un teléfono válido (solo dígitos, puede empezar por +).';

// Configuración general (settings)
$string['recipient'] = 'Correo electrónico destinatario';
$string['recipient_desc'] = 'Introduce el email que recibirá los mensajes enviados por el formulario de contacto.';
$string['sendername'] = 'Nombre remitente';
$string['sendername_desc'] = 'Nombre que se mostrará como remitente en los correos enviados.';

$string['emailsubject'] = 'Asunto del correo';
$string['emailsubject_desc'] = 'Asunto por defecto del correo enviado al recibir un mensaje.';
$string['defaultemailsubject'] = 'Nuevo mensaje desde el formulario de contacto';

$string['emailgreeting'] = 'Saludo del email';
$string['emailgreeting_desc'] = 'Texto de saludo al inicio del email. Puedes usar <strong>{$a->name}</strong> para el nombre del remitente.';
$string['defaultemailgreeting'] = '¡Hola {$a->name}!';

$string['emailthanks'] = 'Texto de agradecimiento';
$string['emailthanks_desc'] = 'Texto de agradecimiento tras el saludo. Puedes usar <strong>{$a->sitename}</strong> para el nombre del sitio Moodle.';
$string['defaultemailthanks'] = 'Gracias por contactar con {$a->sitename}. Hemos recibido tu mensaje y te responderemos lo antes posible.';

$string['emailfooter'] = 'Pie del email';
$string['emailfooter_desc'] = 'Texto que aparecerá al final del email. Puedes usar <strong>{$a->sitename}</strong>.';
$string['defaultemailfooter'] = 'Un cordial saludo,<br>El equipo de {$a->sitename}';

$string['emailtemplate'] = 'Plantilla HTML del email';
$string['emailtemplate_desc'] = 'Edita aquí la plantilla HTML completa del mensaje. Usa variables como {$a->name}, {$a->email}, {$a->phone}, {$a->message}, {$a->greeting}, {$a->thanks}, {$a->footer}.';
$string['defaultemailtemplate'] = <<<EOT
<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="utf-8"/>
  <title>Formulario de contacto</title>
  <style>
    body { font-family: Arial, sans-serif; color: #222; }
    .container { padding: 16px; background: #f9f9f9; border-radius: 8px; }
    .label { font-weight: bold; }
    .footer { font-size: 0.9em; color: #888; margin-top: 20px; }
  </style>
</head>
<body>
  <div class="container">
    <p>{\$a->greeting}</p>
    <p>{\$a->thanks}</p>
    <h3>Datos enviados:</h3>
    <p>
      <span class="label">Nombre:</span> {\$a->name}<br>
      <span class="label">Email:</span> {\$a->email}<br>
      <span class="label">Teléfono:</span> {\$a->phone}<br>
    </p>
    <p>
      <span class="label">Mensaje:</span><br>
      {\$a->message}
    </p>
    <div class="footer">
      {\$a->footer}
    </div>
  </div>
</body>
</html>
EOT;

// reCAPTCHA
$string['recaptcha'] = 'Verificación anti-spam (reCAPTCHA)';

// GDPR
$string['gdprconsent'] = 'He leído y acepto la política de privacidad.';
$string['gdprrequired'] = 'Debes aceptar la política de privacidad para continuar.';

// Capacidad
$string['contactform:view'] = 'Acceder al formulario de contacto';

<?php
// Cadenas de idioma en español para local_contactform

$string['pluginname'] = 'Formulario de contacto';
$string['contactform'] = 'Formulario de contacto';

// Campos del formulario
$string['formintroheading'] = '¿Tienes alguna duda o necesitas ayuda?';
$string['formintromessage'] = 'Rellena este formulario y nos pondremos en contacto contigo lo antes posible. Asegúrate de proporcionar un correo válido.';

$string['name'] = 'Nombre';
$string['email'] = 'Correo electrónico';
$string['phone'] = 'Teléfono (opcional)';
$string['subject'] = 'Asunto';
$string['message'] = 'Mensaje';
$string['submit'] = 'Enviar';

// Mensajes de validación y confirmación
$string['success'] = '¡Tu mensaje ha sido enviado correctamente!';
$string['invalidemail'] = 'Debes introducir un correo electrónico válido.';
$string['invalidphone'] = 'Introduce un teléfono válido (solo dígitos, puede empezar por +).';

// Configuración general (settings)
$string['recipient'] = 'Correo electrónico destinatario';
$string['recipient_desc'] = 'Introduce el email que recibirá los mensajes enviados por el formulario de contacto.';
$string['sendername'] = 'Nombre remitente';
$string['sendername_desc'] = 'Nombre que se mostrará como remitente en los correos enviados.';

$string['emailsubject'] = 'Asunto del correo';
$string['emailsubject_desc'] = 'Asunto por defecto del correo enviado al recibir un mensaje.';
$string['defaultemailsubject'] = 'Nuevo mensaje desde el formulario de contacto';

$string['emailgreeting'] = 'Saludo del email';
$string['emailgreeting_desc'] = 'Texto de saludo al inicio del email. Puedes usar <strong>{$a->name}</strong> para el nombre del remitente.';
$string['defaultemailgreeting'] = '¡Hola {$a->name}!';

$string['emailthanks'] = 'Texto de agradecimiento';
$string['emailthanks_desc'] = 'Texto de agradecimiento tras el saludo. Puedes usar <strong>{$a->sitename}</strong> para el nombre del sitio Moodle.';
$string['defaultemailthanks'] = 'Gracias por contactar con {$a->sitename}. Hemos recibido tu mensaje y te responderemos lo antes posible.';

$string['emailfooter'] = 'Pie del email';
$string['emailfooter_desc'] = 'Texto que aparecerá al final del email. Puedes usar <strong>{$a->sitename}</strong>.';
$string['defaultemailfooter'] = 'Un cordial saludo,<br>El equipo de {$a->sitename}';

$string['emailtemplate'] = 'Plantilla HTML del email';
$string['emailtemplate_desc'] = 'Edita aquí la plantilla HTML completa del mensaje. Usa variables como {$a->name}, {$a->email}, {$a->phone}, {$a->message}, {$a->greeting}, {$a->thanks}, {$a->footer}.';
$string['defaultemailtemplate'] = <<<EOT
<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="utf-8"/>
  <title>Formulario de contacto</title>
  <style>
    body { font-family: Arial, sans-serif; color: #222; }
    .container { padding: 16px; background: #f9f9f9; border-radius: 8px; }
    .label { font-weight: bold; }
    .footer { font-size: 0.9em; color: #888; margin-top: 20px; }
  </style>
</head>
<body>
  <div class="container">
    <p>{\$a->greeting}</p>
    <p>{\$a->thanks}</p>
    <h3>Datos enviados:</h3>
    <p>
      <span class="label">Nombre:</span> {\$a->name}<br>
      <span class="label">Email:</span> {\$a->email}<br>
      <span class="label">Teléfono:</span> {\$a->phone}<br>
    </p>
    <p>
      <span class="label">Mensaje:</span><br>
      {\$a->message}
    </p>
    <div class="footer">
      {\$a->footer}
    </div>
  </div>
</body>
</html>
EOT;

// reCAPTCHA
$string['recaptcha'] = 'Verificación anti-spam (reCAPTCHA)';

// GDPR
$string['gdprconsent'] = 'He leído y acepto la política de privacidad.';
$string['gdprrequired'] = 'Debes aceptar la política de privacidad para continuar.';

// Capacidad
$string['contactform:view'] = 'Acceder al formulario de contacto';

lang/en/local_contactform.php — English language strings

Este archivo contiene la traducción al inglés de todos los textos del plugin.
¿Para qué sirve?
Asegura que el plugin sea totalmente usable en instalaciones internacionales de Moodle, ampliando su alcance a una audiencia global y cumpliendo con las mejores prácticas de internacionalización (i18n).

<?php
// English language strings for local_contactform
defined('MOODLE_INTERNAL') || die();

// General
$string['pluginname'] = 'Contact form';
$string['contactform'] = 'Contact form';

// Form fields
$string['formintroheading'] = 'Do you have any questions or need help?';
$string['formintromessage'] = 'Fill in this form and we will contact you as soon as possible. Please make sure you provide a valid email address.';

$string['name'] = 'Name';
$string['email'] = 'Email address';
$string['phone'] = 'Phone (optional)';
$string['subject'] = 'Subject';
$string['message'] = 'Message';
$string['submit'] = 'Send';

// Validation and messages
$string['success'] = 'Your message has been sent successfully!';
$string['invalidemail'] = 'You must enter a valid email address.';
$string['invalidphone'] = 'Please enter a valid phone number (only digits, may start with +).';

// Configuration settings
$string['recipient'] = 'Recipient email address';
$string['recipient_desc'] = 'Enter the email address that will receive contact form submissions.';
$string['sendername'] = 'Sender name';
$string['sendername_desc'] = 'Name displayed as sender in outgoing emails.';

$string['emailsubject'] = 'Email subject';
$string['emailsubject_desc'] = 'Default subject for sent emails.';
$string['defaultemailsubject'] = 'New message from the contact form';

$string['emailgreeting'] = 'Email greeting';
$string['emailgreeting_desc'] = 'Greeting at the start of the email. Use <strong>{\$a->name}</strong> for the sender\'s name.';
$string['defaultemailgreeting'] = 'Hello {\$a->name}!';

$string['emailthanks'] = 'Thank you text';
$string['emailthanks_desc'] = 'Thank you message. Use <strong>{\$a->sitename}</strong> for the site name.';
$string['defaultemailthanks'] = 'Thank you for contacting {\$a->sitename}. We will reply as soon as possible.';

$string['emailfooter'] = 'Email footer';
$string['emailfooter_desc'] = 'Footer text for the email. Use <strong>{\$a->sitename}</strong>.';
$string['defaultemailfooter'] = 'Best regards,<br>The {\$a->sitename} team';

$string['emailtemplate'] = 'Email HTML template';
$string['emailtemplate_desc'] = 'Edit here the full HTML template for the email. Use variables like {\$a->name}, {\$a->email}, {\$a->phone}, {\$a->message}, {\$a->greeting}, {\$a->thanks}, {\$a->footer}.';
$string['defaultemailtemplate'] = <<<EOT
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8"/>
  <title>Contact form</title>
  <style>
    body { font-family: Arial, sans-serif; color: #222; }
    .container { padding: 16px; background: #f9f9f9; border-radius: 8px; }
    .label { font-weight: bold; }
    .footer { font-size: 0.9em; color: #888; margin-top: 20px; }
  </style>
</head>
<body>
  <div class="container">
    <p>{\$a->greeting}</p>
    <p>{\$a->thanks}</p>
    <h3>Submitted details:</h3>
    <p>
      <span class="label">Name:</span> {\$a->name}<br>
      <span class="label">Email:</span> {\$a->email}<br>
      <span class="label">Phone:</span> {\$a->phone}<br>
    </p>
    <p>
      <span class="label">Message:</span><br>
      {\$a->message}
    </p>
    <div class="footer">
      {\$a->footer}
    </div>
  </div>
</body>
</html>
EOT;

// reCAPTCHA
$string['recaptcha'] = 'Anti-spam verification (reCAPTCHA)';

// GDPR consent
$string['gdprconsent'] = 'I have read and accept the privacy policy.';
$string['gdprrequired'] = 'You must accept the privacy policy to continue.';

// Capability
$string['contactform:view'] = 'Access the contact form';

<?php
// English language strings for local_contactform
defined('MOODLE_INTERNAL') || die();

// General
$string['pluginname'] = 'Contact form';
$string['contactform'] = 'Contact form';

// Form fields
$string['formintroheading'] = 'Do you have any questions or need help?';
$string['formintromessage'] = 'Fill in this form and we will contact you as soon as possible. Please make sure you provide a valid email address.';

$string['name'] = 'Name';
$string['email'] = 'Email address';
$string['phone'] = 'Phone (optional)';
$string['subject'] = 'Subject';
$string['message'] = 'Message';
$string['submit'] = 'Send';

// Validation and messages
$string['success'] = 'Your message has been sent successfully!';
$string['invalidemail'] = 'You must enter a valid email address.';
$string['invalidphone'] = 'Please enter a valid phone number (only digits, may start with +).';

// Configuration settings
$string['recipient'] = 'Recipient email address';
$string['recipient_desc'] = 'Enter the email address that will receive contact form submissions.';
$string['sendername'] = 'Sender name';
$string['sendername_desc'] = 'Name displayed as sender in outgoing emails.';

$string['emailsubject'] = 'Email subject';
$string['emailsubject_desc'] = 'Default subject for sent emails.';
$string['defaultemailsubject'] = 'New message from the contact form';

$string['emailgreeting'] = 'Email greeting';
$string['emailgreeting_desc'] = 'Greeting at the start of the email. Use <strong>{\$a->name}</strong> for the sender\'s name.';
$string['defaultemailgreeting'] = 'Hello {\$a->name}!';

$string['emailthanks'] = 'Thank you text';
$string['emailthanks_desc'] = 'Thank you message. Use <strong>{\$a->sitename}</strong> for the site name.';
$string['defaultemailthanks'] = 'Thank you for contacting {\$a->sitename}. We will reply as soon as possible.';

$string['emailfooter'] = 'Email footer';
$string['emailfooter_desc'] = 'Footer text for the email. Use <strong>{\$a->sitename}</strong>.';
$string['defaultemailfooter'] = 'Best regards,<br>The {\$a->sitename} team';

$string['emailtemplate'] = 'Email HTML template';
$string['emailtemplate_desc'] = 'Edit here the full HTML template for the email. Use variables like {\$a->name}, {\$a->email}, {\$a->phone}, {\$a->message}, {\$a->greeting}, {\$a->thanks}, {\$a->footer}.';
$string['defaultemailtemplate'] = <<<EOT
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8"/>
  <title>Contact form</title>
  <style>
    body { font-family: Arial, sans-serif; color: #222; }
    .container { padding: 16px; background: #f9f9f9; border-radius: 8px; }
    .label { font-weight: bold; }
    .footer { font-size: 0.9em; color: #888; margin-top: 20px; }
  </style>
</head>
<body>
  <div class="container">
    <p>{\$a->greeting}</p>
    <p>{\$a->thanks}</p>
    <h3>Submitted details:</h3>
    <p>
      <span class="label">Name:</span> {\$a->name}<br>
      <span class="label">Email:</span> {\$a->email}<br>
      <span class="label">Phone:</span> {\$a->phone}<br>
    </p>
    <p>
      <span class="label">Message:</span><br>
      {\$a->message}
    </p>
    <div class="footer">
      {\$a->footer}
    </div>
  </div>
</body>
</html>
EOT;

// reCAPTCHA
$string['recaptcha'] = 'Anti-spam verification (reCAPTCHA)';

// GDPR consent
$string['gdprconsent'] = 'I have read and accept the privacy policy.';
$string['gdprrequired'] = 'You must accept the privacy policy to continue.';

// Capability
$string['contactform:view'] = 'Access the contact form';

settings.php — Configuración personalizable desde la administración

El archivo settings.php permite que los administradores de Moodle configuren fácilmente los principales parámetros del plugin desde el panel de administración.
Esto significa que, sin tocar código, puedes definir quién recibe los emails del formulario, qué nombre de remitente se muestra y personalizar los textos que aparecerán en los mensajes enviados.
Esta flexibilidad es clave para adaptar el formulario a diferentes organizaciones, departamentos o idiomas, manteniendo el control desde la interfaz de Moodle. Ruta: local/contactform/settings.php

<?php
defined('MOODLE_INTERNAL') || die();

if ($hassiteconfig) {
    $settings = new admin_settingpage('local_contactform', get_string('pluginname', 'local_contactform'));

    // Email destinatario
    $settings->add(new admin_setting_configtext(
        'local_contactform/recipient',
        get_string('recipient', 'local_contactform'),
        get_string('recipient_desc', 'local_contactform'),
        '',
        PARAM_EMAIL
    ));

    // Nombre del remitente
    $settings->add(new admin_setting_configtext(
        'local_contactform/sendername',
        get_string('sendername', 'local_contactform'),
        get_string('sendername_desc', 'local_contactform'),
        '',
        PARAM_TEXT
    ));

    // Asunto del email
    $settings->add(new admin_setting_configtext(
        'local_contactform/emailsubject',
        get_string('emailsubject', 'local_contactform'),
        get_string('emailsubject_desc', 'local_contactform'),
        get_string('defaultemailsubject', 'local_contactform'),
        PARAM_TEXT
    ));

    // Saludo del email (ahora con editor HTML)
    $settings->add(new admin_setting_confightmleditor(
        'local_contactform/emailgreeting',
        get_string('emailgreeting', 'local_contactform'),
        get_string('emailgreeting_desc', 'local_contactform'),
        get_string('defaultemailgreeting', 'local_contactform')
    ));

    // Texto de agradecimiento (ahora con editor HTML)
    $settings->add(new admin_setting_confightmleditor(
        'local_contactform/emailthanks',
        get_string('emailthanks', 'local_contactform'),
        get_string('emailthanks_desc', 'local_contactform'),
        get_string('defaultemailthanks', 'local_contactform')
    ));

    // Pie del email (ahora con editor HTML)
    $settings->add(new admin_setting_confightmleditor(
        'local_contactform/emailfooter',
        get_string('emailfooter', 'local_contactform'),
        get_string('emailfooter_desc', 'local_contactform'),
        get_string('defaultemailfooter', 'local_contactform')
    ));

    // Plantilla HTML del email (ahora con editor HTML)
    $settings->add(new admin_setting_confightmleditor(
        'local_contactform/emailtemplate',
        get_string('emailtemplate', 'local_contactform'),
        get_string('emailtemplate_desc', 'local_contactform'),
        get_string('defaultemailtemplate', 'local_contactform')
    ));

    $ADMIN->add('localplugins', $settings);
}

<?php
defined('MOODLE_INTERNAL') || die();

if ($hassiteconfig) {
    $settings = new admin_settingpage('local_contactform', get_string('pluginname', 'local_contactform'));

    // Email destinatario
    $settings->add(new admin_setting_configtext(
        'local_contactform/recipient',
        get_string('recipient', 'local_contactform'),
        get_string('recipient_desc', 'local_contactform'),
        '',
        PARAM_EMAIL
    ));

    // Nombre del remitente
    $settings->add(new admin_setting_configtext(
        'local_contactform/sendername',
        get_string('sendername', 'local_contactform'),
        get_string('sendername_desc', 'local_contactform'),
        '',
        PARAM_TEXT
    ));

    // Asunto del email
    $settings->add(new admin_setting_configtext(
        'local_contactform/emailsubject',
        get_string('emailsubject', 'local_contactform'),
        get_string('emailsubject_desc', 'local_contactform'),
        get_string('defaultemailsubject', 'local_contactform'),
        PARAM_TEXT
    ));

    // Saludo del email (ahora con editor HTML)
    $settings->add(new admin_setting_confightmleditor(
        'local_contactform/emailgreeting',
        get_string('emailgreeting', 'local_contactform'),
        get_string('emailgreeting_desc', 'local_contactform'),
        get_string('defaultemailgreeting', 'local_contactform')
    ));

    // Texto de agradecimiento (ahora con editor HTML)
    $settings->add(new admin_setting_confightmleditor(
        'local_contactform/emailthanks',
        get_string('emailthanks', 'local_contactform'),
        get_string('emailthanks_desc', 'local_contactform'),
        get_string('defaultemailthanks', 'local_contactform')
    ));

    // Pie del email (ahora con editor HTML)
    $settings->add(new admin_setting_confightmleditor(
        'local_contactform/emailfooter',
        get_string('emailfooter', 'local_contactform'),
        get_string('emailfooter_desc', 'local_contactform'),
        get_string('defaultemailfooter', 'local_contactform')
    ));

    // Plantilla HTML del email (ahora con editor HTML)
    $settings->add(new admin_setting_confightmleditor(
        'local_contactform/emailtemplate',
        get_string('emailtemplate', 'local_contactform'),
        get_string('emailtemplate_desc', 'local_contactform'),
        get_string('defaultemailtemplate', 'local_contactform')
    ));

    $ADMIN->add('localplugins', $settings);
}

¿Para qué sirve?

• Todos estos valores se pueden ajustar desde el panel de administración del sitio, en la sección de plugins locales.
• Así, puedes cambiar el destinatario de los emails, el nombre del remitente y personalizar el contenido de los mensajes en cualquier momento, sin editar el código.
• Además, los textos personalizados pueden incluir variables como {$a->name} o {$a->sitename} que serán reemplazadas dinámicamente al enviar el email.
  

lib.php — Funciones auxiliares y extensibilidad futura

El archivo lib.php está reservado para incluir funciones auxiliares, integraciones futuras o callbacks de eventosrelacionados con tu plugin.
En la mayoría de los plugins locales, puede empezar vacío, pero dejarlo preparado es una buena práctica para mantener la estructura estándar y facilitar el mantenimiento a largo plazo.

¿Por qué conviene incluirlo, aunque empiece vacío?
Aunque en esta primera versión de tu formulario no lo utilices, incluir lib.php desde el inicio es una buena práctica, ya que:

• Te permitirá ampliar el plugin fácilmente en el futuro (por ejemplo, añadiendo integración con otros sistemas, hooks para eventos, tareas programadas, etc.).
• Mantiene la estructura estándar recomendada por Moodle, mejorando el mantenimiento y la colaboración en equipo.
• Si en versiones futuras necesitas implementar callbacks como local_contactform_before_http_request o integraciones con la API de eventos, este será el sitio adecuado.
  Ruta: local/contactform/lib.php

<?php
// lib.php — Funciones auxiliares del plugin local_contactform
// (Vacío en la versión inicial, preparado para extensiones futuras)

<?php
// lib.php — Funciones auxiliares del plugin local_contactform
// (Vacío en la versión inicial, preparado para extensiones futuras)

form/contact_form.php — Definición y validación del formulario

El archivo form/contact_form.php contiene la clase que define la estructura del formulario utilizando la API estándar de Moodle (moodleform).
¿Por qué es fundamental?
Te permite crear formularios seguros, con validación de datos tanto en cliente como en servidor, y listos para integrarse con el sistema de roles y la lógica de Moodle. Además, aquí se puede integrar reCAPTCHA para prevenir el spam. Ruta: local/contactform/form/contact_form.php

<?php
require_once($CFG->libdir.'/formslib.php');

class local_contactform_form extends moodleform {

    public function definition() {
        $mform = $this->_form;

        // Campo: Nombre
        $mform->addElement('text', 'name', get_string('name', 'local_contactform'));
        $mform->setType('name', PARAM_TEXT);
        $mform->addRule('name', get_string('required'), 'required', null, 'client');

        // Campo: Email
        $mform->addElement('text', 'email', get_string('email', 'local_contactform'));
        $mform->setType('email', PARAM_EMAIL);
        $mform->addRule('email', get_string('required'), 'required', null, 'client');

        // Campo: Teléfono (opcional)
        $mform->addElement('text', 'phone', get_string('phone', 'local_contactform'));
        $mform->setType('phone', PARAM_TEXT);

        // Campo: Asunto
        $mform->addElement('text', 'subject', get_string('subject', 'local_contactform'));
        $mform->setType('subject', PARAM_TEXT);
        $mform->addRule('subject', get_string('required'), 'required', null, 'client');

        // Campo: Mensaje
        $mform->addElement('textarea', 'message', get_string('message', 'local_contactform'), 'wrap="virtual" rows="6" cols="50"');
        $mform->setType('message', PARAM_TEXT);
        $mform->addRule('message', get_string('required'), 'required', null, 'client');

        // Checkbox: Acepto política de privacidad
        $mform->addElement('advcheckbox', 'gdpr', '', get_string('gdprconsent', 'local_contactform'));
        $mform->addRule('gdpr', get_string('gdprrequired', 'local_contactform'), 'required', null, 'client');

        // Campo: reCAPTCHA (si está activado)
        if (get_config('auth', 'recaptcha_site_key') && get_config('auth', 'recaptcha_secret_key')) {
            $mform->addElement('recaptcha', 'recaptcha_element', get_string('recaptcha', 'local_contactform'));
        }

        // Botón de envío
        $this->add_action_buttons(false, get_string('submit', 'local_contactform'));
    }

    public function validation($data, $files) {
        $errors = parent::validation($data, $files);

        if (!validate_email($data['email'])) {
            $errors['email'] = get_string('invalidemail', 'local_contactform');
        }

        if (!empty($data['phone']) && !preg_match('/^\+?\d{7,16}$/', $data['phone'])) {
            $errors['phone'] = get_string('invalidphone', 'local_contactform');
        }

        if (empty($data['gdpr'])) {
            $errors['gdpr'] = get_string('gdprrequired', 'local_contactform');
        }

        if (get_config('auth', 'recaptcha_site_key') && get_config('auth', 'recaptcha_secret_key')) {
            if (empty($data['recaptcha_element'])) {
                $errors['recaptcha_element'] = get_string('missingrecaptchaanswer', 'auth');
            }
        }

        return $errors;
    }
}

<?php
require_once($CFG->libdir.'/formslib.php');

class local_contactform_form extends moodleform {

    public function definition() {
        $mform = $this->_form;

        // Campo: Nombre
        $mform->addElement('text', 'name', get_string('name', 'local_contactform'));
        $mform->setType('name', PARAM_TEXT);
        $mform->addRule('name', get_string('required'), 'required', null, 'client');

        // Campo: Email
        $mform->addElement('text', 'email', get_string('email', 'local_contactform'));
        $mform->setType('email', PARAM_EMAIL);
        $mform->addRule('email', get_string('required'), 'required', null, 'client');

        // Campo: Teléfono (opcional)
        $mform->addElement('text', 'phone', get_string('phone', 'local_contactform'));
        $mform->setType('phone', PARAM_TEXT);

        // Campo: Asunto
        $mform->addElement('text', 'subject', get_string('subject', 'local_contactform'));
        $mform->setType('subject', PARAM_TEXT);
        $mform->addRule('subject', get_string('required'), 'required', null, 'client');

        // Campo: Mensaje
        $mform->addElement('textarea', 'message', get_string('message', 'local_contactform'), 'wrap="virtual" rows="6" cols="50"');
        $mform->setType('message', PARAM_TEXT);
        $mform->addRule('message', get_string('required'), 'required', null, 'client');

        // Checkbox: Acepto política de privacidad
        $mform->addElement('advcheckbox', 'gdpr', '', get_string('gdprconsent', 'local_contactform'));
        $mform->addRule('gdpr', get_string('gdprrequired', 'local_contactform'), 'required', null, 'client');

        // Campo: reCAPTCHA (si está activado)
        if (get_config('auth', 'recaptcha_site_key') && get_config('auth', 'recaptcha_secret_key')) {
            $mform->addElement('recaptcha', 'recaptcha_element', get_string('recaptcha', 'local_contactform'));
        }

        // Botón de envío
        $this->add_action_buttons(false, get_string('submit', 'local_contactform'));
    }

    public function validation($data, $files) {
        $errors = parent::validation($data, $files);

        if (!validate_email($data['email'])) {
            $errors['email'] = get_string('invalidemail', 'local_contactform');
        }

        if (!empty($data['phone']) && !preg_match('/^\+?\d{7,16}$/', $data['phone'])) {
            $errors['phone'] = get_string('invalidphone', 'local_contactform');
        }

        if (empty($data['gdpr'])) {
            $errors['gdpr'] = get_string('gdprrequired', 'local_contactform');
        }

        if (get_config('auth', 'recaptcha_site_key') && get_config('auth', 'recaptcha_secret_key')) {
            if (empty($data['recaptcha_element'])) {
                $errors['recaptcha_element'] = get_string('missingrecaptchaanswer', 'auth');
            }
        }

        return $errors;
    }
}

¿Para qué sirve este archivo?

• Estructura los campos que verá el usuario: nombre, email, teléfono, mensaje y el recaptcha.
• Permite validar los datos para evitar errores y spam.
• Facilita añadir o quitar campos según tus necesidades, ampliando fácilmente el formulario para otros usos.
  

index.php — Renderizado del formulario y gestión del flujo principal

Este archivo es el punto de entrada del plugin. Controla el flujo completo: muestra el formulario, procesa los datos enviados, utiliza la plantilla y los textos configurados en administración y envía el email tanto al destinatario como al usuario.

¿Cómo funciona el renderizado del formulario?

1. Preparación del contexto:
   Se establece el contexto del sistema y se verifican los permisos.
   Esto garantiza que solo los usuarios con permiso puedan acceder y usar el formulario, según lo definido en db/access.php.
2. Configuración de la página:
   Se configuran la URL, el título y el encabezado de la página para integrarse con el diseño de Moodle.
3. Instanciación y gestión del formulario:
   • Se crea una instancia de la clase local_contactform_form (definida en form/contact_form.php).
   • Se gestiona el ciclo de vida del formulario:
     • Si el usuario cancela, se redirige a la página principal.
     • Si el formulario es enviado correctamente, se recogen y sanitizan los datos, y se procede al procesamiento (por ejemplo, envío del email).
     • Si es la primera vez o hay errores, simplemente se muestra el formulario en pantalla.
4. Renderizado en pantalla:
   Se utilizan las funciones $OUTPUT->header(), $OUTPUT->heading() y $OUTPUT->footer() para asegurar que el formulario herede el estilo, la navegación y el diseño global de Moodle.
   El propio formulario se muestra con $mform->display();.

Ruta: local/contactform/index.php

<?php
// Página principal del formulario de contacto - local_contactform

require('../../config.php');
require_once($CFG->dirroot . '/local/contactform/form/contact_form.php');

$context = context_system::instance();
require_login();
require_capability('local/contactform:view', $context);

$PAGE->set_url(new moodle_url('/local/contactform/index.php'));
$PAGE->set_context($context);
$PAGE->set_title(get_string('pluginname', 'local_contactform'));
$PAGE->set_heading(format_string($SITE->fullname));
$PAGE->navbar->add(get_string('pluginname', 'local_contactform'));

$mform = new local_contactform_form();

if ($mform->is_cancelled()) {
    redirect(new moodle_url('/'));
} else if ($data = $mform->get_data()) {
    // Procesar datos enviados

    $name    = clean_param($data->name, PARAM_TEXT);
    $email   = clean_param($data->email, PARAM_EMAIL);
    $phone   = clean_param($data->phone, PARAM_TEXT);
    $subject = clean_param($data->subject, PARAM_TEXT);
    $message = clean_param($data->message, PARAM_TEXT);

    $recipientemail = trim(get_config('local_contactform', 'recipient'));
    if (empty($recipientemail) || !validate_email($recipientemail)) {
        throw new moodle_exception('Invalid recipient email configuration.');
    }

    $sendername = trim(get_config('local_contactform', 'sendername')) ?: $SITE->fullname;
    $defaultsubject = trim(get_config('local_contactform', 'emailsubject')) ?: get_string('defaultemailsubject', 'local_contactform');
    $sitename   = format_string($SITE->fullname);

    // Variables auxiliares
    $a = (object)[
        'name'     => $name,
        'email'    => $email,
        'phone'    => $phone,
        'message'  => nl2br(s($message)), // Escapar correctamente el mensaje
        'sitename' => $sitename,
    ];

    // Obtener y procesar greeting, thanks, footer
    $a->greeting = str_replace(['{$a->name}', '{$a->sitename}'], [$a->name, $sitename], get_config('local_contactform', 'emailgreeting'));
    $a->thanks   = str_replace(['{$a->name}', '{$a->sitename}'], [$a->name, $sitename], get_config('local_contactform', 'emailthanks'));
    $a->footer   = str_replace(['{$a->name}', '{$a->sitename}'], [$a->name, $sitename], get_config('local_contactform', 'emailfooter'));

    // Plantilla
    $template = get_config('local_contactform', 'emailtemplate');
    $template = html_entity_decode($template);

    $template = preg_replace_callback('/\{\$a->(\w+)\}/', function ($matches) use ($a) {
        $key = $matches[1];
        return isset($a->$key) ? $a->$key : '';
    }, $template);

    // Objeto destinatario (usuario del sistema)
    $recipient = (object)[
        'id' => 1,
        'email' => $recipientemail,
        'firstname' => $sendername,
        'lastname' => '',
        'username' => 'recipient',
        'firstnamephonetic' => '',
        'lastnamephonetic' => '',
        'middlename' => '',
        'alternatename' => ''
    ];

    // Objeto remitente (simula usuario externo)
    $sender = (object)[
        'id' => 2,
        'email' => $email,
        'firstname' => $name,
        'lastname' => '',
        'username' => 'formuser',
        'firstnamephonetic' => '',
        'lastnamephonetic' => '',
        'middlename' => '',
        'alternatename' => ''
    ];


    // Enviar a ambos
    $success = email_to_user($recipient, $sender, $subject ?: $defaultsubject, strip_tags($template), $template)
        && email_to_user($sender, $recipient, $subject ?: $defaultsubject, strip_tags($template), $template);

    // Mostrar confirmación
    echo $OUTPUT->header();
    echo html_writer::start_div('container mt-5');
    echo html_writer::start_div('card border-success');
    echo html_writer::div(
        $success
            ? get_string('success', 'local_contactform')
            : get_string('emailerror', 'local_contactform'),
        $success ? 'alert alert-success m-4' : 'alert alert-danger m-4'
    );
    echo html_writer::end_div(); // .card
    echo html_writer::end_div(); // .container
    echo $OUTPUT->footer();
    exit;
}

// Renderizar formulario
echo $OUTPUT->header();
echo html_writer::start_div('container mt-5 mb-5');

echo html_writer::start_div('alert alert-info mb-4');
echo html_writer::tag('h4', get_string('formintroheading', 'local_contactform'), ['class' => 'mb-2']);
echo html_writer::tag('p', get_string('formintromessage', 'local_contactform'));
echo html_writer::end_div();

echo html_writer::start_div('card shadow-sm');
echo html_writer::start_div('card-body');
echo html_writer::tag('h2', get_string('contactform', 'local_contactform'), ['class' => 'card-title mb-4']);
$mform->display();
echo html_writer::end_div(); // .card-body
echo html_writer::end_div(); // .card
echo html_writer::end_div(); // .container
echo $OUTPUT->footer();

<?php
// Página principal del formulario de contacto - local_contactform

require('../../config.php');
require_once($CFG->dirroot . '/local/contactform/form/contact_form.php');

$context = context_system::instance();
require_login();
require_capability('local/contactform:view', $context);

$PAGE->set_url(new moodle_url('/local/contactform/index.php'));
$PAGE->set_context($context);
$PAGE->set_title(get_string('pluginname', 'local_contactform'));
$PAGE->set_heading(format_string($SITE->fullname));
$PAGE->navbar->add(get_string('pluginname', 'local_contactform'));

$mform = new local_contactform_form();

if ($mform->is_cancelled()) {
    redirect(new moodle_url('/'));
} else if ($data = $mform->get_data()) {
    // Procesar datos enviados

    $name    = clean_param($data->name, PARAM_TEXT);
    $email   = clean_param($data->email, PARAM_EMAIL);
    $phone   = clean_param($data->phone, PARAM_TEXT);
    $subject = clean_param($data->subject, PARAM_TEXT);
    $message = clean_param($data->message, PARAM_TEXT);

    $recipientemail = trim(get_config('local_contactform', 'recipient'));
    if (empty($recipientemail) || !validate_email($recipientemail)) {
        throw new moodle_exception('Invalid recipient email configuration.');
    }

    $sendername = trim(get_config('local_contactform', 'sendername')) ?: $SITE->fullname;
    $defaultsubject = trim(get_config('local_contactform', 'emailsubject')) ?: get_string('defaultemailsubject', 'local_contactform');
    $sitename   = format_string($SITE->fullname);

    // Variables auxiliares
    $a = (object)[
        'name'     => $name,
        'email'    => $email,
        'phone'    => $phone,
        'message'  => nl2br(s($message)), // Escapar correctamente el mensaje
        'sitename' => $sitename,
    ];

    // Obtener y procesar greeting, thanks, footer
    $a->greeting = str_replace(['{$a->name}', '{$a->sitename}'], [$a->name, $sitename], get_config('local_contactform', 'emailgreeting'));
    $a->thanks   = str_replace(['{$a->name}', '{$a->sitename}'], [$a->name, $sitename], get_config('local_contactform', 'emailthanks'));
    $a->footer   = str_replace(['{$a->name}', '{$a->sitename}'], [$a->name, $sitename], get_config('local_contactform', 'emailfooter'));

    // Plantilla
    $template = get_config('local_contactform', 'emailtemplate');
    $template = html_entity_decode($template);

    $template = preg_replace_callback('/\{\$a->(\w+)\}/', function ($matches) use ($a) {
        $key = $matches[1];
        return isset($a->$key) ? $a->$key : '';
    }, $template);

    // Objeto destinatario (usuario del sistema)
    $recipient = (object)[
        'id' => 1,
        'email' => $recipientemail,
        'firstname' => $sendername,
        'lastname' => '',
        'username' => 'recipient',
        'firstnamephonetic' => '',
        'lastnamephonetic' => '',
        'middlename' => '',
        'alternatename' => ''
    ];

    // Objeto remitente (simula usuario externo)
    $sender = (object)[
        'id' => 2,
        'email' => $email,
        'firstname' => $name,
        'lastname' => '',
        'username' => 'formuser',
        'firstnamephonetic' => '',
        'lastnamephonetic' => '',
        'middlename' => '',
        'alternatename' => ''
    ];


    // Enviar a ambos
    $success = email_to_user($recipient, $sender, $subject ?: $defaultsubject, strip_tags($template), $template)
        && email_to_user($sender, $recipient, $subject ?: $defaultsubject, strip_tags($template), $template);

    // Mostrar confirmación
    echo $OUTPUT->header();
    echo html_writer::start_div('container mt-5');
    echo html_writer::start_div('card border-success');
    echo html_writer::div(
        $success
            ? get_string('success', 'local_contactform')
            : get_string('emailerror', 'local_contactform'),
        $success ? 'alert alert-success m-4' : 'alert alert-danger m-4'
    );
    echo html_writer::end_div(); // .card
    echo html_writer::end_div(); // .container
    echo $OUTPUT->footer();
    exit;
}

// Renderizar formulario
echo $OUTPUT->header();
echo html_writer::start_div('container mt-5 mb-5');

echo html_writer::start_div('alert alert-info mb-4');
echo html_writer::tag('h4', get_string('formintroheading', 'local_contactform'), ['class' => 'mb-2']);
echo html_writer::tag('p', get_string('formintromessage', 'local_contactform'));
echo html_writer::end_div();

echo html_writer::start_div('card shadow-sm');
echo html_writer::start_div('card-body');
echo html_writer::tag('h2', get_string('contactform', 'local_contactform'), ['class' => 'card-title mb-4']);
$mform->display();
echo html_writer::end_div(); // .card-body
echo html_writer::end_div(); // .card
echo html_writer::end_div(); // .container
echo $OUTPUT->footer();

¿Qué ventajas aporta este flujo?

• Usa las configuraciones y plantillas personalizadas sin tocar código.
• Garantiza la seguridad mediante limpieza y validación de datos.
• El email es enviado tanto al destinatario designado (ej. soporte) como al usuario que hizo la consulta.
• Si se cancela el formulario, se redirige al inicio; si hay errores de validación, se muestran automáticamente.

emailtemplates/contactform_mail.html — Plantilla HTML para los correos electrónicos

Esta plantilla define el aspecto y estructura del mensaje que recibirán tanto el usuario como el destinatario administrativo tras enviar el formulario.
Puedes personalizar el contenido y diseño usando variables como {$a->name}, {$a->email}, {$a->phone}, {$a->message}, {$a->greeting}, {$a->thanks} y {$a->footer}.
La plantilla se puede editar desde la administración de Moodle, permitiendo adaptar el email a la imagen corporativa o necesidades de comunicación de tu organización.

Ruta: local/contactform/emailtemplates/contactform_mail.html

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="utf-8"/>
  <title>Formulario de contacto</title>
  <style>
    body { font-family: Arial, sans-serif; color: #222; }
    .container { padding: 16px; background: #f9f9f9; border-radius: 8px; }
    .label { font-weight: bold; }
    .footer { font-size: 0.9em; color: #888; margin-top: 20px; }
  </style>
</head>
<body>
  <div class="container">
    <p>{$a->greeting}</p>
    <p>{$a->thanks}</p>
    <h3>Datos enviados:</h3>
    <p>
      <span class="label">Nombre:</span> {$a->name}<br>
      <span class="label">Email:</span> {$a->email}<br>
      <span class="label">Teléfono:</span> {$a->phone}<br>
    </p>
    <p>
      <span class="label">Mensaje:</span><br>
      {$a->message}
    </p>
    <div class="footer">
      {$a->footer}
    </div>
  </div>
</body>
</html>

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="utf-8"/>
  <title>Formulario de contacto</title>
  <style>
    body { font-family: Arial, sans-serif; color: #222; }
    .container { padding: 16px; background: #f9f9f9; border-radius: 8px; }
    .label { font-weight: bold; }
    .footer { font-size: 0.9em; color: #888; margin-top: 20px; }
  </style>
</head>
<body>
  <div class="container">
    <p>{$a->greeting}</p>
    <p>{$a->thanks}</p>
    <h3>Datos enviados:</h3>
    <p>
      <span class="label">Nombre:</span> {$a->name}<br>
      <span class="label">Email:</span> {$a->email}<br>
      <span class="label">Teléfono:</span> {$a->phone}<br>
    </p>
    <p>
      <span class="label">Mensaje:</span><br>
      {$a->message}
    </p>
    <div class="footer">
      {$a->footer}
    </div>
  </div>
</body>
</html>

¿Cómo funciona?

• El sistema reemplaza automáticamente las variables {$a->...} por los datos del usuario y los textos configurados desde la administración.
• Puedes editar la plantilla desde Ajustes del sitio > Plugins locales > Formulario de contacto, o bien sustituir este HTML en la configuración cuando lo necesites.
• Puedes añadir más variables o campos en el futuro fácilmente, manteniendo la personalización y el branding.

Consejo:
Si tu Moodle es multilingüe, puedes tener distintas versiones de la plantilla para diferentes idiomas, o adaptar el texto usando las cadenas de idioma y la configuración del plugin.

Definición del formulario en Moodle paso a paso

La definición del formulario es un aspecto clave en cualquier plugin de recogida de datos en Moodle. Utilizando la clase moodleform, puedes crear formularios robustos, multilingües y con validación avanzada, completamente integrados en la experiencia de usuario de tu campus.

A continuación, te mostramos el proceso completo para construir el formulario de contacto de este tutorial, de forma que sea seguro, ampliable y alineado con las buenas prácticas de desarrollo en Moodle.

Crear el archivo y la clase del formulario

Dentro de la carpeta de tu plugin, crea el archivo: local/contactform/form/contact_form.php

Extiende la clase moodleform para aprovechar todas las funcionalidades del sistema de formularios de Moodle.

$mform->addElement('text', 'subject', 'Asunto');
$mform->setType('subject', PARAM_TEXT);
$mform->addRule('subject', 'Campo obligatorio', 'required', null, 'client');

$mform->addElement('text', 'subject', 'Asunto');
$mform->setType('subject', PARAM_TEXT);
$mform->addRule('subject', 'Campo obligatorio', 'required', null, 'client');

Definir los campos del formulario

En el método definition(), añade los campos necesarios: nombre, email, teléfono (opcional), mensaje y protección anti-spam con reCAPTCHA.

public function definition() {
    $mform = $this->_form;

    // Nombre
    $mform->addElement('text', 'name', get_string('name', 'local_contactform'));
    $mform->setType('name', PARAM_TEXT);
    $mform->addRule('name', get_string('required'), 'required', null, 'client');

    // Email
    $mform->addElement('text', 'email', get_string('email', 'local_contactform'));
    $mform->setType('email', PARAM_EMAIL);
    $mform->addRule('email', get_string('required'), 'required', null, 'client');

    // Teléfono (opcional)
    $mform->addElement('text', 'phone', get_string('phone', 'local_contactform'));
    $mform->setType('phone', PARAM_TEXT);

    // Mensaje
    $mform->addElement('textarea', 'message', get_string('message', 'local_contactform'), 'wrap="virtual" rows="6" cols="50"');
    $mform->setType('message', PARAM_TEXT);
    $mform->addRule('message', get_string('required'), 'required', null, 'client');

    // reCAPTCHA (si está configurado en el sitio)
    if (get_config('auth', 'recaptcha_site_key') && get_config('auth', 'recaptcha_secret_key')) {
        $mform->addElement('recaptcha', 'recaptcha_element', get_string('recaptcha', 'local_contactform'));
    }

    // Botón de envío
    $this->add_action_buttons(false, get_string('submit', 'local_contactform'));
}

public function definition() {
    $mform = $this->_form;

    // Nombre
    $mform->addElement('text', 'name', get_string('name', 'local_contactform'));
    $mform->setType('name', PARAM_TEXT);
    $mform->addRule('name', get_string('required'), 'required', null, 'client');

    // Email
    $mform->addElement('text', 'email', get_string('email', 'local_contactform'));
    $mform->setType('email', PARAM_EMAIL);
    $mform->addRule('email', get_string('required'), 'required', null, 'client');

    // Teléfono (opcional)
    $mform->addElement('text', 'phone', get_string('phone', 'local_contactform'));
    $mform->setType('phone', PARAM_TEXT);

    // Mensaje
    $mform->addElement('textarea', 'message', get_string('message', 'local_contactform'), 'wrap="virtual" rows="6" cols="50"');
    $mform->setType('message', PARAM_TEXT);
    $mform->addRule('message', get_string('required'), 'required', null, 'client');

    // reCAPTCHA (si está configurado en el sitio)
    if (get_config('auth', 'recaptcha_site_key') && get_config('auth', 'recaptcha_secret_key')) {
        $mform->addElement('recaptcha', 'recaptcha_element', get_string('recaptcha', 'local_contactform'));
    }

    // Botón de envío
    $this->add_action_buttons(false, get_string('submit', 'local_contactform'));
}

Implementar la validación personalizada

El método validation() permite controlar la calidad y seguridad de los datos introducidos por el usuario.
Valida el email, el teléfono (si se introduce) y la respuesta del reCAPTCHA.

public function validation($data, $files) {
    $errors = parent::validation($data, $files);

    // Email válido
    if (!validate_email($data['email'])) {
        $errors['email'] = get_string('invalidemail', 'local_contactform');
    }

    // Teléfono válido (opcional)
    if (!empty($data['phone']) && !preg_match('/^\+?\d{7,16}$/', $data['phone'])) {
        $errors['phone'] = get_string('invalidphone', 'local_contactform');
    }

    // Validación de reCAPTCHA
    if (get_config('auth', 'recaptcha_site_key') && get_config('auth', 'recaptcha_secret_key')) {
        if (empty($data['recaptcha_element'])) {
            $errors['recaptcha_element'] = get_string('missingrecaptchaanswer', 'auth');
        }
    }

    return $errors;
}

public function validation($data, $files) {
    $errors = parent::validation($data, $files);

    // Email válido
    if (!validate_email($data['email'])) {
        $errors['email'] = get_string('invalidemail', 'local_contactform');
    }

    // Teléfono válido (opcional)
    if (!empty($data['phone']) && !preg_match('/^\+?\d{7,16}$/', $data['phone'])) {
        $errors['phone'] = get_string('invalidphone', 'local_contactform');
    }

    // Validación de reCAPTCHA
    if (get_config('auth', 'recaptcha_site_key') && get_config('auth', 'recaptcha_secret_key')) {
        if (empty($data['recaptcha_element'])) {
            $errors['recaptcha_element'] = get_string('missingrecaptchaanswer', 'auth');
        }
    }

    return $errors;
}

Ampliar el formulario con nuevos campos

La arquitectura de moodleform facilita añadir nuevos campos en cualquier momento, como selectores, menús desplegables o adjuntos de archivo.
Solo necesitas añadir una línea más en el método definition() y la lógica correspondiente en validation().

Ejemplo: campo “Asunto” obligatorio

$mform->addElement('text', 'subject', 'Asunto');
$mform->setType('subject', PARAM_TEXT);
$mform->addRule('subject', 'Campo obligatorio', 'required', null, 'client');

$mform->addElement('text', 'subject', 'Asunto');
$mform->setType('subject', PARAM_TEXT);
$mform->addRule('subject', 'Campo obligatorio', 'required', null, 'client');

Resumen visual del proceso

1. Modularidad:
   Puedes añadir, modificar o eliminar campos del formulario en cualquier momento. Esto facilita adaptar el formulario a nuevas necesidades, como incluir menús desplegables, adjuntos de archivos o validaciones específicas, sin reescribir el código base.
2. Validación avanzada:
   El sistema permite aplicar reglas de validación tanto en el lado del cliente como en el servidor, asegurando la calidad y la seguridad de los datos recibidos. Así evitas errores, envíos incompletos o intentos de spam.
3. Internacionalización (i18n):
   Todos los textos y mensajes del formulario pueden gestionarse desde los archivos de idioma del plugin. Esto facilita su traducción y adaptación a entornos multilingües, mejorando la experiencia del usuario en campus internacionales.
4. Escalabilidad:
   La arquitectura del formulario está pensada para crecer junto al proyecto. Puedes integrar nuevos campos, lógica condicional, integración con APIs externas o funcionalidades avanzadas sin modificar la estructura principal.

Procesamiento y envío del formulario en Moodle

Una vez que el usuario rellena y envía el formulario, tu plugin debe gestionar el flujo de validación, procesar los datos y generar los emails personalizados. Moodle proporciona todas las herramientas necesarias para hacerlo de forma segura y profesional.

A continuación te explicamos el flujo típico, paso a paso, y cómo aprovechar la plantilla HTML editable desde la administración para maximizar la personalización y el branding en tus comunicaciones.

Comprobar permisos y preparar la página

Antes de mostrar el formulario, el plugin verifica que el usuario tenga permiso para usarlo y prepara la página con el contexto adecuado.
Esto se realiza siempre al inicio de index.php:

$context = context_system::instance();
require_capability('local/contactform:view', $context);

$PAGE->set_url('/local/contactform/index.php');
$PAGE->set_context($context);
$PAGE->set_title(get_string('pluginname', 'local_contactform'));
$PAGE->set_heading(get_string('pluginname', 'local_contactform'));

$context = context_system::instance();
require_capability('local/contactform:view', $context);

$PAGE->set_url('/local/contactform/index.php');
$PAGE->set_context($context);
$PAGE->set_title(get_string('pluginname', 'local_contactform'));
$PAGE->set_heading(get_string('pluginname', 'local_contactform'));

Instanciar el formulario y procesar el envío

Se instancia la clase del formulario. Si el usuario cancela, se le redirige. Si hay datos enviados y validados, se procesan:

$mform = new local_contactform_form();

if ($mform->is_cancelled()) {
    redirect(new moodle_url('/'));
} else if ($data = $mform->get_data()) {
    // Aquí comienza el procesamiento de los datos del formulario
    // (ver paso siguiente)
}

$mform = new local_contactform_form();

if ($mform->is_cancelled()) {
    redirect(new moodle_url('/'));
} else if ($data = $mform->get_data()) {
    // Aquí comienza el procesamiento de los datos del formulario
    // (ver paso siguiente)
}

Recoger y limpiar los datos recibidos

Utiliza las funciones clean_param() para garantizar que los datos sean seguros antes de procesarlos o incluirlos en el email:

$name = clean_param($data->name, PARAM_TEXT);
$email = clean_param($data->email, PARAM_EMAIL);
$phone = clean_param($data->phone, PARAM_TEXT);
$message = clean_param($data->message, PARAM_TEXT);

$name = clean_param($data->name, PARAM_TEXT);
$email = clean_param($data->email, PARAM_EMAIL);
$phone = clean_param($data->phone, PARAM_TEXT);
$message = clean_param($data->message, PARAM_TEXT);

Preparar los textos, destinatarios y plantilla

Recoge todos los textos personalizados y la plantilla HTML desde la configuración (settings.php).
Sustituye las variables necesarias ({$a->name}, {$a->email}, etc.) en la plantilla con los valores reales del envío:

$recipientemail = get_config('local_contactform', 'recipient');
$sendername = get_config('local_contactform', 'sendername');
$subject = get_config('local_contactform', 'emailsubject');
$greeting = get_config('local_contactform', 'emailgreeting');
$thanks = get_config('local_contactform', 'emailthanks');
$footer = get_config('local_contactform', 'emailfooter');
$template = get_config('local_contactform', 'emailtemplate');
$sitename = format_string($SITE->fullname);

$a = (object)[
    'name' => $name,
    'email' => $email,
    'phone' => $phone,
    'message' => nl2br(s($message)),
    'greeting' => str_replace('{$a->name}', $name, $greeting),
    'thanks' => str_replace('{$a->sitename}', $sitename, $thanks),
    'footer' => str_replace('{$a->sitename}', $sitename, $footer),
];

// Sustituye las variables en la plantilla
foreach ($a as $key => $val) {
    $template = str_replace('{$a->'.$key.'}', $val, $template);
}

$recipientemail = get_config('local_contactform', 'recipient');
$sendername = get_config('local_contactform', 'sendername');
$subject = get_config('local_contactform', 'emailsubject');
$greeting = get_config('local_contactform', 'emailgreeting');
$thanks = get_config('local_contactform', 'emailthanks');
$footer = get_config('local_contactform', 'emailfooter');
$template = get_config('local_contactform', 'emailtemplate');
$sitename = format_string($SITE->fullname);

$a = (object)[
    'name' => $name,
    'email' => $email,
    'phone' => $phone,
    'message' => nl2br(s($message)),
    'greeting' => str_replace('{$a->name}', $name, $greeting),
    'thanks' => str_replace('{$a->sitename}', $sitename, $thanks),
    'footer' => str_replace('{$a->sitename}', $sitename, $footer),
];

// Sustituye las variables en la plantilla
foreach ($a as $key => $val) {
    $template = str_replace('{$a->'.$key.'}', $val, $template);
}

Configurar destinatarios para el envío de emails

Prepara los “usuarios” que recibirán el mensaje: el destinatario (administrador/tutor/soporte) y el usuario que ha rellenado el formulario.

$recipient = (object)[
    'id' => 1, // Valor ficticio para email_to_user
    'email' => $recipientemail,
    'firstname' => $sendername ?: $sitename,
    'lastname' => '',
];
$user = (object)[
    'id' => 2,
    'email' => $email,
    'firstname' => $name,
    'lastname' => '',
];

$recipient = (object)[
    'id' => 1, // Valor ficticio para email_to_user
    'email' => $recipientemail,
    'firstname' => $sendername ?: $sitename,
    'lastname' => '',
];
$user = (object)[
    'id' => 2,
    'email' => $email,
    'firstname' => $name,
    'lastname' => '',
];

Enviar el email con la plantilla personalizada

Utiliza la función estándar de Moodle email_to_user() para el envío. Así aseguras compatibilidad con sistemas de logs, multilingüismo y extensiones futuras.

// Envía el email al destinatario configurado
email_to_user($recipient, $user, $subject, '', $template);

// Envía copia al usuario que hizo la consulta
email_to_user($user, $recipient, $subject, '', $template);

// Envía el email al destinatario configurado
email_to_user($recipient, $user, $subject, '', $template);

// Envía copia al usuario que hizo la consulta
email_to_user($user, $recipient, $subject, '', $template);

Mostrar mensaje de confirmación al usuario

Al finalizar el proceso, muestra un aviso claro y amigable para confirmar que el envío ha sido exitoso:

echo $OUTPUT->header();
echo $OUTPUT->notification(get_string('success', 'local_contactform'), 'notifysuccess');
echo $OUTPUT->footer();
exit;

echo $OUTPUT->header();
echo $OUTPUT->notification(get_string('success', 'local_contactform'), 'notifysuccess');
echo $OUTPUT->footer();
exit;

Resumen del flujo

• Se recogen y validan los datos del formulario.
• Se personaliza la plantilla HTML del email usando los textos y branding definidos en administración.
• Se envía el email tanto al destinatario como al usuario remitente.
• El usuario recibe feedback inmediato sobre el estado de su envío.

Buenas prácticas, pruebas e ideas de ampliación

Una vez finalizado el desarrollo e integración del formulario, es esencial validar su correcto funcionamiento y contemplar posibles ampliaciones para cubrir nuevas necesidades o escenarios reales.

Recomendaciones de buenas prácticas

1. Prueba el formulario en diferentes roles y dispositivos
   Accede como administrador, profesor, estudiante e invitado para verificar que los permisos definidos en db/access.php funcionan como esperas. Comprueba también que la experiencia es correcta en móvil y escritorio.
2. Valida siempre los datos recibidos
   Aunque Moodle incorpora validación en cliente y servidor, asegúrate de usar clean_param() y de aplicar reglas estrictas en el método validation() de la clase del formulario.
3. Aprovecha la configuración desde settings.php
   Cambia los textos y la plantilla HTML desde el panel de administración, y verifica que los cambios se reflejan en los correos electrónicos enviados, sin necesidad de modificar código.
4. Mantén los archivos de idioma actualizados
   Si añades nuevos campos o funcionalidades, incorpora sus textos en todos los archivos de idioma (lang/en/, lang/es/, etc.) para garantizar la coherencia y el multilingüismo.
5. Documenta cualquier ampliación
   Si extiendes el formulario con nuevos campos, integraciones o flujos personalizados, deja comentarios claros en el código y en la documentación para facilitar el mantenimiento futuro.

Pruebas recomendadas antes de poner en producción

• Envía formularios con distintos valores, incluyendo campos vacíos y formatos incorrectos, para comprobar que la validación funciona correctamente.
• Prueba el envío de emails con diferentes plantillas, incluyendo textos largos, caracteres especiales y HTML.
• Cambia la configuración de destinatario y asegúrate de que los correos llegan tanto al usuario como al administrador.
• Simula escenarios de error (por ejemplo, dejando el campo email vacío o introduciendo un teléfono no válido) y verifica que los mensajes de error son claros y útiles.
• Comprueba el funcionamiento del reCAPTCHA, si está activo, tanto en el frontend como en el backend.

Ideas de ampliación y evolución

• Guardar envíos en base de datos:
  Permite registrar un histórico de formularios recibidos, consultables desde un panel de administración o reportes personalizados.
• Adjuntar archivos al formulario:
  Añade campos tipo filepicker o filemanager para que los usuarios puedan subir documentos o imágenes junto con su mensaje.
• Integración con sistemas externos:
  Envía los datos recogidos a un CRM, Helpdesk (como Redmine, Jira, Zendesk) o dispara automatizaciones en herramientas como n8n, Zapier o Power Automate.
• Campos condicionales y lógica avanzada:
  Muestra u oculta campos según la selección del usuario, o implementa flujos de aprobación multietapa.
• Notificaciones y seguimiento:
  Añade avisos en el área personal de Moodle o genera tareas pendientes para los responsables de responder a los mensajes recibidos.

Instalación y configuración del plugin

Una vez generado todo el código del plugin —puedes descargártelo en formato ZIP haciendo clic aquí—, instalarlo en tu Moodle 4.x es un proceso rápido y directo. A continuación, te explicamos cómo hacerlo paso a paso.

1. Subir el plugin al servidor

Para comenzar, descomprime el archivo si lo has descargado comprimido y copia la carpeta contactform en la siguiente ruta de tu instalación de Moodle: /local/contactform

📁 Asegúrate de que el nombre del directorio sea exactamente contactform, respetando minúsculas y sin espacios, para evitar errores durante la instalación.

2. Ejecutar el instalador desde la interfaz web

Accede a tu plataforma Moodle con una cuenta de administrador y visita: /admin , ejemplo http://localhost/moodle/admin .
Moodle detectará automáticamente el nuevo plugin local y te mostrará la pantalla de instalación. Revisa los detalles y haz clic en “Continuar” para completar el proceso.

3. Configurar el plugin desde la administración

Una vez instalado el plugin, Moodle añade automáticamente una nueva página de configuración en el panel de administración, dentro del menú Administración del sitio > Extensiones > Local plugins > Formulario de contacto. Desde esta interfaz, el administrador podrá personalizar por completo el comportamiento del formulario y el contenido del correo que se enviará tras su envío.

Esta funcionalidad se define en el archivo settings.php, que registra los ajustes del plugin y permite almacenarlos en la configuración global del sitio ($CFG). A través de este archivo, es posible añadir campos editables como:

• Correo electrónico destinatario (contactemail)
  Email al que llegarán los mensajes enviados desde el formulario.
• Nombre del remitente (sendername)
  Nombre que aparecerá como remitente en el mensaje enviado.
• Asunto del correo (emailsubject)
  Asunto por defecto que se asignará a los correos generados.
• Saludo inicial del correo (emailgreeting)
  Texto introductorio que aparecerá al inicio del mensaje, por ejemplo: Hola {$a->name}.
• Texto de agradecimiento (emailthanks)
  Mensaje que aparece justo después del saludo. Ejemplo: Gracias por contactarnos desde {$a->sitename}.
• Pie del mensaje (emailfooter)
  Despedida o firma final del correo. Por ejemplo: El equipo de {$a->sitename}.
• Plantilla HTML completa del correo (emailtemplate)
  Editor enriquecido donde puedes modificar el contenido completo del email con HTML, incluyendo el uso de variables dinámicas como {$a->name}, {$a->message}, {$a->footer}, etc.

Todos estos campos son editables desde la interfaz web, como se muestra en la siguiente imagen:

💡 Nota: Esta configuración puede cambiarse en cualquier momento sin necesidad de modificar el código fuente del plugin, lo que permite adaptarlo fácilmente a nuevas campañas, responsables o mensajes personalizados.

🧪 Ejemplos de valores para los campos de configuración

🧾 Ejemplo de plantilla HTML completa

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="utf-8" />
  <title>Formulario de contacto</title>
  <style>
    body { font-family: Arial, sans-serif; color: #222; }
    .container { padding: 16px; background: #f9f9f9; border-radius: 8px; }
    .label { font-weight: bold; margin-top: 8px; }
    .footer { font-size: 0.9em; color: #888; margin-top: 20px; }
  </style>
</head>
<body>
  <div class="container">
    <p>{$a->greeting}</p>
    <p><strong>{$a->thanks}</strong></p>
    <h3>Detalles del mensaje</h3>
    <p class="label">Nombre:</p> <p>{$a->name}</p>
    <p class="label">Email:</p> <p>{$a->email}</p>
    <p class="label">Teléfono:</p> <p>{$a->phone}</p>
    <p class="label">Mensaje:</p> <p>{$a->message}</p>
    <div class="footer">
      {$a->footer}
    </div>
  </div>
</body>
</html>

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="utf-8" />
  <title>Formulario de contacto</title>
  <style>
    body { font-family: Arial, sans-serif; color: #222; }
    .container { padding: 16px; background: #f9f9f9; border-radius: 8px; }
    .label { font-weight: bold; margin-top: 8px; }
    .footer { font-size: 0.9em; color: #888; margin-top: 20px; }
  </style>
</head>
<body>
  <div class="container">
    <p>{$a->greeting}</p>
    <p><strong>{$a->thanks}</strong></p>
    <h3>Detalles del mensaje</h3>
    <p class="label">Nombre:</p> <p>{$a->name}</p>
    <p class="label">Email:</p> <p>{$a->email}</p>
    <p class="label">Teléfono:</p> <p>{$a->phone}</p>
    <p class="label">Mensaje:</p> <p>{$a->message}</p>
    <div class="footer">
      {$a->footer}
    </div>
  </div>
</body>
</html>

🔄 Uso de variables dinámicas

El sistema de plantillas permite usar variables como:

• {$a->name} – Nombre del usuario que ha rellenado el formulario.
• {$a->email} – Correo electrónico del usuario.
• {$a->phone} – Teléfono proporcionado.
• {$a->message} – Mensaje enviado por el usuario.
• {$a->thanks} – Texto de agradecimiento configurado.
• {$a->footer} – Firma final del mensaje.
• {$a->sitename} – Nombre del sitio Moodle.

Esto facilita la creación de correos totalmente personalizados y dinámicos, mejorando la experiencia del destinatario.

✅ Recomendación

Utiliza siempre las variables proporcionadas por el sistema ({$a->name}, {$a->message}, etc.) en vez de texto estático para que el mensaje sea personalizado. Y recuerda que puedes volver a esta configuración desde la administración en cualquier momento si necesitas actualizar los textos.

🌐 Internacionalización y multilingüismo

Los textos introducidos en la configuración pueden usarse con filtros multilingües si tienes habilitado el plugin de filtros de contenido multilingüe, lo que permite:

• Personalizar mensajes en función del idioma del usuario.
• Ofrecer una experiencia coherente en entornos multilingües (por ejemplo, universidades o empresas internacionales).

3. Probando el formulario

Para probar nuestro formulario, accede a la URL http://localhost/local/contactform/. Rellena los campos requeridos (nombre, correo electrónico, asunto y mensaje), acepta la política de privacidad marcando la casilla correspondiente y pulsa el botón Enviar.

Si todo está bien configurado, verás un mensaje de confirmación en pantalla y se enviarán dos correos electrónicos:

• Uno al destinatario configurado en la administración del plugin.
• Otro al propio remitente, con una copia del mensaje enviado.

Esto confirma que tanto el formulario como el sistema de notificación funcionan correctamente.

🔧 Asegúrate de que tu instalación de Moodle tenga configurado un servidor de correo saliente (SMTP) para poder enviar mensajes desde el formulario de contacto.
Puedes hacerlo desde:
Administración del sitio > Servidor > Correo saliente (SMTP)

Allí deberás especificar los datos del servidor SMTP de tu proveedor (host, puerto, usuario, contraseña, etc.). Sin esta configuración, Moodle no podrá enviar correos electrónicos.

---

Una vez rellenados y validados los valores correctamente, Moodle envía el formulario de contacto

Si todo ha ido bien, deberías recibir un email de contacto similar a este.

4. 🧪 Prueba del formulario: cómo verificar que todo funciona

Una vez instalado y configurado el plugin, es fundamental realizar una prueba completa del formulario para asegurarte de que:

• Los campos se muestran correctamente.
• El envío funciona como se espera.
• El correo llega al destinatario con el formato y datos adecuados.

Pasos para hacer una prueba funcional

1. Accede al formulario desde un curso o desde la ruta directa
   Accede al enlace http://localhost/local/contactform/
2. Rellena el formulario con datos reales de prueba
   Introduce información válida en todos los campos: nombre, email, teléfono y mensaje. Revisa que los campos obligatorios estén correctamente validados.
3. Envía el formulario
   Al pulsar el botón de envío:
   • Verás un mensaje de confirmación.
   • Se ejecutará el envío del email.
   • Se generará el log interno (si has activado trazabilidad de envíos en tu código).
4. Verifica la recepción del correo
   Revisa la bandeja de entrada del destinatario configurado en los ajustes del plugin. Comprueba que:
   • El asunto es el esperado.
   • El saludo y texto de agradecimiento están personalizados.
   • El contenido HTML respeta la estructura de plantilla definida.
   • Las variables ({$a->name}, {$a->email}, etc.) se han sustituido correctamente.
5. Corrige posibles errores
   Si no recibes el email:
   • Asegúrate de que el servidor tiene activado el envío de correos (cron, SMTP o PHP mail).
   • Comprueba el log de errores de Moodle o habilita el modo desarrollador para más detalles.
   • Verifica que no haya restricciones por dominio o políticas SPF/DMARC en la cuenta receptora.

Consejos para la validación

• Prueba con diferentes navegadores y dispositivos para validar la usabilidad.
• Activa el modo multilingüe, si procede, y verifica que el formulario y correos se adapten al idioma del usuario.
• Incluye capturas de pantalla del formulario y del correo recibido para documentar el test, especialmente si formas parte de un equipo de QA o desarrollo.

Resumen

Con este ejemplo práctico, has aprendido a crear un plugin local en Moodle 4.x capaz de gestionar formularios personalizados de forma avanzada. Hemos recorrido paso a paso cómo construir un sistema que:

• Utiliza moodleform para generar formularios robustos y validados.
• Envía correos electrónicos con plantillas HTML personalizables.
• Permite al administrador configurar los textos y el destinatario desde settings.php.
• Incorpora medidas de seguridad como la protección contra spam con reCAPTCHA.
• Está diseñado bajo buenas prácticas de desarrollo y escalabilidad.

Gracias a esta guía, ahora puedes integrar formularios en Moodle de forma profesional, alineados con los procesos de tu organización y capaces de ofrecer una experiencia moderna y eficiente tanto para usuarios como para administradores.

🔗 ¿El siguiente paso? Integrar formularios en Moodle con APIs externas

El verdadero valor de un formulario no es solo recoger datos, sino activarlos. Puedes programar tus formularios para que, una vez enviados, lancen procesos automatizados mediante webhooks, APIs REST o herramientas como n8n o Zapier.

Ejemplos de integración:

• Enviar un JSON con los datos a un endpoint externo vía curl.
• Activar un flujo en n8n que cree un ticket en Redmine y una notificación en Slack.
• Registrar datos directamente en un CRM como Salesforce u Odoo.
• Generar una fila en Google Sheets con cada envío.

🔒 Seguridad y control

• Puedes autenticar las peticiones con tokens o cabeceras personalizadas.
• Controlar errores mediante respuestas condicionales (try/catch, validaciones).
• Garantizar el cumplimiento del RGPD al mantener el control dentro de Moodle.

💡 Casos reales de integración de formularios en Moodle

• Soporte técnico: generación automática de tickets en Redmine.
• Feedback: envíos que activan alertas según la urgencia (Slack, Teams).
• Formación interna: integración con herramientas de RRHH o compliance.
• CRM: creación de leads directamente desde formularios de contacto.

Gracias a este enfoque, puedes integrar formularios en Moodle no solo como una forma de recoger información, sino como puntos de activación estratégica en tu stack digital. Para técnicos TIC y responsables de formación, esto abre un abanico de posibilidades: automatización, trazabilidad, eficiencia operativa y seguridad en la gestión de datos.

🔍 Caso real: Buscador avanzado en Moodle con integración de campos personalizados

Uno de los grandes retos que enfrentan muchas instituciones educativas y organismos públicos es ofrecer a sus usuarios una forma moderna, ágil y segmentada de buscar entre cientos de cursos. Aunque Moodle incluye filtros básicos por nombre o categoría, estos se quedan cortos cuando se busca una experiencia de búsqueda personalizada y eficiente.

🧩 El reto: un catálogo de más de 500 cursos

Un cliente institucional del gremio de la abogacía nos planteó el desafío de mejorar radicalmente el proceso de búsqueda dentro de su campus Moodle, con más de 500 acciones formativas en activo. Necesitaban un buscador que permitiera filtrar por modalidad, ubicación, fecha, tipo de formación y estado de inscripción, sin complejidad técnica para el usuario.

🛠️ Solución: integración avanzada de formularios con campos personalizados

En Entornos de Formación, desarrollamos un bloque personalizado de búsqueda avanzada, basado en la funcionalidad nativa de campos personalizados de curso (course custom fields), disponible desde Moodle 3.8.

Esta solución permitió integrar formularios en Moodle con una capa visual mejorada y conectada directamente con los metadatos de cada curso.

Características clave del buscador:

• Lectura automática de todos los custom fields activos desde la administración.
• Formulario visual intuitivo, con menús desplegables, casillas de verificación y selectores de fecha.
• Búsqueda dinámica por AJAX, con resultados instantáneos y sin recargar la página.
• Diseño responsive, optimizado para móviles y tablets.
• 100 % configurable: los administradores pueden añadir o modificar criterios sin tocar código.
  

🧪 Campos personalizados integrados

Cada uno de estos filtros correspondía a un campo personalizado de curso, gestionado desde el backend de Moodle:

• Modalidad: Online, Presencial.
• Provincia: Desplegable geolocalizado.
• Estado de inscripción: Abierta, Próximamente, Finalizada.
• Tipo de formación: Curso, Jornada, Congreso, Ponencia…
• Fecha de inicio: Campo de fecha con búsqueda inteligente.
  

📈 Impacto directo en la experiencia del usuario

• Aumento del 60 % en las búsquedas efectivas dentro del catálogo.
• Reducción del tiempo medio de inscripción y de consultas al soporte.
• Mejora significativa en la navegación móvil.
• Autonomía total para el equipo técnico: pueden ampliar filtros desde el panel sin tocar código.

🎯 ¿Por qué es una solución estratégica?

Porque permite integrar formularios en Moodle que no solo recogen datos, sino que también mejoran la experiencia de descubrimiento formativo. Con este desarrollo a medida, el LMS se transforma en un sistema inteligente de navegación, filtrado y acceso a contenidos, alineado con los mejores estándares de usabilidad del sector EdTech.

Este caso demuestra cómo Moodle, bien extendido y adaptado, puede ofrecer una experiencia comparable o superior a muchos LMS comerciales, con todas las ventajas de flexibilidad, soberanía de datos y cumplimiento normativo.

❓ Preguntas frecuentes sobre cómo integrar formularios en Moodle

✅ ¿Puedo crear formularios avanzados en Moodle sin depender de herramientas externas como Google Forms o Typeform?

Sí. Es posible integrar formularios en Moodle que cumplen con las mismas funcionalidades —y muchas veces más— que ofrecen herramientas externas. Gracias a la API interna moodleform, puedes construir formularios completamente personalizados, con lógica condicional, validación de datos, subida de archivos y más, sin salir del ecosistema Moodle. Además, alojando los datos en tu propio servidor, garantizas el cumplimiento del RGPD y refuerzas la soberanía digital de tu organización.

🔗 ¿Puedo conectar un formulario de Moodle con herramientas como Salesforce, CRMs, ERPs o canales como Teams y Slack?

Absolutamente. Moodle permite integración avanzada vía API REST o mediante herramientas como n8n o Zapier, lo que significa que los datos enviados desde un formulario pueden activar flujos automáticos en plataformas externas. Algunos ejemplos reales de automatización:

• n8n: al enviar un formulario, puedes crear una tarea en ClickUp, registrar eventos en Google Calendar o enviar alertas a Slack.
• Salesforce y otros CRMs: crea leads, oportunidades o actualiza fichas automáticamente desde formularios de inscripción o contacto.
• ERPs como Odoo o SAP: registra solicitudes de formación, asistencia o incidencias sin duplicación de datos.
• Teams o Slack: notifica a canales privados cuando se completa un formulario, con detalles y enlaces directos.
• Sistemas de RRHH o compliance: recoge datos de evaluaciones, feedback o seguimiento de personal y sincronízalos automáticamente.

En Entornos de Formación, diseñamos estas integraciones a medida para garantizar seguridad, trazabilidad y compatibilidad a largo plazo, cumpliendo con la normativa de protección de datos.

🧩 ¿Qué tipos de formularios se pueden desarrollar en Moodle?

Puedes integrar formularios en Moodle de casi cualquier tipo, entre ellos:

• Formularios de soporte técnico
• Inscripciones a cursos o eventos
• Recogida de feedback y encuestas
• Evaluaciones internas y autoevaluaciones
• Formularios de contacto y consentimiento RGPD

Todos ellos pueden personalizarse según rol, idioma, contexto o reglas condicionales, y responder con notificaciones automáticas o flujos posteriores.

📊 ¿Cómo se gestionan los datos recogidos? ¿Puedo exportarlos o analizarlos?

Sí. Los datos pueden:

• Almacenarse en Moodle para trazabilidad y cumplimiento.
• Exportarse en formatos como CSV, Excel o PDF.
• Activar notificaciones automáticas.
• Visualizarse en reportes internos o en dashboards externos conectados.

También puedes programar backups automáticos, asegurar integridad y configurar accesos por rol para una gestión más segura.

🔍 ¿Puedo usar los campos personalizados de curso como filtros en buscadores?

Sí. Desde Moodle 3.8, puedes crear campos personalizados de cursos (como modalidad, duración, ubicación, tipo de formación) y utilizarlos para desarrollar buscadores avanzados, altamente configurables. Con una interfaz moderna y AJAX, estos filtros ofrecen una experiencia de búsqueda personalizada y eficaz para los usuarios.

🛠️ ¿Necesito conocimientos técnicos para gestionar estos formularios?

No necesariamente. Aunque su desarrollo requiere intervención técnica, una vez implementados, puedes:

• Modificar campos y contenidos desde el panel de administración.
• Activar o desactivar funcionalidades sin tocar código.
• Consultar y exportar datos con un par de clics.

Además, en Entornos de Formación te acompañamos con formación personalizada y soporte técnico, para que tu equipo pueda operar con total autonomía.

Moodle como centro de soporte y automatización: más allá del LMS

Moodle ya no debe verse únicamente como un LMS para impartir cursos. Con los desarrollos adecuados, puede convertirse en el centro operativo de tu ecosistema formativo, permitiendo integrar formularios en Moodle que automatizan procesos, centralizan la comunicación y mejoran la experiencia del usuario.

Tal como has visto a lo largo de esta guía, la posibilidad de crear formularios personalizados en Moodle no solo cubre necesidades básicas de recogida de datos, sino que desbloquea un amplio abanico de soluciones estratégicas:

• Formularios de soporte conectados con herramientas externas como Redmine, que permiten centralizar la gestión de incidencias sin salir del campus virtual.
• Flujos automatizados mediante plataformas como n8n o Zapier, transformando los formularios en disparadores que se integran con CRMs, ERPs o canales de comunicación como Slack o Microsoft Teams.
• Buscadores formativos avanzados, capaces de filtrar por campos personalizados de curso, mejorando radicalmente la navegación y la experiencia del estudiante.

Estas soluciones no solo resuelven retos técnicos del día a día. También:

• Reducen la carga operativa del equipo TIC y docente.
• Aumentan la eficiencia administrativa.
• Garantizan el cumplimiento del RGPD, al mantener los datos dentro del entorno Moodle y bajo control institucional.

En resumen: Moodle, con una estrategia de desarrollo adecuada, se convierte en una plataforma educativa escalable, conectada y preparada para crecer contigo.

👉 ¿Quieres seguir explorando? Te recomendamos leer nuestro próximo artículo:
Automatizaciones edTech: cómo construir un ecosistema conectado desde el rol del CTO

🚀 ¿Quieres un Moodle que trabaje por ti?

Sabes que Moodle es una gran decisión. Pero para que sea una solución real, necesitas más que una simple instalación: una plataforma moderna, segura y alineada con tus procesos.

En Entornos de Formación llevamos más de 16 años ayudando a universidades, centros de FP y empresas a transformar Moodle en campus virtuales eficaces, escalables y automatizados.

🔧 ¿Qué podemos hacer por ti?

• Instalación técnica completa en tu servidor (VPS o cloud), con configuración segura, backups automatizados y rendimiento optimizado (Apache, PHP, MySQL/MariaDB).
• Diseño personalizado, que refleje tu identidad institucional o de marca, con un estilo actual y accesible.
• Integración de plugins clave: videoconferencias, pasarelas de pago, gamificación, analítica, formularios avanzados, encuestas y automatizaciones.
• Flujos personalizados: adaptamos Moodle a tus procesos, incluyendo automatizaciones con herramientas como Salesforce, Odoo o n8n.
• Formación y acompañamiento real para que gestiones tu Moodle con autonomía desde el primer día.

🎯 ¿Te identificas con alguno de estos perfiles?

• Laura, técnica TIC de una escuela: necesitas un Moodle accesible, multilingüe y adaptado al modelo pedagógico de tu centro.
  
• Carlos, responsable de formación en empresa: buscas integrar formularios en Moodle conectados a RRHH, compliance o CRM interno.
  
• Sofía, fundadora de una academia EdTech: quieres lanzar un campus visual, responsive y automatizado con lógica de negocio desde cero.
  

✅ ¿Por qué elegirnos?

Porque no nos limitamos a instalar Moodle. Diseñamos soluciones a medida que convierten tu plataforma en una verdadera herramienta de gestión, formación y automatización.

👉 Sin tecnicismos.
👉 Sin plantillas genéricas.
✅ Con resultados reales y soporte experto.

---

📩 ¿Hablamos?

Cuéntanos tu proyecto. ¿Es una universidad, una pyme, una administración pública, una startup o un centro educativo?

En Entornos de Formación te ayudamos a crear una plataforma Moodle alineada con tus objetivos, integrando formularios inteligentes, automatización y experiencia de usuario.

✉️ Escríbenos: andresmartinezsoto at gmail.com
🌐 Visítanos: www.edf.global