Mostrando entradas con la etiqueta codeigniter. Mostrar todas las entradas
Mostrando entradas con la etiqueta codeigniter. Mostrar todas las entradas

martes, 18 de diciembre de 2012

Como extender clases en CodeIgniter (II)

El otro día hablábamos de Como extender clases del modelo en CodeIgniter sin recibir el temible error "Class not found". El método comentado consistía en cargar manualmente la clase base antes que la clase hija. Desgraciadamente este método no puede usarse para los controladores pues es el propio framework el que se encarga de cargar los controladores. Afortunadamente en PHP 5 hay un método adecuado para extender cualquier clase si recibir ese fatal error: La función __autoload()

Dicha función se diseñó para evitar que los desarrolladores de aplicaciones orientadas a objetos que escriben cada clase en un fichero fuente PHP separado tuvieran que poner una larga lista de includes al comienzo de cada script. La función __autoload() es invocada automáticamente por el motor PHP (si está definida) en caso de que se intente usar una clase o interfaz que todavía no hayan sido definidos. Es como una última oportunidad.

En el caso de CodeIgniter la siguiente función cargaría automáticamente cualquier clase del controlador o del modelo.

function __autoload($class_name) {

  $class_folders = array(
    'controllers',
    'models'
  );

  foreach ($class_folders as $folder_name) {

    $full_address = APPPATH . $folder_name . '/' . strtolower($class_name) . EXT;
    if (file_exists($full_address)) {
      require_once($full_address);
    }
  }
}

Ya solamente queda poner esa función en un lugar del código fuente de la aplicación que se ejecute siempre. Algunos autores recomiendan añadirla al final del archivo de configuraciones "/application/config/config.php". Yo he probado con el fichero "/application/config/autoload.php" porque me parecía un buen sitio pero el controlador se invoca antes, con lo que no funciona.

viernes, 14 de diciembre de 2012

Como extender clases del modelo en CodeIgniter

Una de las características de la Programación Orienta a Objetos es que las clases pueden heredar características de una clase base. En el patrón de diseño MVC que implementa CodeIgniter todas las clases que usamos al diseñar nuestra aplicación derivarán de alguna clase base del framework (CI_Model, CI_Controller, etc.) pero también es posible crear nuestras propias clases base.

Para ello la clase base derivará de alguna del framework y la clase definitiva derivará de nuestra clase base. Como en el siguiente ejemplo:

class Mybaseclass_model extends CI_Model {

  public function __construct() {
    parent::__construct();
  }

  // ...
}

class Myclass_model extends Mybaseclass_model {

  public function __construct() {
    parent::__construct();
  }

  // ...
}

class Myclass2_model extends Mybaseclass_model {

  public function __construct() {
    parent::__construct();
  }

  // ...
}

El problema de hacer esto es que las diferentes clases Mybaseclass_model, Myclass_model y Myclass2_model estarán definidas en archivos distintos, con lo que al intentar cargar una de las clases derivadas nos encontraremos con el error:

Fatal error: Class 'Mybaseclass_model' not found in
W:\www\test\application\models\myclass_model.php on line 17.

Para solucionarlo es necesario cargar la clase base antes que la derivada, ya sea manualmente, como vemos abajo, a sea agregando la clase base a la carga automática de componentes del modelo en el archivo "/application/config/autoload.php"

$this->load->model('Mybaseclass_model');
$this->load->model('Myclass_model');

ACTUALIZACIÓN:

El método descrito en este artículo para extender clases del modelo sin recibir el temible error "Class not found" no es válido para extender clases del controlador, pues éstas son cargadas por el propio framework. Por suerte en PHP 5 tenemos la función __autoload() que permite extender clases del modelo y del controlador en CodeIgniter.

martes, 11 de diciembre de 2012

Tratamiento de idiomas en CodeIgniter

Siguiendo con la serie de artículos sobre la programación del framework CodeIgniter hoy hablaré de las posibilidades de CodeIgniter respecto al tratamiento de idiomas: Veremos como convertir todo el framework al español, como hacer un proyecto multiidioma y hablaremos de la clase Language y del helper Language.


Como poner CodeIgniter en Español.

CodeIgniter como la mayoría de frameworks PHP proporciona un mecanismo para poder cambiar el idioma en que se muestra un página web. Los archivos de idioma del framework se encuentran en la carpeta "/system/language/". Dentro de dicha carpeta habrá una carpeta para cada idioma: "english" para Inglés, "spanish" para español, etc. Inicialmente sólo se proporcionan traducciones para el idioma Inglés. Si queremos el framework en español tendremos que crear la carpeta "/system/language/spanish/", copiar los archivos de la versión inglesa y traducir los textos.

El formato de los archivos de idioma lo vemos en el siguiente ejemplo:

$lang['cal_sunday'] = "Sunday";
$lang['cal_monday'] = "Monday";
$lang['cal_tuesday'] = "Tuesday";
$lang['cal_wednesday'] = "Wednesday";
$lang['cal_thursday'] = "Thursday";
$lang['cal_friday'] = "Friday";
$lang['cal_saturday'] = "Saturday";

Este fragmento es parte del archivo "calendar_lang.php". Para crear la versión en español crearíamos el archivo "/system/languge/spanish/calendar_lang.php" y traduciríamos los textos, pero no los literales:

$lang['cal_sunday'] = "Domingo";
$lang['cal_monday'] = "Lunes";
$lang['cal_tuesday'] = "Martes";
$lang['cal_wednesday'] = "Miércoles";
$lang['cal_thursday'] = "Jueves";
$lang['cal_friday'] = "Viernes";
$lang['cal_saturday'] = "Sábado";

En Internet se pueden encontrar archivos con las traducciones para los distintos idiomas. Por ejemplo en una búsqueda rápida he encontrado en github un proyecto de traducción de CodeIgniter al Español, pero los packs de idiomas no están actualizados. Lo que sí hay es está actualizado a la última versión en un manual de CodeIgniter en Español (PDF). También he encontrado un "CodeIgniter 2.0.2 Spanish Pack" en el blog de César de la Cruz. A partir de ese trabajo que creado mi propio CodeIgniter Spanish Pack actualizado a la versión 2.1.3, que es la versión oficial de CodeIgniter en el momento de escribir este artículo.

CodeIgniter 2.1.3 Spanish Pack (ZIP/8Kb). Licencia libre.


Cambiando el idioma de un proyecto.

Además de los archivos de idioma del sistema, también podemos definir nuestros propios archivos de idioma para el proyecto PHP. Estos se guardarán en la carpeta "/application/language/{lang}/" donde {lang} es el nombre del idioma (english, spanish, etc). El nombre de los archivos de idioma debe acabar en "_lang.php". Por ejemplo un archivo con mensajes de error se llamaría "error_lang.php". El formato del archivo será el mismo que se ha comentado más arriba:

$lang['error_resource_not_found'] = "Recurso no encontrado.";
$lang['error_resource_unavailable'] = "Recurso no disponible.";
//... etc.

Para poder usar un archivo de idioma primero tendremos que cargarlo. Para ello se utiliza la clase Language. Esto se hará en el controlador:

$this->lang->load('error', 'spanish');

Si no se especifica idioma, se usará el idioma por defecto, definido como una variable dentro del archivo "/application/config/config.php". Generalmente su valor es "english", pero podemos modificarlo si hemos creado la carpeta de idiomas correspondiente:

$config['language'] = 'spanish';
Luego para obtener una cadena traducida hay que llamar a la función line():
$var = $this->lang->line('error_resource_unavailable');

Esto es todo lo que se necesita para cambiar de idioma en CodeIgniter. Si queremos hacer una web multi-idioma podemos crear una cookie con el idioma del usuario y usar ese valor al cargar los archivos de idioma.


El helper Language.

En CodeIgniter un helper es un conjunto de funciones que ayudan a realizar una tarea. Podríamos traducir helper como ayudante o asistente. En concreto el helper Language contiene funciones que ayudan al programador en el tratamiento con archivos de idioma. Para poder usar este helper lo primero será cargarlo, cosa que haremos en el controlador:

$this->load->helper('language');

Una ver cargado podemos usar la función global lang() para cargar los textos de los ficheros de idiomas en lugar de $this->lang->line(). Se aconseja el uso de este helper en las vistas para favorecer la lectura de los archivos fuente. Ejemplo:

<div class="error">
<h1><?= lang('error_heading'); ?></h1>
<p><?= lang('error_resource_unavailable'); ?></p>
</div>

Fuentes y referencias:

lunes, 26 de noviembre de 2012

Ejemplo de programación con CodeIgniter

El otro día hablábamos de CodeIgniter, un framework PHP muy ligero que he descubierto recientemente. CodeIgniter implementa el modelo-vista-controlador (MVC) y permite el desarrollo de aplicaciones web de forma rápida y eficiente. En este artículo vamos a ver un ejemplo de desarrollo de una aplicación web usando CodeIgniter. Va a ser un ejemplo muy sencillo que utiliza las características básicas de CodeIgniter.

Enunciado.

Vamos a suponer que tenemos una tabla de productos y que queremos una aplicación web que muestre por un lado la lista de productos con su precio y por otro lado todos los detalles de cada producto. A continuación la tabla de productos:

CREATE TABLE `products`
( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY
, `name` VARCHAR(64) NOT NULL
, `descri` TEXT NOT NULL
, `price` FLOAT NOT NULL
);

Las únicas URLs permitidas para nuestra aplicación web serán las siguientes:

http://www.midominio.com/ Mostrará la lista de productos.
http://www.midominio.com/productos/ Mostrará la lista de productos.
http://www.midominio.com/productos/prod/1 Mostrará los datos del producto con ID=1.


PASO 1: Descargar e instalar CodeIgniter.

Lo primero de todo será descargar CodeIgniter desde la página web del producto. Instalar CodeIgniter es muy sencillo: basta descomprimir el contenido del archivo ZIP descargado en el directorio raíz o en una carpeta del servidor web.

Al acabar la instalación se habrán creado 3 carpetas: "application" contendrá los archivos fuente de nuestra aplicación; "system" contendrá las clases base y librerías necesarias para que todo funcione; "user_guide" es el manual de utilización y puede borrarse. También se habrá creado el archivo "index.php" que será el punto de entrada de nuestra aplicación. Por ahora no debe modificarse.


PASO 2: Configurar nuestro proyecto CodeIgniter.

  • Crear un archivo ".htaccess" en la carpeta raíz de nuestro proyecto. Esto sirve para hacer las URLs de CodeIgniter más amigables, eliminando la referencia a "index.php".
  • Options -Indexes +FollowSymLinks
    RewriteEngine on
    RewriteCond $1 !^(index.php|css|js|images|robots.txt)
    RewriteRule ^(.*)$ /index.php/$1 [L]
    
  • Editar el archivo "/application/config/config.php":
  • $config['base_url'] = 'http://www.midominio.com/';
    $config['index_page'] = '';
    
  • Editar el archivo "/application/config/database.php" sustituyendo los valores de "my_username", "my_password" y "my_database" por datos reales de acceso a la base de datos MySQL:
  • $db['default']['hostname'] = 'localhost';
    $db['default']['username'] = 'my_username';
    $db['default']['password'] = 'my_password';
    $db['default']['database'] = 'my_database';
    
  • Editar el archivo "/application/config/routes.php" para especificar que el controlador por defecto del proyecto será "products":
  • $route['default_controller'] = "products";
    

PASO 3: Crear el modelo.

Como sabemos el modelo es la parte del patrón de diseño MVC que permite el acceso a los datos y concretamente nuestros datos estarán en la tabla products de una base de datos MySQL. En CodeIgniter las clases del modelo derivarán de CI_Model y se guardarán en la carpeta "/application/models/".

Creamos el archivo "/application/models/products_model.php"

class Products_Model extends CI_Model {

  public function __construct() {
    parent::__construct();
    $this->load->database();
  }

  public function selectProducts() {

    $sql = "
      SELECT `id`
      , `name`
      , `price`
      FROM `products`
      ORDER BY `id` ASC;
      ";

    $result = $this->db->query($sql);
    if(!$result) {
      return false;
    }

    return $result;
  }

  public function selectProduct($id) {

    $sql = "
      SELECT `id`
      , `name`
      , `descri`
      , `price`
      FROM `products`
      WHERE `id` = ?;
      ";

    $bindings = array(
      $id
    );

    $result = $this->db->query($sql, $bindings);
    if(!$result) {
      return false;
    }

    return $result;
  }
}

Como vemos la clase Products_Model tiene constructor y dos métodos: selectProducts() y selectProduct(). En el constructor se carga la librería de acceso a base de datos. Los métodos realizan las queries y devuelven el resultado.


PASO 4: Crear el controlador.

Nuestra aplicación CodeIgniter sólo tendrá un controlador al que llamaremos Products. La clase derivará de CI_Controller y se guardará en la carpeta "/application/controllers/":

Creamos el archivo "/application/controllers/products.php"

class Products extends CI_Controller {

  public function __construct() {
    parent::__construct();
    $this->load->helper('url');
    $this->load->model('Products_Model');
  }

  public function index() {

  $data = array( );

    $query = $this->Products_Model->selectProducts();
    if(!$query || $query->num_rows() < 1) {
      $data['product_list'] = null;
    }
    else {

      $data['product_list'] = array( );
      foreach ($query->result() as $row) {
        $product = array( );
        $product['id'] = $row->id;
        $product['name'] = $row->name;
        $product['price'] = $row->price;
        $data['product_list'][] = $product;
      }
    }

    $this->load->view('product_list', $data);
  }

  public function prod($prod_id) {

    if(!$prod_id) {
      show_404();
      return;
    }

    $query = $this->Products_Model->selectProduct($prod_id);
    if(!$query || $query->num_rows() < 1) {
      show_404();
      return;
    }

    $row = $query->row();
    if(!$row) {
      show_404();
      return;
    }

    $product = array( );
    $product['id'] = $row->id;
    $product['name'] = $row->name;
    $product['descri'] = $row->descri;
    $product['price'] = $row->price;
    $data['product_data'] = $product;

    $this->load->view('product_data', $data);
  }
}

Nuestro controlador tendrá constructor, el método index() y el método prod(). El constructor cargará el modelo Products_Model, que hemos creado anteriormente, y el helper url. Un helper es como una librería que proporciona CodeIgniter con funciones comunes de ayuda a la programación. En este caso el helper url proporciona funciones para trabajar con las URLs del sitio web: site_url(), base_url(), current_url(), etc.

El método index() llama al modelo para cargar la lista de productos y posteriomente llama a la vista product_list pasándole un array con la lista de productos que tiene que mostrar. El método prod(), que recibe como parámetro el identificador del producto, carga los datos del producto a través del modelo e invoca la vista product_data pasándole esos datos. Si el producto no existe se muestra la página de error 404.


PASO 5: Crear las vistas.

Como hemos visto, nuestra aplicación web tendrá dos vistas: product_list y product_data. Las vistas en CodeIgniter son archivos PHP que se guardan en la carpeta "application/views/".

Creamos el archivo "/application/views/product_list.php"

<!DOCTYPE html>
<html>
<head>
<title>Lista de productos</title>
<meta http-equiv="content-type" content="text/html; charset=utf8">
</head>
<body>
<h1>
  Lista de productos
</h1>
<?php if(!$product_list) : ?>
<p>
  La lista de productos está vacía.
</p>
<?php else : ?>
<ul>
<?php
  reset($product_list);
  foreach ($product_list as $product) {
    echo "<li>";
    echo "<a ";
    echo "href='", site_url('/products/prod/' . $product['id']) . "'>";
    echo $product['name'];
    echo "</a>";
    echo " ";
    echo number_format($product['price'], 2, ',', '.');
    echo "€";
    echo "</li>";
    echo PHP_EOL;
  }
?>
</ul>
<?php endif; ?>
</body>
</html>

Creamos el archivo "/application/views/product_data.php"

<!DOCTYPE html>
<html>
<head>
<title><?php echo $product_data['name']; ?></title>
<meta name="description" content="<?php echo $product_data['descri']; ?>">
<meta http-equiv="content-type" content="text/html; charset=utf8">
</head>
<body>
<h1>
  <?php echo $product_data['name']; ?>
</h1>
<p>
  <?php echo $product_data['descri']; ?>
</p>
<p>
  Precio: <?php echo number_format($product_data['price'], 2, ',', '.'); ?>€
</p>
<p>
  <a href="<?php echo site_url(); ?>">Volver a la lista</a>.
</p>
</body>
</html>

Como vemos detro de las vistas podemos usar los datos pasados desde el controlador a través del segundo parámetro del método $this->load->view() como variables globales.


Y con esto ya tenemos acabada la primera aplicación web hecha con CodeIgniter.

lunes, 19 de noviembre de 2012

Herramientas de programación web: CodeIgniter

El otro día me estuvieron hablado muy bien de CodeIgniter, un framework para PHP, totalmente orientado a objetos, sencillo pero muy potente, así que me he puesto a investigar y aquí está el resultado.

Para empezar, ¿Qué es un framework? En términos generales un framework es un conjunto de librerías y otras herramientas que facilitan y organizan el desarrollo de software (típicamente aplicaciones web), proporcionando un marco de trabajo común (framework), unas librerías extensibles y una determinada metodología de trabajo. Muchos frameworks, especialmente los orientados a web, implementan el llamado Modelo-Vista-Controlador (MVC) que separa los distintos componentes de la aplicación en:

  • Modelo: Gestiona los datos que generalmente se encontrarán en una base de datos MySQL, aunque podrían estar en ficheros o en cualquier otra fuente.

  • Vista: Interacciona con el usuario. Presenta los datos al usuario y recoge los datos proporcionados por el mismo. En los frameworks orientados a web el modelo es el que monta la salida HTML.

  • Controlador: Gestiona y controla lo que ocurre en la aplicación. El controlador recibe la petición, obtiene los datos del modelo y llama a la vista adecuada.

En concreto el framework CodeIgniter permite realizar nuestros desarrollos PHP de forma más rápida y eficiente, proporcionando una librería de clases altamente extensible que implementa el Modelo-Vista-Controlador. Sus principales ventajas son que es rápido, que es fácil de usar, que tiene una gran documentación y que detrás hay una amplia comunidad de desarrolladores. Además es un producto de código libre para cualquier aplicación, incluso comerciales. CodeIgniter tiene muchas ayudas para la creación de aplicaciones PHP avanzadas que hacen que el proceso de desarrollo sea más rápido, obteniendo aplicaciones web más profesionales y con código más reutilizable.

Enlaces de interés: