FuelPHP - Programación avanzada de formularios

FuelPHP proporciona una programación de formularios avanzada a través de las clases Fieldset y Fieldset_Field. Fieldsetproporciona una forma orientada a objetos para crear un formulario. Tiene soporte completo para modelos. También tiene soporte incorporado para la validación del lado del cliente y del lado del servidor. Para crear un formulario completo, es suficiente crear un modelo con el formulario y la configuración de validación adecuados. Aprendamos sobre la clase Fieldset y cómo crear un formulario usándolo en este capítulo.

Fieldset

Fieldset es una colección de Fieldset_Fieldobjetos. Fieldset_Field define la entrada individual de un formulario como nombre, apellido, etc. junto con validaciones. La clase Fieldset tiene métodos para agregar / editar / eliminar campos. Tiene opciones para identificar los campos definidos en un modelo y crear los campos a partir del modelo dado.Fieldsetusa las clases Form y Validation en segundo plano para hacer el trabajo real. Veamos algunos de los métodos importantes de la clase Fieldset.

fragua

forgecrea una nueva instancia de Fieldset. Tiene los siguientes dos parámetros:

  • $name - identificador del conjunto de campos

  • $config- matriz de configuración. Las opciones posibles son validation_instance y form_instance. validation_instance puede tener un objeto Validation y form_instance puede tener un objeto Form.

$employee_form = Fieldset::forge('employee');

ejemplo

instance devuelve la instancia de Fieldset creada anteriormente por identificador.

$employee_form = Fieldset::instance('employee');

get_name

Obtiene el identificador de la instancia del conjunto de campos.

$employee_form = Fieldset::forge('employee'); 
$name = $employee_form->get_name();

añadir

addcrea una nueva instancia de Fieldset_Field y la agrega al fieldset actual. Contiene los siguientes cuatro parámetros,

  • $name - nombre del campo

  • $label - etiqueta para el campo

  • $attributes - atributos de etiqueta HTML

  • $rules - reglas de validación

$employee_field = $employee_form-> add (
   'employee_lastname', 
   'Lastname', 
   array ('class' => 'pretty_input')
);  

// with validation rules 
$employee_form->add ( 
   'email', 'E-mail', 
   array('type' => 'email', 'class' => 'pretty_input'), 
   array('required', 'valid_email') 
);

add_before

add_before es similar a add, excepto que tiene un parámetro adicional para especificar el campo antes del cual se agregará el campo recién creado.

$employee_form->add_before (
   'employee_firstname', 
   'Firstname', 
   array ('class' => 'pretty_input'), 
   array(), 
   'employee_lastname'
);

Eliminar

delete elimina el campo especificado del conjunto de campos.

$employee_form->delete('employee_firstname');

campo

field obtiene todos los campos o el especificado del conjunto de campos.

$fields = $employee_form->field(); 
$lastname_field = $employee_form->field('employee_lastname');

construir

buildes el alias de $ this-> form () -> build () . Genera el marcado HTML del formulario.

$employee_form->build(Uri::create('employee/add'));

habilitar

enable vuelve a habilitar un campo que ha sido previamente inhabilitado.

$employee_form->enable('employee_firstname');

inhabilitar

disable permite deshabilitar la construcción de un campo en el conjunto de campos.

$employee_form->disable('employee_firstname');

formar

form devuelve la instancia de formulario del conjunto de campos actual.

$form = employee_form->form();

add_model

add_model agrega el campo del modelo al conjunto de campos. Tiene los siguientes tres parámetros,

  • $class - nombre de la clase

  • $instance - instancia de la clase para completar los campos con valor

  • $method- nombre del método en la clase. Este método se utiliza para agregar campos al conjunto de campos. Orm \ Model tiene el método requerido. El nombre del método predeterminado es set_form_fields.

$employee_form = Fieldset::forge('employee'); 
$employee_form->add_model('Model_Employee');

poblar

populate establece el valor inicial de los campos en fieldset usando la instancia del modelo.

$emp = new Model_Employee(); 
$emp->name = "Jon"; 
$employee_form->populate($emp);

repoblar

repopulate es lo mismo que rellenar, excepto que vuelve a rellenar los campos del conjunto de campos.

validación

validation obtiene la instancia de validación del conjunto de campos actual.

$validation = $employee_form->validation();

validado

Alias ​​para $ this-> validation () -> validated ().

input

Alias ​​para $ this-> validation () -> input ().

error

Alias ​​para $ this-> validation () -> error ().

show_errors

Alias ​​para $ this-> validation () -> show_errors ().

Ejemplo de trabajo

Creemos un formulario avanzado para agregar un nuevo empleado en nuestra aplicación de empleado de muestra usando la clase Fieldset.

Modelo de actualización

Actualice el modelo de empleado con las reglas de validación necesarias y agregue un observador de validación de la siguiente manera.

<?php  
   class Model_Employee extends Orm\Model { 
      protected static $_connection = 'production'; 
      protected static $_table_name = 'employee'; 
      protected static $_primary_key = array('id'); 
      
      protected static $_properties = array ( 
         'id',  
         'name' => array ( 
            'data_type' => 'varchar',
            'label' => 'Employee Name', 
            'validation' => array ( 
               'required',  
               'min_length' => array(3),  
               'max_length' => array(80) 
            ), 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
         'age' => array ( 
            'data_type' => 'int', 
            'label' => 'Employee Age', 
            'validation' => array ( 
               'required',  
            ), 
            'form' => array ('type' => 'text' ), 
         ), 
      );  
      
      // Just add the Observer, and define the required event 
      protected static $_observers = array('Orm\\Observer_Validation' => array ( 
         'events' => array('before_save'))); 
   }

Aquí, hemos definido las reglas de validación para los campos de nombre y edad y hemos agregado un nuevo observador para realizar la validación del lado del servidor antes de guardar el modelo en la base de datos. La misma regla de validación creará los atributos de validación de entrada necesarios también en el formulario.

Crear formulario

Cree una nueva acción, action_advancedform en el controlador de empleados de la siguiente manera.

public function action_advancedform() { 
   
   // create a new fieldset and add employee model
   $fieldset = Fieldset::forge('employee')->add_model('Model_Employee');  
   
   // get form from fieldset 
   $form = $fieldset->form();  
   
   // add submit button to the form 
   $form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit'));  
   
   // build the form  and set the current page as action  
   $formHtml = $fieldset->build(Uri::create('employee/advancedform'));  
   
   // set form in data 
   $data = array(); 
   $data['form'] = $formHtml;  
   return Response::forge(View::forge('employee/advancedform', $data, false)); 
}

Aquí, hemos creado el formulario usando fieldset y enviamos el formulario a la vista. A continuación, agregue una vista para la acción,fuel/app/views/employee/advancedform.php como sigue.

<!DOCTYPE html> 
<html lang = "en"> 
   
   <head> 
      <title>Employee :: add page</title> 
      <meta charset = "utf-8"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1"> 
      <?php echo Asset::css('bootstrap.css'); ?> 
      
      <style>  
         table { 
            width: 90%; 
         }  
         table tr { 
            width: 90% 
         }
         table tr td { 
            width: 50% 
         }  
         input[type = text], select { 
            width: 100%; 
            padding: 12px 20px; 
            margin: 8px 0; 
            display: inline-block; 
            border: 1px solid #ccc; 
            border-radius: 4px; 
            box-sizing: border-box; 
         }  
         input[type = submit] { 
            width: 100%; 
            background-color: #3c3c3c; 
            color: white; 
            padding: 14px 20px; 
            margin: 8px 0; 
            border: none; 
            border-radius: 4px; 
            cursor: pointer; 
         }  
         div { 
            border-radius: 5px; 
            background-color: #f2f2f2; 
            padding: 20px; 
         } 
      </style> 
   </head> 
   
   <body> 
      <div class = "container"> 
         <?php
            if(isset($errors)) { 
               echo $errors; 
            } 
            echo $form; 
         ?> 
      </div> 
   </body> 
   
</html>

Ahora, solicitando la página http://localhost:8080/employee/add mostrará el siguiente formulario.

Formulario de proceso

Actualice el método de acción, action_advancedform para procesar el formulario y agregue los datos del empleado ingresados ​​por el usuario en la base de datos en el controlador de empleados de la siguiente manera.

public function action_advancedform() { 
   
   // create a new fieldset and add employee model 
   $fieldset = Fieldset::forge('employee')->add_model('Model_Employee');  
   
   // get form from fieldset 
   $form = $fieldset->form();  
   
   // add submit button to the form 
   $form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit')); 
   
   // build the form  and set the current page as action  
   $formHtml = $fieldset->build(Uri::create('employee/advancedform'));  
   
   if (Input::param() != array()) { 
      try { 
         $article = Model_Employee::forge(); 
         $article->name = Input::param('name'); 
         $article->url = Input::param('age'); 
         $article->save(); 
         Response::redirect('employee/list'); 
      
      } 
      catch (Orm\ValidationFailed $e) { 
         $view = View::forge('employee/advancedform'); 
         $view->set('form', $formHtml, false); 
         $view->set('errors', $e->getMessage(), false); 
      } 
   } 
   
   return Response::forge($view); 
}

Aquí, hemos sido redirigidos a la página de lista de empleados, una vez que los datos ingresados ​​por el usuario se validan y guardan en la base de datos. De lo contrario, se nos volverá a mostrar el formulario.

Crea el formulario

Ahora, solicite la URL, http://localhost:8080/employee/adde ingrese algunos datos del empleado y envíe el formulario. Si no se proporcionan los datos, el formulario le pedirá al usuario que ingrese los datos como se muestra en la siguiente captura de pantalla.

Si el usuario omite la validación del lado del cliente, el servidor validará el formulario y mostrará un error como se muestra en la siguiente captura de pantalla.

Si los datos pasaron la validación del lado del cliente y del servidor, los datos del empleado se guardarán en la base de datos y la página se redirigirá a la página de lista.