Forms

Phalcon\Forms is a component that aid the developer in the creation and maintenance of forms in web applications.

The following example shows its basic usage:

use Phalcon\Forms\Form,
    Phalcon\Forms\Element\Text,
    Phalcon\Forms\Element\Select;

$form = new Form();

$form->add(new Text("name"));

$form->add(new Text("telephone"));

$form->add(new Select("telephoneType", array(
    'H' => 'Home',
    'C' => 'Cell'
)));

Forms can be rendered based on the form definition:

<h1>Contacts</h1>

<form method="post">

    <p>
        <label>Name</label>
        <?php echo $form->render("name") ?>
    </p>

    <p>
        <label>Telephone</label>
        <?php echo $form->render("telephone") ?>
    </p>

    <p>
        <label>Type</label>
        <?php echo $form->render("telephoneType") ?>
    </p>

    <p>
        <input type="submit" value="Save" />
    </p>

</form>

Each element in the form can be rendered as required by the developer. Internally, Phalcon\Tag is used to produce the right HTML for each element, you can pass additional html attributes as second parameter for render:

<p>
    <label>Name</label>
    <?php echo $form->render("name", array('maxlength' => 30, 'placeholder' => 'Type your name')) ?>
</p>

HTML Attributes also can be set in the element’s definition:

$form->add(new Text("name", array(
    'maxlength' => 30,
    'placeholder' => 'Type your name'
)));

Initializing forms

As seen before, forms can be initialized outside the form class by adding elements to it. You can re-use code or organize your form classes implementing the form in a separated file:

use Phalcon\Forms\Form,
    Phalcon\Forms\Element\Text,
    Phalcon\Forms\Element\Select;

class ContactForm extends Form
{
    public function initialize()
    {
        $this->add(new Text("name"));

        $this->add(new Text("telephone"));

        $this->add(new Select("telephoneType", TelephoneTypes::find(), array(
            'using' => array('id', 'name')
        )));
    }
}

Phalcon\Forms\Form extends Phalcon\DI\Injectable so you have access to the application services if needed:

use Phalcon\Forms\Form,
    Phalcon\Forms\Element\Text,
    Phalcon\Forms\Element\Hidden;

class ContactForm extends Form
{

    /**
     * This method returns the default value for field 'csrf'
     */
    public function getCsrf()
    {
        return $this->security->getToken();
    }

    public function initialize()
    {

        //Set the same form as entity
        $this->setEntity($this);

        //Add a text element to capture the 'email'
        $this->add(new Text("email"));

        //Add a text element to put a hidden csrf
        $this->add(new Hidden("csrf"));
    }
}

The associated entity added to the form in the initialization and custom user options are passed to the form constructor:

use Phalcon\Forms\Form,
    Phalcon\Forms\Element\Text,
    Phalcon\Forms\Element\Hidden;

class UsersForm extends Form
{
    /**
     * Forms initializer
     *
     * @param Users $user
     * @param array $options
     */
    public function initialize($user, $options)
    {

        if ($options['edit']) {
            $this->add(new Hidden('id'));
        } else {
            $this->add(new Text('id'));
        }

        $this->add(new Text('name'));
    }
}

In the form’s instantiation you must use:

$form = new UsersForm(new Users(), array('edit' => true));

Validation

Phalcon forms are integrated with the validation component to offer instant validation. Built-in or custom validators could be set to each element:

use Phalcon\Forms\Element\Text,
    Phalcon\Validation\Validator\PresenceOf,
    Phalcon\Validation\Validator\StringLength;

$name = new Text("name");

$name->addValidator(new PresenceOf(array(
    'message' => 'The name is required'
)));

$name->addValidator(new StringLength(array(
    'min' => 10,
    'messageMinimum' => 'The name is too short'
)));

$form->add($name);

Then you can validate the form according to the input entered by the user:

if (!$form->isValid($_POST)) {
    foreach ($form->getMessages() as $message) {
        echo $message, '<br>';
    }
}

Validators are executed in the same order as they were registered.

By default messages generated by all the elements in the form are joined so they can be traversed using a single foreach, you can change this behavior to get the messages separated by the field:

foreach ($form->getMessages(false) as $attribute => $messages) {
    echo 'Messages generated by ', $attribute, ':', "\n";
    foreach ($messages as $message) {
        echo $message, '<br>';
    }
}

Or get specific messages for an element:

foreach ($form->getMessagesFor('name') as $message) {
    echo $message, '<br>';
}

Filtering

A form is also able to filter data before be validated, you can set filters in each element:

Setting User Options

Forms + Entities

An entity such as a model/collection/plain instance or just a plain PHP class can be linked to the form in order to set default values in the form’s elements or assign the values from the form to the entity easily:

$robot = Robots::findFirst();

$form = new Form($robot);

$form->add(new Text("name"));

$form->add(new Text("year"));

Once the form is rendered if there is no default values assigned to the elements it will use the ones provided by the entity:

<?php echo $form->render('name') ?>

You can validate the form and assign the values from the user input in the following way:

$form->bind($_POST, $robot);

//Check if the form is valid
if ($form->isValid()) {

    //Save the entity
    $robot->save();
}

Setting up a plain class as entity also is possible:

class Preferences
{

    public $timezone = 'Europe/Amsterdam';

    public $receiveEmails = 'No';

}

Using this class as entity, allows the form to take the default values from it:

$form = new Form(new Preferences());

$form->add(new Select("timezone", array(
    'America/New_York' => 'New York',
    'Europe/Amsterdam' => 'Amsterdam',
    'America/Sao_Paulo' => 'Sao Paulo',
    'Asia/Tokyo' => 'Tokyo',
)));

$form->add(new Select("receiveEmails", array(
    'Yes' => 'Yes, please!',
    'No' => 'No, thanks'
)));

Entities can implement getters, which have more precedence than public properties, these methods give you more free to produce values:

class Preferences
{

    public $timezone;

    public $receiveEmails;

    public function getTimezone()
    {
        return 'Europe/Amsterdam';
    }

    public function getTimezone()
    {
        return 'No';
    }

}

Form Elements

Phalcon provides a set of built-in elements to use in your forms, all these elements are located in the Phalcon\Forms\Element namespace:

Name	Description	Example
Text	Generate INPUT[type=text] elements	Example
Password	Generate INPUT[type=password] elements	Example
Select	Generate SELECT tag (combo lists) elements based on choices	Example
Check	Generate INPUT[type=check] elements	Example
Textarea	Generate TEXTAREA elements	Example
Hidden	Generate INPUT[type=hidden] elements	Example
File	Generate INPUT[type=file] elements	Example
Date	Generate INPUT[type=date] elements	Example
Numeric	Generate INPUT[type=number] elements	Example
Submit	Generate INPUT[type=submit] elements	Example

Event Callbacks

Whenever forms are implemented as classes, the callbacks: beforeValidation and afterValidation can be implemented in the form’s class to perform pre-validations and post-validations:

class ContactForm extends Phalcon\Mvc\Form
{
    public function beforeValidation()
    {

    }
}

Rendering Forms

You can render the form with total flexibility, the following example shows how to render each element using an standard procedure:

<?php

<form method="post">
    <?php
        //Traverse the form
        foreach ($form as $element) {

            //Get any generated messages for the current element
            $messages = $form->getMessagesFor($element->getName());

            if (count($messages)) {
                //Print each element
                echo '<div class="messages">';
                foreach ($messages as $message) {
                    echo $message;
                }
                echo '</div>';
            }

            echo '<p>';
            echo '<label for="', $element->getName(), '">', $element->getLabel(), '</label>';
            echo $element;
            echo '</p>';

        }
    ?>
    <input type="submit" value="Send"/>
</form>

Or reuse the logic in your form class:

class ContactForm extends Phalcon\Forms\Form
{
    public function initialize()
    {
        //...
    }

    public function renderDecorated($name)
    {
        $element = $this->get($name);

        //Get any generated messages for the current element
        $messages = $this->getMessagesFor($element->getName());

        if (count($messages)) {
            //Print each element
            echo '<div class="messages">';
            foreach ($messages as $message) {
                echo $this->flash->error($message);
            }
            echo '</div>';
        }

        echo '<p>';
        echo '<label for="', $element->getName(), '">', $element->getLabel(), '</label>';
        echo $element;
        echo '</p>';
    }

}

In the view:

echo $element->renderDecorated('name');

echo $element->renderDecorated('telephone');

Creating Form Elements

In addition to the form elements provided by Phalcon you can create your own custom elements:

use Phalcon\Forms\Element;

class MyElement extends Element
{
    public function render($attributes=null)
    {
        $html = //... produce some html
        return $html;
    }
}

Forms Manager

This component provides a forms manager that can be used by the developer to register forms and access them via the service locator:

$di['forms'] = function() {
    return new Phalcon\Forms\Manager();
};

Forms are added to the forms manager and referenced by a unique name:

$this->forms->set('login', new LoginForm());

Using the unique name, forms can be accessed in any part of the application:

echo $this->forms->get('login')->render();

External Resources

• Vökuró, is a sample application that uses the forms builder to create and manage forms, [Github]