Aprende a crear un formulario de contacto fácilmente en Symfony 3 con FormType.

Tratar con formularios HTML es una de las tareas más comunes y desafiantes para un desarrollador web. Symfony integra un componente Form que facilita el manejo de formularios.

En este artículo, aprenderá a crear un formulario de contacto básico en Symfony 3 usando FormBuilder y SwiftMailer para enviar el correo electrónico.

Requisitos

  • Symfony 3.
  • SwiftMailer Bundle (que normalmente viene preinstalado y todas las distribuciones de Symfony).

Implementación

Se recomienda el uso de un FormType, ya que es el flujo de trabajo correcto cuando se usa Symfony. Le ayudará a lidiar fácilmente con la personalización de errores y propiedades fácilmente.

Crear un FormType para el formulario de contacto

La siguiente clase contiene la ContactTypeclase que se utilizará para crear el formulario en el controlador más adelante.

<?php
// your-path-to-types/ContactType.php

namespace myapplication\myBundle\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;
use Symfony\Component\Form\Extension\Core\Type\EmailType;
use Symfony\Component\Validator\Constraints\Email;
use Symfony\Component\Validator\Constraints\NotBlank;

class ContactType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('name', TextType::class, array('attr' => array('placeholder' => 'Your name'),
                'constraints' => array(
                    new NotBlank(array("message" => "Please provide your name")),
                )
            ))
            ->add('subject', TextType::class, array('attr' => array('placeholder' => 'Subject'),
                'constraints' => array(
                    new NotBlank(array("message" => "Please give a Subject")),
                )
            ))
            ->add('email', EmailType::class, array('attr' => array('placeholder' => 'Your email address'),
                'constraints' => array(
                    new NotBlank(array("message" => "Please provide a valid email")),
                    new Email(array("message" => "Your email doesn't seems to be valid")),
                )
            ))
            ->add('message', TextareaType::class, array('attr' => array('placeholder' => 'Your message here'),
                'constraints' => array(
                    new NotBlank(array("message" => "Please provide a message here")),
                )
            ))
        ;
    }

    public function setDefaultOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults(array(
            'error_bubbling' => true
        ));
    }

    public function getName()
    {
        return 'contact_form';
    }
}

Nota: cambie el espacio de nombres según la ubicación del FormType en su paquete y guárdelo para usarlo en el siguiente paso.

Creando la vista en Twig

Ahora, la vista (en este caso se renderizará a través de twig), debería ser básica para probar:

{# contact.html.twig #}

{{ form_start(form) }}

    <div>
        {{ form_widget(form.subject) }}
        {{ form_errors(form.subject) }}
    </div>
    <div>
        {{ form_widget(form.name) }}
        {{ form_errors(form.name) }}
    </div>
    <div>
        {{ form_widget(form.email) }}
        {{ form_errors(form.email) }}
    </div>
    <div>
        {{ form_widget(form.message) }}
        {{ form_errors(form.message) }}
    </div>

    {# Render CSRF token etc .#}
    <div style="display:none">
        {{ form_rest(form) }}
    </div>
    
    <input type="submit" value="Submit">
    
{{ form_end(form) }}

Creando el controlador

Ahora, llega el punto más importante del tutorial, el controlador que manejará nuestro formulario.

Como de costumbre, su acción en el controlador ya debería tener una ruta en el archivo routing.yml y se dirige a ella:

myapplication_contact:
    path:     /contact
    defaults: { _controller: myBundle:Default:contact }

Finalmente, nuestro controlador (con la acción de contacto) debería verse así:

<?php

namespace myapplication\myBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Request;

class DefaultController extends Controller
{
    public function contactAction(Request $request)
    {
        // Cree el formulario de acuerdo con el FormType creado anteriormente.
        // Y da los parámetros adecuados
        $form = $this->createForm('myapplication\myBundle\Form\ContactType',null,array(
            // Para configurar la acción, use $ this-> generateUrl ('route_identifier')
            'action' => $this->generateUrl('myapplication_contact'),
            'method' => 'POST'
        ));

        if ($request->isMethod('POST')) {
            // Refill the fields in case the form is not valid.
            $form->handleRequest($request);

            if($form->isValid()){
                // Enviar correo
                if($this->sendEmail($form->getData())){

                    // ¡Todo bien, redirige a donde quieras! :
                    
                    return $this->redirectToRoute('redirect_to_somewhere_now');
                }else{
                    // Ocurrió un error, maneje
                    var_dump("Errooooor :(");
                }
            }
        }

        return $this->render('myBundle:Default:contact.html.twig', array(
            'form' => $form->createView()
        ));
    }

    private function sendEmail($data){
        $myappContactMail = '[email protected]';
        $myappContactPassword = 'yourmailpassword';
        
        // En este caso usaremos los servicios de correo de ZOHO.
        // Si su servicio es otro, lea el siguiente artículo para saber qué código smtp usar y qué puerto
        // http://ourcodeworld.com/articles/read/14/swiftmailer-send-mails-from-php-easily-and-effortlessly
        $transport = \Swift_SmtpTransport::newInstance('smtp.zoho.com', 465,'ssl')
            ->setUsername($myappContactMail)
            ->setPassword($myappContactPassword);

        $mailer = \Swift_Mailer::newInstance($transport);
        
        $message = \Swift_Message::newInstance("Our Code World Contact Form ". $data["subject"])
        ->setFrom(array($myappContactMail => "Message by ".$data["name"]))
        ->setTo(array(
            $myappContactMail => $myappContactMail
        ))
        ->setBody($data["message"]."<br>ContactMail :".$data["email"]);
        
        return $mailer->send($message);
    }
}

El contactAction es una forma normal y típico Symfony 3. Valida si el formulario ha sido enviado con el POSTmétodo, luego verifica si las restricciones dadas en el ContactType son correctas. Si son válidos, proceda a enviar el correo electrónico utilizando la sendEmailfunción.

FormType symfony 3

Conclusión

  • Tenga en cuenta que la función sendEmail es un uso de implementación sencillo de SwiftMailer. Acabamos de usar la implementación con Zoho Mail, si usa otro proveedor de correo electrónico, debe cambiar la dirección SMTP y verificar si su servicio requiere SSL. Puede leer cómo enviar correos desde SwiftMailer a diferentes proveedores de correos electrónicos en este artículo . En la función, solo necesita cambiar la variable de correo y la contraseña y recibirá un correo electrónico enviado desde la misma dirección que recibe ([email protected] envía a [email protected]).
  • Puede agregar más campos fácilmente a su formulario en FormType, para recuperarlos en la función sendEmail (que se convierte en una matriz de $form->getData) use su valor clave.
  • También puede utilizar Google Recaptcha en sus formularios si desea evitar robots, etc. Lea el siguiente artículo para aprender cómo implementar recaptcha en un formulario Symfony 3 .
  • El uso del componente Formulario de Symfony es más confiable que implementar un formulario usted mismo sin protección CSRF y proporciona una manera fácil de manejar errores.

Interesado en la programación desde los 14 años, Carlos es un programador autodidacta, fundador y autor de la mayoría de los artículos de Our Code World.

Conviertete en un programador más sociable

Patrocinadores