Forms

    Phalcon\Forms\Form is a component that helps with the creation and maintenance of forms in web applications.

    The following example shows its basic usage:

    Forms can be rendered based on the form definition:

    2.     Contacts
    3. </h1>
    5. <form method='post'>
    7.     <p>
    8.         <label>
    9.             Name
    10.         </label>
    12.         <?php echo $form->render('name'); ?>
    13.     </p>
    15.     <p>
    16.         <label>
    17.             Telephone
    18.         </label>
    20.         <?php echo $form->render('telephone'); ?>
    21.     </p>
    23.     <p>
    24.         <label>
    25.             Type
    26.         </label>
    28.         <?php echo $form->render('telephoneType'); ?>
    29.     </p>
    31.     <p>
    32.         <input type='submit' value='Save' />
    33.     </p>
    35. </form>

    Each element in the form can be rendered as required by the developer. Internally, is used to produce the correct HTML for each element and you can pass additional HTML attributes as the second parameter of render():

    1. <p>
    2.     <label>
    3.         Name
    4.     </label>
    6.     <?php echo $form->render('name', ['maxlength' => 30, 'placeholder' => 'Type your name']); ?>
    7. </p>

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

    1. <?php
    3. $form->add(
    4.     new Text(
    5.         'name',
    6.         [
    7.             'maxlength'   => 30,
    8.             'placeholder' => 'Type your name',
    9.         ]
    10.     )
    11. );

    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:

    1. <?php
    3. use Phalcon\Forms\Form;
    4. use Phalcon\Forms\Element\Text;
    5. use Phalcon\Forms\Element\Select;
    7. class ContactForm extends Form
    8. {
    9.     public function initialize()
    10.     {
    11.         $this->add(
    12.             new Text(
    13.                 'name'
    14.             )
    15.         );
    17.         $this->add(
    18.             new Text(
    19.                 'telephone'
    20.             )
    21.         );
    23.         $this->add(
    24.             new Select(
    25.                 'telephoneType',
    26.                 TelephoneTypes::find(),
    27.                 [
    28.                     'using' => [
    29.                         'id',
    30.                         'name',
    31.                     ],
    32.                     'useEmpty'   => true,
    33.                     'emptyText'  => 'Select one...',
    34.                     'emptyValue' => '',
    35.                 ]
    36.             )
    37.         );
    38.     }
    39. }

    Additionally, the Select elements support the useEmpty option to enable the use of a blank element within the list of available options. The options emptyText and emptyValue are optional, which allow you to customize, respectively, the text and the value of the empty element

    extends Phalcon\Di\Injectable so you have access to the application services if needed:

    1. <?php
    3. use Phalcon\Forms\Form;
    4. use Phalcon\Forms\Element\Text;
    5. use Phalcon\Forms\Element\Hidden;
    7. class ContactForm extends Form
    8. {
    9.     /**
    10.      * This method returns the default value for field 'csrf'
    11.      */
    12.     public function getCsrf()
    13.     {
    14.         return $this->security->getToken();
    15.     }
    17.     public function initialize()
    18.     {
    19.         // Set the same form as entity
    20.         $this->setEntity($this);
    22.         // Add a text element to capture the 'email'
    23.         $this->add(
    24.             new Text(
    25.                 'email'
    26.             )
    27.         );
    29.         // Add a text element to put a hidden CSRF
    30.         $this->add(
    31.             new Hidden(
    32.                 'csrf'
    33.             )
    34.         );
    35.     }
    36. }

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

    1. <?php
    3. use Phalcon\Forms\Form;
    4. use Phalcon\Forms\Element\Text;
    5. use Phalcon\Forms\Element\Hidden;
    7. class UsersForm extends Form
    8.     /**
    9.      * Forms initializer
    10.      */
    11.     public function initialize(Users $user, array $options)
    12.     {
    13.         if ($options['edit']) {
    14.             $this->add(
    15.                 new Hidden(
    16.                     'id'
    18.             );
    19.         } else {
    20.             $this->add(
    21.                 new Text(
    22.                     'id'
    23.                 )
    24.             );
    25.         }
    27.         $this->add(
    28.             new Text(
    29.                 'name'
    30.             )
    31.         );
    32.     }
    33. }

    In the form’s instantiation you must use:

    1. <?php
    3. $form = new UsersForm(
    4.     new Users(),
    5.     [
    6.         'edit' => true,
    7.     ]
    8. );

    Validation

    1. <?php
    3. use Phalcon\Forms\Element\Text;
    4. use Phalcon\Validation\Validator\PresenceOf;
    5. use Phalcon\Validation\Validator\StringLength;
    7. $name = new Text(
    8.     'name'
    9. );
    11. $name->addValidator(
    12.     new PresenceOf(
    13.         [
    14.             'message' => 'The name is required',
    15.         ]
    16.     )
    17. );
    19. $name->addValidator(
    20.     new StringLength(
    21.         [
    22.             'min'            => 10,
    23.             'messageMinimum' => 'The name is too short',
    24.         ]
    25.     )
    26. );
    28. $form->add($name);

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

    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:

    1. <?php
    3. $messages = $form->getMessages(false);
    5. foreach ($messages as $attribute => $messages) {
    6.     echo 'Messages generated by ', $attribute, ':', "\n";
    8.     foreach ($messages as $message) {
    9.         echo $message, '<br>';
    10.     }
    11. }

    Or get specific messages for an element:

    1. <?php
    3. $messages = $form->getMessagesFor('name');
    5. foreach ($messages as $message) {
    6.     echo $message, '<br>';
    7. }

    A form is also able to filter data before it is validated. You can set filters in each element:

    1. <?php
    3. use Phalcon\Forms\Element\Text;
    5. $name = new Text(
    6.     'name'
    7. );
    9. // Set multiple filters
    10. $name->setFilters(
    11.     [
    12.         'string',
    13.         'trim',
    14.     ]
    15. );
    17. $form->add($name);
    19. $email = new Text(
    20.     'email'
    21. );
    23. // Set one filter
    24. $email->setFilters(
    25.     'email'
    26. );
    28. $form->add($email);

    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:

    1. <?php
    3. $robot = Robots::findFirst();
    5. $form = new Form($robot);
    7. $form->add(
    8.     new Text(
    9.         'name'
    10.     )
    11. );
    13. $form->add(
    14.     new Text(
    15.         'year'
    16.     )
    17. );

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

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

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

    1. <?php
    3. $form->bind($_POST, $robot);
    5. // Check if the form is valid
    6. if ($form->isValid()) {
    7.     // Save the entity
    8.     $robot->save();
    9. }

    Setting up a plain class as entity also is possible:

    1. <?php
    3. class Preferences
    4. {
    5.     public $timezone = 'Europe/Amsterdam';
    7.     public $receiveEmails = 'No';
    8. }
    1. <?php
    3. $form = new Form(
    4. );
    6. $form->add(
    7.     new Select(
    8.         'timezone',
    9.         [
    10.             'America/New_York'  => 'New York',
    11.             'Europe/Amsterdam'  => 'Amsterdam',
    12.             'America/Sao_Paulo' => 'Sao Paulo',
    13.             'Asia/Tokyo'        => 'Tokyo',
    14.         ]
    16. );
    18. $form->add(
    19.     new Select(
    20.         'receiveEmails',
    21.         [
    22.             'Yes' => 'Yes, please!',
    23.             'No'  => 'No, thanks',
    24.         ]
    25.     )
    26. );

    Entities can implement getters, which have a higher precedence than public properties. These methods give you more freedom to produce values:

    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:

    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:

    1. <?php
    3. use Phalcon\Forms\Form;
    5. class ContactForm extends Form
    6. {
    7.     public function beforeValidation()
    8.     {
    10.     }
    11. }

    Rendering Forms

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

    1. <?php
    3. <form method='post'>
    4.     <?php
    6.         // Traverse the form
    7.         foreach ($form as $element) {
    8.             // Get any generated messages for the current element
    9.             $messages = $form->getMessagesFor(
    10.                 $element->getName()
    11.             );
    13.             if (count($messages)) {
    14.                 // Print each element
    15.                 echo '<div class='messages'>';
    17.                 foreach ($messages as $message) {
    18.                     echo $message;
    19.                 }
    21.                 echo '</div>';
    22.             }
    24.             echo '<p>';
    26.             echo '<label for='', $element->getName(), ''>', $element->getLabel(), '</label>';
    28.             echo $element;
    30.             echo '</p>';
    31.         }
    33.     ?>
    35.     <input type='submit' value='Send' />
    36. </form>

    Or reuse the logic in your form class:

    1. <?php
    3. use Phalcon\Forms\Form;
    5. class ContactForm extends Form
    6. {
    7.     public function initialize()
    8.     {
    9.         // ...
    10.     }
    12.     public function renderDecorated($name)
    13.     {
    14.         $element  = $this->get($name);
    16.         // Get any generated messages for the current element
    17.         $messages = $this->getMessagesFor(
    18.             $element->getName()
    19.         );
    21.         if (count($messages)) {
    22.             // Print each element
    23.             echo "<div class='messages'>";
    25.             foreach ($messages as $message) {
    26.                 echo $this->flash->error($message);
    27.             }
    29.             echo '</div>';
    30.         }
    32.         echo '<p>';
    34.         echo '<label for="', $element->getName(), '">', $element->getLabel(), '</label>';
    36.         echo $element;
    38.         echo '</p>';
    39.     }
    40. }

    In the view:

    1. <?php
    3. echo $element->renderDecorated('name');
    5. echo $element->renderDecorated('telephone');

    Creating Form Elements

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

    1. <?php
    3. use Phalcon\Forms\Element;
    5. class MyElement extends Element
    6. {
    7.     public function render($attributes = null)
    8.     {
    9.         $html = // ... Produce some HTML
    11.         return $html;
    12.     }
    13. }

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

    1. <?php
    3. use Phalcon\Forms\Manager as FormsManager;
    5. $di['forms'] = function () {
    6.     return new FormsManager();
    7. };

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

    1. <?php
    3. $this->forms->set(
    4.     'login',
    5.     new LoginForm()
    6. );

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

    1. <?php
    3. $loginForm = $this->forms->get('login');
    5. echo $loginForm->render();

    External Resources