FuelPHP - Modelos y base de datos

El modelo juega un papel importante en el marco web FuelPHP. Representa a las entidades comerciales de la aplicación. Los proporcionan los clientes o se obtienen de la base de datos de backend, se manipulan de acuerdo con las reglas comerciales y se conservan en la base de datos. Aprendamos sobre los modelos y cómo interactúan con el sistema de back-end en este capítulo.

Creando un modelo

En FuelPHP, el modelo es simplemente una clase PHP simple que extiende la clase Model incorporada. Por defecto, los modelos pueden tener el prefijo Model_ similar a los controladores y deben colocarse enfuel/app/classes/model/carpeta. Creemos un modelo de empleado básico y ampliémoslo a medida que avanzamos.

fuel / app / classes / model / employee.php

<?php 
   namespace Model; 

   class Model_Employee extends \Model { 
      public static function fetchAll() { 
         // Code to fetch employee from database 
      } 
   }

Acceder a un modelo

Una vez que se define un modelo, se puede usar libremente en cualquier controlador con solo incluirlo en el controlador de la siguiente manera.

use \Model\Employee; 

class Controller_Employee extends Controller { 
   public function action_index() { 
      $employees = Employee::fetchAll(); 
   } 
}

Descripción general de la base de datos

FuelPHP proporciona su propia capa de abstracción de la base de datos para obtener datos de la base de datos. Proporciona una herramienta basada en ORM tanto básica como avanzada. El kit de herramientas básico consta de clases basadas en DB, DBUtil y Query_Builer. El conjunto de herramientas avanzado es Orm. El kit de herramientas de Orm se deriva del kit de herramientas básico y se incluye como un paquete separado.

Configuración de la base de datos

FuelPHP separa la configuración de la base de datos del archivo de configuración principal y el archivo es fuel/app/config/db.php. Admite una configuración separada para cada entorno. Actualmente, FuelPHP admite controladores MySQL, MySQLi y PDO. La configuración de muestra es la siguiente:

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'    => 'localhost', 
            'port'        => '3306', 
            'database'    => 'tutorialspoint_fueldb', 
            'username'    => 'root', 
            'password'    => 'password', 
            'persistent'  => false, 
            'compress'    => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   )

Kit de herramientas basado en DB

los DB classes la opción más sencilla para acceder a la base de datos desde la aplicación. Proporciona opciones para crear la consulta de la base de datos, ejecutarla en la base de datos de destino y, finalmente, recuperar el resultado. La clase DB interactúa con las siguientes clases y proporciona una API de base de datos completa.

Database_Connection - Singleton y clase principal para interactuar con la base de datos
Database_Query - Clase base, concreta para ejecutar la consulta SQL y obtener el resultado
Database_Query_Builder - Clase base, abstracta para construir consultas SQL
Database_Query_Builder_Join - Clase para construir uniones SQL
Database_Query_Builder_Where - Clase abstracta para construir condiciones de consulta SQL
Database_Query_Builder_Select - Clase concreta para construir una consulta de selección SQL
Database_Query_Builder_Insert - Clase abstracta para construir una consulta de inserción SQL
Database_Query_Builder_Update - Clase abstracta para construir consultas de actualización SQL
Database_Query_Builder_Delete - Clase abstracta para construir consultas de eliminación SQL

El siguiente diagrama muestra la relación entre las clases y los métodos proporcionados por las clases.

API de base de datos

Aprendamos los métodos más importantes disponibles en la clase DB en esta sección.

ejemplo

Purpose- Crea y devuelve la nueva instancia de Database_Connection .
Parameter -
- $db - Nombre de la conexión a la base de datos definido en el archivo de configuración, opcional.
Returns- Devuelve el objeto Database_Connection

Por ejemplo,

$db = DB::instance(); 
$db = DB::instance('test');

consulta

Purpose - Prepara la declaración SQL proporcionada y devuelve el objeto Database_Query, que se puede usar para insertar, actualizar, eliminar o recuperar los datos de la base de datos.
Parameter -
- $query - instrucción SQL, puede contener marcadores de posición;
- $type - Tipo SQL, opcional (DB :: SELECT, DB :: INSERT, DB :: UPDATE y DB :: DELETE)
Returns- Devuelve el objeto Database_Query

Por ejemplo,

$query = DB::query('SELECT * FROM 'employees'');

last_query

Purpose - Para obtener la última consulta ejecutada
Parameter - Ninguno
Returns - Devuelve la última consulta ejecutada

Por ejemplo,

$employees = DB::Select('Select * from 'employee''); 
$sql = DB::last_query();

Seleccione

Purpose - Generar la parte seleccionada de la consulta
Parameter -
- $columns - Lista de los nombres de las columnas de la base de datos
Returns - Devuelve el objeto Database_Query_Builder_Select

Por ejemplo,

$query = DB::select();              // Select *
$query = DB::select('id', 'name'); // Select id, name

select_array (DB)

Es similar a seleccionar excepto que podemos enviar columnas como matriz.

$query = DB::select_array(array('id', 'name')); // Select id, name

insertar

Purpose - Generar la parte de inserción de la consulta
Parameter -
- $table_name - nombre de la tabla de la base de datos;
- $columns - matriz de columnas de la tabla
Returns - Devuelve el objeto Database_Query_Builder_Insert

Por ejemplo,

$query = DB::insert('employee');  // Insert into employee 
$query = DB::insert('employee', array('id', 'name')); // Insert into employee (id, name)

actualizar

Purpose - Generar la parte de actualización de la consulta.
Parameter -
- $table_name - nombre de la tabla de la base de datos
Returns - Devuelve el objeto Database_Query_Builder_Update

Por ejemplo,

$query = DB::update('employee'); // update `employee`

Eliminar

Purpose - Generar la parte de borrar de la consulta
Parameter -
- $table_name - nombre de la tabla de la base de datos
Returns - Devuelve el objeto Database_Query_Builder_Delete

Por ejemplo

$query = DB::delete('employee');  // delete from 'employee'

API de consulta

Database_Queryproporciona una opción para establecer la conexión a la base de datos, ejecutar la consulta y obtener el resultado como una matriz u objeto asociativo. Veamos los métodos proporcionados por la clase Database_Query.

set_connection

Purpose - Para configurar la base de datos (detalles de conexión de la base de datos) contra la cual ejecutar la consulta
Parameter - $ db - nombre de conexión a la base de datos
Returns- Devuelve el objeto Database_Query

Por ejemplo,

$query = DB::query('DELETE * FROM employee', DB::DELETE); 
$query->set_connection('2nd-db');

param

Purpose - Para establecer el valor del parámetro definido en el objeto Consulta
Parameter -
- $param - nombre del parámetro;
- $value - valor del parámetro
Returns- Devuelve el objeto Database_Query

Por ejemplo,

// set some variables
$table = 'employee';
$id = 1;
$name = 'Jon';

// don't use
$query = DB::query('SELECT * FROM '.$table.'. WHERE id = '.$id.' AND name = "'.$name.'"');

// but use
$query = DB::query('SELECT * FROM :tablename WHERE id = :id AND name = :name');
$query->param('tablename', 'employee');
$query->param('id', $id);
$query->param('name', $name);

Métodos similares

parameters es un objeto similar excepto que ofrece la opción de dar varios valores a la vez.

$query->parameters (array( 
   'tablename' => $table, 
   'id' => $id, 
   'name' => $name 
});

enlazar

Purpose - Para establecer una variable en el parámetro definido en el objeto Consulta
Parameter -
- $param - nombre del parámetro
- $var - la variable a la que enlazar el parámetro
Returns- Devuelve el objeto Database_Query

Por ejemplo,

// bind a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->bind('tablename', $table);  

// update the variable 
$table = 'employee_salary'; 

// DELETE * FROM `employee_salary`; 
$sql = $query->compile();

compilar

Purpose - Para compilar el objeto de consulta definido en una consulta SQL
Parameter -
- $db - cadena de conexión, opcional
Returns -

Por ejemplo,

// assign a value to a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->param('tablename', $table);

// compile the query, returns: DELETE * FROM employee 
$sql = $query->compile();

ejecutar

Purpose - Ejecutar la consulta definida en el objeto Consulta y devolver el resultado
Parameter -
- $db - nombre de conexión a la base de datos
Returns - Devuelve el resultado

Por ejemplo,

// assign a value to a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->param('tablename', $table);  

// execute the query 
$query->execute();

as_assoc

Purpose - Para establecer el tipo de retorno como matriz asociativa en lugar de objetos
Parameter - Ninguno
Returns - Devuelve el objeto actual

Por ejemplo,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_assoc()->execute(); 
foreach ($result as $row) { 
   echo $row['id']; 
}

as_object

Purpose - Para establecer el tipo de retorno como objeto en lugar de matriz asociativa
Parameter - Ninguno
Returns - Devuelve el objeto actual

Por ejemplo,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_object()->execute(); 
foreach ($result as $row) { 
   echo $row->id; 
}  

// have ORM model objects return instead 
$result = $query->as_object('Model_Employee')->execute();

API del generador de consultas

Las clases basadas en el generador de consultas (Query_Builder) proporcionan opciones para generar consultas SQL de forma dinámica. Tiene cuatro clases, cada una para seleccionar (Query_Builder_Select) , insertar (Query_Builder_Insert) , actualizar (Query_Builder_Update) y eliminar (Query_Builder_Delete) consultas. Estas clases se derivan de la clase Query_Builder_Where (opción para generar condiciones), que a su vez se deriva de Query_Builder , base de todas las clases.

Veamos los métodos proporcionados por la clase Query_Builder.

Seleccione

Purpose - Generar las columnas de consultas seleccionadas.
Parameter -
- $columns - lista de columnas, opcional
Returns - Devuelve la instancia actual

Por ejemplo,

$query = DB::select('name')  // select `name` 
$query = DB::select(array('first_name', 'name')) // select `first_name` as `name`

desde

Purpose - Para generar los detalles de la tabla de consultas seleccionadas
Parameter -
- $tables - lista de tablas
Returns - Devuelve la instancia actual

Por ejemplo,

$query = DB::select('name')->from('employee') // select `name` from `employee`

dónde

Purpose - Generar las condiciones de seleccionar, insertar y actualizar consultas
Parameters -
- $column - nombre de columna o matriz ($ columna, $ alias);
- $op - operadores lógicos, =,! =, IN, BETWEEN y LIKE, opcional;
- $value - valor de columna
Returns - Devuelve la instancia actual

Por ejemplo,

$query = DB::select('name')->from('employee')  
$query = $query->where('name', '=', 'Jon'); 
// select `name` from `employee` where `name` = `Jon`;

Métodos similares

Los métodos similares son where_open (), and_where_open (), or_where_open (), where_close (), and_where_close (), or_where_close (). Son similares a los métodos where () excepto que añaden palabras clave adicionales y corchetes alrededor de las condiciones. A continuación se muestra un código de muestra.

$query = DB::select('*')->from('employee');  
$query->where('email', 'like', '%@gmail.com'); 
$query->or_where_open(); 
$query->where('name', 'Jon'); 
$query->and_where('surname', 'Peter');
$query->or_where_close();  
// SELECT * FROM `employee` WHERE `email` LIKE "%gmail.com" OR 
   (`name` = "Jon" AND `surname` = "Peter")

unirse

Purpose - Para generar las combinaciones de tablas de consultas seleccionadas
Parameters -
- $table - nombre de la tabla o matriz ($ tabla, $ alias);
- $type - tipo de unión (IZQUIERDA, DERECHA, INTERIOR, etc.,)
Returns - Devuelve la instancia actual

Ejemplo

$query = DB::select('name')->from('employee')->join('employee_salary') 
// select `name` from `employee` JOIN `employee_salary`

en

Purpose - Generar la condición de uniones en consultas seleccionadas
Parameters -
- $c1 - nombre de tabla o nombre de tabla con alias en matriz;
- $op - operador lógico;
- $c2 - nombre de tabla o nombre de tabla con alias en matriz
Returns - Devuelve la instancia actual

Por ejemplo,

$query = DB::select('name')->from('employee')->join('employee_salary') 
$query = $query->on('employee.employee_id', '=', 'employee_salary.employee_id') 
// select `name` from `employee` JOIN `employee_salary` on 
// `employee.employee_id` = `employee_salary.employee_id`

Métodos similares

Los métodos relacionados son and_on () y or_on (). Son similares a on () excepto que agregan palabras clave adicionales y corchetes alrededor de las combinaciones.

agrupar por

Purpose - Generar grupo por consultas
Parameter - $columns - Nombre de la columna por la que agrupar el resultado
Returns - Devuelve la instancia actual

Por ejemplo,

$query = DB::select('name')->from('employee')  
$query = $query->group_by('name'); 
// select `name` from `employee` group by `name`

teniendo

Purpose - Generar el grupo por condiciones de consultas SQL
Parameter - $column - nombre de columna o matriz ($ columna, $ alias); $op - operadores lógicos, =,! =, IN, BETWEEN y LIKE, opcional; $value - valor de columna
Returns - Devuelve la instancia actual

Ejemplo

$query = DB::select('name')->from('employee')
$query = $query->group_by('name');
$query = $query->having('name', '!=', 'Jon');
// select `name` from `employee` group by `name` having `name` != `Jon`

Métodos similares

Los métodos similares son have_open (), and_having_open (), or_having_open (), having_close (), and_having_close () o_having_close (). Son similares a los métodos have () excepto que agregan palabras clave adicionales y corchetes alrededor de las condiciones.

Reiniciar

Purpose - Para resetear la consulta
Parameter - Ninguno
Returns - Devuelve la instancia actual

Por ejemplo,

$query = DB::select('name')->from('employee')  
$query->reset() 
$query = DB::select('name')->from('employee_salary') 
// select `name` from `employee_salary`

Clase DBUtil

La clase DBUtil proporciona una opción para administrar y realizar operaciones de base de datos de rutina. Algunos de los métodos importantes son los siguientes:

set_connection: establece la conexión predeterminada

DBUtil::set_connection('new_database');

create_database: crea una base de datos.

DBUtil::create_database('my_database');

drop_database: elimina una base de datos.

DBUtil::drop_database('my_database');

table_exists: comprueba si existe una tabla determinada.

if(DBUtil::table_exists('my_table')) { 
   // Table exists 
} else { 
   // Table does NOT exist, create it! 
}

drop_table: suelta una tabla.

DBUtil::drop_table('my_table');

create_table: crea una tabla.

\DBUtil::create_table ( 
   'users', 
   array ( 
      'id' => array('type' => 'int', 'auto_increment' => true), 
      'name' => array('type' => 'text'), 
   ), 
);

Kit de herramientas de Orm

FuelPHP proporciona una capa de base de datos avanzada usando el concepto ORM basado en el popular Active record pattern. El kit de herramientas está incluido en la aplicación pero no está configurado de forma predeterminada. Se incluye como un paquete y el nombre del paquete es orm. Podemos agregar la siguiente configuración en el archivo de configuración principal,fuel/app/config/config.php para cargar el kit de herramientas de orm.

'always_load' => array ( 
   'packages' => array (
      'orm', 
   ), 
),

Creando modelos

Orm proporciona la clase de modelo base Orm \ Model. Necesitamos ampliar nuestros modelos con el modelo orm para usar las funciones ORM. A continuación se muestra un código de muestra.

class Model_Employee extends Orm\Model {}

Configuración

Orm proporciona un conjunto de opciones para configurar el modelo para utilizar las funciones de ORM. Son los siguientes:

connection- Establezca una propiedad _connection estática en el modelo para especificar el nombre de la conexión.

class Model_Employee extends Orm\Model { 
   protected static $_connection = "production"; 
}

table name- Establezca una propiedad _table_name estática en el modelo para especificar el nombre de la tabla de backend.

class Model_Employee extends Orm\Model { 
   protected static $_table_name = 'employee'; 
}

primary key- Establezca una propiedad _primary_key estática en el modelo para especificar la clave principal de la tabla de backend.

class Model_Employee extends Orm\Model { 
   protected static $_primary_key = array('id'); 
}

Columns- Establezca una propiedad _properties estática en el modelo para especificar las columnas de la tabla de back-end. Admite tipo de datos, etiqueta, validación, elementos de formulario, etc.

class Model_Employee extends Orm\Model { 
   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' 
         ), 
      ),  
   ); 
}

Conditions- Establecer una propiedad _conditions estática para establecer las condiciones y ordenar por opciones.

class Model_Employee extends Orm\Model { 
   protected static $_conditions = array ( 
      'order_by' => array('id' => 'desc'), 
      'where' => array ( 
         array('is_active', > true), 
      ), 
   ); 
}

Observers- Orm proporciona un sistema de eventos basado en observadores para agregar comportamiento a eventos específicos. Para agregar un comportamiento, primero establezca una propiedad _observers en el modelo. Luego, defina el comportamiento como una clase y configúrelo en la propiedad _observers junto con los eventos. Si no se especifica ningún evento, el comportamiento se invocará para todos los eventos. También podemos especificar comportamientos múltiples.

class Model_Employee { 
   protected static $_observers = array ( 
      'example',  // will call Observer_Example class for all events 
      'Orm\\Observer_CreatedOn' => array ( 
         'events' => array('before_insert'),  
         // will only call Orm\Observer_CreatedOn at before_insert event 
      ) 
   ); 
}

Crear

Una vez que configuramos el modelo, podemos empezar a utilizar los métodos de inmediato. Orm proporciona una parada método para guardar el objeto en la base de datos. Podemos configurar los datos usando propiedades configuradas de la siguiente manera:

// option 1 
$new = new Model_Employee(); 
$new->name = 'Jon'; 
$new->save();  

// option 2, use forge instead of new 
$new = Model_Employee::forge();
$new->name = 'Jon'; 
$new->save();  

// option 3, use array for properties 
$props = array('name' => 'Jon'); 
$new = Model_Employee::forge($props); 
$new>save();

Leer

Orm proporciona un método, buscar para obtener los datos de la base de datos y vincularlos al objeto. El método de búsqueda funciona según el parámetro de entrada. Veamos las diferentes opciones:

by primary key - Especificar la clave principal devuelve el registro haciendo coincidir la clave principal de la tabla configurada.

$employee = Model_Employee::find(1);

first / last record- Especificar 'primero' o 'último' buscará el primer registro o el último registro respectivamente. También podemos pasar el pedido por opción.

$entry = Model_Employee::find('first'); 
$entry = Model_Article::find('last', array('order_by' => 'id'));

All- Especificar 'todos' buscará todos los registros de la tabla configurada. Podemos especificar orden por opción así como condiciones.

$entry = Model_Employee::find('all');  
$entry = Model_Article::find ('all', array ( 
   'where' => array ( 
      array ('name', 'Jon'), 
   ), 
   'order_by' => array ('id' => 'desc'), 
));

Podemos usar la API de consulta del kit de herramientas de base de datos básica junto con el modelo para la opción de búsqueda avanzada de la siguiente manera.

$query = Model_Employee::query()->where('category_id', 1)->order_by('date', 'desc');
$number_of_employees = $query->count(); 
$latest_employee = $query->max('id'); 
$young_employee = $query->min('age'); 
$newest_employee = $query->get_one(); 
$employees = $query->limit(15)->get();

Actualizar

Actualizar el modelo es lo mismo que crear, excepto que en lugar de crear un nuevo modelo, simplemente busque el modelo que se actualizará usando el método de búsqueda, actualice la propiedad y luego llame al método de guardar de la siguiente manera.

$entry = Model_Employee:find(4);
$entry->name = 'Peter'; 
$entry->save();

Eliminar

Orm proporciona un método de eliminación para eliminar el modelo. Simplemente busque el objeto y llame al método de eliminación.

$entry = Model_Employee:find(4); 
$entry->delete();

Ejemplo de trabajo

Creemos un ejemplo funcional en este capítulo para comprender el modelo y la base de datos.

Crear una base de datos

Cree una nueva base de datos en el servidor MySQL, usando el siguiente comando.

create database tutorialspoint_fueldb

Luego, cree una tabla dentro de la base de datos usando el siguiente comando.

create table employee(id int primary key, name varchar(20), age int not null);

Configurar la base de datos

Configuremos la base de datos usando el archivo de configuración de la base de datos, * fuel / app / config / db.php. Agregue los siguientes cambios para conectar el servidor MySQL.

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ),  
      
      'production' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   );

Incluir paquete ORM

Actualice el archivo de configuración principal, fuel/app/config/config.php para incluir el paquete ORM agregando la siguiente configuración.

'always_load' => array ( 
   'packages' => array ( 
      'orm' 
   ), 
),

Ahora, ORM está habilitado en su aplicación

Crear modelo de empleado

Cree un nuevo modelo, Empleado en la carpeta del modelo “fuel/app/classes/model”. Se define como sigue.

Employee.php

<?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', 
            'form' => array (
               'type' => 'text' 
            ), 
         ),  
         
         'age' => array ( 
            'data_type' => 'int', 
            'label' => 'Employee Age', 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
      ); 
   }

Crear acción

Crear nueva acción action_model en Controlador de empleados ubicado en fuel/app/classes/controller/employee.php como sigue.

class Controller_Employee extends Controller { 
   public function action_model() { 
      
      // db based sql command to delete all employees 
      $query = db::query('delete from `employee`'); 
      $query->execute('production');  
      
      // orm based query to add new employees 
      $model = new model_employee(); 
      $model->name = "john"; 
      $model->age = 25; 
      $model->save();  
      $model = new model_employee(); 
      $model->name = "peter"; 
      $model->age = 20; 
      $model->save(); 
      
      // orm based query to fetch all employee data 
      $data = array(); 
      $data['emps'] = model_employee::find('all');  
      return response::forge(view::forge('employee/model', $data)); 
   } 
}

Crear vista

Ahora, cree un archivo de vista model.php situado en “fuel/app/views/employee”. Agregue los siguientes cambios en el archivo.

<ul> 
   <?php 
      foreach($emps as $emp) {  
   ?> 
   <li><?php echo $emp['name']; ?></li> 
   
   <?php 
   } 
   ?> 
</ul>

Ahora, solicite la URL, http://localhost:8080/employee/model y producirá el siguiente resultado.

Resultado

↰ Previous page Next page ↱