Introducción

Hoy veremos un ejemplo de modelo en CodeIgniter 3 para ver cómo podemos crearlo, además de las ventajas que tiene y las responsabilidades que le podemos asignar.

En CodeIgniter, un modelo representa un objeto o una entidad dentro de nuestro sistema. Por ejemplo, podemos tener el modelo Usuario, Venta, Recibo, Mascota, etcétera. Es como una clase (técnicamente sí es una clase, pero me refiero al modo de abstraerlo) que se comunica con un controlador.

Lecturas recomendadas para aprender CodeIgniter

Te recomiendo leer:

• Cómo empezar un proyecto de CI
• Configurar base de datos MySQL con PDO en CodeIgniter
• Controladores en CodeIgniter

Ubicación de los modelos

Todos los modelos que creemos van dentro de application/models. Dentro de esa carpeta creamos modelos, que no son más que clases PHP que extienden de CI_model.

Igual podemos crear subcarpetas para organizar nuestros modelos de mejor manera.

Nomenclatura de los modelos

Recomiendo poner el nombre de la entidad seguida de Model. Por ejemplo, si la entidad es Producto entonces se llamaría ProductoModel, y por lo tanto la clase también tendría ese nombre.

Ejemplo de modelo

Justo ahora estoy haciendo un sistema de ventas como el que ya hicimos la vez pasada con PHP puro, pero con CI (lo publicaré pronto, de hecho ya está en GitHub). Tengo el modelo producto, que se ve así:

<?php
    class ProductoModel extends CI_Model{
        public $id;
        public $codigo;
        public $descripcion;
        public $precioVenta;
        public $precioCompra;
        public $existencia;
        public function __construct(){
            $this->load->database();
        }
        public function nuevo($codigo, $descripcion, $precioVenta, $precioCompra, $existencia){
            $this->codigo = $codigo;
            $this->descripcion = $descripcion;
            $this->precioVenta = $precioVenta;
            $this->precioCompra = $precioCompra;
            $this->existencia = $existencia;
            return $this->db->insert('productos', $this);
        }
        public function guardarCambios($id, $codigo, $descripcion, $precioVenta, $precioCompra, $existencia){
            $this->id = $id;
            $this->codigo = $codigo;
            $this->descripcion = $descripcion;
            $this->precioVenta = $precioVenta;
            $this->precioCompra = $precioCompra;
            $this->existencia = $existencia;
            return $this->db->update('productos', $this, array("id" => $id));
        }
        public function todos(){
            return $this->db->get("productos")->result();
        }
        public function eliminar($id){
            return $this->db->delete("productos", array("id" => $id));
        }
        public function uno($id){
            return $this->db->get_where("productos", array("id" => $id))->row();
        }
        public function porCodigoDeBarras($codigoDeBarras){
            return $this->db->get_where("productos", array("codigo" => $codigoDeBarras))->row();
        }
    }
?>

Analiza el código y aquí lo vamos a explorar.

Extender a CI_model

Vemos que nuestros modelos son una clase que extiende a la clase CI_model, esto es para que herede las propiedades que permiten cargar librerías o bases de datos.

El constructor

Podemos aprovechar la programación orientada a objetos para hacer determinadas cosas en nuestro modelo. En mi caso cargo la base de datos para ahorrar cargarla en todos mis métodos.

Esto lo hago porque en todos mis métodos interactúo con la base de datos, pero si la cargamos sin usarla es un desperdicio.

Por cierto, podemos cargarla igualmente dentro de cada método, o en aquellos en donde la usemos.

Las propiedades

Como toda clase, tiene propiedades o miembros. Es importante definir esto porque:

• El programador que lea nuestro modelo sabrá qué se hace en ese modelo, y cuáles propiedades tiene la entidad
• Evitamos definir propiedades en tiempo de ejecución

Además, esto permite mandar el objeto al insertarlo, como veremos más adelante.

Los métodos

Una clase define métodos o funciones. Deben ser métodos relacionados con la misma; por ejemplo, si tenemos a la clase Mascota podemos tener al método comer.

Del mismo modo, ahora tenemos a la clase Producto. Un producto se vende o se elimina, pero aquí es cuando entra algo de confusión porque… ¿un producto se inserta? es un poco ambiguo.

Por eso es que no debemos ver a los modelos como una clase, sino como un modelo; que se encarga de gestionar la lógica de una entidad.

La protección de métodos

Como en toda clase, podemos definir métodos públicos o privados y esas cosas. Es sólo un aviso, puede que haya métodos que sólo usemos dentro de la clase pero no permitamos que se accedan desde afuera.

La base de datos

Esto no es una regla, pero la mayoría de veces un modelo gestiona lo que se hace dentro de la base de datos. Aquí vemos algo bueno en el método nuevo y guardarCambios, pues mandamos a $this en lugar de un arreglo o en lugar de hacer la consulta a mano.

Esto es gracias al query builder de CodeIgniter, el cual recibe un objeto con las columnas como claves y los datos como valores. De esta forma recibimos datos, los establecemos en el objeto y finalmente insertamos; así de simple y sencillo: nada de escribir consultas a mano.

Llamada a un modelo

Los modelos se llaman desde los controladores. Este post habla sobre modelos, no sobre controladores. Pero para dar un ejemplo, en un controlador podemos cargar un modelo así:

<?php
$this->load->model("ProductoModel");

# Ahora ya podemos usarlo
$this->ProductoModel->eliminar(1);

Y recordemos que el controlador se encarga de comunicarse con el usuario. Por ejemplo, puede recibir datos de un formulario, validarlos si es necesario y finalmente pasárselos al modelo.

Nota: no le asignes mucho trabajo al modelo; por ejemplo, deja la validación en los controladores para que los modelos solamente se encarguen de guardar datos.

Conclusión

Así es más o menos la anatomía de un modelo en CodeIgniter 3. Puedes basarte en este para tus próximos proyectos, y modificarlo a tu gusto y necesidades.